chanko 2.0.0 → 2.3.0

data/lib/chanko/active_if.rb

@@ -1,5 +1,8 @@
 module Chanko
   class ActiveIf
+    class NoConditionFound < StandardError
+    end
+
     class << self
       def define(label, &block)
         definitions[label] = block
@@ -18,10 +21,18 @@ module Chanko
       end
     end
 
-    attr_reader :conditions, :options
+    attr_reader :conditions
+
+    def options # remains just for backward compatibility
+      warn "ActiveIf#options is deprecated and is never used at #{caller[0]}"
+      @options
+    end
 
     def initialize(*conditions, &block)
       @options    = conditions.extract_options!
+      unless @options.empty?
+        warn "options in ActiveIf#new are deprecated and are never used at #{caller[0]}"
+      end
       @conditions = conditions
       @block      = block
     end
@@ -33,26 +44,47 @@ module Chanko
     def blocks
       @blocks ||= begin
         conditions.map do |condition|
-          condition.is_a?(Any) ? condition.to_block : self.class.find(condition)
+          Block.new(condition)
         end << @block
       end.compact
     end
 
-    class Any
-      def initialize(*labels)
-        @labels = labels
+    class Block
+      def initialize(*conditions)
+        @conditions = conditions
+      end
+
+      def call(context, options)
+        block.call(context, options)
+      end
+
+      def block
+        condition = @conditions.first
+        if condition.kind_of?(Block)
+          condition
+        else
+          ActiveIf.find(condition) or raise NoConditionFound, condition
+        end
       end
+    end
 
-      def to_block
+    class Any < Block
+      def block
         proc do |context, options|
-          definitions.any? do |definition|
-            definition.call(context, options)
+          @conditions.any? do |condition|
+            Block.new(condition).call(context, options)
           end
         end
       end
+    end
 
-      def definitions
-        @labels.map {|label| ActiveIf.find(label) }
+    class None < Block
+      def block
+        proc do |context, options|
+          @conditions.none? do |condition|
+            Block.new(condition).call(context, options)
+          end
+        end
       end
     end
   end

data/lib/chanko/config.rb

@@ -1,3 +1,5 @@
+require 'chanko/resolver/no_cache_file_system_resolver'
+
 module Chanko
   module Config
     class << self
@@ -7,10 +9,10 @@ module Chanko
         :cache_units,
         :compatible_css_class,
         :enable_logger,
+        :propagated_errors,
         :proxy_method_name,
         :raise_error,
         :resolver,
-        :units_directory_path
       )
 
       def reset
@@ -18,11 +20,27 @@ module Chanko
         self.backtrace_limit      = 10
         self.compatible_css_class = false
         self.enable_logger        = true
+        self.propagated_errors    = []
         self.proxy_method_name    = :unit
         self.raise_error          = Rails.env.development?
-        self.resolver             = ActionView::OptimizedFileSystemResolver
+        self.resolver = resolver_for_using_rails_and_env
         self.units_directory_path = "app/units"
       end
+
+      def units_directory_path=(path)
+        @units_directory_path = path
+      end
+
+      def units_directory_path
+        @resolved_units_directory_path ||= Rails.root.join(@units_directory_path).to_s
+      end
+
+      def resolver_for_using_rails_and_env
+        return ActionView::FileSystemResolver if Rails::VERSION::MAJOR >= 7
+        return Chanko::Resolver::NoCacheFileSystemResolver if Rails.env.development?
+        return ActionView::OptimizedFileSystemResolver
+      end
+      private :resolver_for_using_rails_and_env
     end
 
     reset

data/lib/chanko/controller.rb

@@ -8,7 +8,7 @@ module Chanko
       def inherited(base)
         if Config.auto_reload && base.name == "ApplicationController"
           base.class_eval do
-            prepend_before_filter do
+            prepend_before_action do
               Chanko::Loader.cache.clear
             end
           end

data/lib/chanko/exception_handler.rb

@@ -1,10 +1,37 @@
 module Chanko
-  module ExceptionHandler
-    class << self
-      def handle(exception, unit = nil)
-        Logger.debug(exception)
-        raise exception if unit.try(:raise_error?) || Config.raise_error
+  class ExceptionHandler
+    def self.handle(*args)
+      new(*args).handle
+    end
+
+    attr_reader :exception, :unit
+
+    def initialize(exception, unit = nil)
+      @exception = exception
+      @unit      = unit
+    end
+
+    def handle
+      if propagated?
+        raise exception
+      else
+        log
+        raise exception if raised?
       end
     end
