nyanko 0.0.1

data/spec/nyanko/controller_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module Nyanko
+  describe Controller do
+    describe ".unit_action" do
+      let(:controller_class) do
+        Class.new(ActionController::Base) do
+          include Nyanko::Controller
+          unit_action(:example_unit, :test)
+          unit_action(:example_unit, :foo, :bar)
+          unit_action(:example_unit, :error)
+
+          def head(code)
+            "Bad Request #{code}"
+          end
+        end
+      end
+
+      let(:controller) do
+        controller_class.new
+      end
+
+      it "defines an action to invoke unit function" do
+        controller.test.should == "test"
+      end
+
+      it "defines 2 actions at one line" do
+        controller.foo.should == "foo"
+        controller.bar.should == "bar"
+      end
+
+      context "when invoke is fallen back" do
+        it "halts with 400 status code" do
+          controller.error.should == "Bad Request 400"
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/function_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module Nyanko
+  describe Function do
+    let(:unit) do
+      Loader.load(:example_unit)
+    end
+
+    let(:context) do
+      Class.new(ActionView::Base) do
+        include Nyanko::Invoker
+
+        def current_unit
+          units.last
+        end
+
+        def units
+          @units ||= []
+        end
+
+        def path
+          view_paths.first.to_s
+        end
+      end.new
+    end
+
+    describe ".invoke" do
+      it "invokes block with given context and stacked unit" do
+        described_class.new(unit, :label) { current_unit }.invoke(context).should == unit
+      end
+
+
+      context "when context is a view" do
+        it "invokes with unit's view path" do
+          described_class.new(unit, :label) { path }.invoke(context).should == unit.view_path
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/helper_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+module Nyanko
+  describe Helper do
+    describe ".define" do
+      after do
+        described_class.class_eval do
+          remove_method :__example_unit_test rescue nil
+        end
+      end
+
+      let(:view) do
+        Class.new { include Nyanko::Helper }.new
+      end
+
+      it "defines helper methods with special prefix" do
+        described_class.define("ExampleUnit") do
+          def test
+            "test"
+          end
+        end
+        view.__example_unit_test.should == "test"
+      end
+    end
+  end
+end

data/spec/nyanko/invoker_spec.rb

