nyanko 0.0.7 → 0.0.8

data/README.md

@@ -100,6 +100,7 @@ $ rails s
 
 
 ## Todo
-* configuration
-* document
-* test (for now, test coverage is 100%)
+* Test macros
+* Generator
+* Documentation
+* Backward compatibility

data/lib/generators/nyanko/unit/templates/unit.rb.erb

@@ -0,0 +1,88 @@
+module <%= class_name %>
+  include Nyanko::Unit
+
+  # ## active_if
+  # This block is used to decide if this unit is active or not.
+  # `context` is the receiver object of `invoke`.
+  # `options` is passed via `invoke(:foo, :bar, :active_if_options => { ... })`.
+  # By default, this is set as `active_if { true }`.
+  #
+  # ```
+  # active_if do |context, options|
+  #   true
+  # end
+  # ```
+
+  # ## raise_error
+  # `raise_error` is used to force an unit to raise up errors occured in invoking.
+  # You can force to raise up errors also by `Config.raise_error`.
+  #
+  # ```
+  # raise_error
+  # ```
+
+  # ## function
+  # In controller or view context, you can call functions defined by `function`
+  # via `invoke(:<%= file_name %>, :function_name)`.
+  #
+  # scope(:controller) do
+  #   function(:function_name) do
+  #     "Nyanko!"
+  #   end
+  # end
+
+  # ## render
+  # In addition, the view path "<%= "#{directory}/views" %>" is added into view_paths.
+  # So you can render <%= "#{directory}/views/example.html.erb" %> in invoking.
+  #
+  # ```
+  # scope(:controller) do
+  #   function(:function_name) do
+  #     render "/example", :foo => "bar"
+  #   end
+  # end
+  # ```
+
+  # ## models
+  # In models block, you can expand model features by `expand` method.
+  # The expanded methods are available via unit proxy like `User.unit.active`,
+  # and `User.find(params[:id]).unit.active?`, and so on.
+  #
+  # ```
+  # models do
+  #   expand(:User) do
+  #     scope :active, lambda { where(:deleted_at => nil) }
+  #
+  #     def active?
+  #       deleted_at.nil?
+  #     end
+  #   end
+  # end
+  # ```
+
+  # ## shared
+  # You can call methods defined by `shared` in invoking.
+  #
+  # ```
+  # scope(:view) do
+  #   function(:function_name) do
+  #     hello
+  #   end
+  # end
+  #
+  # shared(:hello) do |world|
+  #   "Hello, #{world}"
+  # end
+  # ```
+
+  # ## helpers
+  # You can call helpers in view via unit proxy like `unit.helper_method`
+  #
+  # ```
+  # helpers do
+  #   def helper_method
+  #     "helper method"
+  #   end
+  # end
+  # ```
+end

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

@@ -0,0 +1,45 @@
+module Nyanko
+  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}/units/#{file_name}"
+        to   = "../../../../#{directory}/#{type}"
+        create_link(from, to)
+      end
+
+      def directory
+        "#{Nyanko::Config.units_directory_path}/#{file_name}"
+      end
+    end
+  end
+end

data/lib/nyanko/config.rb

@@ -9,6 +9,7 @@ module Nyanko
         :enable_logger,
         :proxy_method_name,
         :raise_error,
+        :resolver,
         :units_directory_path
       )
 
@@ -20,6 +21,7 @@ module Nyanko
         self.enable_logger        = true
         self.proxy_method_name    = :unit
         self.raise_error          = Rails.env.development?
+        self.resolver             = ActionView::OptimizedFileSystemResolver
         self.units_directory_path = "app/units"
       end
     end

data/lib/nyanko/exception_handler.rb

@@ -1,9 +1,9 @@
 module Nyanko
   module ExceptionHandler
     class << self
-      def handle(exception)
+      def handle(exception, unit = nil)
         Logger.debug(exception)
-        raise exception if Config.raise_error
+        raise exception if unit.try(:raise_error?) || Config.raise_error
       end
     end
   end

data/lib/nyanko/function.rb

@@ -21,7 +21,11 @@ module Nyanko
     def invoke(context, options = {})
       with_unit_stack(context) do
         with_unit_view_path(context) do
-          context.instance_eval(&block)
+          capture_exception(context) do
+            result = context.instance_eval(&block)
+            result = decorate(result, context, options[:type]) if context.view?
+            result
+          end
         end
       end
     end
@@ -54,12 +58,28 @@ module Nyanko
     end
 
     def with_unit_view_path(context)
-      if context.view?
-        context.view_paths.unshift unit.resolver
-      end
+      context.view_paths.unshift unit.resolver
       yield
     ensure
