chanko 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12298afeff1eced18d28a06531c8a34469c97da44a93f988a6caa7835fca337b
-  data.tar.gz: 3eb396ab691ec4d7c84fa58bdb23d43c017f6ca1eb2da29902ee2ed9adc5e542
+  metadata.gz: 72b1ce54ea0cf5bbf3d56237723d00c9383213d67534c21531ed568465d95435
+  data.tar.gz: 74c763b3087ac11d7ddaa4700995240681ceafd6fcfa1dcf26785d547a20e934
 SHA512:
-  metadata.gz: ddd983d0d75d909378694f3d752d8f2b07fc8166c018de5ba1667f7309e94da09d98fdf186f746c96fc74bd1f45180b017341f999d6cb717ef18bb97269dff06
-  data.tar.gz: b92cac319cbb13c2c381c40159a784550fec5714e9b83ea867cc59605e70929c601c247d8f003d39b2f58935caeafb9d96d3e8e65b82784e1cd13abf1c22c93e
+  metadata.gz: ec921fb9b47ca4f5878f902a01de61a8e5c96d4f671a1a3f991c3d047f2102c24245697a27e05e0af928acaa7b5345bf8cd79465082a3aabffaf2e66f26a7d68
+  data.tar.gz: a6f855b9f756b034f9098718bc1ad2c0e112f5ad0a616ac2a9023767ba92228c4f41a6cb0e1a21bf53910140dc2a8bf1480180a6aec0b1cbe8b75dd829be7d47

data/.github/workflows/master_and_pr.yml

@@ -0,0 +1,40 @@
+name: master & PR
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+jobs:
+  spec:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rails_version:
+          - "6.1"
+          - "7.0"
+          - "7.1"
+        ruby_version:
+          - "3.1"
+          - "3.2"
+          - "3.3"
+        eager_load:
+          - "true"
+          - "false"
+    name: Test on Rails ${{ matrix.rails_version }} & Ruby ${{ matrix.ruby_version }} & EagerLoad ${{ matrix.eager_load }}
+    env:
+      BUNDLE_GEMFILE: gemfiles/Gemfile_rails_${{ matrix.rails_version }}.rb
+      CI: true
+      EAGER_LOAD: ${{ matrix.eager_load }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby_version }}
+          bundler-cache: true
+      - name: rspec
+        run: bundle exec rspec
+      - name: Coveralls
+        if: matrix.rails_version == '7.1' && matrix.ruby_version == '3.3'
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}

data/.gitignore

@@ -8,7 +8,7 @@ spec/dummy/.sass-cache
 .bundle
 .config
 .yardoc
-Gemfile.lock
+gemfiles/Gemfile_rails_*.rb.lock
 InstalledFiles
 _yardoc
 coverage

data/CHANGELOG.md

@@ -1,4 +1,18 @@
-## Unreleased
+## 3.0.0
+* Support Rails 6,1. 7.0, 7.1.
+* Support Ruby >= 3.0.
+* Drop support for Rails <= 6.0.
+* Drop support for Ruby 2.
+* Drop support for classic loader.
+* The functionality to extend the view_paths has been discontinued.
+* The functionality to extend the models has been discontinued.
+
+## 2.3.0
+* Support Rails 5.0, 5.1, 5,2, 6.0, 6,1.
+* Drop support of Rails 4.x.
+* Rails7 not supported yet.
+* Chanko::Config.eager_load has been replaced by a direct reference to Rails.configuration.eager_load.
+* Fix cache resolver error on Rails 6.
 
 ## 2.2.1
 * Support Rails 7.0.

data/README.md

@@ -10,11 +10,9 @@ With Chanko, you can release many features concurrently and manage target users
 When any errors are raised from chanko's features,
 it will be automatically hidden and fallback to its normal behavior.
 
-
 ## Requirements
-* Ruby >= 2.1.0
-* Rails >= 4.0.0
-
+* Ruby >= 3.0.0
+* Rails >= 6.1.0
 
 ## Usage
 Add to your Gemfile.
@@ -63,11 +61,6 @@ end
 = invoke(:example_unit, :render_example)
 ```
 
-```
--# app/units/example_unit/views/_example.html.slim
-= foo
-```
-
 ## Unit
 You can see [the real example of an unit module file](https://github.com/cookpad/chanko/blob/master/spec/dummy/app/units/entry_deletion/entry_deletion.rb).
 
@@ -120,39 +113,7 @@ end
 ```
 
 ### render
