return an object from an array, keyed by the value at the given id
Fixes stack traces for files with source maps
Curated collection of data structures for the JavaScript/TypeScript.
Serve directory listings
Fast, fault-tolerant, cross-platform, disk-based, data-agnostic, content-addressable cache.
Convert a string index to its line and column position
Custom webpack builders for Angular build facade. Allow to modify Angular build configuration without ejecting it
Like a Set, but provides the index of the `key` in the backing array
A small JS+SVG library for drawing railroad syntax diagrams.
A fast function for calculating where a string should be truncated, given an optional width limit and an ellipsis string.
A very fast static 2D index for points based on kd-tree.
This package provides support for the [RediSearch](https://redis.io/docs/interact/search-and-query/) module, which adds indexing and querying support for data stored in Redis Hashes or as JSON documents with the [RedisJSON](https://redis.io/docs/data-type
reduce an object
TypeScript definitions for serve-index
Use sign and abs functions in CSS
Rope-based persistent sequence type
A tiny and fast selection algorithm in JavaScript.
Utilities related to a bindings index
Provides a fallback for non-existing directories so that the HTML 5 history API can be used.
Low footprint ECMAScript source code parser
Convert efficiently index to/from line-column in a string
Reduce z-index values with PostCSS.
Simple HTML5 charts using the canvas element.
A utility function to index arrays by any criteria
gem was developed by: markbates
This elasticsearch client is just all you need to search and index your data with persistent http connection
Calculates your USGA handicap. Just enter your scores, and this calculator will calculate your golf handicap index using the exact formula that the USGA uses.
Just Adds "ADD ON MENUS" to admin_tabs."ADD ON MENUS" simply shows a blank Index page titled "MASTER CONTROLS".Expected to be used for other extensions, things like putting a link on the additional data to this index page.
Because Solr sometimes fails, it happens. It might be a maintenance work you have to do or just Out-Of-Memory problems. If you are running search-sensitive Rails app, you have to deal with it.This gem was developed to postpone your index tasks automatically into a sidekiq queue if Solr engine becomes unavailable
Prints numbers to the console in a pyramid-like step pattern, where each step displays the numbers from 1 to the current index in ascending order. P.S. It's just test gem"
Ruby on Rails supports RESTful routing out-of-the-box. However, as you move along, you will often find yourself repeating the code for the seven REST actions: index, show, new, create, edit, update, destroy. This gem allows you to get all of the code for free by simply typing 'include BTech::Rest' at top of your controller code. That's it! Even better, you can have nested resources as well by adding a 'belongs_to' statement to your controllers much like you would for ActiveRecord models. This is just the tip of the iceburg so make sure to read the RDoc for more info.
Ruby on Rails supports RESTful routing out-of-the-box. However, as you move along, you will often find yourself repeating the code for the seven REST actions: index, show, new, create, edit, update, destroy. This gem allows you to get all of the code for free by simply typing 'include Rest' at top of your controller code. That's it! Even better, you can have nested resources as well by adding a 'belongs_to' statement to your controllers much like you would for ActiveRecord models. This is just the tip of the iceburg so make sure to read the RDoc for more info.
Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner. It does this in lots in lots of different places, but in one manner: it encourages specification in place of implementation. Hammock enforces RESTful resource access by abstracting actions away from the controller in favour of a clean, model-like callback system. Hammock tackles the hard and soft sides of security at once with a scoping security system on your models. Specify who can verb what resources under what conditions once, and everything else - the actual security, link generation, index filtering - just happens. Hammock inspects your routes and resources to generate a routing tree for each resource. Parent resources in a nested route are handled transparently at every point - record retrieval, creation, and linking. It makes more sense when you see how it works though. There's a screencast coming soon.
A Rack middleware to make URLs in one-page webapps easier. In a couple of recent projects, I've needed to avoid full page refreshes as much as possible. In the first, I wanted to keep an embedded music player active while the user was browsing. In the second, I just wanted fancier transitions between pages. It's possible to do this in an ad-hoc way, but I very quickly got tired of hacking things together. Enter Onesie. Onesie congealed from these requirements: * I want a one-page web app, * But I want the back button to work, * And I want search engines to still index some stuff, * And I (mostly) don't want to change the way I write a Rails/Sinatra app. If someone visits <tt>http://example.org/meta/contact</tt>, I want them to be redirected to <tt>http://example.org/blah/#/meta/contact</tt>, but after the redirection I still want the original route to be rendered for search engine indexing, etc. When Onesie gets a request, it looks to see if under your preferred one-page app path ("blah" in the example above). If it's not, Onesie sets the current request's path in the session and redirects to your app path. If a request is under the one-page app path, the "real" request's path is retrieved from the session and used for subsequent routing and rendering. This means that, as above, a request for http://example.org/meta/contact Will be redirected to http://example.org/blah/#/meta/contact But still render the correct action in the wrapped app, even though URL fragments aren't passed to the server. This is a terrible explanation. I'll write a sample app or something soon.
{<img src="https://secure.travis-ci.org/socialcast/socialcast-shoulda-ext.png?branch=master" alt="Build Status" />}[http://travis-ci.org/socialcast/socialcast-shoulda-ext] = Socialcast Shoulda Extensions Adds new matchers and functionality to the shoulda test library = Installation In your Gemfile: group :test do gem 'socialcast_shoulda_ext', :git => 'git@github.com:socialcast/socialcast-shoulda-ext.git', :require => 'shoulda_ext' end If you want to include the trigger_callbacks matcher, also add the following to your test helper: ShouldaExt::Matchers::TriggerCallbackMatcher.attach_active_record_callback_hooks! = Matchers == RecordCountChangeMatcher Test if the count for a model has changed, and by how much. Requires the context_with_matcher_before_hooks patch, which is included by default. Provides the following matcher methods: - create_record(klass_or_symbol) Alias for change_record_count.for(klass_or_symbol).by(1) - create_records(klass_or_symbol, amount) Alias for change_record_count.for(klass_or_symbol).by(amount) - destroy_record(klass_or_symbol) Alias for change_record_count.for(klass_or_symbol).by(-1) - destroy_records(klass_or_symbol, amount) Alias for change_record_count.for(klass_or_symbol).by(-amount) - change_record_count Tests the difference in record count before and after the current setup/subject block Can be used with the follow methods: - for(klass_or_symbol) Provides the class which the test is being performed on. Can be a constant or a symbol - by(amount) Provides an expected difference for the number of records for the specified class. Excluding this number will allow the matcher to check for any difference Examples: context "creating a blog article" do context "with good parameters" do setup do post :create, :blog => {:title => 'my blog post', :body => 'Ipsum lorem...'} end should create_record :blog end context "without a body" do setup do post :create, :blog => {:title => 'my blog post' } end should_not create_record Blog end end == RespondWithJson Check if the controller's response is json Examples: context ":index.json" do setup do get :index, :format => 'json' end # Just check to see that the response was json should respond_with_json # Evaluate the hash produced by the json yourself should respond_with_json { |json| json.first['blog']['title'] == 'blog post 1'} # Provide an exact match should respond_with_json.exactly(['blog' => {'id' => 1, 'title' => 'blog post 1'}]) # Provide an exact match with a block should response_with_json.exactly{ |json| JSON.parse(Blog.all.to_json)} end context ":index.html" do setup do get :index end # or the negation should_not respond_with_json end == TriggerCallbackMatcher Test if create, update, destroy, or save callbacks were triggered. Requires running ShouldaExt::Matchers::TriggerCallbackMatcher.attach_active_record_callback_hooks! in your test suite in order to work properly. Examples: context "doing nothing to a record" do subject { Blog.new :title => 'blog title' } should_not trigger_callbacks end context "creating a record" do subject { Blog.create! :title => 'blog title' } should trigger_callbacks.for :create should_not trigger_callbacks.for :update, :destroy end = Integrations Currently only integrates with test/unit. RSpec support to come. = Shoulda Extensions == ContextWithMatcherBeforeHooks Adds the ability to define a 'before' method on any method which will be run before each context's setup/subject block. Used by RecordCountChangeMatcher to record the number of records before the tested operation takes place.
== README.md: #ScheduledResource This gem is for displaying how things are used over time -- a schedule for a set of "resources". You can configure the elements of the schedule and there are utilities and protocols to connect them: - Configuration (specification and management), - Query interfaces (a REST-like API and internal protocols to query the models), and - A basic Rails controller implementation. We have a way to configure the schedule, internal methods to generate the data, and a way to retrieve data from the client. However this gem is largely view-framework agnostic. We could use a variety of client-side packages or even more traditional Rails view templates to generate HTML. In any case, to get a good feel in a display like this we need some client-side code. The gem includes client-side modules to: - Manage <b>time and display geometries</b> with "infinite" scroll along the time axis. - <b>Format display cells</b> in ways specific to the resource models. - <b>Update text justification</b> as the display is scrolled horizontally. ## Configuration A **scheduled resource** is something that can be used for one thing at a time. So if "Rocky & Bullwinkle" is on channel 3 from 10am to 11am on Saturday, then 'channel 3' is the <u>resource</u> and that showing of the episode is a <u>resource-use</u> block. Resources and use-blocks are typically Rails models. Each resource and its use-blocks get one row in the display. That row has a label to the left with some timespan visible on the rest of the row. Something else you would expect see in a schedule would be headers and labels -- perhaps one row with the date and another row with the hour. Headers and labels also fit the model of resources and use-blocks. Basic timezone-aware classes (ZTime*) for those are included in this gem. ### Config File The schedule configuration comes from <tt>config/resource_schedule.yml</tt> which has three top-level sections: - ResourceKinds: A hash where the key is a Resource and the value is a UseBlock. (Both are class names), - Resources: A list where each item is a Resource Class followed by one or more resource ids, and - visibleTime: The visible timespan of the schedule in seconds. The example file <tt>config/resource_schedule.yml</tt> (installed when you run <tt>schedulize</tt>) should be enough to display a two-row schedule with just the date above and the hour below. Of course you can monkey-patch or subclass these classes for your own needs. ### The schedule API The 'schedule' endpoint uses parameters <tt>t1</tt> and <tt>t2</tt> to specify a time interval for the request. A third parameter <tt>inc</tt> allows an initial time window to be expanded without repeating blocks that span those boundaries. The time parameters _plus the configured resources_ define the data to be returned. ### More About Configuration Management The <b>ScheduledResource</b> class manages resource and use-block class names, id's and labels for a schedule according to the configuration file. A ScheduledResource instance ties together: 1. A resource class (eg TvStation), 2. An id (a channel number in this example), and 3. Strings and other assets that will go into the DOM. The id is used to - select a resource _instance_ and - select instances of the _resource use block_ class (eg Program instances). The id _could_ be a database id but more often is something a little more suited to human use in the configuration. In any case it is used by model class method <tt>(resource_use_block_class).get_all_blocks()</tt> to select the right use-blocks for the resource. A resource class name and id are are joined with a '_' to form a tag that also serves as an id for the DOM. Once the configuration yaml is loaded that data is maintained in the session structure. Of course having a single configuration file limits the application's usefulness. A more general approach would be to have a user model with login and configuration would be associated with the user. ## Installation Add this line to your application's Gemfile: ```ruby gem 'scheduled_resource' ``` And then execute: $ bundle Or install it yourself as: $ gem install scheduled_resource Then from your application's root execute: $ schedulize . This will install a few image placeholders, client-side modules and a stylesheet under <tt>vendor/assets</tt>, an example configuration in <tt>config/resource_schedule.yml</tt> and an example controller in <tt>app/controllers/schedule_controller.rb</tt>. Also, if you use $ bundle show scheduled_resource to locate the installed source you can browse example classes <tt>lib/z_time_*.rb</tt> and the controller helper methods in <tt>lib/scheduled_resource/helper.rb</tt> ## Testing This gem also provides for a basic test application using angularjs to display a minimal but functional schedule showing just the day and hour headers in two different timezones (US Pacific and Eastern). Proceed as follows, starting with a fresh Rails app: $ rails new test_sr As above, add the gem to the Gemfile, then $ cd test_sr $ bundle $ schedulize . Add lines such as these to <tt>config/routes.rb</tt> get "/schedule/index" => "schedule#index" get "/schedule" => "schedule#schedule" Copy / merge these files from the gem source into the test app: $SR_SRC/app/views/layouts/application.html.erb $SR_SRC/app/views/schedule/index.html.erb $SR_SRC/app/assets/javascripts/{angular.js,script.js,controllers.js} and add <tt>//= require angular</tt> to application.js just below the entries for <tt>jquery</tt>. After you run the server and browse to http://0.0.0.0:3000/schedule/index you should see the four time-header rows specified by the sample config file. ## More Examples A better place to see the use of this gem is at [tv4](https://github.com/emeyekayee/tv4). Specifically, models <tt>app/models/event.rb</tt> and <tt>app/models/station.rb</tt> give better examples of implementing the ScheduledResource protocol and adapting to a db schema organized along somewhat different lines. ## Contributing 1. Fork it ( https://github.com/emeyekayee/scheduled_resource/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request
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.