-      context.view_paths.paths.shift if context.view?
+      context.view_paths.paths.shift
+    end
+
+    def capture_exception(context)
+      yield
+    rescue Exception => exception
+      ExceptionHandler.handle(exception, unit)
+      context.run_default
+    end
+
+    def decorate(str, context, type)
+      case type
+      when :plain
+        str
+      when :inline
+        context.content_tag(:span, str, :class => css_classes)
+      else
+        context.content_tag(:div, str, :class => css_classes)
+      end
     end
   end
 end

data/lib/nyanko/invoker.rb

@@ -5,20 +5,15 @@ module Nyanko
   module Invoker
     def invoke(*args, &block)
       options = Options.new(*args)
-      defaults_stack << block
-      unit_locals_stack << options.locals
-      function = FunctionFinder.find(self, options)
-      result   = function.invoke(self, options.invoke_options)
-      result   = surround_with_html_tag(result, function, options) if view?
-      result
-    rescue FunctionFinder::FunctionNotFound
-      run_default
-    rescue Exception => exception
-      ExceptionHandler.handle(exception)
-      run_default
-    ensure
-      defaults_stack.pop
-      unit_locals_stack.pop
+      __with_default_stack(block) do
+        __with_unit_locals_stack(options.locals) do
+          if function = FunctionFinder.find(self, options)
+            function.invoke(self, options.invoke_options)
+          else
+            run_default
+          end
+        end
+      end
     end
 
     def units
@@ -30,45 +25,77 @@ module Nyanko
     end
 
     def run_default
-      if block = defaults_stack.last
-        if view?
-          capture(&block)
-        else
-          instance_exec(&block)
-        end
-      end
+      __invoke_default_block if __has_default_block?
     end
 
     private
 
-    # Search shared method or locals variable
     def method_missing(method_name, *args, &block)
-      if (methods = units.last.try(:shared_methods)) && block = methods[method_name]
-        self.instance_exec(*args, &block)
-      elsif args.empty? && value = (unit_locals_stack.last || {})[method_name]
-        value
+      if shared_method = __find_shared_method(method_name)
+        instance_exec(*args, &shared_method)
+      elsif args.empty? && local = __find_unit_local(method_name)
+        local
       else
         super
       end
     end
 
-    def defaults_stack
-      @defaults_stack ||= []
+    def __find_unit_local(method_name)
+      __current_unit_locals[method_name]
+    end
+
+    def __current_unit_locals
+      __unit_locals_stack.last || {}
+    end
+
+    def __unit_locals_stack
+      @__unit_locals_stack ||= []
+    end
+
+    def __find_shared_method(method_name)
+      __current_shared_methods[method_name]
+    end
+
+    def __current_shared_methods
+      __current_unit.try(:shared_methods) || {}
     end
 
-    def unit_locals_stack
-      @unit_locals_stack ||= []
+    def __current_unit
+      units.last
     end
 
-    def surround_with_html_tag(str, function, options)
-      case options.type
-      when :plain
-        str
-      when :inline
-        content_tag(:span, str, :class => function.css_classes)
+    def __defaults_stack
+      @__defaults_stack ||= []
+    end
+
+    def __default_block
+      __defaults_stack.last
+    end
+
+    def __has_default_block?
+      !!__default_block
+    end
+
+    def __invoke_default_block
+      if view?
+        capture(&__default_block)
       else
-        content_tag(:div, str, :class => function.css_classes)
+        instance_exec(&__default_block)
       end
     end
+
+    def __with_default_stack(default)
+      __defaults_stack << default
+      yield
+    ensure
+      __defaults_stack.pop
+    end
+
+    def __with_unit_locals_stack(locals)
+      __unit_locals_stack << locals
+      yield
+    ensure
+      __unit_locals_stack.pop
+    end
   end
 end

data/lib/nyanko/invoker/function_finder.rb

@@ -1,47 +1,37 @@
 module Nyanko
   module Invoker
     class FunctionFinder
-      FunctionNotFound = Class.new(StandardError)
-
       def self.find(context, options)
-        new(context, options).find or
-          raise FunctionNotFound, "The function for #{options[:functions].inspect} is not found"
+        new(context, options).find
       end
 
+      attr_reader :context, :options
+
+      delegate :active_if_options, :as, :label, :unit_name, :to => :options
+
       def initialize(context, options)
         @context = context
         @options = options
       end
 
       def find
-        @options[:functions].find do |unit_name, label|
-          unit       = find_unit(unit_name)
-          identifier = @options[:as] || @context.class
-          next unless unit.try(:active?, @context, @options[:active_if_options])
-          function = unit.find_function(identifier, label)
-          break function if function
-        end
-      end
-
-      def find_with_dependencies
-        find_without_dependencies unless has_inactive_dependent_unit?
+        active? && find_function
       end
-      alias_method_chain :find, :dependencies
 
-      def find_unit(name)
-        Loader.load(name)
+      def scope
+        as || context.class
       end
 
