chanko 2.0.0 → 2.3.0

data/spec/chanko/exception_handler_spec.rb

@@ -14,6 +14,27 @@ module Chanko
       Exception.new
     end
 
+    context "when Config.propagated_errors includes given error" do
+      before do
+        Config.propagated_errors << Exception
+      end
+
+      it "raises up error without any logging" do
+        expect(Logger).not_to receive(:debug)
+        expect { described_class.handle(error, insensitive_unit) }.to raise_error(error)
+      end
+    end
+
+    context "when Config.propagated_errors does not include given error" do
+      before do
+        Config.propagated_errors << StandardError
+      end
+
+      it "raises up no error" do
+        expect { described_class.handle(error, insensitive_unit) }.not_to raise_error
+      end
+    end
+
     context "when Config.raise_error is false" do
       it "raises up no error" do
         expect { described_class.handle(error, insensitive_unit) }.not_to raise_error
@@ -26,13 +47,13 @@ module Chanko
       end
 
       it "raises up error" do
-        expect { described_class.handle(error, insensitive_unit) }.to raise_error
+        expect { described_class.handle(error, insensitive_unit) }.to raise_error(error)
       end
     end
 
     context "when unit.raise_error is configured" do
       it "raises up error" do
-        expect { described_class.handle(error, sensitive_unit) }.to raise_error
+        expect { described_class.handle(error, sensitive_unit) }.to raise_error(error)
       end
     end
   end

data/spec/chanko/function_spec.rb

@@ -6,10 +6,25 @@ module Chanko
       Loader.load(:example_unit)
     end
 
-    let(:context) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
+    def rails5_action_view_instance
+      klass = Class.new(ActionView::Base) do
+        def current_unit
+          units.last
+        end
+
+        def units
+          @units ||= []
+        end
+
+        def path
+          view_paths.first.to_s
+        end
+      end
+      klass.new
+    end
 
+    def rails6_action_view_instance
+      klass = Class.new(ActionView::Base.with_empty_template_cache) do
         def current_unit
           units.last
         end
@@ -21,7 +36,18 @@ module Chanko
         def path
           view_paths.first.to_s
         end
-      end.new
+      end
+
+      klass.with_view_paths([], {}, nil)
+    end
+
+    let(:context) do
+      case Rails::VERSION::MAJOR
+      when 5
+        rails5_action_view_instance
+      when 6
+        rails6_action_view_instance
+      end
     end
 
     let(:context_without_view_paths) do
@@ -40,19 +66,19 @@ module Chanko
 
     describe ".invoke" do
       it "invokes block with given context and stacked unit" do
-        described_class.new(unit, :label) { current_unit }.invoke(context, options).should == unit
+        expect(described_class.new(unit, :label) { current_unit }.invoke(context, options)).to eq(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, options).should == unit.view_path
+          expect(described_class.new(unit, :label) { path }.invoke(context, options)).to eq(unit.view_path)
         end
       end
 
       context "when context does not have view_paths" do
         it "invokes successfully" do
-          described_class.new(unit, :label) { "test" }.
-            invoke(context_without_view_paths, options).should == "test"
+          expect(described_class.new(unit, :label) { "test" }.
+            invoke(context_without_view_paths, options)).to eq("test")
         end
       end
     end

data/spec/chanko/helper_spec.rb

@@ -19,7 +19,7 @@ module Chanko
             "test"
           end
         end
-        view.__example_unit_test.should == "test"
+        expect(view.__example_unit_test).to eq("test")
       end
     end
   end

data/spec/chanko/invoker_spec.rb

@@ -3,67 +3,67 @@ require "spec_helper"
 module Chanko
   describe Invoker do
     let(:view) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      controller.helpers
     end
 
     let(:controller) do