+
+    private
+
+    def propagated?
+      Config.propagated_errors.any? {|klass| exception.is_a?(klass) }
+    end
+
+    def raised?
+      unit.try(:raise_error?) || Config.raise_error
+    end
+
+    def log
+      Logger.debug(exception)
+    end
   end
 end

data/lib/chanko/function.rb

@@ -2,9 +2,11 @@ module Chanko
   class Function
     attr_reader :block, :unit, :label
 
+    THREAD_LOCAL_UNITS_KEY = 'Chanko::Function.units'
+
     class << self
       def units
-        @units ||= []
+        Thread.current[THREAD_LOCAL_UNITS_KEY] ||= []
       end
 
       def current_unit

data/lib/chanko/invoker.rb

@@ -81,10 +81,17 @@ module Chanko
     end
 
     def __invoke_default_block
-      if view?
-        capture(&__default_block)
-      else
-        instance_exec(&__default_block)
+      current_default_block = __default_block
+      begin
+        __without_default_stack do
+          __without_locals_stack do
+            if view?
+              capture(&current_default_block)
+            else
+              instance_exec(&current_default_block)
+            end
+          end
+        end
       end
     end
 
@@ -101,5 +108,19 @@ module Chanko
     ensure
       __unit_locals_stack.pop
     end
+
+    def __without_default_stack
+      default = __defaults_stack.pop
+      yield
+    ensure
+      __defaults_stack << default
+    end
+
+    def __without_locals_stack
+      locals = __unit_locals_stack.pop
+      yield
+    ensure
+      __unit_locals_stack << locals
+    end
   end
 end

data/lib/chanko/loader.rb

@@ -1,65 +1,149 @@
 require "pathname"
-
 module Chanko
-  class Loader
-    class << self
-      def load(unit_name)
-        new(unit_name).load
-      end
+  module Loader
+    class MissingEagarLoadSettingError < StandardError; end
 
-      def cache
-        @cache ||= {}
-      end
+    class << self
+      delegate :load, :cache, :eager_load_units!, to: "loader"
     end
 
-    def initialize(name)
-      @name = name
+    def self.loader
+      zeitwerk? ? ZeitwerkLoader : ClassicLoader
     end
 
-    def load
-      if loaded?
-        load_from_cache
-      else
-        load_from_file
-      end
+    def self.zeitwerk?
+      Rails.respond_to?(:autoloaders) && Rails.autoloaders.zeitwerk_enabled?
     end
 
-    def loaded?
-      cache[@name] != nil
+    def self.classic?
+      !zeitwerk?
     end
 
-    def load_from_cache
-      cache[@name]
+    def self.prepare_eager_load(mode: )
+      if mode == :zeitwerk && zeitwerk?
+        self.loader.prepare_eager_load
+      elsif mode == :classic && classic?
+        self.loader.prepare_eager_load
+      end
     end
 
-    def load_from_file
-      add_autoload_path
-      cache[@name] = constantize
-    rescue Exception => exception
-      ExceptionHandler.handle(exception)
-      cache[@name] = false
-      nil
-    end
+    class ZeitwerkLoader
+      def self.load(name)
+        self.new(name).load
+      end
 
-    def add_autoload_path
-      ActiveSupport::Dependencies.autoload_paths << autoload_path
-      ActiveSupport::Dependencies.autoload_paths.uniq!
-    end
+      def self.cache
+        # backward compatibility
+        { }
+      end
 
-    def autoload_path
-      Rails.root.join("#{directory_path}/#@name").to_s
-    end
+      def self.eager_load_units!
+        # Zeitwerk load chanko units as default
+      end
 
-    def directory_path
-      Config.units_directory_path
-    end
+      def self.prepare_eager_load
+        add_unit_directory_to_eager_load_paths
+        Rails.autoloaders.main.collapse(Chanko::Config.units_directory_path + '/*')
+        Rails.autoloaders.main.ignore(Chanko::Config.units_directory_path + '/*/spec*')
+      end
+
+      def self.add_unit_directory_to_eager_load_paths
+        path = Chanko::Config.units_directory_path
+
+        unless Rails.configuration.eager_load_paths.include?(path)
+          Rails.configuration.eager_load_paths << path
+        end
+      end
+
+      def initialize(name)
+        @name = name
+      end
 
