chanko 2.2.1 → 2.3.0

data/lib/chanko/config.rb

@@ -1,3 +1,5 @@
+require 'chanko/resolver/no_cache_file_system_resolver'
+
 module Chanko
   module Config
     class << self
@@ -6,13 +8,11 @@ module Chanko
         :backtrace_limit,
         :cache_units,
         :compatible_css_class,
-        :eager_load,
         :enable_logger,
         :propagated_errors,
         :proxy_method_name,
         :raise_error,
         :resolver,
-        :units_directory_path
       )
 
       def reset
@@ -20,13 +20,27 @@ module Chanko
         self.backtrace_limit      = 10
         self.compatible_css_class = false
         self.enable_logger        = true
-        self.eager_load           = Rails.env.production?
         self.propagated_errors    = []
         self.proxy_method_name    = :unit
         self.raise_error          = Rails.env.development?
-        self.resolver             = Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('7') ? ActionView::FileSystemResolver : 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/loader.rb

@@ -1,73 +1,149 @@
 require "pathname"
-
 module Chanko
-  class Loader
+  module Loader
+    class MissingEagarLoadSettingError < StandardError; end
+
     class << self
-      def load(unit_name)
-        new(unit_name).load
+      delegate :load, :cache, :eager_load_units!, to: "loader"
+    end
+
+    def self.loader
+      zeitwerk? ? ZeitwerkLoader : ClassicLoader
+    end
+
+    def self.zeitwerk?
+      Rails.respond_to?(:autoloaders) && Rails.autoloaders.zeitwerk_enabled?
+    end
+
+    def self.classic?
+      !zeitwerk?
+    end
+
+    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 cache
-        @cache ||= {}
+    class ZeitwerkLoader
+      def self.load(name)
+        self.new(name).load
+      end
+
+      def self.cache
+        # backward compatibility
+        { }
+      end
+
+      def self.eager_load_units!
+        # Zeitwerk load chanko units as default
+      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 eager_load_units!
-        Pathname.glob("#{Rails.root}/#{Config.units_directory_path}/*").select(&:directory?).each do |path|
-          load(path.to_s.split("/").last.to_sym) rescue nil
+      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
-    end
 
-    def initialize(name)
-      @name = name
-    end
+      def initialize(name)
+        @name = name
+      end
 
-    def load
-      if loaded?
-        load_from_cache
-      else
-        load_from_file
+      def load
+        constantize
+      rescue NameError
+        # Chanko never raise error even if the constant fails to reference
+        false
       end
-    end
 
-    def loaded?
-      cache[@name] != nil
+      def constantize
+        @name.to_s.camelize.constantize
+      end
     end
 
-    def load_from_cache
-      cache[@name]
-    end
+    class ClassicLoader
+      def self.cache
+        @cache ||= {}
+      end
 
-    def load_from_file
-      add_autoload_path
-      cache[@name] = constantize
-    rescue Exception => exception
-      ExceptionHandler.handle(exception)
-      cache[@name] = false
-      nil
-    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 add_autoload_path
-      unless Rails.respond_to?(:autoloaders) && Rails.autoloaders.zeitwerk_enabled?
-        ActiveSupport::Dependencies.autoload_paths << autoload_path
-        ActiveSupport::Dependencies.autoload_paths.uniq!
+      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
-    end
 
-    def autoload_path
-      Rails.root.join("#{directory_path}/#@name").to_s
-    end
+      def self.ruleout_unit_files_from_rails_eager_loading
+        Rails.configuration.eager_load_paths.delete(Chanko::Config.units_directory_path)
+      end
 
-    def directory_path
-      Config.units_directory_path
-    end
+      def self.load(name)
+        self.new(name).load
+      end
 
-    def constantize
-      @name.to_s.camelize.constantize
-    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 cache
-      self.class.cache
+      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,6 +1,6 @@
 module Chanko
   class Railtie < Rails::Railtie
-    initializer "chanko" do |app|
+    initializer "chanko.include", before: :eager_load! do |app|
       ActiveSupport.on_load :action_view do
         ::ActionView::Base.send(:include, Helper, Invoker, UnitProxyProvider)
       end
