chanko 2.2.1 → 3.0.0

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

@@ -14,7 +14,7 @@ module <%= class_name %>
   # ```
 
   # ## raise_error
-  # `raise_error` is used to force an unit to raise up errors occured in invoking.
+  # `raise_error` is used to force an unit to raise up errors occurred in invoking.
   # You can force to raise up errors also by `Config.raise_error`.
   #
   # ```
@@ -34,36 +34,11 @@ module <%= class_name %>
   # ```
 
   # ## render
-  # In addition, the view path "<%= "#{directory}/views" %>" is added into view_paths.
-  # So you can render <%= "#{directory}/views/_example.html.erb" %> in invoking.
-  #
+  # If you want to place the views path under the unit, create a symbolic link under app/views/units and refer to it.
   # ```
   # 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`,
-  # `User.find(params[:id]).unit.active?` or `User.unit.gc_all_soft_deleted_users`.
-  #
-  # ```
-  # 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
+  #     render "/units/<%= file_name.underscore %>/example", :foo => "bar"
   #   end
   # end
   # ```

data/lib/generators/chanko/unit/unit_generator.rb

@@ -6,44 +6,53 @@ module Chanko
       source_root File.expand_path("../templates", __FILE__)
 
       def create_unit_directory
-        empty_directory(directory)
+        empty_directory(unit_directory)
       end
 
       def create_unit_file
-        template("unit.rb.erb", "#{directory}/#{file_name}.rb")
+        template("unit.rb.erb", "#{unit_directory}/#{file_name}.rb")
       end
 
-      def create_views_directory
-        create_file("#{directory}/views/.gitkeep", "")
+      def create_views_unit_directory
+        create_file("#{unit_directory}/views/.gitkeep", "")
       end
 
       ASSETS_TYPES.each do |type|
-        define_method("create_#{type}_directory") do
-          create_file("#{directory}/#{type}/.gitkeep", "")
+        define_method("create_#{type}_unit_directory") do
+          create_file("#{unit_directory}/#{type}/.gitkeep", "")
         end
-      end
 
-      ASSETS_TYPES.each do |type|
-        define_method("create_#{type}_symlink") do
+        define_method("create_#{type}_unit_symlink") do
           create_assets_symlink(type)
         end
       end
 
+      def create_views_symlink
+        from = "app/views/#{units_directory_name}/#{file_name}"
+        to   = "../../../#{relative_unit_directory}/views"
+        create_link(from, to)
+      end
+
       private
 
       def create_assets_symlink(type)
-        from = "app/assets/#{type}/#{directory_name}/#{file_name}"
-        to   = "../../../../#{directory}/#{type}"
+        from = "app/assets/#{type}/#{units_directory_name}/#{file_name}"
+        to   = "../../../../#{relative_unit_directory}/#{type}"
         create_link(from, to)
       end
 
-      def directory
+      def relative_unit_directory
+        Pathname.new(unit_directory).relative_path_from(Rails.root)
+      end
+
+      def unit_directory
         "#{Chanko::Config.units_directory_path}/#{file_name}"
       end
 
-      def directory_name
+      def units_directory_name
         Chanko::Config.units_directory_path.split("/").last
       end
     end
   end
 end
+

data/spec/chanko/function_spec.rb

@@ -6,10 +6,8 @@ module Chanko
       Loader.load(:example_unit)
     end
 
-    let(:context) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
-
+    def action_view_instance
+      klass = Class.new(ActionView::Base.with_empty_template_cache) do
         def current_unit
           units.last
         end
@@ -17,21 +15,12 @@ module Chanko
         def units
           @units ||= []
         end
-
-        def path
-          view_paths.first.to_s
-        end
-      end.new
+      end
+      klass.with_view_paths([], {}, nil)
     end
 
-    let(:context_without_view_paths) do
-      Class.new do
-        include Chanko::Invoker
-
-        def units
-          @units ||= []
-        end
-      end.new
+    let(:context) do
+      action_view_instance
     end
 
     let(:options) do
@@ -42,19 +31,6 @@ module Chanko
       it "invokes block with given context and stacked unit" do
         expect(described_class.new(unit, :label) { current_unit }.invoke(context, options)).to eq(unit)
       end
