chanko 1.0.6 → 2.0.0

data/lib/chanko/railtie.rb

@@ -0,0 +1,11 @@
+module Chanko
+  class Railtie < Rails::Railtie
+    initializer "chanko" do |app|
+      ::ActionView::Base.send(:include, Helper, Invoker, UnitProxyProvider)
+      ::ActionController::Base.send(:include, Controller, Invoker, UnitProxyProvider)
+      ::ActiveRecord::Base.send(:include, UnitProxyProvider)
+      ::ActiveRecord::Relation.send(:include, UnitProxyProvider)
+      ::ActiveRecord::Associations::CollectionAssociation.send(:include, UnitProxyProvider)
+    end
+  end
+end

data/lib/chanko/test.rb

@@ -0,0 +1,44 @@
+module Chanko
+  module Test
+    class << self
+      def activations
+        @activations ||= {}
+      end
+
+      def included(base)
+        base.send :include, UnitProxyProvider
+      end
+    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 Chanko::Test
+  config.after { Chanko::Test.activations.clear }
+end

data/lib/chanko/unit.rb

@@ -0,0 +1,101 @@
+require "chanko/unit/extender"
+require "chanko/unit/scope_finder"
+
+module Chanko
+  module Unit
+    extend ActiveSupport::Concern
+
+    included do
+      active_if { true }
+    end
+
+    module ClassMethods
+      attr_accessor :current_scope
+
+      def scope(identifier)
+        self.current_scope = ScopeFinder.find(identifier)
+        scopes[current_scope] ||= {}
+        yield
+      ensure
+        self.current_scope = nil
+      end
+
+      def function(label, &block)
+        functions[label] = Function.new(self, label, &block)
+      end
+      alias_method :callback, :function
+
+      def shared(label, &block)
+        shared_methods[label] = block
+      end
+
+      def helpers(&block)
+        Helper.define(unit_name, &block)
+      end
+
+      def models(&block)
+        extender.instance_eval(&block)
+      end
+
+      def active_if(*conditions, &block)
+        @active_if = ActiveIf.new(*conditions, &block)
+      end
+
+      def active?(context, options = {})
+        @active_if.active?(context, options.merge(:unit => self))
+      end
+
+      def any(*labels)
+        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
+
+      def to_prefix
+        UnitProxy.generate_prefix(unit_name)
+      end
+
+      def view_path
+        "#{Config.units_directory_path}/#{unit_name}/views"
+      end
+
+      def find_function(identifier, label)
+        scope     = ScopeFinder.find(identifier)
+        target    = scope.ancestors.find {|klass| scopes[klass] }
+        functions = scopes[target]
+        functions[label] if functions
+      end
+
+      def functions
+        scopes[current_scope]
+      end
+
+      def scopes
+        @scopes ||= {}
+      end
+
+      def shared_methods
+        @shared_methods ||= {}
+      end
+
+      def resolver
+        @resolver ||= Config.resolver.new(view_path)
+      end
+
+      def extender
+        @extender ||= Extender.new(to_prefix)
+      end
+    end
+  end
+end

data/lib/chanko/unit/extender.rb

@@ -0,0 +1,21 @@
+require "chanko/unit/extender/active_record_class_methods"
+require "chanko/unit/extender/extension"
+
+module Chanko
+  module Unit
+    class Extender
+      def initialize(prefix = nil)
+        @prefix = prefix
+      end
+
+      def expand(mod, &block)
+        mod       = mod.to_s.camelize.constantize unless mod.is_a?(Module)
+        extension = Extension.new(mod, @prefix, &block)
+        mod.class_eval do
+          include extension.instance_methods_module
+          extend extension.class_methods_module
+        end
+      end
+    end
+  end
+end

data/lib/chanko/unit/extender/active_record_class_methods.rb

