rails_core_extensions 0.12.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e362185defe03c222c8b0d0cf77b3281f0fac38fde27f90ed1273d026bb28d7
-  data.tar.gz: 4f91461d5666fdb4ce836c50e11d0808a27da50605f40343e3c0b17cf53e441f
+  metadata.gz: b9a3bc99415c6959119365c5b542dc8ae3c912d004d7a4ae809755c7eeaccc44
+  data.tar.gz: 3a3db36a2823a7116674253ede3efe09222829285e038561de663b33bf8b9671
 SHA512:
-  metadata.gz: b73a245c3f1039fed5d0b2246d3b758a452364a114af36972ecfbeef970c426389271b9eac2feab4da7d0147b133532477dea28506f5b9cdb486ab943b396b3d
-  data.tar.gz: 101efda04a0f37b08757be11b4e2d89314e99d3e8935de832d550bd0dae4046d3c69eb9ec124c428dd9c62d59341a2f9015fc98d6619ca8a16329818b2613e83
+  metadata.gz: 2b02c74b69ba727097ecea9edbba9db615c517ac15f9573c12770f0ce9893bb31d5beaa8701e259854db15fe41f7f3b49fc269784fabdcf3d51a7c6d0243aec2
+  data.tar.gz: deeab7f200cd2439ea720c4c2338dd82d9feb370be4d650bd25675d6cab826c6701e95bdc716f133740a95a083e06d07d977d5c7a7510049a6184ff4a2a10f63

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.13.2
+
+- [PLAT-390] Fix broken `action_view` extensions
+
+## 0.13.1
+
+- [PLAT-384] Fix the liquid extension
+
+## 0.13.0
+
+- [PLAT-378] Improve bundler startup time; Drop Concurrency
+
 ## 0.12.0
 
 - [PLAT-183] Ruby 3.1, Rails 7.0 and publish coverage with github action

data/lib/rails_core_extensions/action_controller_sortable.rb

@@ -1,8 +1,6 @@
 module RailsCoreExtensions
   module ActionControllerSortable
-    def self.included(base)
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       def sortable

data/lib/rails_core_extensions/action_view_has_many_extensions.rb

@@ -28,5 +28,7 @@ module RailsCoreExtensions
   end
 end
 
-ActionView::Base.send(:include, RailsCoreExtensions::HasManyExtensions::Tags) if defined?(ActionView::Base)
-ActionView::Helpers::FormBuilder.send(:include, RailsCoreExtensions::HasManyExtensions::FormBuilder) if defined?(ActionView::Base)
+ActiveSupport.on_load :action_view do
+  ActionView::Base.send(:include, RailsCoreExtensions::HasManyExtensions::Tags)
+  ActionView::Helpers::FormBuilder.send(:include, RailsCoreExtensions::HasManyExtensions::FormBuilder)
+end

data/lib/rails_core_extensions/active_model_extensions.rb

@@ -1,8 +1,6 @@
 module ActiveModelExtensions
   module Validations
-    def self.included(base)
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::Concern
 
     # Validates the presence of the required fields identified in a rule-string.
     #

data/lib/rails_core_extensions/active_record_cloning.rb

@@ -1,7 +1,5 @@
 module ActiveRecordCloning
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
+  extend ActiveSupport::Concern
 
   module ClassMethods
 

data/lib/rails_core_extensions/active_record_extensions.rb

@@ -1,7 +1,5 @@
 module ActiveRecordExtensions
-  def self.included(base)
-    base.extend ClassMethods
-  end
+  extend ActiveSupport::Concern
 
   module ClassMethods
     # Like establish_connection but postfixes the key with the rails environment

data/lib/rails_core_extensions/active_record_liquid_extensions.rb

@@ -1,32 +1,30 @@
 module RailsCoreExtensions
   module ActiveRecordLiquidExtensions
-    def self.included(base)
-      base.extend ClassMethods
-    end
-  end
+    extend ActiveSupport::Concern
 