@@ -0,0 +1,116 @@
+require "spec_helper"
+
+module Nyanko
+  describe Invoker do
+    let(:view) do
+      Class.new(ActionView::Base) do
+        include Nyanko::Invoker
+        include Nyanko::Helper
+        include Nyanko::UnitProxyProvider
+      end.new
+    end
+
+    let(:controller) do
+      Class.new(ActionController::Base) do
+        include Nyanko::Invoker
+        include Nyanko::Helper
+        include Nyanko::UnitProxyProvider
+      end.new
+    end
+
+    describe "#invoke" do
+      it "invokes in the same context with receiver" do
+        view.invoke(:example_unit, :self, :type => :plain).should == view
+      end
+
+      it "invokes with locals option" do
+        view.invoke(:example_unit, :locals, :locals => { :key => "value" }, :type => :plain).
+          should == "value"
+      end
+
+      it "invokes with shared method" do
+        view.invoke(:example_unit, :shared, :type => :plain).should == "shared args"
+      end
+
+      it "invokes with helper method in view context" do
+        view.invoke(:example_unit, :helper, :type => :plain).should == "helper"
+      end
+
+      context "when short-hand style args is passed" do
+        it "recognizes args as locals option" do
+          view.invoke(:example_unit, :locals, :key => "value").should ==
+            '<div class="unit unit__example_unit unit__example_unit__locals">value</div>'
+        end
+      end
+
+      context "when type is not specified" do
+        it "invokes and returns result surrounded by div" do
+          view.invoke(:example_unit, :test).should ==
+            '<div class="unit unit__example_unit unit__example_unit__test">test</div>'
+        end
+      end
+
+      context "when type is :plain" do
+        it "invokes defined function for current context and return result" do
+          view.invoke(:example_unit, :test, :type => :plain).should == "test"
+        end
+      end
+
+      context "when type is :inline" do
+        it "invokes and returns result surrounded by span" do
+          view.invoke(:example_unit, :test, :type => :inline).should ==
+            '<span class="unit unit__example_unit unit__example_unit__test">test</span>'
+        end
+      end
+
+      context "when context is not a view" do
+        it "does not surround result with html tag" do
+          controller.invoke(:example_unit, :test).should == "test"
+        end
+      end
+
+      context "when non-existent unit is specified" do
+        it "does nothing" do
+          view.invoke(:non_existent_unit, :test, :type => :plain).should == nil
+        end
+      end
+
+      context "when dependent unit is inactive" do
+        it "does nothing" do
+          view.invoke(:example_unit, :test, :if => :inactive_unit).should == nil
+        end
+      end
+
+      context "when 2 functions are specified" do
+        it "invokes first active function" do
+          view.invoke([:inactive_unit, :inactive], [:example_unit, :test], :type => :plain).
+            should == "test"
+        end
+      end
+
+      context "when an error is raised in invoking" do
+        context "when block is given" do
+          context "when context is a view" do
+            it "captures given block as a fallback" do
+              view.should_receive(:capture).and_call_original
+              view.invoke(:example_unit, :error) { "error" }.should == "error"
+            end
+          end
+
+          context "when context is not a view" do
+            it "calls given block as a fallback" do
+              controller.should_not_receive(:capture)
+              controller.invoke(:example_unit, :error) { "error" }.should == "error"
+            end
+          end
+        end
+
+        context "when no block is given" do
+          it "rescues the error and does nothing" do
+            view.invoke(:example_unit, :error).should == nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/loader_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module Nyanko
+  describe Loader do
+    describe ".load" do
+      after do
+        described_class.cache.clear
+      end
+
+      context "when existent unit name is passed" do
+        it "loads unit in units directory and returns the Module" do
+          described_class.load(:example_unit).should == ExampleUnit
+        end
+      end
+
+      context "when non-existent unit name is passed" do
+        it "returns nil" do
+          described_class.load(:non_existent_unit).should == nil
+        end
+      end
+
+      context "when loader has ever loaded specified unit" do
+        it "load unit from cache" do
+          described_class.any_instance.should_receive(:load_from_file).and_call_original
+          described_class.load(:example_unit)
+          described_class.load(:example_unit)
+        end
+      end
+
+      context "when loader has ever loaded specified wrong unit" do
+        before do
+          described_class.cache.clear
+        end
+
+        it "load unit from cache" do
+          described_class.any_instance.should_receive(:load_from_file).and_call_original
+          described_class.load(:non_existent_unit)
+          described_class.load(:non_existent_unit)
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/unit/extender_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module Nyanko
+  module Unit
+    describe Extender do
+      before do
+        stub_const("ExampleClass", Class.new)
+      end
+
+      it "extends instance methods" do
+        Extender.new.expand(:ExampleClass) do
+          def test
+            "test"
+          end
+        end
+        ExampleClass.new.test.should == "test"
+      end
+
+      it "extends class methods" do
+        Extender.new.expand(:ExampleClass) do
+          class_methods do
+            def test
+              "test"
+            end
+          end
+        end
+        ExampleClass.test.should == "test"
+      end
+
+      it "extends instance methods with prefix" do
+        Extender.new("__prefix_").expand(:ExampleClass) do
+          def test
+            "test"
+          end
+        end
+        ExampleClass.new.__prefix_test.should == "test"
+      end
+    end
+  end
+end

data/spec/nyanko/unit/scope_finder_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module Nyanko
+  module Unit
+    describe ScopeFinder do
+      describe ".find(identifier)" do
+        context "when identifier is a class" do
+          it "returns identifier with no change" do
+            identifier = ActionView::Base
+            described_class.find(identifier).should == ActionView::Base
+          end
+        end
+
+        context "when identifier is a reserved label" do
+          it "returns reserved class for that" do
+            identifier = :view
+            described_class.find(identifier).should == ActionView::Base
+          end
+        end
+
+        context "when identifier is a string that means a class" do
+          it "returns class of that string" do
+            identifier = "ActionView::Base"
+            described_class.find(identifier).should == ActionView::Base
+          end
+        end
+
+        context "when no class is found" do
+          it "returns nil" do
+            identifier = "Non::Existent::Class"
+            described_class.find(identifier).should == nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/unit_proxy_provider_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module Nyanko
+  describe UnitProxyProvider do
+    let(:view) do
+      Class.new { include Nyanko::UnitProxyProvider }.new
+    end
+
+    describe "#unit" do
+      context "when given unit name" do
+        it "returns proxy for specified unit" do
+          proxy = view.unit(:example_unit)
+          proxy.should be_a UnitProxy
+          proxy.unit.should == ExampleUnit
+        end
+
+        context "when unit is not found" do
+          it "raises NoUnitError" do
+            expect { view.unit(:non_existent_unit) }.to raise_error(described_class::NoUnitError)
+          end
+        end
+      end
+
+      context "when given no unit name" do
+        before do
+          Function.units << Loader.load(:example_unit)
+        end
+
+        after do
+          Function.units.pop
+        end
+
+        it "returns proxy for the top unit of current unit stack" do
+          proxy = view.unit
+          proxy.unit.should == ExampleUnit
+        end
+      end
+    end
+  end
+end

