RubyGems - page_specific_js - Versions diffs - 0.0.2 - Mend

page_specific_js 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

data/.gitignore +4 -0
data/.rvmrc +1 -0
data/Gemfile +4 -0
data/README.md +85 -0
data/Rakefile +10 -0
data/lib/page_specific_js.rb +8 -0
data/lib/page_specific_js/helper.rb +5 -0
data/lib/page_specific_js/version.rb +3 -0
data/page_specific_js.gemspec +31 -0
data/spec/javascripts/fixtures/.gitkeep +0 -0
data/spec/javascripts/helpers/jasmine-jquery-1.3.1.js +288 -0
data/spec/javascripts/helpers/jquery.js +9266 -0
data/spec/javascripts/page_specific_spec.js +160 -0
data/spec/javascripts/support/jasmine.yml +76 -0
data/spec/javascripts/support/jasmine_config.rb +23 -0
data/spec/javascripts/support/jasmine_runner.rb +32 -0
data/vendor/assets/javascripts/page_specific.js +72 -0
metadata +94 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,4 @@
+.bundle
+Gemfile.lock
+/pkg/*
+/.idea

data/.rvmrc ADDED Viewed

	@@ -0,0 +1 @@
1	+ rvm use --create 1.9.2@page_specific_js

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in page_specific_js.gemspec
+gemspec

data/README.md ADDED Viewed

@@ -0,0 +1,85 @@
+Page Specific JavaScript Framework
+==================================
+This is a page-specific JavaScript framework (primarily for Rails).
+It allows you to target JS to run on all pages, for a specific action on all pages (e.g. index),
+for all actions for a specific controller, or for one page (specific controller/action).
+Dependencies
+------------
+* Rails 3.1+
+* JQuery
+Installation
+------------
+1.  Require the gem. Add the following to your Gemfile, then run 'bundle install':
+        gem 'page_specific_js'
+2.  Cause the page-specific JS framework to be loaded.  For Rails 3.1: in your
+    app/assets/javascripts/application.css.scss:
+        //= require page_specific
+3.  Create a JS namespace for your page-specific code, and call PageSpecific.init() on page load.
+    This system assumes you follow the best-practise of namespacing all of your application JavaScript.
+    For example let's assume you are namespacing all your JS under class "MyApplication".
+    Put this in an appropriate spot in your JavaScript:
+        MyApplication.PageSpecific = {};
+        $(document).ready(function() {
+          PageSpecific.init(MyApplication);
+        });
+4.  Set data-controller_name and data-action_name attributes on your document body, e.g. if you are using ERB,
+    in application.html.erb:
+        <body data-controller_name="<%= underscored_controller_name %>",
+              data-action_name="<%= action_name %>">
+    or if you are using HAML, in application.html.haml:
+        %body{ :'data-controller_name' => underscored_controller_name, :'data-action_name' => action_name }
+Usage
+-----
+Write controller or page specific JavaScript as follows:
+    MyApplication.PageSpecific['AllControllers'] = {
+      allActions: function() {
+        // JS to be executed on every page
+      },
+      indexAction: function() {
+        // code to be executed on all index pages
+      }
+    };
+    MyApplication.PageSpecific['FooController'] = {
+      allActions: function() {
+        // code to be executed on all pages of FooController
+      },
+      barAction: function() {
+        // code to be executed on FooController#bar page
+      }
+    }
+Notes
+-----
+*   This is not an original teqhnique.  I learned it from others while developing at Pivotal Labs and have
+    implemented it several times over the years.  This just my cleaned up and organized version.
+*   All you JavaScript is still going to get loaded on every page; this only impacts what is executed.
+    In practice this is not an issue as your javascript should be aggregated, minified, compressed and cached.
+License
+-------
+MIT.  See LICENSE.txt

data/Rakefile ADDED Viewed

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+begin
+  require 'jasmine'
+  load 'jasmine/tasks/jasmine.rake'
+rescue LoadError
+  task :jasmine do
+    abort "Jasmine is not available. In order to run jasmine, you must: (sudo) gem install jasmine"
+  end
+end

data/lib/page_specific_js.rb ADDED Viewed

@@ -0,0 +1,8 @@
+require "page_specific_js/version"
+require "page_specific_js/helper"
+module PageSpecificJs
+  class Engine < ::Rails::Engine
+    # This causes Rails to search for assets in our vendor/assets folder
+  end
+end

data/lib/page_specific_js/helper.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module ::ApplicationHelper
+ def underscored_controller_name
+    controller.class.name.underscore.gsub('/', '_')
+  end
+end

data/lib/page_specific_js/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module PageSpecificJs
+  VERSION = "0.0.2"
+end

data/page_specific_js.gemspec ADDED Viewed

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "page_specific_js/version"
+Gem::Specification.new do |s|
+  s.name        = "page_specific_js"
+  s.version     = PageSpecificJs::VERSION
+  s.authors     = ["Sam Pierson"]
+  s.email       = ["sam@sampierson.com"]
+  s.homepage    = ""
+  s.summary     = %q{ Page-specific JavaScript framework for Rails }
+  s.description = %q{ It allows you to target JS to run on all pages,
+                      for a particular action on all pages (e.g. index),
+                      for all actions for a specific controller,
+                      or for one specific controller/action (i.e. a single page).
+                    }
+  s.rubyforge_project = "page_specific_js"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "jasmine"
+  # jQuery is a dependency, but I'm leaving this commented for those folks not using jquery-rails.
+  # s.add_runtime_dependency "jquery-rails"
+end

data/spec/javascripts/fixtures/.gitkeep ADDED Viewed

File without changes

data/spec/javascripts/helpers/jasmine-jquery-1.3.1.js ADDED Viewed

@@ -0,0 +1,288 @@
+var readFixtures = function() {
+  return jasmine.getFixtures().proxyCallTo_('read', arguments);
+};
+var preloadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('preload', arguments);
+};
+var loadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('load', arguments);
+};
+var setFixtures = function(html) {
+  jasmine.getFixtures().set(html);
+};
+var sandbox = function(attributes) {
+  return jasmine.getFixtures().sandbox(attributes);
+};
+var spyOnEvent = function(selector, eventName) {
+  jasmine.JQuery.events.spyOn(selector, eventName);
+}
+jasmine.getFixtures = function() {
+  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
+};
+jasmine.Fixtures = function() {
+  this.containerId = 'jasmine-fixtures';
+  this.fixturesCache_ = {};
+  this.fixturesPath = 'spec/javascripts/fixtures';
+};
+jasmine.Fixtures.prototype.set = function(html) {
+  this.cleanUp();
+  this.createContainer_(html);
+};
+jasmine.Fixtures.prototype.preload = function() {
+  this.read.apply(this, arguments);
+};
+jasmine.Fixtures.prototype.load = function() {
+  this.cleanUp();
+  this.createContainer_(this.read.apply(this, arguments));
+};
+jasmine.Fixtures.prototype.read = function() {
+  var htmlChunks = [];
+  var fixtureUrls = arguments;
+  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
+    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
+  }
+  return htmlChunks.join('');
+};
+jasmine.Fixtures.prototype.clearCache = function() {
+  this.fixturesCache_ = {};
+};
+jasmine.Fixtures.prototype.cleanUp = function() {
+  jQuery('#' + this.containerId).remove();
+};
+jasmine.Fixtures.prototype.sandbox = function(attributes) {
+  var attributesToSet = attributes || {};
+  return jQuery('<div id="sandbox" />').attr(attributesToSet);
+};
+jasmine.Fixtures.prototype.createContainer_ = function(html) {
+  var container;
+  if(html instanceof jQuery) {
+    container = jQuery('<div id="' + this.containerId + '" />');
+    container.html(html);
+  } else {
+    container = '<div id="' + this.containerId + '">' + html + '</div>'
+  }
+  jQuery('body').append(container);
+};
+jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {
+  if (typeof this.fixturesCache_[url] == 'undefined') {
+    this.loadFixtureIntoCache_(url);
+  }
+  return this.fixturesCache_[url];
+};
+jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
+  var self = this;
+  var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
+  jQuery.ajax({
+    async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
+    cache: false,
+    dataType: 'html',
+    url: url,
+    success: function(data) {
+      self.fixturesCache_[relativeUrl] = data;
+    },
+    error: function(jqXHR, status, errorThrown) {
+        throw Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')');
+    }
+  });
+};
+jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
+  return this[methodName].apply(this, passedArguments);
+};
+jasmine.JQuery = function() {};
+jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
+  return jQuery('<div/>').append(html).html();
+};
+jasmine.JQuery.elementToString = function(element) {
+  return jQuery('<div />').append(element.clone()).html();
+};
+jasmine.JQuery.matchersClass = {};
+(function(namespace) {
+  var data = {
+    spiedEvents: {},
+    handlers:    []
+  };
+  namespace.events = {
+    spyOn: function(selector, eventName) {
+      var handler = function(e) {
+        data.spiedEvents[[selector, eventName]] = e;
+      };
+      jQuery(selector).bind(eventName, handler);
+      data.handlers.push(handler);
+    },
+    wasTriggered: function(selector, eventName) {
+      return !!(data.spiedEvents[[selector, eventName]]);
+    },
+    cleanUp: function() {
+      data.spiedEvents = {};
+      data.handlers    = [];
+    }
+  }
+})(jasmine.JQuery);
+(function(){
+  var jQueryMatchers = {
+    toHaveClass: function(className) {
+      return this.actual.hasClass(className);
+    },
+    toBeVisible: function() {
+      return this.actual.is(':visible');
+    },
+    toBeHidden: function() {
+      return this.actual.is(':hidden');
+    },
+    toBeSelected: function() {
+      return this.actual.is(':selected');
+    },
+    toBeChecked: function() {
+      return this.actual.is(':checked');
+    },
+    toBeEmpty: function() {
+      return this.actual.is(':empty');
+    },
+    toExist: function() {
+      return this.actual.size() > 0;
+    },
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+    toHaveText: function(text) {
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(this.actual.text());
+      } else {
+        return this.actual.text() == text;
+      }
+    },
+    toHaveValue: function(value) {
+      return this.actual.val() == value;
+    },
+    toHaveData: function(key, expectedValue) {
+      return hasProperty(this.actual.data(key), expectedValue);
+    },
+    toBe: function(selector) {
+      return this.actual.is(selector);
+    },
+    toContain: function(selector) {
+      return this.actual.find(selector).size() > 0;
+    },
+    toBeDisabled: function(selector){
+      return this.actual.is(':disabled');
+    },
+    // tests the existence of a specific event binding
+    toHandle: function(eventName) {
+      var events = this.actual.data("events");
+      return events && events[eventName].length > 0;
+    },
+    // tests the existence of a specific event binding + handler
+    toHandleWith: function(eventName, eventHandler) {
+      var stack = this.actual.data("events")[eventName];
+      var i;
+      for (i = 0; i < stack.length; i++) {
+        if (stack[i].handler == eventHandler) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+  var hasProperty = function(actualValue, expectedValue) {
+    if (expectedValue === undefined) {
+      return actualValue !== undefined;
+    }
+    return actualValue == expectedValue;
+  };
+  var bindMatcher = function(methodName) {
+    var builtInMatcher = jasmine.Matchers.prototype[methodName];
+    jasmine.JQuery.matchersClass[methodName] = function() {
+      if (this.actual instanceof jQuery) {
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        this.actual = jasmine.JQuery.elementToString(this.actual);
+        return result;
+      }
+      if (builtInMatcher) {
+        return builtInMatcher.apply(this, arguments);
+      }
+      return false;
+    };
+  };
+  for(var methodName in jQueryMatchers) {
+    bindMatcher(methodName);
+  }
+})();
+beforeEach(function() {
+  this.addMatchers(jasmine.JQuery.matchersClass);
+  this.addMatchers({
+    toHaveBeenTriggeredOn: function(selector) {
+      this.message = function() {
+        return [
+          "Expected event " + this.actual + " to have been triggered on" + selector,
+          "Expected event " + this.actual + " not to have been triggered on" + selector
+        ];
+      };
+      return jasmine.JQuery.events.wasTriggered(selector, this.actual);
+    }
+  })
+});
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+  jasmine.JQuery.events.cleanUp();
+});