-      Class.new(ActionController::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      Class.new(ActionController::Base).new
     end
 
     describe "#invoke" do
       it "invokes in the same context with receiver" do
-        view.invoke(:example_unit, :self, :type => :plain).should == view
+        expect(view.invoke(:example_unit, :self, :type => :plain)).to eq(view)
       end
 
       it "invokes with locals option" do
-        view.invoke(:example_unit, :locals, :locals => { :key => "value" }, :type => :plain).
-          should == "value"
+        expect(view.invoke(:example_unit, :locals, :locals => { :key => "value" }, :type => :plain)).
+          to eq("value")
       end
 
       it "invokes with falsy locals" do
-        view.invoke(:example_unit, :falsy, :locals => { :key => nil }, :type => :plain).
-          should == true
+        expect(view.invoke(:example_unit, :falsy, :locals => { :key => nil }, :type => :plain)).
+          to eq(true)
       end
 
       it "invokes with shared method" do
-        view.invoke(:example_unit, :shared, :type => :plain).should == "shared args"
+        expect(view.invoke(:example_unit, :shared, :type => :plain)).to eq("shared args")
       end
 
       it "invokes with helper method in view context" do
-        view.invoke(:example_unit, :helper, :type => :plain).should == "helper"
+        expect(view.invoke(:example_unit, :helper, :type => :plain)).to eq("helper")
+      end
+
+      context 'when unit is referred from unit function' do
+        it 'responds to method which the context responds to' do
+          expect(view.invoke(:example_unit, :respond_to_helper?, type: :plain)).to eq(true)
+        end
       end
 
       context "when invoked in view" do
         it "invokes with partial view" do
-          view.invoke(:example_unit, :render, :type => :plain).should == "test\n"
+          expect(view.invoke(:example_unit, :render, :type => :plain)).to eq("test\n")
         end
       end
 
       context "when invoked in controller" do
         it "invokes with unit views path" do
-          controller.invoke(:example_unit, :render, :type => :plain).should == "test\n"
+          expect(controller.invoke(:example_unit, :render, :type => :plain)).to eq("test\n")
         end
       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 ==
+          expect(view.invoke(:example_unit, :locals, :key => "value")).to eq(
             '<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 ==
+          expect(view.invoke(:example_unit, :test)).to eq(
             '<div class="unit unit__example_unit unit__example_unit__test">test</div>'
+          )
         end
       end
 
@@ -73,58 +73,84 @@ module Chanko
         end
 
         it "invokes and returns result surrounded by div" do
-          view.invoke(:example_unit, :test).should ==
+          expect(view.invoke(:example_unit, :test)).to eq(
             '<div class="extension ext_example_unit ext_example_unit-test">test</div>'
+          )
         end
       end
 
       context "when type is :plain" do
         it "does not surround result with html element" do
-          view.invoke(:example_unit, :test, :type => :plain).should == "test"
+          expect(view.invoke(:example_unit, :test, :type => :plain)).to eq("test")
         end
       end
 
       context "when the result is blank" do
         it "does not surround result with html element" do
-          view.invoke(:example_unit, :blank).should == " "
+          expect(view.invoke(:example_unit, :blank)).to eq(" ")
         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 ==
+          expect(view.invoke(:example_unit, :test, :type => :inline)).to eq(
             '<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"
+          expect(controller.invoke(:example_unit, :test)).to eq("test")
         end
       end
 
       context "when run_default is called in function" do
         it "invokes given block as a fallback" do
-          controller.invoke(:example_unit, :default) { "default" }.should == "default"
+          expect(controller.invoke(:example_unit, :default) { "default" }).to eq("default")
+        end
+      end
+
+      context "when nested run_default is called in function" do
+        it "invokes given block as a fallback" do
+          Chanko::Loader.load("sensitive_unit")
+          expect(SensitiveUnit).to receive(:ping).once
+
+          expect(controller.invoke(:sensitive_unit, :outer_default) do
+            "default"
+          end).to eq "default"
+        end
+
+        it 'use both locals' do
+          expect(controller.invoke(:example_unit, :nesting_locals_outer, :locals => { :outer_one => "outer_one", :outer_two => "outer_two", :outer_three => "outer_three"}) do
+            "default"
+          end).to eq "outer_one.inner_one.outer_two.default.inner_two.outer_three"
+        end
+
+        context 'active_if is false' do
+          it "invokes given block as a fallback " do
+            Chanko::Loader.load("sensitive_inactive_unit")
+            expect(controller.invoke(:sensitive_inactive_unit, :outer) { invoke(:sensitive_inactive_unit, :inner) }).to eq(nil)
+          end
         end
       end
 
       context "when run_default is called but no block given" do
         it "invokes given block as a fallback" do
-          controller.invoke(:example_unit, :default).should == nil
+          expect(controller.invoke(:example_unit, :default)).to eq(nil)
         end
       end
 
       context "when non-existent unit is specified" do
         it "does nothing" do
-          view.invoke(:non_existent_unit, :test, :type => :plain).should == nil
+          expect(view.invoke(:non_existent_unit, :test, :type => :plain)).to eq(nil)
         end
       end
 
       context "when function is not found" do
         it "runs default but not handled by ExceptionHandler" do
-          ExceptionHandler.should_not_receive(:handle)
-          view.invoke(:example_unit, :non_existent_function) { "default" }.should == "default"
+          expect(ExceptionHandler).not_to receive(:handle)
+          expect(view.invoke(:example_unit, :non_existent_function) { "default" }).to eq("default")
         end
       end
 
@@ -132,22 +158,22 @@ module Chanko
         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"
+              expect(view).to receive(:capture).and_call_original
+              expect(view.invoke(:example_unit, :error) { "error" }).to eq("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"
+              expect(controller).not_to receive(:capture)
+              expect(controller.invoke(:example_unit, :error) { "error" }).to eq("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
+            expect(view.invoke(:example_unit, :error)).to eq(nil)
           end
         end
       end

data/spec/chanko/loader_spec.rb

@@ -4,38 +4,40 @@ module Chanko
   describe Loader do
     describe ".load" do
       after do
-        described_class.cache.clear
+        Chanko::Loader.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
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
         end
       end
 
       context "when non-existent unit name is passed" do
         it "returns nil" do
-          described_class.load(:non_existent_unit).should == nil
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
         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)
+        it "load unit from cache", classic: true do
+          expect(Chanko::Loader::ClassicLoader).to receive(:load_from_cache).twice.and_call_original
+          expect(Chanko::Loader::ClassicLoader).to receive(:save_to_cache).with(anything, ExampleUnit).and_call_original
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
         end
       end
 
       context "when loader has ever loaded specified wrong unit" do
         before do
-          described_class.cache.clear
+          Chanko::Loader.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)
+        it "load unit from cache", classic: true do
+          expect(Chanko::Loader::ClassicLoader).to receive(:load_from_cache).twice.and_call_original
+          expect(Chanko::Loader::ClassicLoader).to receive(:save_to_cache).with(anything, false).and_call_original
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
         end
       end
     end

data/spec/chanko/logger_spec.rb

@@ -4,11 +4,17 @@ require "stringio"
 module Chanko
   describe Logger do
     around do |example|
-      origin, Rails.logger = Rails.logger, ::Logger.new(io)
+      origin, Rails.logger = Rails.logger, logger
       example.run
       Rails.logger = origin
     end
 
+    let(:logger) do
+      logger = ::Logger.new(io)
+      logger.formatter = lambda {|severity, time, progname, message| message }
+      logger
+    end
+
     let(:io) do
       StringIO.new
     end
@@ -47,7 +53,7 @@ module Chanko
       context "when given Exception" do
         it "parses and logs it" do
           described_class.debug(exception)
-          log.should == lines.join("\n")
+          expect(log).to eq(lines.join("\n"))
         end
 
         context "when Config.backtrace_limit is configured" do
@@ -57,7 +63,7 @@ module Chanko
 
           it "prints backtrace up to configured depth" do
             described_class.debug(exception)
-            log.should == lines[0..5].join("\n")
+            expect(log).to eq(lines[0..5].join("\n"))
           end
         end
       end
@@ -65,7 +71,7 @@ module Chanko
       context "when given String" do
         it "adds prefix" do
           described_class.debug("test")
-          log.should == "  [Chanko] test"
+          expect(log).to eq("  [Chanko] test")
         end
       end
     end
@@ -77,17 +83,17 @@ module Chanko
 
       it "logs nothing" do
         described_class.debug("test")
-        log.should == ""
+        expect(log).to eq("")
       end
     end
 
     context "when Rails.logger is nil" do
       before do
-        Rails.stub(:logger)
+        allow(Rails).to receive(:logger)
       end
 
       it "does notihng" do
-        expect { described_class.debug(exception) }.not_to raise_error(NoMethodError)
+        expect { described_class.debug(exception) }.not_to raise_error
       end
     end
   end

data/spec/chanko/test_spec.rb

@@ -3,25 +3,35 @@ require "chanko/test"
 
 module Chanko
   describe Test do
+    def rails5_action_view_instance
+      Class.new(ActionView::Base).new
+    end
+
+    def rails6_action_view_instance
+      klass = Class.new(ActionView::Base.with_empty_template_cache)
+      klass.with_view_paths(nil, {}, nil)
+    end
+
     let(:view) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      case Rails::VERSION::MAJOR
+      when 5
+        rails5_action_view_instance
+      when 6
+        rails6_action_view_instance
+      end
     end
 
     describe "#enable_unit" do
       it "forces to enable specified unit" do
         enable_unit(:inactive_unit)
-        view.invoke(:inactive_unit, :inactive, :type => :plain).should == "inactive"
+        expect(view.invoke(:inactive_unit, :inactive, :type => :plain)).to eq("inactive")
       end
     end
 
     describe "#disable_unit" do
       it "forces to disable specified unit" do
         disable_unit(:example_unit)
-        view.invoke(:example_unit, :test).should == nil
+        expect(view.invoke(:example_unit, :test)).to eq(nil)
       end
     end
   end

data/spec/chanko/unit/extender_spec.rb

@@ -13,7 +13,7 @@ module Chanko
             "test"
           end
         end
-        ExampleClass.new.test.should == "test"
+        expect(ExampleClass.new.test).to eq("test")
       end
 
       it "extends class methods" do
@@ -24,7 +24,7 @@ module Chanko
             end
           end
         end
-        ExampleClass.test.should == "test"
+        expect(ExampleClass.test).to eq("test")
       end
 
       it "extends instance methods with prefix" do
@@ -33,7 +33,7 @@ module Chanko
             "test"
           end
         end
-        ExampleClass.new.__prefix_test.should == "test"
+        expect(ExampleClass.new.__prefix_test).to eq("test")
       end
     end
   end

data/spec/chanko/unit/scope_finder_spec.rb

@@ -7,28 +7,28 @@ module Chanko
         context "when identifier is a class" do
           it "returns identifier with no change" do
             identifier = ActionView::Base
-            described_class.find(identifier).should == ActionView::Base
+            expect(described_class.find(identifier)).to eq(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
+            expect(described_class.find(identifier)).to eq(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
+            expect(described_class.find(identifier)).to eq(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
+            expect(described_class.find(identifier)).to eq(nil)
           end
         end
       end

data/spec/chanko/unit_proxy_provider_spec.rb

@@ -10,8 +10,8 @@ module Chanko
       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
+          expect(proxy).to be_a UnitProxy
+          expect(proxy.unit).to eq(ExampleUnit)
         end
       end
 
@@ -26,7 +26,7 @@ module Chanko
 
         it "returns proxy for the top unit of current unit stack" do
           proxy = view.unit
-          proxy.unit.should == ExampleUnit
+          expect(proxy.unit).to eq(ExampleUnit)
         end
       end
 
@@ -39,10 +39,10 @@ module Chanko
         end
 
         it "change this method name with it" do
-          view.should_not be_respond_to(:proxy)
+          expect(view).not_to be_respond_to(:proxy)
           proxy = view.proxy(:example_unit)
-          proxy.should be_a UnitProxy
-          view.should be_respond_to(:proxy)
+          expect(proxy).to be_a UnitProxy
+          expect(view).to be_respond_to(:proxy)
         end
       end
 
@@ -55,12 +55,12 @@ module Chanko
         end
 
         it "change this method name with it" do
-          view.should_not be_respond_to(:proxy1)
-          view.should_not be_respond_to(:proxy2)
-          view.proxy1(:example_unit).should be_a UnitProxy
-          view.proxy2(:example_unit).should be_a UnitProxy
-          view.should be_respond_to(:proxy1)
-          view.should be_respond_to(:proxy2)
+          expect(view).not_to be_respond_to(:proxy1)
+          expect(view).not_to be_respond_to(:proxy2)
+          expect(view.proxy1(:example_unit)).to be_a UnitProxy
+          expect(view.proxy2(:example_unit)).to be_a UnitProxy
+          expect(view).to be_respond_to(:proxy1)
+          expect(view).to be_respond_to(:proxy2)
         end
       end
     end

data/spec/chanko/unit_proxy_spec.rb

@@ -8,14 +8,14 @@ module Chanko
 
     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
+        expect(view.unit(:example_unit)).to be_active
+        expect(view.unit(:inactive_unit)).not_to be_active
       end
     end
 
     describe "#method_missing" do
       it "calls prefixed method" do
-        view.should_receive(:__example_unit_test)
+        expect(view).to receive(:__example_unit_test)
         view.unit(:example_unit).test
       end
     end