magic_carpet 0.5.0

data/app/helpers/magic_carpet/application_helper.rb

@@ -0,0 +1,4 @@
+module MagicCarpet
+  module ApplicationHelper
+  end
+end

data/app/helpers/magic_carpet/js_fixtures_helper.rb

@@ -0,0 +1,139 @@
+module MagicCarpet
+  module JsFixturesHelper
+    attr_accessor :models
+    NIL = "nil"
+
+    def hydrate(value)
+      if array?(value)
+        hydrate_array(value)
+      elsif date?(value)
+        hydrate_date(value)
+      elsif time?(value)
+        hydrate_time(value)
+      elsif datetime?(value)
+        hydrate_datetime(value)
+      elsif model?(value)
+        hydrate_model(value)
+      elsif number?(value)
+        hydrate_number(value)
+      elsif array_as_hash?(value)
+        hydrate_array(value.values)
+      elsif hash?(value)
+        hydrate_hash(value)
+      elsif is_nil?(value)
+        nil
+      elsif true?(value)
+        true
+      elsif false?(value)
+        false
+      else
+        value
+      end
+    end
+
+    private
+
+    def hydrate_hash(hash)
+      hash.each do |key, value|
+        hash[key] = hydrate(value)
+      end
+    end
+
+    def hydrate_array(array)
+      array.map do |element|
+        hydrate(element)
+      end
+    end
+
+    def hydrate_number(hash)
+      number = hash[:number]
+      hash[:integer] ? number.to_i : number.to_f
+    end
+
+    def hydrate_date(hash)
+      Date.parse(hash[:date])
+    end
+
+    def hydrate_time(hash)
+      time = Time.parse(hash[:time])
+      time = time.utc if hash.key?(:utc)
+      time
+    end
+
+    def hydrate_datetime(hash)
+      DateTime.parse(hash[:datetime])
+    end
+
+    def hydrate_model(hash)
+      hydrate_hash(hash)
+
+      model_name = hash.delete(:model)
+      model = get_model(model_name)
+      model.new(hash)
+    end
+
+    def get_model(model_name)
+      self.models ||= {}
+      self.models[model_name] ||= self.class.const_get(model_name)
+    end
+
+    def hash?(value)
+      value.is_a?(Hash)
+    end
+
+    def array?(value)
+      value.is_a?(Array)
+    end
+
+    def array_as_hash?(value)
+      if hash?(value) && value.present?
+        keys = value.keys.sort
+        keys.each_with_index.all? do |key, i|
+          key.to_s == i.to_s
+        end
+      else
+        false
+      end
+    end
+
+    def model?(value)
+      hash_with_key?(value, :model)
+    end
+
+    def number?(value)
+      hash_with_key?(value, :number)
+    end
+
+    def date?(value)
+      hash_with_key?(value, :date)
+    end
+
+    def time?(value)
+      hash_with_key?(value, :time)
+    end
+
+    def datetime?(value)
+      hash_with_key?(value, :datetime)
+    end
+
+    def hash_with_key?(value, key)
+      hash?(value) && value.key?(key)
+    end
+
+    def is_nil?(value)
+      same_string?(value, NIL)
+    end
+
+    def true?(value)
+      same_string?(value, true)
+    end
+
+    def false?(value)
+      same_string?(value, false)
+    end
+
+    def same_string?(value, string)
+      value.is_a?(String) && value == string.to_s
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+MagicCarpet::Engine.routes.draw do
+  root to: "js_fixtures#index"
+end

data/lib/magic_carpet/engine.rb

@@ -0,0 +1,12 @@
+module MagicCarpet
+  class Engine < ::Rails::Engine
+    isolate_namespace MagicCarpet
+
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/magic_carpet/version.rb

@@ -0,0 +1,3 @@
+module MagicCarpet
+  VERSION = "0.5.0"
+end

data/lib/magic_carpet.rb