-
-      context "when context is a view" do
-        it "invokes with unit's view path" do
-          expect(described_class.new(unit, :label) { path }.invoke(context, options)).to eq(unit.view_path)
-        end
-      end
-
-      context "when context does not have view_paths" do
-        it "invokes successfully" do
-          expect(described_class.new(unit, :label) { "test" }.
-            invoke(context_without_view_paths, options)).to eq("test")
-        end
-      end
     end
   end
 end

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

@@ -4,11 +4,8 @@ require "chanko/test"
 module Chanko
   describe Test do
     let(:view) do
-      Class.new(ActionView::Base) do
-        include Chanko::Invoker
-        include Chanko::Helper
-        include Chanko::UnitProxyProvider
-      end.new
+      klass = Class.new(ActionView::Base.with_empty_template_cache)
+      klass.with_view_paths(nil, {}, nil)
     end
 
     describe "#enable_unit" do

data/spec/chanko/unit_spec.rb

@@ -188,68 +188,5 @@ module Chanko
         expect(view.__example_unit_test).to eq("test")
       end
     end
-
-    describe ".models" do
-      before do
-        stub_const("ExampleModel", model_class)
-        unit.models do
-          expand(:ExampleModel) do
-            scope :active, lambda { where(:deleted_at => nil) }
-
-            has_one :user
-
-            def test
-              "test"
-            end
-
-            class_methods do
-              def test
-                "test"
-              end
-            end
-          end
-        end
-      end
-
-      let(:model_class) do
-        Class.new do
-          include UnitProxyProvider
-
-          def self.scope(name, *args)
-            singleton_class.class_eval do
-              define_method(name) { "scoped" }
-            end
-          end
-
-          def self.has_one(name, *args)
-            singleton_class.class_eval do
-              define_method(name) { args }
-            end
-          end
-        end
-      end
-
-      it "defines instance methods with prefix" do
-        expect(ExampleModel.new.__example_unit_test).to eq("test")
-      end
-
-      it "defines class methods with prefix" do
-        expect(ExampleModel.__example_unit_test).to eq("test")
-      end
-
-      it "defines scope method with prefix" do
-        expect(ExampleModel.__example_unit_active).to eq("scoped")
-      end
-
-      it "defines has_one association method with prefix" do
-        expect(ExampleModel.__example_unit_user).to eq([:class_name => "User"])
-      end
-    end
-
-    describe ".view_path" do
-      it "returns path for its view directory" do
-        expect(unit.view_path).to eq("#{Config.units_directory_path}/example_unit/views")
-      end
-    end
   end
 end

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/app/units/entry_deletion/entry_deletion.rb

@@ -19,22 +19,6 @@ module EntryDeletion
     end
   end
 
-  models do
-    expand(:Entry) do
-      scope :active, lambda { where(:deleted_at => nil) }
-
-      def soft_delete
-        update_attributes(:deleted_at => Time.now)
-      end
-
-      class_methods do
-        def gc_all_soft_deleted_users
-          where.not(deleted_at: nil).delete_all
-        end
-      end
-    end
-  end
-
   helpers do
     def link_to_deletion(entry)
       link_to "Delete", entry, :method => :delete

data/spec/dummy/app/views/units/example_unit

@@ -0,0 +1 @@
+../../../../fixtures/units/example_unit/views

data/spec/dummy/config/application.rb

@@ -47,7 +47,15 @@ module Dummy
     # config.active_record.schema_format = :sql
 
     # Version of your assets, change this if you want to expire all your assets
-    config.assets.version = '1.0'
+
+    # for Rails 6.1
+    if config.respond_to?("assets")
+      config.assets.version = '1.0'
+      config.assets.quiet = true
+    end
+
+    config.autoloader = :zeitwerk
   end
 end
 
+Rails.autoloaders.main.collapse(Rails.root.join('app', 'units', '*'))

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/fixtures/units/example_unit/example_unit.rb

@@ -27,7 +27,7 @@ module ExampleUnit
     end
 
     function(:render) do
-      render_to_string :partial => "/test", :locals => { :local => "test" }
+      render_to_string :partial => "/units/example_unit/test", :locals => { :local => "test" }
     end
 
     function(:nesting_locals_outer) do
@@ -78,7 +78,7 @@ module ExampleUnit
     end
 
     function(:render) do
-      render "/test", :local => "test"
+      render "/units/example_unit/test", :local => "test"
     end
 
     function(:blank) do

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__)