Library to perform an action on all user-defined modules under a given directory
Create aliases of directories and register custom module paths
nodejs wrapper for nektos/act
Webpack Virtual Modules
Sharing Connection among Multi-Process Nodejs
This plugin transforms ES2015 modules to CommonJS
The directory used by npm for globally installed npm modules.
OpenTelemetry Node SDK provides automatic telemetry (tracing, metrics, etc) for Node.js applications
Easily get the CWD (current working directory) of a project based on package.json, optionally starting from a given path. (node.js/javascript util)
This plugin transforms ES2015 modules to UMD
This plugin transforms ES2015 modules to AMD
This plugin transforms ES2015 modules to SystemJS
Types for roosterjs
Routes requests to KV assets
Plugins for roosterjs
Format API for roosterjs
Content Model for roosterjs
Core editor for roosterjs
A robust Punycode converter that fully complies to RFC 3492 and RFC 5891, and works on nearly all JavaScript platforms.
The Sodium cryptographic library compiled to pure JavaScript (wrappers)
The Sodium cryptographic library compiled to pure JavaScript (raw library, no wrappers)
Functional programming in TypeScript
A CSS Modules transform to extract local aliases for inline imports
Next-generation ES module bundler
a generic way to create modules that act as proxies to your existing Ruby modules
A module that attempts to act as a universal WHOIS output interpreter allowing you to get information about most domain name extensions.
The Rules Module of CompassAE includes classes which act as helpers in externalizing the execution context of CompassAE value objects for processing by a rules engine. It also includes an integration with Ruleby, which is a pure ruby implementation of the forward chaining Rete algorithm.
Provides `Module#const_set_p`, a wrapper method for `Module#const_set`, it acts like `mkdir -p` does for `mkdir`.
A module that attempts to act as a universal WHOIS output interpreter allowing you to get information about most domain name extensions.
A module that attempts to act as a universal WHOIS output interpreter allowing you to get information about most domain name extensions.
If you've recently created an API you may have felt frustrated at the removal of Devise's token authenticatable module. ArcadeX fills the void with a set of functions that act on a token class to provide authentication to an API. Enjoy!
Use an ActiveRecord Hash column as backend for dynamic attributes. Dynamic attributes will act like table columns. Just include the HashAttributes module in your ActiveRecord::Base class.
StaticRecord is a module allowing to perform ActiveRecord-like queries over Ruby files. Those act as immutable database records that only developers can alter. Their attributes are stored in a SQLite3 database re-created on startup. Queries instantiate each retrieved records.
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.
Mutability is a module that provides the very simple ability to designate an "original" version of an object that is frozen, and will not change even if the working copy of the object does. The best example is a Hash or Array -- collections like those exist partly so they can be mutated in some way, either by adding or removing elements or changing their order. Now, rather than having to establish a separate "original" version of the object (not to mention dealing with the whole ivars-act-like-pointers-and-can-get-magically-changed-oops problem), you can use a MutableHash or MutableArray, and then change it to your heart's content. The MutableHash/Array are built from the Mutability mix-in, so downloading this gem also provides a library for you to add the same capabilities to any other Class you might want. Also included is the ability to revert to the original form with a single method call.
== E9Tags An extension to ActsAsTaggableOn[http://github.com/mbleigh/acts-as-taggable-on] which "improves" on custom tagging, or at least makes it more dynamic. Additionally it provides some autocomplete rack apps and the corresponding javascript. == Installation 1. E9Tags requires jquery and jquery-ui for the autocompletion and tag-adding form, be sure they're loaded in your pages where the tags form will be rendered. 2. E9Tags extends ActsAsTaggableOn and requires it. Run it's generator if you have not. 3. Run the E9Tags install script to copy over the required JS rails g e9_tags:install 4. Then make sure it is loaded, how you do that doesn't matter, e.g. <%= javascript_include_tag 'e9_tags' %> 5. Create an initializer for that sets up the taggable models and their controllers. This gives the models the tag associations and methods and prepares their controller to handle the otherwise unexpected tag params. require 'e9_tags' require 'contacts_controller' require 'contact' E9Tags.controllers << ContactsController E9Tags.models << Contact OR You can just include the modules in your classes yourself. The first way really exists for the case where the classes you wish to extend are part of another plugin/gem. # in contact.rb include E9Tags:Model # in contacts_controller.rb include E9Tags::Controller 6. Render the tags form partial in whatever model forms require it. = render 'e9_tags/form', :f => f If you pass a context, it will be locked and no longer possible to change/add the contexts on the form (and as a side effect, the tags autocompletion will be restricted to that context). = render 'e9_tags/form', :f => f, :context => :users Finally if you pass a 2nd arg to :context you can set a tag context to be "private" (default is false). In this case the tag context will be locked as private (typically suffixed with *), meaning that the tags will not be publicly searchable/visible. This is useful for organizational tags tags, say if you wanted to arbitrarily group records, or create a custom search based on a tag context. = render 'e9_tags/form', :f => f, :context => [:users, true] NOTE: The form and javascript are intended to work out of the box, but the certainly aren't going to look pretty. If you do intend to use the forms, you'll no doubt need to style them.