chanko 1.0.6 → 2.0.0

data/lib/generators/chanko/unit/unit_generator.rb

@@ -0,0 +1,49 @@
+module Chanko
+  module Generators
+    class UnitGenerator < Rails::Generators::NamedBase
+      ASSETS_TYPES = %w[images javascripts stylesheets]
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_unit_directory
+        empty_directory(directory)
+      end
+
+      def create_unit_file
+        template("unit.rb.erb", "#{directory}/#{file_name}.rb")
+      end
+
+      def create_views_directory
+        create_file("#{directory}/views/.gitkeep", "")
+      end
+
+      ASSETS_TYPES.each do |type|
+        define_method("create_#{type}_directory") do
+          create_file("#{directory}/#{type}/.gitkeep", "")
+        end
+      end
+
+      ASSETS_TYPES.each do |type|
+        define_method("create_#{type}_symlink") do
+          create_assets_symlink(type)
+        end
+      end
+
+      private
+
+      def create_assets_symlink(type)
+        from = "app/assets/#{type}/#{directory_name}/#{file_name}"
+        to   = "../../../../#{directory}/#{type}"
+        create_link(from, to)
+      end
+
+      def directory
+        "#{Chanko::Config.units_directory_path}/#{file_name}"
+      end
+
+      def directory_name
+        Chanko::Config.units_directory_path.split("/").last
+      end
+    end
+  end
+end

data/spec/chanko/controller_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+module Chanko
+  describe Controller do
+    describe ".unit_action" do
+      let(:controller_class) do
+        Class.new(ActionController::Base) do
+          include Chanko::Controller
+          unit_action(:example_unit, :test)
+          unit_action(:example_unit, :foo, :bar)
+          unit_action(:example_unit, :error)
+          ext_action(:example_unit, :alias)
+
+          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
+
+      it "is aliased with `ext_action`" do
+        controller.alias.should == "alias"
+      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/chanko/exception_handler_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module Chanko
+  describe ExceptionHandler do
+    let(:sensitive_unit) do
+      Loader.load(:sensitive_unit)
+    end
+
+    let(:insensitive_unit) do
+      Loader.load(:insensitive_unit)
+    end
+
+    let(:error) do
+      Exception.new
+    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
+      end
+    end
+
+    context "when Config.raise_error is true" do
+      before do
+        Config.raise_error = true
+      end
+
+      it "raises up error" do
+        expect { described_class.handle(error, insensitive_unit) }.to raise_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
+      end
+    end
+  end
+end

data/spec/chanko/function_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+module Chanko
+  describe Function do
+    let(:unit) do
+      Loader.load(:example_unit)
+    end
+
+    let(:context) do
+      Class.new(ActionView::Base) do
+        include Chanko::Invoker
+
+        def current_unit
+          units.last
+        end
+
+        def units
+          @units ||= []
+        end
+
+        def path
+          view_paths.first.to_s
+        end
+      end.new
+    end
+
+    let(:context_without_view_paths) do
+      Class.new do
+        include Chanko::Invoker
+
+        def units
+          @units ||= []
+        end
+      end.new
+    end
+
+    let(:options) do
+      { :type => :plain }
+    end
+
+    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
+      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
+        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"
+        end
+      end
+    end
+  end
+end

data/spec/chanko/helper_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+module Chanko
+  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 Chanko::Helper }.new
+      end
+
+      it "defines helper methods with special prefix" do
+        described_class.define(:example_unit) do
+          def test
+            "test"
+          end
+        end
+        view.__example_unit_test.should == "test"
+      end
+    end
+  end
+end

data/spec/chanko/invoker_spec.rb

@@ -0,0 +1,156 @@
+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
+    end
+
+    let(:controller) do
+      Class.new(ActionController::Base) do
+        include Chanko::Invoker
+        include Chanko::Helper
+        include Chanko::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 falsy locals" do
+        view.invoke(:example_unit, :falsy, :locals => { :key => nil }, :type => :plain).
+          should == true
+      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 invoked in view" do
+        it "invokes with partial view" do
+          view.invoke(:example_unit, :render, :type => :plain).should == "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"
+        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 ==
+            '<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 Config.compatible_css_class is true" do
+        before do
+          Config.compatible_css_class = true
+        end
+
+        it "invokes and returns result surrounded by div" do
+          view.invoke(:example_unit, :test).should ==
+            '<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"
+        end
+      end
+
+      context "when the result is blank" do
+        it "does not surround result with html element" do
+          view.invoke(:example_unit, :blank).should == " "
+        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 run_default is called in function" do
+        it "invokes given block as a fallback" do
+          controller.invoke(:example_unit, :default) { "default" }.should == "default"
+        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
+        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 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"
+        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/chanko/loader_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module Chanko
+  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/chanko/logger_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+require "stringio"
+
+module Chanko
+  describe Logger do
+    around do |example|
+      origin, Rails.logger = Rails.logger, ::Logger.new(io)
+      example.run
+      Rails.logger = origin
+    end
+
+    let(:io) do
+      StringIO.new
+    end
+
+    let(:log) do
+      io.string.rstrip
+    end
+
+    let(:exception) do
+      exception = Exception.new("error message")
+      exception.set_backtrace(20.times.map {|i| "test.rb:#{i + 1}:in `method#{i + 1}'" })
+      exception
+    end
+
+    let(:lines) do
+      <<-EOS.strip_heredoc.split("\n").map {|line| "  #{line}" }
+        [Chanko] Exception - error message
+        [Chanko]   test.rb:1:in `method1'
+        [Chanko]   test.rb:2:in `method2'
+        [Chanko]   test.rb:3:in `method3'
+        [Chanko]   test.rb:4:in `method4'
+        [Chanko]   test.rb:5:in `method5'
+        [Chanko]   test.rb:6:in `method6'
+        [Chanko]   test.rb:7:in `method7'
+        [Chanko]   test.rb:8:in `method8'
+        [Chanko]   test.rb:9:in `method9'
+        [Chanko]   test.rb:10:in `method10'
+      EOS
+    end
+
+    context "when Config.enable_logger is true" do
+      before do
+        Config.enable_logger = true
+      end
+
+      context "when given Exception" do
+        it "parses and logs it" do
+          described_class.debug(exception)
+          log.should == lines.join("\n")
+        end
+
+        context "when Config.backtrace_limit is configured" do
+          before do
+            Config.backtrace_limit = 5
+          end
+
+          it "prints backtrace up to configured depth" do
+            described_class.debug(exception)
+            log.should == lines[0..5].join("\n")
+          end
+        end
+      end
+
+      context "when given String" do
+        it "adds prefix" do
+          described_class.debug("test")
+          log.should == "  [Chanko] test"
+        end
+      end
+    end
+
+    context "when Config.enable_logger is false" do
+      before do
+        Config.enable_logger = false
+      end
+
+      it "logs nothing" do
+        described_class.debug("test")
+        log.should == ""
+      end
+    end
+
+    context "when Rails.logger is nil" do
+      before do
+        Rails.stub(:logger)
+      end
+
+      it "does notihng" do
+        expect { described_class.debug(exception) }.not_to raise_error(NoMethodError)
+      end
+    end
+  end
+end