-  module ClassMethods
-    def validates_liquid(field)
-      field = field.to_sym
-      before_validation do |record|
-        begin
-          Liquid::Template.parse(record.send(field), error_mode: :strict)
-        rescue Liquid::SyntaxError => e
-          record.errors.add(field, "Liquid Syntax Error: #{e}")
+    module ClassMethods
+      def validates_liquid(field)
+        field = field.to_sym
+        before_validation do |record|
+          begin
+            Liquid::Template.parse(record.send(field), error_mode: :strict)
+          rescue Liquid::SyntaxError => e
+            record.errors.add(field, "Liquid Syntax Error: #{e}")
+          end
         end
       end
-    end
 
-    def liquid_field(field)
-      class_eval <<-CODE
-        def parsed_#{field}
-          Liquid::Template.parse(#{field})
-        end
+      def liquid_field(field)
+        class_eval <<-CODE
+          def parsed_#{field}
+            Liquid::Template.parse(#{field})
+          end
 
-        def render_#{field}(*args)
-          parsed_#{field}.render!(*args)
-        end
-      CODE
+          def render_#{field}(*args)
+            parsed_#{field}.render!(*args)
+          end
+        CODE
+      end
     end
   end
 end

data/lib/rails_core_extensions/translations.rb

@@ -1,8 +1,6 @@
 module RailsCoreExtensions
   module Translations
-    def self.included(base)
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       def translate(key, options = {})

data/lib/rails_core_extensions/version.rb

@@ -1,3 +1,3 @@
 module RailsCoreExtensions
-  VERSION = '0.12.0'
+  VERSION = '0.13.2'
 end

data/lib/rails_core_extensions.rb

@@ -3,8 +3,6 @@ module RailsCoreExtensions
   require 'rails_core_extensions/position_initializer'
   require 'rails_core_extensions/time_with_zone'
   require 'rails_core_extensions/transfer_records'
-  require 'rails_core_extensions/active_support_concern'
-  require 'rails_core_extensions/concurrency'
 
   require 'rails_core_extensions/railtie' if defined?(Rails)
 
@@ -12,15 +10,19 @@ module RailsCoreExtensions
     require 'rails_core_extensions/activatable'
     require 'rails_core_extensions/action_controller_sortable'
 
-    ActionController::Base.send(:include, Activatable)
-    ActionController::Base.send(:include, ActionControllerSortable)
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.send(:include, Activatable)
+      ActionController::Base.send(:include, ActionControllerSortable)
+    end
   end
 
   if defined? ActionView
     require 'rails_core_extensions/action_view_extensions'
     require 'rails_core_extensions/action_view_has_many_extensions'
 
-    ActionView::Base.send(:include, RailsCoreExtensions::ActionViewExtensions)
+    ActiveSupport.on_load(:action_view) do
+      ActionView::Base.send(:include, RailsCoreExtensions::ActionViewExtensions)
+    end
   end
 
   if defined? ActiveRecord
@@ -30,11 +32,13 @@ module RailsCoreExtensions
     require 'rails_core_extensions/translations'
     require 'rails_core_extensions/active_model_extensions'
 
-    ActiveRecord::Base.send(:include, ActiveRecordCloning)
-    ActiveRecord::Base.send(:include, ActiveRecordExtensions)
-    ActiveRecord::Base.send(:include, RailsCoreExtensions::ActiveRecordLiquidExtensions)
-    ActiveRecord::Base.send(:include, ActiveRecordExtensions::InstanceMethods)
-    ActiveRecord::Base.send(:include, RailsCoreExtensions::Translations)
-    ActiveRecord::Base.send(:include, ActiveModelExtensions::Validations)
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Base.send(:include, ActiveRecordCloning)
+      ActiveRecord::Base.send(:include, ActiveRecordExtensions)
+      ActiveRecord::Base.send(:include, RailsCoreExtensions::ActiveRecordLiquidExtensions)
+      ActiveRecord::Base.send(:include, ActiveRecordExtensions::InstanceMethods)
+      ActiveRecord::Base.send(:include, RailsCoreExtensions::Translations)
+      ActiveRecord::Base.send(:include, ActiveModelExtensions::Validations)
+    end
   end
 end

data/spec/support/coverage_loader.rb

@@ -1,3 +1,3 @@
 require 'coverage/kit'
 
-Coverage::Kit.setup(minimum_coverage: 86.7)
+Coverage::Kit.setup(minimum_coverage: 84.1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_core_extensions
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.2
 platform: ruby
 authors:
 - Michael Noack
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -167,8 +167,6 @@ files:
 - lib/rails_core_extensions/active_record_cloning.rb
 - lib/rails_core_extensions/active_record_extensions.rb
 - lib/rails_core_extensions/active_record_liquid_extensions.rb
-- lib/rails_core_extensions/active_support_concern.rb
-- lib/rails_core_extensions/concurrency.rb
 - lib/rails_core_extensions/position_initializer.rb
 - lib/rails_core_extensions/railtie.rb
 - lib/rails_core_extensions/sortable.rb
@@ -183,7 +181,6 @@ files:
 - spec/active_model_extensions_spec.rb
 - spec/active_record_cloning_spec.rb
 - spec/active_record_extensions_spec.rb
-- spec/concurrency_spec.rb
 - spec/en.yml
 - spec/position_initializer_spec.rb
 - spec/schema.rb
@@ -221,7 +218,6 @@ test_files:
 - spec/active_model_extensions_spec.rb
 - spec/active_record_cloning_spec.rb
 - spec/active_record_extensions_spec.rb
-- spec/concurrency_spec.rb
 - spec/en.yml
 - spec/position_initializer_spec.rb
 - spec/schema.rb

data/lib/rails_core_extensions/active_support_concern.rb

@@ -1,134 +0,0 @@
-module ActiveSupport
-  # A typical module looks like this:
-  #
-  #   module M
-  #     def self.included(base)
-  #       base.extend ClassMethods
-  #       base.send(:include, InstanceMethods)
-  #       scope :disabled, where(:disabled => true)
-  #     end
-  #
-  #     module ClassMethods
-  #       ...
-  #     end
-  #
-  #     module InstanceMethods
-  #       ...
-  #     end
-  #   end
-  #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
-  #
-  #   require 'active_support/concern'
-  #
-  #   module M
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       scope :disabled, where(:disabled => true)
-  #     end
-  #
-  #     module ClassMethods
-  #       ...
-  #     end
-  #
-  #     module InstanceMethods
-  #       ...
-  #     end
-  #   end
-  #
-  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
-  # module which depends on the former, we would typically write the following:
-  #
-  #   module Foo
-  #     def self.included(base)
-  #       base.class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Foo # We need to include this dependency for Bar
-  #     include Bar # Bar is the module that Host really needs
-  #   end
-  #
-  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
-  # these from +Host+ directly including +Foo+ in +Bar+:
-  #
-  #   module Bar
-  #     include Foo 
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar
-  #   end
-  #
-  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
-  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
-  #
-  #   require 'active_support/concern'
-  #
-  #   module Foo
-  #     extend ActiveSupport::Concern
-  #     included do
-  #       class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     extend ActiveSupport::Concern
-  #     include Foo
-  #
-  #     included do
-  #       self.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar # works, Bar takes care now of its dependencies
-  #   end
-  #
-  module Concern
-    def self.extended(base)
-      base.instance_variable_set("@_dependencies", [])
-    end
-
-    def append_features(base)
-      if base.instance_variable_defined?("@_dependencies")
-        base.instance_variable_get("@_dependencies") << self
-        return false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.send(:include, dep) }
-        super
-        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
-        base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
-        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
-      end
-    end
-
-    def included(base = nil, &block)
-      if base.nil?
-        @_included_block = block
-      else
-        super
-      end
-    end
-  end
-end

data/lib/rails_core_extensions/concurrency.rb

@@ -1,152 +0,0 @@
-module Concurrency
-  extend ActiveSupport::Concern
-  
-  module ClassMethods
-    
-    def concurrency_safe(*methods)
-      options = methods.extract_options!
-      methods.each do |method|
-        add_concurrency_check(method, options)
-      end
-    end
-    
-    
-    def concurrency_safe_method_locked?(method)
-      concurrency_cache.read(concurrency_safe_method_cache_name(method)) == 'locked'
-    end
-    
-    
-    def concurrency_cache
-      @concurrency_cache ||= ::Rails.cache
-    end
-    
-    
-    def concurrency_cache=(cache)
-      [:read,:write,:delete].each do |method|
-        raise ConcurrencyCacheException, "#{cache} does not implement #{method}" unless cache.respond_to?(method)
-      end
-      @concurrency_cache = cache
-    end
-    
-    
-    private
-    
-    def add_concurrency_check(method, options = {})
-      method_definition = <<-DEFINITION
-        def #{method}_with_concurrency_lock(*args)
-          if concurrency_safe_method_locked?(:#{method})
-            raise ConcurrentCallException.new(self,:#{method}), "#{self.name}.#{method} is already running"
-          end
-          lock_concurrency_safe_method(:#{method})
-          return_value = nil
-          begin
-            return_value = #{method}_without_concurrency_lock(*args)
-          ensure
-            unlock_concurrency_safe_method(:#{method})
-          end
-          return_value
-        end
-        alias_method :#{method}_without_concurrency_lock, :#{method}
-        alias_method :#{method}, :#{method}_with_concurrency_lock
-      DEFINITION
-      
-      if method_type(method, options[:type]) == 'class'
-        method_definition = <<-DEFINITION
-          class << self
-            #{method_definition}
-          end
-        DEFINITION
-      end
-      
-      module_eval method_definition
-    end
-    
-    
-    def lock_concurrency_safe_method(method)
-      concurrency_cache.write(concurrency_safe_method_cache_name(method), 'locked')
-    end
-    
-    
-    def unlock_concurrency_safe_method(method)
-      concurrency_cache.delete(concurrency_safe_method_cache_name(method))
-    end
-    
-    
-    def concurrency_safe_method_cache_name(method)
-      "#{self.name.underscore}_concurrency_safe_class_method_#{method}"
-    end
-    
-    
-    def method_type(method, type = nil)
-      types = method_types(method, type)
-      raise AmbiguousMethodException.new(self, method), "#{method} for #{self.name} is ambiguous. Please specify the type (instance/class) option" if types.count == 2
-      raise NoMethodException.new(self, method), "#{method} is not not a valid method for #{self.name}." if types.blank?
-      types.first
-    end
-    
-    
-    def method_types(method, type = nil)
-      ['class', 'instance'].select do |mt|
-        (type.blank? || type.to_s == mt) && self.send("#{mt}_method?", method)
-      end
-    end
-    
-    
-    def class_method?(method)
-      self.respond_to?(method, true)
-    end
-    
-    
-    def instance_method?(method)
-      (self.instance_methods + self.private_instance_methods).map(&:to_s).include?(method.to_s)
-    end
-    
-  end
-  
-  
-  module InstanceMethods
-    
-    def concurrency_cache
-      self.class.concurrency_cache
-    end
-    
-    
-    def concurrency_safe_method_locked?(method)
-      concurrency_cache.read(concurrency_safe_method_cache_name(method)) == 'locked'
-    end
-    
-    
-    private
-    
-    def lock_concurrency_safe_method(method)
-      concurrency_cache.write(concurrency_safe_method_cache_name(method), 'locked')
-    end
-    
-    
-    def unlock_concurrency_safe_method(method)
-      concurrency_cache.delete(concurrency_safe_method_cache_name(method))
-    end
-    
-    
-    def concurrency_safe_method_cache_name(method)
-      "#{self.class.name.underscore}_concurrency_safe_instance_method_#{method}"
-    end
-    
-  end
-  
-  
-  class ConcurrencyException < ::Exception; end
-  class ConcurrencyCacheException < ConcurrencyException; end
-  class MethodException < ConcurrencyException
-    attr_reader :object, :method
-    
-    def initialize(object, method)
-      @object = object
-      @method = method
-    end
-  end
-  class ConcurrentCallException < MethodException; end
-  class NoMethodException < MethodException; end
-  class AmbiguousMethodException < MethodException; end
-    
-end

data/spec/concurrency_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-class TestConcurrencyCache
-  @@cache = {}
-
-  def self.read(key)
-    @@cache[key]
-  end
-
-  def self.write(key, value)
-    @@cache[key] = value
-  end
-
-  def self.delete(key)
-    @@cache.delete(key)
-  end
-
-  def self.clear
-    @@cache = {}
-  end
-end
-
-describe Concurrency do
-  before :each do
-    TestConcurrencyCache.clear
-
-    class ConcurrencyTest
-      include Concurrency
-
-      self.concurrency_cache = TestConcurrencyCache
-
-      def self.class_test_method
-        sleep(1)
-      end
-
-      def instance_test_method
-        sleep(1)
-      end
-
-      def self.both_instance_and_class_test_method; end
-      def both_instance_and_class_test_method; end
-    end
-  end
-
-  after :each do
-    Object.send(:remove_const, :ConcurrencyTest)
-  end
-
-  it "should allow specifying which methods should implement the concurrency check" do
-    expect { ConcurrencyTest.send(:concurrency_safe, :instance_test_method) }
-      .to_not raise_error
-    expect { ConcurrencyTest.send(:concurrency_safe, :class_test_method) }
-      .to_not raise_error
-    expect { ConcurrencyTest.send(:concurrency_safe, :both_instance_and_class_test_method) }
-      .to raise_error(Concurrency::AmbiguousMethodException)
-    expect { ConcurrencyTest.send(:concurrency_safe, :both_instance_and_class_test_method, type: :instance) }
-      .to_not raise_error
-    expect { ConcurrencyTest.send(:concurrency_safe, :both_instance_and_class_test_method, type: :class) }
-      .to_not raise_error
-    expect { ConcurrencyTest.send(:concurrency_safe, :unknown_method) }
-      .to raise_error(Concurrency::NoMethodException)
-  end
-
-  it "should allow identyfying the type of a method" do
-    expect(ConcurrencyTest.send(:method_types, :class_test_method)).to eq ['class']
-    expect(ConcurrencyTest.send(:method_types, :instance_test_method)).to eq ['instance']
-    expect(ConcurrencyTest.send(:method_types, :both_instance_and_class_test_method)).to eq ['class','instance']
-    expect(ConcurrencyTest.send(:method_types, :unknown_method)).to be_blank
-    expect(ConcurrencyTest.send(:method_type, :class_test_method)).to eq 'class'
-    expect(ConcurrencyTest.send(:method_type, :instance_test_method)).to eq 'instance'
-    expect { ConcurrencyTest.send(:method_type, :both_instance_and_class_test_method) }
-      .to raise_error(Concurrency::AmbiguousMethodException)
-    expect { ConcurrencyTest.send(:method_type, :unknown_method) }
-      .to raise_error(Concurrency::NoMethodException)
-  end
-
-  it "should allow checking the concurrency lock for specified class methods" do
-    ConcurrencyTest.send(:concurrency_safe, :class_test_method)
-    started = false
-    expect(ConcurrencyTest.concurrency_safe_method_locked?(:class_test_method)).to be false
-    thread = Thread.new { ConcurrencyTest.send(:class_test_method); started = true }
-    thread.join
-    expect(ConcurrencyTest.concurrency_safe_method_locked?(:class_test_method)).to be true until started
-  end
-
-  it "should allow checking the concurrency lock for specified instance methods" do
-    ConcurrencyTest.send(:concurrency_safe, :class_test_method)
-    instance = ConcurrencyTest.new
-    started = false
-    expect(instance.concurrency_safe_method_locked?(:instance_test_method)).to be false
-    thread = Thread.new { instance.send(:instance_test_method); started = true }
-    thread.join
-    expect(instance.concurrency_safe_method_locked?(:instance_test_method)).to be true until started
-  end
-
-  it "should implement the concurrency check for specified class methods" do
-    ConcurrencyTest.send(:concurrency_safe, :class_test_method)
-    threads = 2.times.map { Thread.new { ConcurrencyTest.send(:class_test_method) } }
-    expect { threads.each(&:join) }
-      .to raise_error(Concurrency::ConcurrentCallException)
-  end
-
-  it "should implement the concurrency check for specified instance methods" do
-    ConcurrencyTest.send(:concurrency_safe, :instance_test_method)
-    instance = ConcurrencyTest.new
-    threads = 2.times.map { Thread.new { instance.send(:instance_test_method) } }
-    expect { threads.each(&:join) }
-      .to raise_error(Concurrency::ConcurrentCallException)
-  end
-end