js-initializers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d98734161907a8ef44b4ba6e34e4f9022226520
+  data.tar.gz: 4c97c67aa9c450b82bd0beb410b6a39d58f8d0d0
+SHA512:
+  metadata.gz: 5fe199e0251cd868b655a3ceeb62cb1cb2a5e196d0657b3195daf0e6c187f3d2cd60eeadcff53a9acf240ce7d6097ec1c23547bfb13b89eca5e2f5d5e37c2b52
+  data.tar.gz: b31cacbdc7a833c3a69b3c5f0aaeae8fb4e0011228e2d7c4fd942996e33a3c7deb8668cc111f667cb8ece3266e1287e905d76905776e51924dc4d45faaf85df0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in js-initializers.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nahuel Cuesta Luengo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,47 @@
+# js-initializers
+
+Rails engine that provides a micro-framework for organizing in a modular way your client-side scripts, as well as it enables you to only run the *necessary* modules for each page.
+
+(Better readme coming soon!)
+
+## Usage
+
+Add `js-initializers` to your Gemfile
+
+```ruby
+# Gemfile
+gem 'js-initializers'
+```
+
+Add `js-initializers` to your Sprockets manifest:
+
+```javascript
+//= require js-initializers
+```
+
+Et voilà! You're ready to add your initializers:
+
+```javascript
+// app/assets/javascripts/initializers/rickroll.js
+(function($) {
+  function isRickrollable() {
+    return window.user !== 'admin';
+  }
+
+  function rickroll() {
+    $('a').on('click', function() { window.location = 'www.youtube.com/watch?v=dQw4w9WgXcQ'; return false; });
+  }
+
+  Initializers.register('rickroll', rickroll, isRickrollable);
+}(jQuery));
+```
+
+For further instructions on how to use this library and defining your own initializers, you may refer to the source code of [js-initializers.js](https://github.com/ncuesta/js-initializers/blob/master/app/assets/javascripts/js-initializers/initializers.js).
+
+# Contributing
+
+Contributions are welcome! Just fork, commit and send a pull request :)
+
+# Author
+
+This skinny gem is brought to you by Nahuel Cuesta Luengo. You may reach him at [@ncuestal](https://twitter.com/ncuestal) on Twitter or by email at nahuelcuestaluengo@gmail.com.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/app/assets/javascripts/js-initializers/index.js

@@ -0,0 +1,7 @@
+// js-initializers manifest
+//
+// This file is provided for convenience purposes so you can simply
+// //= require js-initializers
+// in your application's manifest
+//
+//= require_tree .

data/app/assets/javascripts/js-initializers/initializers.js

@@ -0,0 +1,168 @@
+// Copyright (c) 2015 Nahuel Cuesta Luengo <nahuelcuestaluengo@gmail.com>
+//
+// Injectable initializers micro-framework
+//
+// This allows for decoupled addition of new javascript initializers into your
+// regular workflow and unobstrusively running the code, both with the winning
+// of modularity -you can organize every piece of JS code in different files-
+// and clarity. You can either have your scripts run on every page load, or
+// only when a certain condition is met, which even will boost the performance
+// of your application on the client side by only running the necessary JS for
+// each situation.
+//
+// Initializers may provide the minimum necessary logic to get up and running
+// with a third-party JS library, preparing target elements for usage and/or
+// add complex logic to the page to initialize a super cool UX bloated with
+// in-house JS code.
+//
+// Usage:
+//   Add an initializer with the initialization logic:
+//
+//     // app/assets/javascripts/initializers/alert.js
+//     (function($) {
+//       Initializers.register('alert', function() {
+//         $('a').on('click', function() { alert('Hey there!'); });
+//       });
+//     }(jQuery))
+//
+//   Once the initializer is registered, it will be automatically run
+//   on every page load (or page:change event, if using Turbolinks),
+//   so go refresh that page and see those alerts pop up!
+//
+// Using conditions:
+//   An initializer with a condition guard will only get run when its guard
+//   evaluates to a truthy value:
+//
+//     // app/assets/javascripts/initializers/fridays.js
+//     (function() {
+//       function party() {
+//         alert('Today is friday! w00t!');
+//       }
+//
+//       function isFriday() {
+//         return (new Date()).getDay() === 5;
+//       }
+//
+//       Initializers.register('fridays', party, isFriday);
+//     }())
+//
+//   Once the initializer is registered, it will run only when its condition
+//   returns true.
+//
+// Running the initializers without jQuery:
+//   If the page where js-initializers is included has jQuery loaded, all
+//   registerd initializers will be automatically run on page load. But what
+//   about non-jQuery pages? Those pages only ned to have the following snippet
+//   after the page has been loaded:
+//
+//     Initializers.run()
+//
+//   And that's it! Pretty straight-forward, huh?
+window.Initializers = (function($, doc, undefined) {
+  var I = {}, initializers = {};
+
+  /**
+   * Default condition function: always returns true.
+   * By default any initializer will be run.
+   */
+  function defaultCondition() {
+    return true;
+  }
+
+  /**
+   * Error reporting helper.
+   */
+  function error(message) {
+    if (window.console && window.console.error) {
+      console.error(message);
+    }
+  }
+
+  /**
+   * Adds a new element to the list of registered initializers.
+   * Once an initializer is registered, it becomes instantly available to the
+   * `Initializers.run()` method.
+   *
+   * Trying to overwrite an existing initializer won't affect the state of the
+   * existing one, instead will yield an error on the console -if possible-.
+   *
+   *     // Register an initializer that alerts 'meow' on every page load
+   *     // only if the user is 'catlover492'
+   *     Initializer.register(
+   *       'meow',
+   *       function() { alert('meow'); },
+   *       function() { return window.user === 'catlover492' }
+   *     )
+   */
+  I.register = function(name, initializer, condition) {
+    if (initializers[name] !== undefined) {
+      error('Cowardly refusing to overwrite existing initializer: ' + name);
+    } else {
+      initializers[name] = { condition: condition || defaultCondition,
+                             logic: initializer };
+    }
+  };
+
+  /**
+   * Removes an initializer from the registered ones so it's no longer
+   * avaiable to the `Initializers.run()` function.
+   *
+   *     Initializers.unregister('alert')
+   */
+  I.unregister = function(name) {
+    if (initializers[name] === undefined) {
+      delete initializers[name];
+    } else {
+      error('Trying to unregister unknown initializer: ' + name);
+    }
+  };
+
+  /**
+   * Goes through all the registered initializers, checking the condition block
+   * provided for each of them and running the logic of every initializer whose
+   * condition block returns a truthy value.
+   *
+   * Returns an array with the names of the initializers that were run.
+   *
+   *     Initializers.run()
+   *     //=> ['alert', 'snowPage', 'marquee']
+   *
+   * This function may be called any number of times, but bear in mind that any
+   * non-idempotent initializer may result in an unexpected/undesired behavior.
+   * It's entirely up to the implementer of the initializer to provide with a
+   * safe logic
+   */
+  I.run = function() {
+    var run = [];
+    for (var name in initializers) {
+      if (initializers[name].condition.apply()) {
+        initializers[name].logic.apply(this);
+        run.push(name);
+      }
+    }
+    return run;
+  };
+
+  /**
+   * Returns all registered initializers at the moment of invocation,
+   * as known by the microframework:
+   *
+   *     Initializers.registered()
+   *     //=> {alert: {condition: function() {...}, logic: function() {...}}}
+   */
+  I.registered = function() {
+    return initializers;
+  };
+
+  // If jQuery is available, automatically run registed initializers
+  if ($ !== undefined) {
+    // Trigger initializers on page load (either with Turbolinks or without 'em)
+    if (window.Turbolinks === undefined) {
+      $($.runInitializers);
+    } else {
+      $(doc).on('page:change', $.runInitializers);
+    }
+  }
+
+  return I;
+}(jQuery, document));

data/js-initializers.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'js-initializers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'js-initializers'
+  spec.version       = JsInitializers::VERSION
+  spec.authors       = ['Nahuel Cuesta Luengo']
+  spec.email         = ['nahuelcuestaluengo@gmail.com']
+  spec.summary       = %q{Avoid JS mayhem on your Rails app! js-initializers is an engine that adds a micro-framework for initializing and organizing client-side logic in a modular way}
+  spec.description   = %q{Avoid JS mayhem on your Rails app! js-initializers is an engine that adds a micro-framework for initializing and organizing client-side logic in a modular way}
+ 
+  spec.homepage      = 'https://github.com/ncuesta/js-initializers'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_dependency 'rails', '> 3.1'
+end

data/lib/js-initializers.rb

@@ -0,0 +1,5 @@
+require 'js-initializers/version'
+require 'js-initializers/engine'
+
+module JsInitializers
+end

data/lib/js-initializers/engine.rb

@@ -0,0 +1,6 @@
+require 'rails'
+
+module JsInitializers
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/js-initializers/version.rb

@@ -0,0 +1,3 @@
+module JsInitializers
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: js-initializers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nahuel Cuesta Luengo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Avoid JS mayhem on your Rails app! js-initializers is an engine that
+  adds a micro-framework for initializing and organizing client-side logic in a modular
+  way
+email:
+- nahuelcuestaluengo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/js-initializers/index.js
+- app/assets/javascripts/js-initializers/initializers.js
+- js-initializers.gemspec
+- lib/js-initializers.rb
+- lib/js-initializers/engine.rb
+- lib/js-initializers/version.rb
+homepage: https://github.com/ncuesta/js-initializers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Avoid JS mayhem on your Rails app! js-initializers is an engine that adds
+  a micro-framework for initializing and organizing client-side logic in a modular
+  way
+test_files: []