-    def constantize
-      @name.to_s.camelize.constantize
+      def load
+        constantize
+      rescue NameError
+        # Chanko never raise error even if the constant fails to reference
+        false
+      end
+
+      def constantize
+        @name.to_s.camelize.constantize
+      end
     end
 
-    def cache
-      self.class.cache
+    class ClassicLoader
+      def self.cache
+        @cache ||= {}
+      end
+
+      def self.eager_load_units!
+        Pathname.glob("#{Chanko::Config.units_directory_path}/*").select(&:directory?).each do |path|
+          Chanko::Loader::ClassicLoader.load(path.basename.to_s.to_sym)
+        end
+      end
+
+      def self.prepare_eager_load
+        raise MissingEagarLoadSettingError if Rails.configuration.eager_load.nil?
+
+        if Rails.configuration.eager_load
+          ruleout_unit_files_from_rails_eager_loading
+        end
+      end
+
+      def self.ruleout_unit_files_from_rails_eager_loading
+        Rails.configuration.eager_load_paths.delete(Chanko::Config.units_directory_path)
+      end
+
+      def self.load(name)
+        self.new(name).load
+      end
+
+      def self.load_from_cache(name)
+        self.cache[name]
+      end
+
+      def self.save_to_cache(name, unit)
+        self.cache[name] = unit
+      end
+
+      def initialize(name)
+        @name = name
+      end
+
+      def load
+        load_from_cache.then do |unit|
+          next unit unless unit.nil?
+          load_from_file_and_store_to_cache
+        end
+      end
+
+      def load_from_file_and_store_to_cache
+        add_autoload_path
+        constantize.tap do |unit|
+          self.class.save_to_cache(@name, unit)
+        end
+      rescue Exception => exception
+        ExceptionHandler.handle(exception)
+        self.class.save_to_cache(@name, false)
+        false
+      end
+
+      def load_from_cache
+        self.class.load_from_cache(@name)
+      end
+
+      def add_autoload_path
+        ActiveSupport::Dependencies.autoload_paths << autoload_path
+        ActiveSupport::Dependencies.autoload_paths.uniq!
+      end
+
+      def autoload_path
+        "#{Config.units_directory_path }/#{@name}"
+      end
+
+      def constantize
+        @name.to_s.camelize.constantize
+      end
     end
   end
 end

data/lib/chanko/railtie.rb

@@ -1,11 +1,38 @@
 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)
+    initializer "chanko.include", before: :eager_load! do |app|
+      ActiveSupport.on_load :action_view do
+        ::ActionView::Base.send(:include, Helper, Invoker, UnitProxyProvider)
+      end
+      ActiveSupport.on_load :action_controller do
+        ::ActionController::Base.send(:include, Controller, Invoker, UnitProxyProvider)
+      end
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.send(:include, UnitProxyProvider)
+        ::ActiveRecord::Relation.send(:include, UnitProxyProvider)
+        ::ActiveRecord::Associations::CollectionAssociation.send(:include, UnitProxyProvider)
+      end
+    end
+
+
+    initializer("chanko.zeitwerk.prepare_eager_load", before: :set_autoload_paths) do |app|
+      # zeitwerk freezes autoload_paths after :set_autoload_paths.
+      # So we need to prepare before set_autoload_paths
+      Chanko::Loader.prepare_eager_load(mode: :zeitwerk)
+    end
+
+    initializer("chanko.classic.prepare_eager_load", after: :load_environment_config) do |app|
+      # Rails5 doens't load environments/*.rb files before :set_autoload_paths.
+      # In other words, at this stage, config.eager_load cannot be determined to be true or false.
+      # But classic loader does not freeze paths on :set_autoload_paths.
+      # After all, It's ok if it is executed after :set_autoload_paths on Rails5 and Rails6(classic).
+      Chanko::Loader.prepare_eager_load(mode: :classic)
+    end
+
+    initializer("chanko.eager_load_units", before: :eager_load!) do |app|
+      # This is why we need handmade eager-loading
+      # https://github.com/cookpad/chanko/pull/38
+      Chanko::Loader.eager_load_units!
     end
   end
 end

data/lib/chanko/resolver/no_cache_file_system_resolver.rb

