jasmine-fixtures-generator 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Luis Porras, Guillermo Iguaran
+
+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,36 @@
+# Jasmine Fixtures Generator [![Build Status](http://travis-ci.org/lporras/jasmine-fixtures-generator.png)](http://travis-ci.org/lporras/jasmine-fixtures-generator)
+Fixtures Generator for Jasmine under Rails 3.x (largelly based in [jasmine-fixtures](https://github.com/mavenlink/jasmine-fixtures) for Rails 2.x)
+
+
+## Installation
+
+Install the gem:
+
+    gem install jasmine-fixtures-generator
+
+Add it to your Gemfile:
+
+    gem "jasmine-fixtures-generator", :group => :development
+
+
+## Usage
+
+Run the generator:
+
+    rails generate jasmine_fixtures
+
+## Contributing to Jasmine Fixtures Generator
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+
+## Copyright
+
+Copyright (c) 2011 Luis Porras, Guillermo Iguaran. See MIT-LICENSE for
+further details.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/jasmine-fixtures-generator.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jasmine-fixtures-generator"
+
+Gem::Specification.new do |s|
+  s.name        = "jasmine-fixtures-generator"
+  s.version     = Jasmine::Fixtures::Generator::VERSION
+  s.authors     = ["Luis Porras", "Guillermo Iguaran"]
+  s.email       = ["lporras16@gmail.com", "guilleiguaran@gmail.com"]
+  s.homepage    = "https://github.com/lporras/jasmine-fixtures-generator"
+  s.summary     = %q{Fixtures Generator for Jasmine under Rails 3.x}
+  s.description = %q{Fixtures Generator for Jasmine BDD framework under Rails 3.x}
+
+  s.rubyforge_project = "jasmine-fixtures-generator"
+
+  s.add_runtime_dependency "jasmine", ">= 1.0.0"
+  s.add_runtime_dependency "railties", ">= 3.0.0"
+  s.add_runtime_dependency "nokogiri", ">= 1.4.0"
+
+  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"]
+end

data/lib/generators/jasmine-fixtures.rb

@@ -0,0 +1,27 @@
+require "rails/generators/base"
+
+class JasmineFixturesGenerator < ::Rails::Generators::Base
+
+  desc "This generator install jasmine-jquery and add fixture_helper_methods.rb"
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_jasmine_jquery
+    say_status("copying", "jasmine-jquery", :green)
+    copy_file "../../../vendor/jasmine-jquery.js", "spec/javascripts/helpers/jasmine-jquery.js"
+  end
+
+  def copy_fixture_helper_methods
+    say_status("copying", "fixture_helper_methods.rb", :green)
+    copy_file "spec/support/fixture_helper_methods.rb", "spec/support/fixture_helper_methods.rb"
+  end
+
+  def copy_jasmine_fixture_creators_spec
+    say_status("copying", "jasmine_fixture_creators_spec.rb", :green)
+    copy_file "spec/controllers/jasmine_fixture_creators_spec.rb", "spec/controllers/jasmine_fixture_creators_spec.rb"
+  end
+
+  def copy_jasmine_spec_example
+    say_status("copying", "jasmine spec example", :green)
+    copy_file "spec/javascripts/example_users_spec.js", "spec/javascripts/example_users_spec.js"
+  end
+end

data/lib/generators/templates/spec/controllers/jasmine_fixture_creators_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+=begin
+
+  You can use this file to define new Jasmine Fixtures
+  or
+  You can add jasmine fixtures spec on your controllers spec
+
+  We have provided an example for you to crib off.
+
+  Basically:
+  1) Visit a route with your controller action
+  2) Make sure response.body has the content you want become fixture
+  3) save_fixture with the response you want and give a name to your fixture
+
+
+Using save_fixture method
+-------------------------
+
+html_for('body') =>  will take only the content of <body> tag and will rename <body> to <div>
+                     to avoid nested <body> tags within the Jasmine runner
+
+If you have custom responses (ajax partials, JSON, etc),
+you can subvert this and use response.body or whatever is appropriate.
+
+=end
+
+####Examples
+
+describe UsersController do
+  #You need to render_views in each of your describes to get the content of the response
+  render_views
+
+  describe "user signup" do
+    #Example of a standard request that would use html_for to strip <body>
+    it "generates a new user signup page" do
+      get :new
+      response.should be_success
+      save_fixture(html_for('body'), 'user-signup-page')
+    end
+
+    #Example of an ajax request that doesn't have a body tag to strip out
+    describe "a user's profile" do
+      it "generates successful signup xhr response" do
+        xhr :post, :create, :user => { :name => 'Bob', :password => 'something', :password_confirmation => 'something' }
+        response.should be_success
+        save_fixture(response.body, 'user-success-ajax-response')
+      end
+    end
+  end
+end

data/lib/generators/templates/spec/javascripts/example_users_spec.js

@@ -0,0 +1,21 @@
+// Here is an example of how you might use the fixtures in your jasmine tests.
+// Obviously this test won't actually work in your project.
+describe('User pages', function () {
+  describe('the signup page', function() {
+    it('looks correct', function() {
+      loadFixtures('user-signup-page.html');
+      expect(jQuery("#some_id")).toExist();
+    });
+  });
+
+  describe('user signup success page load over ajax', function() {
+     it('inserts the returned content into the page', function() {
+        loadFixtures('user-signup-page');
+        var fixtureData = readFixtures('user-success-ajax-response.html');
+        doSomethingInvolvingAnAjaxCallThatReceivesHTML();
+        jQuery.ajax.mostRecentCall.args[0].success(fixtureData);
+        expect(jQuery("#some_id_in_the_ajax_response")).toExist();
+        expect(somethingExcitingToHaveHappened()).toBeTruthy();
+     });
+  });
+});