-      def has_inactive_dependent_unit?
-        dependent_units.any? {|unit| !unit.active?(@context, @options[:active_if_options]) }
+      def unit
+        Loader.load(unit_name)
       end
 
-      def dependent_units
-        dependent_unit_names.map {|name| find_unit(name) }
+      def find_function
+        unit.find_function(scope, label)
       end
 
-      def dependent_unit_names
-        Array.wrap(@options[:dependencies])
+      def active?
+        unit.try(:active?, context, active_if_options)
       end
     end
   end

data/lib/nyanko/invoker/options.rb

@@ -5,7 +5,6 @@ module Nyanko
         :active_if_options => true,
         :as                => true,
         :capture           => true,
-        :if                => true,
         :locals            => true,
         :type              => true,
       }
@@ -15,12 +14,12 @@ module Nyanko
         @args = args
       end
 
-      def [](key)
-        send(key)
+      def unit_name
+        @args[0]
       end
 
-      def functions
-        @args.first.is_a?(Array) ? @args : [[@args[0], @args[1]]]
+      def label
+        @args[1]
       end
 
       def locals
@@ -35,10 +34,6 @@ module Nyanko
         options[:as]
       end
 
-      def dependencies
-        options[:if]
-      end
-
       def capture
         options.has_key?(:capture) ? capture[:capture] : true
       end

data/lib/nyanko/logger.rb

@@ -35,7 +35,7 @@ module Nyanko
 
       def content
         if @object.is_a?(Exception)
-          "#{klass}#{body}\n#{backtrace}"
+          "#{klass}#{body}#{backtrace}"
         else
           @object.to_s
         end
@@ -52,8 +52,15 @@ module Nyanko
       end
 
       def backtrace
-        lines = @object.backtrace[0...Config.backtrace_limit]
-        lines.map {|line| "  #{line}" }.join("\n")
+        if has_backtrace?
+          lines = @object.backtrace[0...Config.backtrace_limit]
+          str   = lines.map {|line| "  #{line}" }.join("\n")
+          "\n#{str}"
+        end
+      end
+
+      def has_backtrace?
+        @object.backtrace
       end
     end
   end

data/lib/nyanko/test.rb

@@ -0,0 +1,38 @@
+module Nyanko
+  module Test
+    def self.activations
+      @activations ||= {}
+    end
+
+    def enable_unit(unit_name)
+      Test.activations[unit_name] = true
+    end
+    alias_method :enable_ext, :enable_unit
+
+    def disable_unit(unit_name)
+      Test.activations[unit_name] = false
+    end
+    alias_method :disable_ext, :disable_unit
+  end
+
+  module Unit
+    module ClassMethods
+      def active_with_activations?(*args)
+        case Test.activations[unit_name]
+        when true
+          true
+        when false
+          false
+        else
+          active_without_activations?(*args)
+        end
+      end
+      alias_method_chain :active?, :activations
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Nyanko::Test
+  config.after { Nyanko::Test.activations.clear }
+end

data/lib/nyanko/unit.rb

@@ -49,6 +49,15 @@ module Nyanko
         ActiveIf::Any.new(*labels)
       end
 
+      def raise_error
+        @raise_error = true
+      end
+      alias_method :propagates_errors, :raise_error
+
+      def raise_error?
+        @raise_error
+      end
+
       def unit_name
         @unit_name ||= name.underscore.to_sym
       end
@@ -81,7 +90,7 @@ module Nyanko
       end
 
       def resolver
-        @resolver ||= ActionView::OptimizedFileSystemResolver.new(view_path)
+        @resolver ||= Config.resolver.new(view_path)
       end
 
       def extender

data/lib/nyanko/unit_proxy_provider.rb

@@ -7,6 +7,8 @@ module Nyanko
       include Helper
     end
 
+    # Define #unit method in this class when #unit is called in first time.
+    # Change Config.proxy_method_name if you want to change this method name.
     def method_missing(method_name, *args, &block)
       if Array.wrap(Config.proxy_method_name).include?(method_name)
         UnitProxyProvider.class_eval do

data/lib/nyanko/version.rb

@@ -1,3 +1,3 @@
 module Nyanko
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/fixtures/units/example_unit/example_unit.rb

@@ -25,6 +25,10 @@ module ExampleUnit
     function(:default) do
       run_default
     end
+
+    function(:render) do
+      render_to_string :partial => "/test", :locals => { :local => "test" }
+    end
   end
 
   scope(:view) do
@@ -51,6 +55,10 @@ module ExampleUnit
     function(:helper) do
       unit.helper
     end
+
+    function(:render) do
+      render "/test", :local => "test"
+    end
   end
 
   helpers do

data/spec/fixtures/units/example_unit/views/_test.html.erb

@@ -0,0 +1 @@
+<%= local %>

data/spec/fixtures/units/insensitive_unit/insensitive_unit.rb