@@ -14,22 +14,25 @@ module Chanko
       end
     end
 
-    initializer("chanko.support_zeitwerk") do |app|
-      if Rails.respond_to?(:autoloaders) && Rails.autoloaders.zeitwerk_enabled?
-        Rails.autoloaders.main.collapse(Rails.root.join(Chanko::Config.units_directory_path, '*'))
-      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.prevent_units_directory_from_eager_loading", before: :set_autoload_paths) do |app|
-      if Chanko::Config.eager_load
-        Rails.configuration.eager_load_paths.delete(Rails.root.join(Chanko::Config.units_directory_path).to_s)
-      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") do |app|
-      if Chanko::Config.eager_load
-        Chanko::Loader.eager_load_units!
-      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)

data/lib/chanko/version.rb

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

data/spec/chanko/function_spec.rb

@@ -6,10 +6,25 @@ module Chanko
       Loader.load(:example_unit)
     end
 
-    let(:context) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
+    def rails5_action_view_instance
+      klass = Class.new(ActionView::Base) do
+        def current_unit
+          units.last
+        end
+
+        def units
+          @units ||= []
+        end
+
+        def path
+          view_paths.first.to_s
+        end
+      end
+      klass.new
+    end
 
+    def rails6_action_view_instance
+      klass = Class.new(ActionView::Base.with_empty_template_cache) do
         def current_unit
           units.last
         end
@@ -21,7 +36,18 @@ module Chanko
         def path
           view_paths.first.to_s
         end
-      end.new
+      end
+
+      klass.with_view_paths([], {}, nil)
+    end
+
+    let(:context) do
+      case Rails::VERSION::MAJOR
+      when 5
+        rails5_action_view_instance
+      when 6
+        rails6_action_view_instance
+      end
     end
 
     let(:context_without_view_paths) do

data/spec/chanko/invoker_spec.rb

@@ -3,19 +3,11 @@ 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
+      controller.helpers
     end
 
     let(:controller) do
