appetizer-ui 0.9.0 → 0.9.1

data/appetizer-ui.gemspec

@@ -10,20 +10,22 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- test/*`.split("\n")
   gem.name          = "appetizer-ui"
   gem.require_paths = ["lib"]
-  gem.version       = "0.9.0"
+  gem.version       = "0.9.1"
 
   gem.required_ruby_version = ">= 1.9.2"
 
-  gem.add_dependency "appetizer",      "~> 0.0"
-  gem.add_dependency "coffee-script",  "~> 2.2"
-  gem.add_dependency "eco",            "~> 1.0"
-  gem.add_dependency "rack-contrib",   "~> 1.1"
-  gem.add_dependency "rack-ssl",       "~> 1.3"
-  gem.add_dependency "sass",           "~> 3.1"
-  gem.add_dependency "sinatra",        "~> 1.3"
-  gem.add_dependency "sprockets",      "~> 2.1"
-  gem.add_dependency "sprockets-sass", "~> 0.6"
-  gem.add_dependency "uglifier",       "~> 1.0"
-  gem.add_dependency "yajl-ruby",      "~> 1.0"
-  gem.add_dependency "yui-compressor", "~> 0.9"
+  gem.add_dependency "appetizer",         "~> 0.0"
+  gem.add_dependency "coffee-script",     "~> 2.2"
+  gem.add_dependency "eco",               "~> 1.0"
+  gem.add_dependency "rack-contrib",      "~> 1.1"
+  gem.add_dependency "rack-ssl",          "~> 1.3"
+  gem.add_dependency "sass",              "~> 3.1"
+  gem.add_dependency "sinatra",           "~> 1.3"
+  gem.add_dependency "sprockets",         "~> 2.11"
+  gem.add_dependency "sprockets-sass",    "~> 1.0"
+  gem.add_dependency "sprockets-helpers", "~> 1.1"
+  gem.add_dependency "uglifier",          "~> 1.0"
+  gem.add_dependency "vendorer",          "~> 0.1"
+  gem.add_dependency "yajl-ruby",         "~> 1.0"
+  gem.add_dependency "yui-compressor",    "~> 0.9"
 end

data/lib/appetizer/ui/assets.rb

@@ -1,10 +1,8 @@
 require "coffee-script"
 require "eco"
 require "fileutils"
-require "sass"
 require "sinatra/base"
-require "sprockets"
-require "sprockets/sass"
+require "sprockets-helpers"
 require "uglifier"
 require "yui/compressor"
 
@@ -12,8 +10,10 @@ module App
   def self.assets
     @sprockets ||= Sprockets::Environment.new.tap do |s|
       if Appetizer::UI::Assets.compiled?
-        s.register_bundle_processor "application/javascript", :uglifier do |ctx, data|
-          Uglifier.compile data
+        if Appetizer::UI::Assets.uglify?
+          s.register_bundle_processor "application/javascript", :uglifier do |ctx, data|
+            Uglifier.compile data, mangle: false, squeeze: false, seqs: false
+          end
         end
 
         s.register_bundle_processor "text/css", :yui do |ctx, data|
@@ -21,6 +21,12 @@ module App
         end
       end
 
+      Sprockets::Helpers.configure do |config|
+        config.environment = s
+        config.prefix      = "/assets"
+        config.digest      = true
+      end
+
       # NOTE: Seems like Sprockets' built-in FileStore is kinda busted
       # in the way it creates directories or processes key names (or I
       # don't understand it yet), so we're manually creating the
@@ -31,11 +37,9 @@ module App
         s.cache = Sprockets::Cache::FileStore.new "tmp/sprockets"
       end
 
-      %w(css img js views).each do |d|
+      %w(css img js views fonts).each do |d|
         s.append_path "./app/#{d}"
         s.append_path "./vendor/#{d}"
-        s.append_path File.expand_path("../app/#{d}", __FILE__)
-        s.append_path File.expand_path("../vendor/#{d}", __FILE__)
       end
     end
   end
@@ -48,6 +52,10 @@ module Appetizer
         App.production? or ENV["APPETIZER_USE_COMPILED_ASSETS"]
       end
 
+      def self.uglify?
+        compiled? and not ENV["APPETIZER_NO_UGLIFY"]
+      end
+
       def self.manifest
         return @manifest if defined? @manifest
 
@@ -63,6 +71,11 @@ module Appetizer
 
       def self.registered app
         app.helpers do
+          def asset_apps
+            apps = Dir.glob(Dir.pwd + "/app/js/*")
+            apps.collect { |path| File.basename(path) if File.directory?(path) }.compact
+          end
+
           def asset name
             if Appetizer::UI::Assets.compiled?
               return cdnify "/assets/#{Appetizer::UI::Assets.manifest[name]}"

data/lib/appetizer/ui/jasmine/js/jquery-jasmine.js

@@ -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();
+});

data/lib/appetizer/ui/jasmine/js/spec-runner.coffee

@@ -1,7 +1,6 @@
 #= require ./jasmine
 #= require ./jasmine-html
 #= require ./jasmine-jquery-matchers
-#= require_tree ./backbone.modelbinding
 
 jasmineEnv = jasmine.getEnv()
 jasmineEnv.updateInterval = 1000

data/lib/appetizer/ui/jasmine/views/specs.erb

@@ -4,14 +4,22 @@
   <head>
     <title>Specs</title>
 
-    <script>App = {}</script>
+    <script>
+      App = {}
+    </script>
 
     <% assets("jasmine.css").each do |css| %>
-    <link href="<%= css %>" rel="stylesheet" type="text/css">
+      <link href="<%= css %>" rel="stylesheet" type="text/css">
     <% end %>
 
-    <% assets("app.js", "spec-runner.js", "spec-helper.js").each do |js| %>
-    <script src="<%= js %>"></script>
+    <% assets("spec-runner.js", "jasmine-jquery.js", "jasmine-mocks.js").each do |js| %>
+      <script src="<%= js %>"></script>
+    <% end %>
+
+    <% asset_apps.each do |app| %>
+      <% assets("#{app}/app.js", "#{app}/spec-helper.js", "#{app}/fixtures.js").each do |js| %>
+        <script src="<%= js %>"></script>
+      <% end %>
     <% end %>
   </head>
 

data/lib/appetizer/ui/rake.rb

@@ -1,29 +1,38 @@
 require "appetizer/rake"
+require "appetizer/ui/assets"
+require "vendorer"
 
 # For Heroku.
 
+desc "Download vendored assets"
+task :vendorer => :init do
+  Vendorer.new(update: true).parse File.read('Vendorfile')
+end
+
 task "assets:precompile" => :compile
 
 desc "Compile the app's CSS and JS files."
 task :compile => :init do
   ENV["APPETIZER_MINIFY_ASSETS"] = "true"
 
-  require "appetizer/ui/assets"
   require "fileutils"
   require "yaml"
 
-  manifest = {}
+  entry_points = ENV["APPETIZER_ASSETS_ENTRY_POINTS"] || "app.scss, app.coffee"
 
-  App.assets.each_file do |path|
-    next if File.basename(path).start_with? "_"
-    next if %r|app/views| =~ path.to_s and not %r|app/views/client| =~ path.to_s
+  assets = App.assets.each_file
+
+  manifest = {}
 
-    if asset = App.assets[path]
-      manifest[asset.logical_path] = asset.digest_path
-      file = "public/assets/#{asset.digest_path}"
+  assets.each do |path|
+    if entry_points.include? File.basename(path)
+      if asset = App.assets[path]
+        manifest[asset.logical_path] = asset.digest_path
+        file = "public/assets/#{asset.digest_path}"
 
-      FileUtils.mkdir_p File.dirname file
-      asset.write_to file
+        FileUtils.mkdir_p File.dirname file
+        asset.write_to file
+      end
     end
   end
 
@@ -31,3 +40,13 @@ task :compile => :init do
     YAML.dump manifest, f
   end
 end
+
+if Gem::Specification.find { |spec| spec.name == "jasmine-headless-webkit" }
+  require "jasmine-headless-webkit"
+
+  Jasmine::Headless::Task.new("test") do |t|
+    t.colors = true
+    t.keep_on_error = true
+    t.jasmine_config = ENV["JASMINE_HEADLESS_CONFIG"] || "config/jasmine.yml"
+  end
+end