@@ -0,0 +1,3 @@
+module InsensitiveUnit
+  include Nyanko::Unit
+end

data/spec/fixtures/units/sensitive_unit/sensitive_unit.rb

@@ -0,0 +1,4 @@
+module SensitiveUnit
+  include Nyanko::Unit
+  raise_error
+end

data/spec/nyanko/exception_handler_spec.rb

@@ -2,13 +2,37 @@ require "spec_helper"
 
 module Nyanko
   describe ExceptionHandler do
-    context "when Config.raise_error is truthy" 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(Exception.new) }.to raise_error
+        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

data/spec/nyanko/function_spec.rb

@@ -24,15 +24,19 @@ module Nyanko
       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).should == unit
+        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).should == unit.view_path
+          described_class.new(unit, :label) { path }.invoke(context, options).should == unit.view_path
         end
       end
     end

data/spec/nyanko/invoker_spec.rb

@@ -36,6 +36,18 @@ module Nyanko
         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 ==
@@ -98,19 +110,6 @@ module Nyanko
         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 function is not found" do
         it "runs default but not handled by ExceptionHandler" do
           ExceptionHandler.should_not_receive(:handle)

data/spec/nyanko/test_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "nyanko/test"
+
+module Nyanko
+  describe Test do
+    let(:view) do
+      Class.new(ActionView::Base) do
+        include Nyanko::Invoker
+        include Nyanko::Helper
+        include Nyanko::UnitProxyProvider
+      end.new
+    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"
+      end
+    end
+
+    describe "#disable_unit" do
+      it "forces to disable specified unit" do
+        disable_unit(:example_unit)
+        view.invoke(:example_unit, :test).should == nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -23,3 +23,5 @@ RSpec.configure do |config|
     Nyanko::Config.units_directory_path = File.expand_path("../fixtures/units", __FILE__)
   end
 end
+
+Nyanko::Config.units_directory_path = File.expand_path("../fixtures/units", __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nyanko
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-30 00:00:00.000000000 Z
+date: 2013-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -199,6 +199,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- lib/generators/nyanko/unit/templates/unit.rb.erb
+- lib/generators/nyanko/unit/unit_generator.rb
 - lib/nyanko.rb
 - lib/nyanko/active_if.rb
 - lib/nyanko/config.rb
@@ -212,6 +214,7 @@ files:
 - lib/nyanko/loader.rb
 - lib/nyanko/logger.rb
 - lib/nyanko/railtie.rb
+- lib/nyanko/test.rb
 - lib/nyanko/unit.rb
 - lib/nyanko/unit/extender.rb
 - lib/nyanko/unit/extender/active_record_class_methods.rb
@@ -266,7 +269,10 @@ files:
 - spec/dummy/public/favicon.ico
 - spec/dummy/script/rails
 - spec/fixtures/units/example_unit/example_unit.rb
+- spec/fixtures/units/example_unit/views/_test.html.erb
 - spec/fixtures/units/inactive_unit/inactive_unit.rb
+- spec/fixtures/units/insensitive_unit/insensitive_unit.rb
+- spec/fixtures/units/sensitive_unit/sensitive_unit.rb
 - spec/nyanko/controller_spec.rb
 - spec/nyanko/exception_handler_spec.rb
 - spec/nyanko/function_spec.rb
@@ -274,6 +280,7 @@ files:
 - spec/nyanko/invoker_spec.rb
 - spec/nyanko/loader_spec.rb
 - spec/nyanko/logger_spec.rb
+- spec/nyanko/test_spec.rb
 - spec/nyanko/unit/extender_spec.rb
 - spec/nyanko/unit/scope_finder_spec.rb
 - spec/nyanko/unit_proxy_provider_spec.rb
@@ -350,7 +357,10 @@ test_files:
 - spec/dummy/public/favicon.ico
 - spec/dummy/script/rails
 - spec/fixtures/units/example_unit/example_unit.rb
+- spec/fixtures/units/example_unit/views/_test.html.erb
 - spec/fixtures/units/inactive_unit/inactive_unit.rb
+- spec/fixtures/units/insensitive_unit/insensitive_unit.rb
+- spec/fixtures/units/sensitive_unit/sensitive_unit.rb
 - spec/nyanko/controller_spec.rb
 - spec/nyanko/exception_handler_spec.rb
 - spec/nyanko/function_spec.rb
@@ -358,6 +368,7 @@ test_files:
 - spec/nyanko/invoker_spec.rb
 - spec/nyanko/loader_spec.rb
 - spec/nyanko/logger_spec.rb
+- spec/nyanko/test_spec.rb
 - spec/nyanko/unit/extender_spec.rb
 - spec/nyanko/unit/scope_finder_spec.rb
 - spec/nyanko/unit_proxy_provider_spec.rb