-The view path app/units/example_unit/views is added into view_paths in invoking.
-So you can render app/units/example_unit/views/_example.html.slim in invoking.
-
-```ruby
-scope(:view) do
-  function(:render_example) do
-    render "/example", :foo => hello("world")
-  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`,
-`User.find(params[:id]).unit.active?` or `User.unit.gc_all_soft_deleted_users`.
-
-```ruby
-models do
-  expand(:User) do
-    scope :active, lambda { where(:deleted_at => nil) }
-
-    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
-```
+In version 2 and earlier, Chanko extended Rails' search path to include the views path of the unit. This functionality has been discontinued. To maintain the views path under the unit, you will need to manually create a symbolic link in app/views/units to access it.
 
 ### shared
 You can call methods defined by `shared` in invoking.
@@ -174,7 +135,6 @@ helpers do
 end
 ```
 
-
 ## Example
 https://github.com/cookpad/chanko/tree/master/spec/dummy  
 Chanko provides an example rails application in spec/dummy directory.

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+for path in gemfiles/Gemfile_*.rb; do
+  BUNDLE_GEMFILE="${path}" bundle install
+done

data/bin/test

@@ -0,0 +1,7 @@
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+for path in gemfiles/Gemfile_*.rb; do
+  BUNDLE_GEMFILE="${path}" bundle exec rspec
+done

data/chanko.gemspec

@@ -12,21 +12,22 @@ Gem::Specification.new do |gem|
   gem.homepage      = "https://github.com/cookpad/chanko"
 
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.required_ruby_version = '>= 2.6.0'
+  gem.required_ruby_version = '>= 3.0.0'
 
-  gem.add_dependency "rails", ">= 4.0.0"
+  gem.add_dependency "rails", ">= 6.1.0"
+  gem.add_development_dependency "byebug"
   gem.add_development_dependency "coffee-rails", ">= 3.0.10"
-  gem.add_development_dependency "coveralls"
   gem.add_development_dependency "jquery-rails"
   gem.add_development_dependency "pry"
+  gem.add_development_dependency "pry-rails"
   gem.add_development_dependency "rspec-rails", ">= 3.0.0"
   gem.add_development_dependency "sass-rails", ">= 3.0.10"
   gem.add_development_dependency "simplecov"
+  gem.add_development_dependency 'simplecov-lcov'
   gem.add_development_dependency "slim"
-  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "sqlite3", ">= 1.4"
   gem.add_development_dependency "thin"
   gem.add_development_dependency "uglifier"
 end

data/gemfiles/Gemfile_rails_6.1.rb

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 6.1.0'
+gem 'sqlite3', '~> 1.4'

data/gemfiles/Gemfile_rails_7.0.rb

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 7.0.0'
+gem 'sqlite3', '~> 1.4'

data/gemfiles/Gemfile_rails_7.1.rb

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 7.1.0'
+gem 'sqlite3', '~> 1.4'

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/function.rb

@@ -22,12 +22,10 @@ module Chanko
 
     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
+        capture_exception(context) do
+          result = context.instance_eval(&block)
+          result = decorate(result, context, options[:type]) if context.view? && result.present?
+          result
         end
       end
     end
@@ -59,13 +57,6 @@ module Chanko
       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

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,35 +1,25 @@
 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
       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.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
-    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.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.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/unit/extender/extension.rb

@@ -2,8 +2,6 @@ module Chanko
   module Unit
     class Extender
       class Extension < Module
-        include ActiveRecordClassMethods
-
         def initialize(mod, prefix = nil, &block)
           @mod    = mod
           @prefix = prefix

data/lib/chanko/unit/extender.rb

@@ -1,4 +1,3 @@
-require "chanko/unit/extender/active_record_class_methods"
 require "chanko/unit/extender/extension"
 
 module Chanko

data/lib/chanko/unit.rb

@@ -33,10 +33,6 @@ module Chanko
         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
@@ -70,10 +66,6 @@ module Chanko
         UnitProxy.generate_prefix(unit_name)
       end
 
-      def view_path
-        Rails.root.join("#{Config.units_directory_path}/#{unit_name}/views").to_s
-      end
-
       def find_function(identifier, label)
         scope     = ScopeFinder.find(identifier)
         target    = scope.ancestors.find {|klass| scopes[klass] }
@@ -93,10 +85,6 @@ module Chanko
         @shared_methods ||= {}
       end
 
-      def resolver
-        @resolver ||= Config.resolver.new(view_path)
-      end
-
       def extender
         @extender ||= Extender.new(to_prefix)
       end

data/lib/chanko/version.rb

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