data/lib/generators/templates/spec/support/fixture_helper_methods.rb

@@ -0,0 +1,50 @@
+module FixtureHelperMethods
+  # Saves the content to a fixture file using the given name
+  def save_fixture(content, name)
+    fixture_path = File.join(Rails.root, '/spec/javascripts/fixtures')
+    FileUtils.mkdir_p(fixture_path) unless File.exists?(fixture_path)
+
+    content = convert_body_tag_to_div(content)
+
+    fixture_file = File.join(fixture_path, "#{name}")
+
+    File.open(fixture_file, 'w') do |file|
+      file.puts(content)
+    end
+  end
+
+  # From the controller spec response body, extracts html identified
+  # by the css selector.
+  def html_for(selector)
+    doc = Nokogiri::HTML(response.body)
+
+    remove_third_party_scripts(doc)
+    content = doc.css(selector).first.to_s
+
+    convert_body_tag_to_div(content)
+  end
+
+  private
+
+  # Recommended that you add all body-level third party scripts inside a div called #third-party-scripts
+  # so that they can be removed during testing.
+  def remove_third_party_scripts(doc)
+    scripts = doc.at('#third-party-scripts')
+    scripts.remove if scripts
+  end
+
+  # Many of our css and jQuery selectors rely on a class attribute we
+  # normally embed in the <body>. For example:
+  #
+  # <body class="workspaces show">
+  #
+  # Here we convert the body tag to a div so that we can load it into
+  # the document running js specs without embedding a <body> within a <body>.
+  def convert_body_tag_to_div(markup)
+    markup.gsub("<body", '<div').gsub("</body>", "</div>")
+  end
+end
+
+# Add fixture-generation methods to ControllerExampleGroup. We load
+# this file within our spec_helper.rb
+RSpec::Rails::ControllerExampleGroup.extend(FixtureHelperMethods) if defined?(RSpec)

data/lib/jasmine-fixtures-generator.rb

@@ -0,0 +1,7 @@
+module Jasmine
+  module Fixtures
+    module Generator
+      VERSION = "0.0.1"
+    end
+  end
+end

data/test/fixture_helper_methods_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+require 'generators/templates/spec/support/fixture_helper_methods'
+
+class FixtureHelperMethodsTest < ActiveSupport::TestCase
+  include FixtureHelperMethods
+
+  test "#save_fixture creates an html file with the given name" do
+    save_fixture("<p>prueba</p>", "test_file.html")
+    fixture_path = File.join(Rails.root, '/spec/javascripts/fixtures')
+    fixture_file = File.join(fixture_path, "test_file.html")
+    assert_equal true, File.exists?(fixture_file)
+  end
+end

data/test/jasmine-fixture-generator_test.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+require "generators/jasmine-fixtures"
+
+class JasmineFixturesGeneratorTest < Rails::Generators::TestCase
+  tests JasmineFixturesGenerator
+  destination File.expand_path("../tmp", File.dirname(__FILE__))
+  setup :prepare_destination
+
+  test "Assert all files are properly created" do
+    run_generator
+    assert_file "spec/support/fixture_helper_methods.rb"
+    assert_file "spec/javascripts/helpers/jasmine-jquery.js"
+    assert_file "spec/controllers/jasmine_fixture_creators_spec.rb"
+    assert_file "spec/javascripts/example_users_spec.js"
+  end
+end

data/test/support/rails_stub.rb

@@ -0,0 +1,5 @@
+module Rails
+  def self.root
+    File.expand_path("../../tmp", File.dirname(__FILE__))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'rails'
+require "rails/test_help"
+
+# For generators
+require 'rails/generators/test_case'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/vendor/jasmine-jquery.js

@@ -0,0 +1,283 @@
+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 = jQuery('<div id="' + this.containerId + '" />');
+  container.html(html);
+  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();
+});

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: jasmine-fixtures-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Luis Porras
+- Guillermo Iguaran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-31 00:00:00.000000000 -05:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jasmine
+  requirement: &2157521960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157521960
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: &2157521460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157521460
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2157521000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157521000
+description: Fixtures Generator for Jasmine BDD framework under Rails 3.x
+email:
+- lporras16@gmail.com
+- guilleiguaran@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- jasmine-fixtures-generator.gemspec
+- lib/generators/jasmine-fixtures.rb
+- lib/generators/templates/spec/controllers/jasmine_fixture_creators_spec.rb
+- lib/generators/templates/spec/javascripts/example_users_spec.js
+- lib/generators/templates/spec/support/fixture_helper_methods.rb
+- lib/jasmine-fixtures-generator.rb
+- test/fixture_helper_methods_test.rb
+- test/jasmine-fixture-generator_test.rb
+- test/support/rails_stub.rb
+- test/test_helper.rb
+- vendor/jasmine-jquery.js
+has_rdoc: true
+homepage: https://github.com/lporras/jasmine-fixtures-generator
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: jasmine-fixtures-generator
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Fixtures Generator for Jasmine under Rails 3.x
+test_files:
+- test/fixture_helper_methods_test.rb
+- test/jasmine-fixture-generator_test.rb
+- test/support/rails_stub.rb
+- test/test_helper.rb