@@ -0,0 +1,57 @@
+module Chanko
+  module Unit
+    class Extender
+      module ActiveRecordClassMethods
+        delegate(
+          :apply_modules,
+          :arel,
+          :array_of_strings?,
+          :build_arel,
+          :build_joins,
+          :build_select,
+          :build_where,
+          :create_with,
+          :custom_join_sql,
+          :eager_load,
+          :extending,
+          :from,
+          :group,
+          :having,
+          :includes,
+          :joins,
+          :limit,
+          :lock,
+          :offset,
+          :order,
+          :preload,
+          :readonly,
+          :reorder,
+          :reverse_order,
+          :reverse_sql_order,
+          :scope,
+          :select,
+          :where,
+          :to => :@mod
+        )
+
+        %w[belongs_to has_many has_one].each do |method_name|
+          class_eval <<-EOS
+            def #{method_name}(*args, &block)
+              label   = args.shift.to_s
+              name    = @prefix + label
+              options = args.extract_options!
+              options = options.reverse_merge(:class_name => label.singularize.camelize)
+              args << options
+              @mod.#{method_name}(name.to_sym, *args, &block)
+            end
+          EOS
+        end
+
+        def scope(*args, &block)
+          name = @prefix + args.shift.to_s
+          @mod.scope(name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/chanko/unit/extender/extension.rb

@@ -0,0 +1,51 @@
+module Chanko
+  module Unit
+    class Extender
+      class Extension < Module
+        include ActiveRecordClassMethods
+
+        def initialize(mod, prefix = nil, &block)
+          @mod    = mod
+          @prefix = prefix
+          @block  = block
+          define_methods_with_prefix(instance_methods_module, &block)
+        end
+
+        def class_methods(&block)
+          define_methods_with_prefix(class_methods_module, &block)
+        end
+
+        def instance_methods_module
+          self
+        end
+
+        def class_methods_module
+          @class_methods_module ||= Module.new
+        end
+
+        private
+
+        def define_methods_with_prefix(container, &block)
+          define_methods(container, &block).each do |added_method_name|
+            change_method_name_with_prefix(container, added_method_name) if @prefix.present?
+          end
+        end
+
+        def define_methods(container, &block)
+          before = container.instance_methods(false)
+          container.class_eval(&block)
+          container.instance_methods(false) - before
+        end
+
+        def change_method_name_with_prefix(container, method_name)
+          from = method_name
+          to   = "#@prefix#{method_name}"
+          container.class_eval do
+            alias_method to, from
+            remove_method from
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chanko/unit/scope_finder.rb

@@ -0,0 +1,41 @@
+module Chanko
+  module Unit
+    class ScopeFinder
+      LABEL_SCOPE_MAP = {
+        :controller => ActionController::Base,
+        :model      => ActiveRecord::Base,
+        :view       => ActionView::Base,
+      }
+
+      def self.find(*args)
+        new(*args).find
+      end
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def find
+        case
+        when class?
+          @identifier
+        when label
+          label
+        else
+          @identifier.to_s.constantize
+        end
+      rescue NameError
+      end
+
+      private
+
+      def class?
+        @identifier.is_a?(Class)
+      end
+
+      def label
+        LABEL_SCOPE_MAP[@identifier]
+      end
+    end
+  end
+end

data/lib/chanko/unit_proxy.rb

@@ -0,0 +1,30 @@
+require "delegate"
+
+module Chanko
+  class UnitProxy
+    attr_reader :unit
+
+    def self.generate_prefix(unit_name)
+      "__#{unit_name}_"
+    end
+
+    def initialize(unit, context)
+      @unit    = unit
+      @context = context
+    end
+
+    def active?(options = {})
+      @unit.active?(@context, options)
+    end
+
+    private
+
+    def prefix
+      self.class.generate_prefix(@unit.unit_name)
+    end
+
+    def method_missing(method_name, *args, &block)
+      @context.send("#{prefix}#{method_name}", *args, &block)
+    end
+  end
+end

data/lib/chanko/unit_proxy_provider.rb

@@ -0,0 +1,27 @@
+module Chanko
+  module UnitProxyProvider
+    extend ActiveSupport::Concern
+
+    included do
+      extend UnitProxyProvider
+    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
+          define_method(method_name) do |*_args|
+            name = _args.first || Function.current_unit.try(:unit_name)
+            if name && unit = Loader.load(name)
+              UnitProxy.new(unit, self)
+            end
+          end
+        end
+        send(method_name, args.first)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/chanko/version.rb

@@ -0,0 +1,3 @@
+module Chanko
+  VERSION = "2.0.0"
+end

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

@@ -0,0 +1,84 @@
+module <%= class_name %>
+  include Chanko::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
+  #     "Chanko!"
+  #   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(:view) 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.
+  #
+  # ```
+  # 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