@@ -0,0 +1,13 @@
+unless defined?(ActionView::FileSystemResolver)
+  require 'action_view/template/resolver'
+end
+
+module Chanko
+  module Resolver
+    class NoCacheFileSystemResolver < ActionView::FileSystemResolver
+      def query(path, details, formats, locals, cache:)
+        super(path, details, formats, locals, cache: false)
+      end
+    end
+  end
+end

data/lib/chanko/test.rb

@@ -8,6 +8,10 @@ module Chanko
       def included(base)
         base.send :include, UnitProxyProvider
       end
+
+      def logger
+        @logger = ::Logger.new(STDOUT)
+      end
     end
 
     def enable_unit(unit_name)
@@ -33,7 +37,8 @@ module Chanko
           active_without_activations?(*args)
         end
       end
-      alias_method_chain :active?, :activations
+      alias_method :active_without_activations?, :active?
+      alias_method :active?, :active_with_activations?
     end
   end
 end

data/lib/chanko/unit/scope_finder.rb

@@ -1,12 +1,6 @@
 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
@@ -34,7 +28,13 @@ module Chanko
       end
 
       def label
-        LABEL_SCOPE_MAP[@identifier]
+        label_scope_map = {
+          :controller => ActionController::Base,
+          :model      => ActiveRecord::Base,
+          :view       => ActionView::Base
+        }
+
+        label_scope_map[@identifier]
       end
     end
   end

data/lib/chanko/unit.rb

@@ -49,6 +49,10 @@ module Chanko
         ActiveIf::Any.new(*labels)
       end
 
+      def none(*labels)
+        ActiveIf::None.new(*labels)
+      end
+
       def raise_error
         @raise_error = true
       end
@@ -67,7 +71,7 @@ module Chanko
       end
 
       def view_path
-        "#{Config.units_directory_path}/#{unit_name}/views"
+        Rails.root.join("#{Config.units_directory_path}/#{unit_name}/views").to_s
       end
 
       def find_function(identifier, label)

data/lib/chanko/unit_proxy.rb

@@ -26,5 +26,9 @@ module Chanko
     def method_missing(method_name, *args, &block)
       @context.send("#{prefix}#{method_name}", *args, &block)
     end
+
+    def respond_to_missing?(method_name, include_private)
+      @context.respond_to?("#{prefix}#{method_name}")
+    end
   end
 end

data/lib/chanko/version.rb

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

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

@@ -48,7 +48,7 @@ module <%= class_name %>
   # ## 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.
+  # `User.find(params[:id]).unit.active?` or `User.unit.gc_all_soft_deleted_users`.
   #
   # ```
   # models do
@@ -58,6 +58,12 @@ module <%= class_name %>
   #     def active?
   #       deleted_at.nil?
   #     end
+  #
+  #     class_methods do
+  #       def gc_all_soft_deleted_users
+  #         where.not(deleted_at: nil).delete_all
+  #       end
+  #     end
   #   end
   # end
   # ```

data/spec/chanko/controller_spec.rb

@@ -22,21 +22,21 @@ module Chanko
       end
 
       it "defines an action to invoke unit function" do
-        controller.test.should == "test"
+        expect(controller.test).to eq("test")
       end
 
       it "defines 2 actions at one line" do
-        controller.foo.should == "foo"
-        controller.bar.should == "bar"
+        expect(controller.foo).to eq("foo")
+        expect(controller.bar).to eq("bar")
       end
 
       it "is aliased with `ext_action`" do
-        controller.alias.should == "alias"
+        expect(controller.alias).to eq("alias")
       end
 
       context "when invoke is fallen back" do
         it "halts with 400 status code" do
-          controller.error.should == "Bad Request 400"
+          expect(controller.error).to eq("Bad Request 400")
         end
       end
     end

data/spec/chanko/deprecated_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+module Chanko
+  describe ActiveIf do
+    around do |example|
+      origin, $stderr = $stderr, StringIO.new
+      example.run
+      $stderr = origin
+    end
+
+    describe ".new" do
+      context "with option arguments" do
+        it "prints warning message on standard error output" do
+          ActiveIf.new(foo: "bar")
+          expect($stderr.string).to match(/\Aoptions in ActiveIf#new are deprecated and are never used at #{__FILE__}/)
+        end
+      end
+    end
+
+    describe "#options" do
+      it "prints warning message on standard error output" do
+        ActiveIf.new.options
+        expect($stderr.string).to match(/\AActiveIf#options is deprecated and is never used at #{__FILE__}/)
+      end
+    end
+  end
+end