A replacement prototype for `Object.prototype` with all the same functions
javascript String Object prototype extend
String, array and object prototype extensions and methods.
A powerfull, high performance, lightweight library to injecs many usefull methods into the Object prototype to sugar many use cases working with common Javascript object.
Object-prototype-like abstraction over lmdb.
Biblioteca de utilitários para Object Prototype
An object prototype building framework
Adds a static `extend` method to a class, to simplify inheritance. Extends the static properties, prototype properties, and descriptors from a `Parent` constructor onto `Child` constructors.
Really Fast Deep Clone
Fastest way for creating null-prototype objects in JavaScript
Create an Object prototype chain based on hierarchy.
javascript String Object prototype extend
Source code handling classes for webpack
No description provided.
Return the prototype of a provided object.
A blazing fast deep object copier
Simple event emitter
request body parsing for co
Access deep object properties using a path
Extends Object prototype to give many powerful and performant utility tools such as lambda iterations
Tree utilities which provides a full-featured extend and object-cloning facility, and various tools to deal with nested object structures.
The library provides functional to dynamically create synthetic object prototype which will created from another object
JSON parse with prototype poisoning protection
Copy static properties, prototype properties, and descriptors from one object to another.
EG: Prototype-based objects for Ruby
Use the Properties pattern (e.g. prototypal objects, like in JavaScript's object system) in Ruby.
Directs objects' behaviors
Provides objects with some JavaScript-like syntax and prototypal inheritance in Ruby
Create objects from object definitions stored as files, like test fixtures, only intended for production use.
Prototypal Ruby objects
Allows the class-oriented Ruby language to double as a simple-object prototype language (a la Javascript)
Delayed Form Observer provides Rails with timed form observers that do not create race conditions. The gem extends Prototype and adds a Rails PrototypeHelper to use this new object.
This gem adds to carrierwave a storage facility which will use the PostgreSQL's oid datatype to reference a large object residing in the databse. It supports up to 2GB files, though it's better suited for smaller ones. Makes life easier for fast prototyping and put all your data in the same place, allows one backup for all your data and file storage in heroku servers.
Toolkit for rapid prototyping of interactors, use cases and service objects. Using DCI (Data, context and interaction) the new programming paradigm from the inventor of the MVC pattern. This implementation consumes excessive memory (hence the name) and is not recommended for production.
**Non Functional / Still in Planning Stage** Here's the high-level (brain dump): * Site content is organized in collections * Collections are serialized * Each have support for next, previous, first, last, etc * The content files are HTML * Templates are object based (each content type can be rendered with their own templates) * Templates are HTML with interspersed Liquid markup * All meta data is described using HTML meta tags * You custom meta data tags in a content objects * You can specify 'prototype' content objects in a collection with a _proto folder in the collection
Remember when RSpec had stub_chain? They removed it for good reasons but sometimes you just need it. Well, here it is, a proxy object. It doesn't actually mock anything for you (the name is just catchy) so you need to do that. But that actually comes with a lot of benefits: 1) It's compatable with any testing framework 2) You can use it for purposes other than testing, e.g. prototyping, code stubs 3) Flexibility in how you use it without overloading the number of methods you have to remember Here's an example usage: let(:model_proxy) do MockProxy.new(email_client: { create_email: { receive: proc {} } }) end before { allow(Model).to receive(:new).and_return model_proxy } it 'should call receive' do proc = MockProxy.get(model_proxy, 'email_client.create_email.receive') expect(proc).to receive(:call) run_system_under_test MockProxy.update(mock_proxy, 'email_client.create_email.validate!') { true } MockProxy.observe(mock_proxy, 'email_client.create_email.send') do |to| expect(to).to eq 'stop@emailing.me' end run_system_under_test2 end As you can see, the proc - which ends the proxy by calling the proc - can be used for anything. You can spy on the call count and arguments, mock methods, or just stub out code you don't want executed. Because it doesn't make any assumptions, it becomes very flexible. Simple, yet powerful, it's uses are infinite. Enjoy
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.