data/spec/nyanko/unit_proxy_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module Nyanko
+  describe UnitProxy do
+    let(:view) do
+      Class.new { include UnitProxyProvider }.new
+    end
+
+    describe "#active?" do
+      it "returns activation status of unit" do
+        view.unit(:example_unit).should be_active
+        view.unit(:inactive_unit).should_not be_active
+      end
+    end
+
+    describe "#method_missing" do
+      it "calls prefixed method" do
+        view.should_receive(:__example_unit_test)
+        view.unit(:example_unit).test
+      end
+    end
+  end
+end

data/spec/nyanko/unit_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+module Nyanko
+  describe Unit do
+    before do
+      unit.stub(:name => "ExampleUnit")
+    end
+
+    let(:unit) do
+      Module.new { include Nyanko::Unit }
+    end
+
+    let(:view) do
+      Class.new { include Nyanko::Helper }.new
+    end
+
+    describe ".active_if" do
+      before do
+        ActiveIf.define(:true) { true }
+        ActiveIf.define(:false) { false }
+      end
+
+      after do
+        ActiveIf.clear
+      end
+
+      subject { unit.active?(view) }
+
+      context "in default configuration" do
+        it "is configured to return always true" do
+          should be_true
+        end
+      end
+
+      context "when labels are specified" do
+        before do
+          unit.active_if(:true, :false)
+        end
+        specify "all of defined conditions must pass" do
+          should be_false
+        end
+      end
+
+      context "when block is passed" do
+        before do
+          unit.active_if(:true) { false }
+        end
+        specify "all of defined conditions and block must pass" do
+          should be_false
+        end
+      end
+
+      context "when any is specified" do
+        before do
+          unit.instance_eval do
+            active_if any(:true, :false)
+          end
+        end
+        specify "any of conditions must pass" do
+          should be_true
+        end
+      end
+    end
+
+    describe ".scope" do
+      specify "given scope is recorded to used scope list" do
+        unit.scope(:view) { }
+        unit.scopes.keys.should == [ActionView::Base]
+      end
+
+      context "in the scoped block" do
+        specify "current_scope returns given scope" do
+          unit.scope(:view) do
+            unit.current_scope.should == ActionView::Base
+          end
+        end
+      end
+
+      context "out of the scoped block" do
+        specify "current_scope returns nil" do
+          unit.scope(:view) { }
+          unit.current_scope.should == nil
+        end
+      end
+    end
+
+    describe ".function" do
+      it "stores given block with current_scope and given label" do
+        unit.scope(:view) do
+          unit.function(:test) do
+            "test"
+          end
+        end
+        unit.scopes[ActionView::Base][:test].block.should === "test"
+      end
+    end
+
+    describe ".shared" do
+      it "stroes given block with given label" do
+        unit.shared(:test) do
+          "test"
+        end
+        unit.shared_methods[:test].call.should == "test"
+      end
+    end
+
+    describe ".helpers" do
+      it "provides interface for unit to define helper methods" do
+        unit.helpers do
+          def test
+            "test"
+          end
+        end
+        view.__example_unit_test.should == "test"
+      end
+    end
+
+    describe ".models" do
+      before do
+        stub_const("ExampleModel", model_class)
+        unit.models do
+          expand(:ExampleModel) do
+            scope :active, lambda { where(:deleted_at => nil) }
+
+            def test
+              "test"
+            end
+
+            class_methods do
+              def test
+                "test"
+              end
+            end
+          end
+        end
+      end
+
+      let(:model_class) do
+        Class.new do
+          include UnitProxyProvider
+
+          def self.scope(name, *args)
+            singleton_class.class_eval do
+              define_method(name) { "scoped" }
+            end
+          end
+        end
+      end
+
+      it "defines instance methods with prefix" do
+        ExampleModel.new.__example_unit_test.should == "test"
+      end
+
+      it "defines class methods with prefix" do
+        ExampleModel.__example_unit_test.should == "test"
+      end
+
+      it "defines association methods with prefix" do
+        ExampleModel.__example_unit_active.should == "scoped"
+      end
+    end
+
+    describe ".view_path" do
+      it "returns path for its view directory" do
+        unit.view_path.should == "#{Config.units_directory_path}/example_unit/views"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec\/fixtures/"
+  add_filter "/spec\/dummy/"
+end
+
+require "nyanko"
+Nyanko::Config.units_directory_path = File.expand_path("../fixtures/units", __FILE__)
+
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../dummy/config/environment", __FILE__)
+require "rspec/rails"
+require "rspec/autorun"
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end