-      Class.new(ActionController::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      Class.new(ActionController::Base).new
     end
 
     describe "#invoke" do

data/spec/chanko/loader_spec.rb

@@ -4,38 +4,40 @@ module Chanko
   describe Loader do
     describe ".load" do
       after do
-        described_class.cache.clear
+        Chanko::Loader.cache.clear
       end
 
       context "when existent unit name is passed" do
         it "loads unit in units directory and returns the Module" do
-          expect(described_class.load(:example_unit)).to eq(ExampleUnit)
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
         end
       end
 
       context "when non-existent unit name is passed" do
         it "returns nil" do
-          expect(described_class.load(:non_existent_unit)).to eq(nil)
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
         end
       end
 
       context "when loader has ever loaded specified unit" do
-        it "load unit from cache" do
-          expect_any_instance_of(described_class).to receive(:load_from_file).and_call_original
-          described_class.load(:example_unit)
-          described_class.load(:example_unit)
+        it "load unit from cache", classic: true do
+          expect(Chanko::Loader::ClassicLoader).to receive(:load_from_cache).twice.and_call_original
+          expect(Chanko::Loader::ClassicLoader).to receive(:save_to_cache).with(anything, ExampleUnit).and_call_original
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
+          expect(Chanko::Loader.load(:example_unit)).to eq(ExampleUnit)
         end
       end
 
       context "when loader has ever loaded specified wrong unit" do
         before do
-          described_class.cache.clear
+          Chanko::Loader.cache.clear
         end
 
-        it "load unit from cache" do
-          expect_any_instance_of(described_class).to receive(:load_from_file).and_call_original
-          described_class.load(:non_existent_unit)
-          described_class.load(:non_existent_unit)
+        it "load unit from cache", classic: true do
+          expect(Chanko::Loader::ClassicLoader).to receive(:load_from_cache).twice.and_call_original
+          expect(Chanko::Loader::ClassicLoader).to receive(:save_to_cache).with(anything, false).and_call_original
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
+          expect(Chanko::Loader.load(:non_existent_unit)).to eq(false)
         end
       end
     end

data/spec/chanko/test_spec.rb

@@ -3,12 +3,22 @@ require "chanko/test"
 
 module Chanko
   describe Test do
+    def rails5_action_view_instance
+      Class.new(ActionView::Base).new
+    end
+
+    def rails6_action_view_instance
+      klass = Class.new(ActionView::Base.with_empty_template_cache)
+      klass.with_view_paths(nil, {}, nil)
+    end
+
     let(:view) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      case Rails::VERSION::MAJOR
+      when 5
+        rails5_action_view_instance
+      when 6
+        rails6_action_view_instance
+      end
     end
 
     describe "#enable_unit" do

data/spec/controllers/application_controller_spec.rb

@@ -7,7 +7,7 @@ describe ApplicationController do
     end
   end
 
-  it "clears cache before each request" do
+  it "clears cache before each request", classic: true do
     expect(Chanko::Loader.cache).to receive(:clear).exactly(2)
     get :index
     get :index

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/spec/dummy/config/application.rb

@@ -48,6 +48,19 @@ module Dummy
 
     # Version of your assets, change this if you want to expire all your assets
     config.assets.version = '1.0'
+    config.assets.quiet = true if ::Rails::VERSION::MAJOR >= 5
+    if Rails::VERSION::MAJOR >= 6
+      if ENV['AUTOLOADER'] == 'zeitwerk'
+        Chanko::Test.logger.info("Autoloader: zeitwerk")
+        config.autoloader = :zeitwerk
+      else
+        Chanko::Test.logger.info("Autoloader: classic")
+        config.autoloader = :classic
+      end
+    end
   end
 end
 
+if Rails::VERSION::MAJOR >= 6 && Rails.autoloaders.zeitwerk_enabled?
+  Rails.autoloaders.main.collapse(Rails.root.join('app', 'units', '*'))
+end

data/spec/dummy/config/boot.rb

@@ -1,10 +1,9 @@
 require 'rubygems'
-gemfile = File.expand_path('../../../../Gemfile', __FILE__)
 
-if File.exist?(gemfile)
-  ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler'
-  Bundler.setup
+unless ENV['BUNDLE_GEMFILE']
+  raise "Select Gemfile_x.rb from gemfiles dir then set BUNDLE_GEMFILE"
 end
 
+require 'bundler/setup'
+
 $:.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/environment.rb

@@ -2,4 +2,4 @@
 require File.expand_path('../application', __FILE__)
 
 # Initialize the rails application
-Dummy::Application.initialize!
+Rails.application.initialize!

data/spec/dummy/config/environments/test.rb

@@ -29,5 +29,12 @@ Dummy::Application.configure do
   # Print deprecation notices to the stderr
   config.active_support.deprecation = :stderr
 
-  config.eager_load = false
+  if ENV['EAGER_LOAD'] == 'true'
+    Chanko::Test.logger.info("EagerLoad: on")
+    config.eager_load = true
+  else
+    Chanko::Test.logger.info("EagerLoad: off")
+    config.eager_load = false
+  end
+
 end

data/spec/dummy/config/storage.yml

@@ -0,0 +1 @@
+

data/spec/spec_helper.rb

@@ -1,14 +1,23 @@
-require "coveralls"
-Coveralls.wear!
+require 'simplecov'
+
+SimpleCov.start 'rails' do
+  if ENV['CI']
+    require 'simplecov-lcov'
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
 
-require "simplecov"
-SimpleCov.start do
   add_filter "/spec\/fixtures/"
   add_filter "/spec\/dummy/"
 end
 
 ENV["RAILS_ENV"] ||= "test"
 require "chanko"
+require "chanko/test"
+Chanko::Config.units_directory_path = File.expand_path("../fixtures/units", __FILE__)
 
 require File.expand_path("../dummy/config/environment", __FILE__)
 require "rspec/rails"
@@ -38,6 +47,11 @@ RSpec.configure do |config|
   #       # Equivalent to being in spec/controllers
   #     end
   config.infer_spec_type_from_file_location!
+
+  if Rails.respond_to?(:autoloaders) && Rails.autoloaders.zeitwerk_enabled?
+    config.filter_run_excluding classic: true
+  else
+    config.filter_run_excluding zeitwerk: true
+  end
 end
 
-Chanko::Config.units_directory_path = File.expand_path("../fixtures/units", __FILE__)