@@ -0,0 +1,4 @@
+require "magic_carpet/engine"
+
+module MagicCarpet
+end

data/lib/tasks/magic_carpet_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :magic_carpet do
+#   # Task goes here
+# end

data/spec/controllers/magic_carpet/js_fixtures_controller_spec.rb

@@ -0,0 +1,275 @@
+require "spec_helper"
+
+module MagicCarpet
+  describe JsFixturesController do
+
+    let(:body) { response.body }
+
+    it "renders a template based on the template param" do
+      get :index, controller_name: "Wishes", template: "plain", use_route: :magic_carpet
+      expect(body).to match("<h1>Plain</h1>\n")
+    end
+
+    it "renders based on controller and action names if there's no template param" do
+      get :index, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+      expect(body).to match("<h1>Plain</h1>\n")
+    end
+
+    describe "fetching a view without variables" do
+      it "returns the view's markup" do
+        get :index, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+        expect(body).to match("<h1>Plain</h1>\n")
+      end
+    end
+
+    describe "rendering a partial" do
+      it "is done by passing the partial's path in the partial option" do
+        hash = {
+          wish: { model: "Wish" }
+        }
+        get :index, partial: "form", controller_name: "Wishes", use_route: :magic_carpet, instance_variables: hash
+        expect(body).to match("<form")
+        expect(body).to match("Create Wish")
+      end
+
+      it "passes collection through when passed" do
+        collection = [
+          { model: "Wish", text: "wish text 1", id: 1 },
+          { model: "Wish", text: "wish text 2", id: 2 },
+          { model: "Wish", text: "wish text 3", id: 3 }
+        ]
+        get :index, partial: "wish", collection: collection, controller_name: "Wishes", use_route: :magic_carpet
+        expect(body).to match("wish text 1")
+        expect(body).to match("wish text 2")
+        expect(body).to match("wish text 3")
+      end
+
+      it "accepts the 'as' option" do
+        collection = [
+          { model: "OpenStruct", id: 1 },
+          { model: "User", id: 2 },
+          { model: "Wish", id: 3 }
+        ]
+        get :index, partial: "shared/id_able", collection: collection, as: "id_able", controller_name: "Wishes", use_route: :magic_carpet
+        expect(body).to match(/id: 1\n\s+class: OpenStruct/)
+        expect(body).to match(/id: 2\n\s+class: User/)
+        expect(body).to match(/id: 3\n\s+class: Wish/)
+      end
+    end
+
+    describe "fetching a view with local variables" do
+      it "interpretes the objects accurately" do
+        locals = {
+          some_hash: { key: "value" },
+          some_array: ["element"],
+          some_string: "hello",
+          some_model: { model: "Wish", text: "wish text" }
+        }
+        get :index, locals: locals, controller_name: "Wishes", action_name: "locals", use_route: :magic_carpet
+        expect(body).to match("some hash: value")
+        expect(body).to match(/some array: \[\&quot;element\&quot;\]/)
+        expect(body).to match("some string: hello")
+        expect(body).to match("some model: wish text")
+      end
+    end
+
+    describe "fetching a view with instance variables" do
+      it "sets the specified instance variables" do
+        instance_variables = {
+          wishes: [
+            { id: "1", model: "Wish", text: "first wish" },
+            { id: "2", model: "Wish", text: "second wish" },
+            { id: "3", model: "Wish", text: "third wish" }
+          ]
+        }
+        get :index, instance_variables: instance_variables, controller_name: "Wishes", action_name: "index", use_route: :magic_carpet
+
+        expect(body).to match("first wish")
+        expect(body).to match("second wish")
+        expect(body).to match("third wish")
+        expect(body).to match("/wishes/1")
+        expect(body).to match("/wishes/2")
+        expect(body).to match("/wishes/3")
+      end
+    end
+
+    describe "fetching a view with a specified layout" do
+      it "returns the view's markup without the layout" do
+        get :index, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+        expect(body).to eq("<h1>Plain</h1>\n")
+        expect(body).to_not match("<!DOCTYPE html>")
+      end
+
+      it "returns the view's markup with the specified layout" do
+        get :index, layout: "other_layout", controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+        expect(body).to match("<h1>Other Layout</h1>")
+        expect(body).to_not match("<h1>Application Layout</h1>")
+      end
+    end
+
+    it "sets flash messages according to flash parameter" do
+      flash = {
+        warning: "this is a flash message",
+        notice: "something noteworthy"
+      }
+      get :index, flash: flash, layout: true, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+      controller_flash = controller.send(:controller).flash
+      expect(controller_flash["warning"]).to eq(flash[:warning])
+      expect(controller_flash["notice"]).to eq(flash[:notice])
+    end
+
+    it "sets the session according to session parameter" do
+      session_hash = { user_id: "4", wish_id: "9" }
+      get :index, session: session_hash, layout: true, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+      controller_session = controller.send(:controller).session
+      expect(controller_session["user_id"]).to eq("4")
+      expect(controller_session["wish_id"]).to eq("9")
+    end
+
+    it "sets the cookies according to the cookies parameter" do
+      cookies_hash = { user_id: "4", wish_id: "9" }
+      get :index, cookies: cookies_hash, layout: true, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+      controller_cookies = controller.send(:controller).send(:cookies)
+      expect(controller_cookies["user_id"]).to eq("4")
+      expect(controller_cookies["wish_id"]).to eq("9")
+    end
+
+    it "sets the params according to params parameter" do
+      params_hash = { user_id: "4", wish_id: "9" }
+      get :index, params: params_hash, layout: true, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+      controller_params = controller.send(:controller).params
+      expect(controller_params[:user_id]).to eq("4")
+      expect(controller_params[:wish_id]).to eq("9")
+    end
+
+    describe "error handling" do
+
+      context "logging" do
+        it "logs NameErrors" do
+          expect(controller.logger).to receive(:error) do |message|
+            expect(message).to match("NonExistantController not found.")
+            expect(message).to match(/\n\s\s\s\s.*js_fixtures_controller.rb:\d\d:in \`const_get'\n/)
+          end
+          get :index, controller_name: "NonExistant", action_name: "plain", use_route: :magic_carpet
+        end
+
+        it "logs Time parse errors" do
+          expect(controller.logger).to receive(:error) do |message|
+            expect(message).to match("no time information in \"invalid-time\"\n")
+            expect(message).to match(/\n\s\s\s\s.*magic_carpet\//)
+          end
+          instance_variables_hash = {
+            wishes: [
+              { id: 1, model: "Wish", created_at: { time: "invalid-time" } },
+              { id: 1, model: "Wish", created_at: { time: Time.now.to_s } }
+            ]
+          }
+          get :index, controller_name: "Wishes", action_name: "index", instance_variables: instance_variables_hash, use_route: :magic_carpet
+        end
+
+        it "logs Date/DateTime parse errors" do
+          expect(controller.logger).to receive(:error) do |message|
+            expect(message).to match("invalid date\n")
+            expect(message).to match(/\n\s\s\s\s.*magic_carpet\//)
+          end
+          instance_variables_hash = {
+            wishes: [
+              { id: 1, model: "Wish", created_at: { date: "invalid-date" } },
+              { id: 1, model: "Wish", created_at: { date: Date.today.to_s } }
+            ]
+          }
+          get :index, controller_name: "Wishes", action_name: "index", instance_variables: instance_variables_hash, use_route: :magic_carpet
+        end
+
+        it "logs NoMethodErrors" do
+          expect(controller.logger).to receive(:error) do |message|
+            expect(message).to match("NoMethodError: undefined method `text' for #<User:")
+            expect(message).to match(/\n\s\s\s\s.*app\/views\/.*\.html\.erb:2/)
+          end
+          locals = { wish: { model: "User" } }
+          get :index, locals: locals, controller_name: "Wishes", partial: "wish", use_route: :magic_carpet
+        end
+
+        it "logs missing template errors" do
+          expect(controller.logger).to receive(:error) do |message|
+            expect(message).to match("Missing template wishes/fake, application/fake")
+            expect(message).to match(/\n\s\s\s\s.*gems\/actionpack/)
+          end
+          get :index, controller_name: "Wishes", template: "fake", use_route: :magic_carpet
+        end
+      end
+
+      context "json" do
+        it "reports missing/misnamed controllers" do
+          get :index, controller_name: "NonExistant", action_name: "plain", use_route: :magic_carpet
+          expected = { error: "Magic Carpet Error: NonExistantController not found." }.to_json
+          expect(body).to eq(expected)
+          expect(response.code).to eq("400")
+        end
+
+        it "reports Time parse errors" do
+          instance_variables_hash = {
+            wishes: [
+              { id: 1, model: "Wish", created_at: { time: "invalid-time" } },
+              { id: 1, model: "Wish", created_at: { time: Time.now.to_s } }
+            ]
+          }
+          get :index, controller_name: "Wishes", action_name: "index", instance_variables: instance_variables_hash, use_route: :magic_carpet
+          expected = { error: "Magic Carpet Error: no time information in \"invalid-time\"" }.to_json
+          expect(body).to eq(expected)
+          expect(response.code).to eq("400")
+        end
+
+        it "reports Date/DateTime parse errors" do
+          instance_variables_hash = {
+            wishes: [
+              { id: 1, model: "Wish", created_at: { date: "invalid-date" } },
+              { id: 1, model: "Wish", created_at: { date: Date.today.to_s } }
+            ]
+          }
+          get :index, controller_name: "Wishes", action_name: "index", instance_variables: instance_variables_hash, use_route: :magic_carpet
+          expected = { error: "Magic Carpet Error: invalid date" }.to_json
+          expect(body).to eq(expected)
+          expect(response.code).to eq("400")
+        end
+
+        it "reports missing/misnamed models" do
+          locals = { wish: { model: "Dish", text: "wish text" } }
+          get :index, locals: locals, controller_name: "Wishes", action_name: "plain", use_route: :magic_carpet
+          expected = { error: "Magic Carpet Error: Dish not found." }.to_json
+          expect(body).to eq(expected)
+          expect(response.code).to eq("400")
+        end
+
+        it "reports missing template errors" do
+          get :index, controller_name: "Wishes", template: "fake", use_route: :magic_carpet
+          expect(JSON.parse(body)["error"]).to match("Magic Carpet Error: Missing template wishes/fake, application/fake")
+          expect(response.code).to eq("400")
+        end
+
+        it "reports missing local variable errors" do
+          get :index, controller_name: "Wishes", template: "locals", use_route: :magic_carpet
+          expected = { error: "Magic Carpet Error: undefined local variable or method `some_hash' for 'locals' template." }.to_json
+          expect(body).to eq(expected)
+          expect(response.code).to eq("400")
+        end
+
+        it "reports missing partial errors" do
+          get :index, controller_name: "Wishes", partial: "zuh", use_route: :magic_carpet
+          expect(JSON.parse(body)["error"]).to match("Magic Carpet Error: Missing partial wishes/zuh, application/zuh")
+          expect(response.code).to eq("400")
+        end
+
+        it "reports no method errors" do
+          locals = { wish: { model: "User" } }
+          get :index, locals: locals, controller_name: "Wishes", partial: "wish", use_route: :magic_carpet
+          error = JSON.parse(body)["error"]
+          expect(error).to match("NoMethodError: undefined method `text' for #<User:")
+          expect(error).to match(/app\/views\/.*\.html\.erb:2/)
+          expect(error).to_not match("activesupport")
+          expect(response.code).to eq("400")
+        end
+      end
+    end
+  end
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .