chanko 1.0.6 → 2.0.0

data/lib/chanko/function.rb

@@ -0,0 +1,85 @@
+module Chanko
+  class Function
+    attr_reader :block, :unit, :label
+
+    class << self
+      def units
+        @units ||= []
+      end
+
+      def current_unit
+        units.last
+      end
+    end
+
+    def initialize(unit, label, &block)
+      @unit  = unit
+      @label = label
+      @block = block
+    end
+
+    def invoke(context, options = {})
+      with_unit_stack(context) do
+        with_unit_view_path(context) do
+          capture_exception(context) do
+            result = context.instance_eval(&block)
+            result = decorate(result, context, options[:type]) if context.view? && result.present?
+            result
+          end
+        end
+      end
+    end
+
+    def css_classes
+      if Config.compatible_css_class
+        %W[
+          extension
+          ext_#{unit.unit_name}
+          ext_#{unit.unit_name}-#{label}
+        ]
+      else
+        %W[
+          unit
+          unit__#{unit.unit_name}
+          unit__#{unit.unit_name}__#{label}
+        ]
+      end
+    end
+
+    private
+
+    def with_unit_stack(context)
+      context.units << @unit
+      self.class.units << @unit
+      yield
+    ensure
+      self.class.units.pop
+      context.units.pop
+    end
+
+    def with_unit_view_path(context)
+      context.view_paths.unshift unit.resolver if context.respond_to?(:view_paths)
+      yield
+    ensure
+      context.view_paths.paths.shift if context.respond_to?(:view_paths)
+    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/chanko/helper.rb

@@ -0,0 +1,29 @@
+module Chanko
+  module Helper
+    class << self
+      def define(unit_name, &block)
+        prefix = UnitProxy.generate_prefix(unit_name)
+        define_methods_with_prefix(prefix, &block)
+      end
+
+      def define_methods_with_prefix(prefix, &block)
+        define_methods(&block).each do |name|
+          change_method_name(name, "#{prefix}#{name}")
+        end
+      end
+
+      def define_methods(&block)
+        before = instance_methods(false)
+        self.class_eval(&block)
+        instance_methods(false) - before
+      end
+
+      def change_method_name(from, to)
+        class_eval do
+          alias_method to, from
+          remove_method from
+        end
+      end
+    end
+  end
+end

data/lib/chanko/invoker.rb

@@ -0,0 +1,105 @@
+require "chanko/invoker/options"
+require "chanko/invoker/function_finder"
+
+module Chanko
+  module Invoker
+    def invoke(*args, &block)
+      options = Options.new(*args)
+      __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
+      @units ||= []
+    end
+
+    def view?
+      is_a?(ActionView::Base)
+    end
+
+    def run_default
+      __invoke_default_block if __has_default_block?
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      if shared_method = __find_shared_method(method_name)
+        instance_exec(*args, &shared_method)
+      elsif args.empty? && __find_unit_local(method_name)
+        __fetch_unit_local(method_name)
+      else
+        super
+      end
+    end
+
+    def __find_unit_local(method_name)
+      __current_unit_locals.has_key?(method_name)
+    end
+
+    def __fetch_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 __current_unit
+      units.last
+    end
+
+    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
+        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/chanko/invoker/function_finder.rb

@@ -0,0 +1,42 @@
+module Chanko
+  module Invoker
+    class FunctionFinder
+      def self.find(context, options)
+        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
+        active? && find_function
+      end
+
+      def scope
+        as || context.class
+      end
+
+      def unit
+        Loader.load(unit_name)
+      end
+
+      def find_function
+        unit.find_function(scope, label)
+      end
+
+      def active?
+        if unit
+          unit.active?(context, active_if_options)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/chanko/invoker/options.rb

@@ -0,0 +1,64 @@
+module Chanko
+  module Invoker
+    class Options
+      CANDIDATES = {
+        :active_if_options => true,
+        :as                => true,
+        :capture           => true,
+        :locals            => true,
+        :type              => true,
+      }
+
+      def initialize(*args)
+        @raw_options = args.extract_options!
+        @args = args
+      end
+
+      def unit_name
+        @args[0]
+      end
+
+      def label
+        @args[1]
+      end
+
+      def locals
+        (options[:locals] || {}).symbolize_keys
+      end
+
+      def active_if_options
+        options[:active_if_options] || {}
+      end
+
+      def as
+        options[:as]
+      end
+
+      def capture
+        options.has_key?(:capture) ? capture[:capture] : true
+      end
+
+      def type
+        options[:type]
+      end
+
+      def invoke_options
+        { :capture => capture, :type => type }
+      end
+
+      def options
+        @options ||= begin
+          if short_hand_options?
+            { :locals => @raw_options }
+          else
+            @raw_options
+          end
+        end
+      end
+
+      def short_hand_options?
+        @raw_options.any? && @raw_options.keys.all? {|key| !CANDIDATES[key] }
+      end
+    end
+  end
+end

data/lib/chanko/loader.rb

@@ -0,0 +1,65 @@
+require "pathname"
+
+module Chanko
+  class Loader
+    class << self
+      def load(unit_name)
+        new(unit_name).load
+      end
+
+      def cache
+        @cache ||= {}
+      end
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def load
+      if loaded?
+        load_from_cache
+      else
+        load_from_file
+      end
+    end
+
+    def loaded?
+      cache[@name] != nil
+    end
+
+    def load_from_cache
+      cache[@name]
+    end
+
+    def load_from_file
+      add_autoload_path
+      cache[@name] = constantize
+    rescue Exception => exception
+      ExceptionHandler.handle(exception)
+      cache[@name] = false
+      nil
+    end
+
+    def add_autoload_path
+      ActiveSupport::Dependencies.autoload_paths << autoload_path
+      ActiveSupport::Dependencies.autoload_paths.uniq!
+    end
+
+    def autoload_path
+      Rails.root.join("#{directory_path}/#@name").to_s
+    end
+
+    def directory_path
+      Config.units_directory_path
+    end
+
+    def constantize
+      @name.to_s.camelize.constantize
+    end
+
+    def cache
+      self.class.cache
+    end
+  end
+end

data/lib/chanko/logger.rb

@@ -0,0 +1,67 @@
+module Chanko
+  module Logger
+
+    class << self
+      ::Logger::Severity.constants.each do |level|
+        method_name = level.downcase
+        define_method(method_name) do |message|
+          logger.try(method_name, decorate(message)) if Config.enable_logger
+        end
+      end
+
+      def decorate(message)
+        Message.new(message).to_s
+      end
+
+      def logger
+        Rails.logger
+      end
+    end
+
+    class Message
+      PREFIX = "  [Chanko]"
+
+      def initialize(object)
+        @object = object
+      end
+
+      def to_s
+        prefix(content)
+      end
+
+      def prefix(str)
+        str.split("\n").map {|line| "#{PREFIX} #{line}" }.join("\n")
+      end
+
+      def content
+        if @object.is_a?(Exception)
+          "#{klass}#{body}#{backtrace}"
+        else
+          @object.to_s
+        end
+      end
+
+      def body
+        unless @object.message.empty?
+          " - #@object"
+        end
+      end
+
+      def klass
+        @object.class
+      end
+
+      def backtrace
+        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
+end