Abstract Core Functionalities
This npm package comprises the abstract core of the dreipol vue and react log utils.
Utils for writing Salesforce CLI plugins
[](https://npm.im/@dnd-kit/abstract)
ECMAScript spec abstract operations.
A collection of implementation for ECMAScript abstract operations
Write Pino transports easily
The core of the humanfs library.
This package contains base abstract interfaces. Generally, you do not want to look at this repository, as there's nothing more than philosophycal reasonments that aren't exactly that pragmatic.
Editing commands for ProseMirror
BitGo UTXO Core types
An Abstract Class for describing an Ethereum Provider for ethers.
A Light–weight CSS Preprocessor
Abstract Global Wallet Client SDK
An Abstract Class for desribing an Ethereum Signer for ethers.
Abstract class for a lexicographically sorted key-value database
No description provided.
BitGo UTXO Core types
[](https://npm.im/@dnd-kit/state)
No description provided.
The purpose of this repository is to provide the components and utilities needed to build a JavaScript/TypeScript enforcer on any platform/environment. This repository is *not* a complete running enforcer; rather, it is a tool kit with all the building bl
A noop logger that conforms to the Log4j interface for modules to stub out internal logging
encode/decode number as bitcoin variable length integer
This is the core library of Cloud Development Kit (CDK) for Kubernetes (cdk8s). cdk8s apps synthesize into standard Kubernetes manifests which can be applied to any Kubernetes cluster.
Abstract contract interfaces and storage layouts
Abstract contract interfaces and storage layouts
A RubyMotion abstraction of Core Data that also provides shortcuts for fetching json resources.
This project contains the abstract layer for APIMatic's core library. The purpose of creating interfaces is to separate out the functionalities needed by APIMatic's core library module. The goal is to support scalability and feature enhancement of the core library and the SDKs along with avoiding any breaking changes by reducing tight coupling between modules through the introduction of interfaces.
RiakRest provides structured, RESTful interaction with the HTTP/JSON interface of a Riak[http://riak.basho.com] document data store. RiakRest provides two levels of interaction: Core Client and Resource. Core Client works at the Jiak level and exposes Jiak internals. JiakResource is an abstraction built on top of the Core Client that gives a true RESTful feel.
MixLib for creating Core libraries in ruby for automating machines. This is an abstraction away from using Chef Providers directly to give us access to the lower layers of Chef implementation to meet additional use cases.
TestBench::Session implements the core testing mechanisms of TestBench: tests, contexts, comments, assertions, and test file execution. Sessions also maintain the pass/fail status of the test run. A diagnostic substitute session is also included that records session telemetry so that test abstractions built using TestBench (called "Fixtures") can observed and tested in isolation.
DDDr stands for Domain Driven Design Repository. It's a Ruby gem that simplifies the implementation of data repositories in a Domain-Driven Design (DDD) architecture. It offers a clean interface for abstracting data access, allowing you to focus on your domain logic rather than database operations. With DDDr, you can easily swap out data sources without affecting your core business logic.
A JRuby adaption and gem packaging of the {Simple Logging Facade for Java}[http://www.slf4j.org/]. Provides all jar dependencies and a Ruby Logger compatible facade. SLF4J is a java logging abstraction and set of adapters to various concrete logging implementations and legacy logging APIs. The slf4j gem adds a ruby core Logger compatible facade to SLF4J, and makes any needed adapters available to JRuby applications. This makes it possible to unify and control logging output of both java and ruby components in a JRuby application.
When we send communications to users it is usually in response to an event. Users often have their own communications preferences (when/how/what). This logic can easily become complicated and so I developed Nofly to abstract it and let the core application only worry about knowing what event happened to which object/record.
Context is a contextual UI framework. It is based on the Model View Presentor model. The idea is that you have model objects that represent the core data in your application. You also have views that represent the user interface input and output. Finally you have "contexts" that represent a user situation in the application. The logic that ties the models and views resides in the contexts. The main advantages to this model are that you can easily write UI unit tests and you can easily create bridge patterns for supporting multiple widget sets (although only GTK+ is supported at the moment). Context is intended to be extremely minimal. Only the top level abstract classes are included. It is *not* a widget set! You have to write your own models, views and contexts.
Parse and generate Portable Action Notation (PAN) strings for representing atomic actions in abstract strategy board games including chess, shogi, xiangqi, and others. PAN provides an intuitive operator-based syntax with six core operators: "-" (move to empty square), "+" (capture), "~" (special moves with side effects), "*" (drop to board), "." (drop with capture), and "=" (in-place transformation), plus "..." (pass turn). Supports coordinates via CELL specification and piece identifiers via EPIN specification. Handles transformations ("e7-e8=Q"), enhanced/diminished states ("+R", "-P"), and style derivation markers ("K'"). Provides comprehensive validation, immutable action objects, and functional API design. Examples: "e2-e4" (move), "d1+f3" (capture), "e1~g1" (castling), "P*e5" (drop), "e7-e8=Q" (promotion), "..." (pass), "+d4" (static capture), "e4=+P" (modify).
Most is a simple academic modular open software tester. Most, the Core is the main part of the system. Most provides the environment and interface bridges for modules that will implement the basic functionality of the testing system. In general Most, the Core consists form two main interfaces: the connector and the tester. The connector interface offers the basic bridge to make an implementation of a module which will act as a controlling interface of the system. It can be a command line interface or it can be a module which will set up a server providing a network access for end users. The tester interface allows building an implementation of the software validator. By default the Most ships with the tester compliant with the ICPC Validator Standard. The Most system proposes to implement a testing system following this standard, but it is not obligatory. The 3-rd party implementation can vary significantly considering the user preferences. It is possible to build other interface bridges using the abstract interface classes provided by the Most system to extend the functionality of the modules. For example the implementation of the connector interface in the form of the network server can build a tunnel interface bridge, so that developers can make implementations, for example, of a SSH tunnel in order to provide a secure connection with the testing system. The default system bundle is shipped with a number of basic interface implementations (modules). Please, consider taking a look on realize notes for the list of supplied modules.
ontoMDE-uml2 contains UML2 meta-model and helper files to manipulate a UML2 model. ontoMDE-uml2 uses ontoMDE-core which provides core fonctionalities for loading a model in RDF/RDFS format. ontoMDE-UML2 is used by ontoMDE-java which contains rules for generating java Code. ontoMDE contains primitives for converting a UML2 model into a Protégé 2000 RDF/RDFS model. UML2 classes are converted into RDFS classes to allow data instances to be created. This feature is used heavily for providing editors for creating tests data for programs. == FEATURES/PROBLEMS: * UML2 meta-model definition in RDFS format * Ruby helper methods for handling a UML2 model. * UML Stereotype handling helpers. * UML predefined enumerations handling helper. * UML model manipulations helpers (add interface implementations, transform multiple inheritance into single inheritance, ...) UML2 to Protege 2000 features: * single and incremental use. * transparent update of name changes from source to target mode. * class * abstract class * interface * enumerated types * generalization links * implementation links * property, association, composition and aggregation * single and multivalued properties * mandatory fields (cardinaly=0 or >0) * UML documentation notes export to Protege 2000 for easy reference.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.