effective_resources 1.9.2 → 1.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 010a64ad908bb27807756924d3f05112c7910568615678bcc8c99b04c7c69f93
-  data.tar.gz: cee9d5812ee210d09a8481c3261b625db6f7cf9b86d36fb261623d5e4fda2145
+  metadata.gz: 0e5b54802ada357459497c873ed7958745da7a62def14f6e0cea1b8b09b1ad3a
+  data.tar.gz: 391b11cbab23ea721aa01bb1ada824ab064b1182f16bc88083591746205424f2
 SHA512:
-  metadata.gz: 72c9617fedc1420ec4b520328d66e92d765691d943c4ed0d0f6b642e876a74d9d2a11f3a9be16003a1fa8540dc20b43617b9f8dec740625010b7cacf37b1f63b
-  data.tar.gz: 7a9e7735119fc14caf02d6cee1e0fe1e9558888fc6ca7df4d33c95f073d28b7422adbb0fd93092391067b8ccd06dcb8eb8708a2017dafac5e5375103aa055d92
+  metadata.gz: e33a16caedeaf449a75457ff5ee8ed7af961b3092e871ea3a404739054cb8fbf7fe0b9f388312e100ec6896c5f597591402a2efd0845a79bd4e44c1aa99fb16c
+  data.tar.gz: eb12d90c64e6e8467fd3dbc6733f7e7da0ee02a94231f33f464dc1896056e01f4b1a3e8998aa949815d741bb760fd732697c63682fe303cef2a132833ff801ee

data/app/controllers/concerns/effective/crud_controller/actions.rb

@@ -9,7 +9,7 @@ module Effective
         @page_title ||= resource_plural_name.titleize
 
         self.resources ||= resource_scope.all if resource_scope.respond_to?(:all)
-        @datatable = resource_datatable(:index)
+        @datatable = resource_datatable()
 
         run_callbacks(:resource_render)
       end
@@ -214,7 +214,7 @@ module Effective
         @page_title ||= "#{action.to_s.titleize} #{resource_plural_name.titleize}"
 
         if request.get?
-          @datatable = resource_datatable(action)
+          @datatable = resource_datatable()
           run_callbacks(:resource_render)
 
           view = lookup_context.template_exists?(action, _prefixes) ? action : :index
@@ -228,7 +228,7 @@ module Effective
 
         # No attributes are assigned or saved. We purely call action! on the resource
 
-        ActiveRecord::Base.transaction do
+        EffectiveResources.transaction do
           successes = resources.select do |resource|
             begin
               resource.public_send("#{action}!") if EffectiveResources.authorized?(self, action, resource)

data/app/controllers/concerns/effective/crud_controller/dsl.rb

@@ -61,7 +61,20 @@ module Effective
         raise 'expected a label or block' unless (label || block_given?)
 
         instance_exec do
-          before_action(opts) { @page_title ||= (block_given? ? instance_exec(&block) : label).to_s }
+          before_action(opts) do
+            @page_title ||= (block_given? ? instance_exec(&block) : label).to_s
+          end
+        end
+      end
+
+      # datatable -> { MyDatatable.new }, only: [:index]
+      def datatable(obj = nil, opts = {}, &block)
+        raise 'expected a proc or block' unless (obj.respond_to?(:call) || block_given?)
+
+        instance_exec do
+          before_action(opts) do
+            @datatable ||= (block_given? ? instance_exec(&block) : obj.call)
+          end
         end
       end
 
@@ -84,7 +97,6 @@ module Effective
         else
           define_method(:resource_scope_relation) { return obj }
         end
-
       end
 
     end

data/app/controllers/concerns/effective/crud_controller/save.rb

@@ -30,7 +30,7 @@ module Effective
 
         success = false
 
-        ActiveRecord::Base.transaction do
+        EffectiveResources.transaction(resource) do
           begin
             run_callbacks(:resource_before_save)
 

data/app/controllers/concerns/effective/crud_controller.rb

@@ -108,15 +108,16 @@ module Effective
       resource_scope.where_values_hash.symbolize_keys
     end
 
-    def resource_datatable(action)
-      datatable_klass = if action == :index
-        effective_resource.datatable_klass
-      else # Admin::ActionDatatable.new
-        "#{[effective_resource.namespace.to_s.classify.presence, action.to_s.classify].compact.join('::')}Datatable".safe_constantize ||
-        "#{[effective_resource.namespace.to_s.classify.presence, action.to_s.pluralize.classify].compact.join('::')}Datatable".safe_constantize ||
-        "#{[effective_resource.namespace.to_s.classify.presence, action.to_s.singularize.classify].compact.join('::')}Datatable".safe_constantize
+    def resource_datatable
+      # This might have been done from a before action or dsl method
+      unless @datatable.nil?
+        raise('expected @datatable to be an Effective::Datatable') unless @datatable.kind_of?(Effective::Datatable)
+
+        @datatable.effective_resource = effective_resource
+        return @datatable
       end
 
+      datatable_klass = effective_resource.datatable_klass
       return unless datatable_klass.present?
 
       datatable = datatable_klass.new(resource_datatable_attributes)

data/app/models/concerns/acts_as_wizard.rb

@@ -76,7 +76,11 @@ module ActsAsWizard
     end
 
     def next_step
-      required_steps.reverse.find { |step| can_visit_step?(step) } || required_steps.first
+      first_uncompleted_step ||
+      last_completed_step ||
+      required_steps.reverse.find { |step| can_visit_step?(step) } ||
+      required_steps.first ||
+      :start
     end
 
     def previous_step(step)
@@ -89,6 +93,13 @@ module ActsAsWizard
       previous.blank? || has_completed_step?(previous)
     end
 
+    def has_completed_all_previous_steps?(step)
+      index = required_steps.index(step).to_i
+      previous = required_steps[0...index]
+
+      previous.blank? || previous.all? { |step| has_completed_step?(step) }
+    end
+
     def has_completed_last_step?
       has_completed_step?(required_steps.last)
     end
@@ -97,12 +108,12 @@ module ActsAsWizard
 
     def can_revisit_completed_steps(step)
       return (step == required_steps.last) if has_completed_last_step?
-      has_completed_previous_step?(step)
+      has_completed_all_previous_steps?(step)
     end
 
     def cannot_revisit_completed_steps(step)
       return (step == required_steps.last) if has_completed_last_step?
-      has_completed_previous_step?(step) && !has_completed_step?(step)
+      has_completed_all_previous_steps?(step) && !has_completed_step?(step)
     end
 
   end

data/app/models/concerns/effective_after_commit.rb

@@ -12,17 +12,17 @@ module EffectiveAfterCommit
 
   module Base
     def after_commit(connection: self.class.connection, &callback)
-      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :execute)
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback)
     end
 
     def before_commit(connection: self.class.connection, &callback)
       raise(NotImplementedError, "#{__method__} works only with Rails 5.0+") if ActiveRecord::VERSION::MAJOR < 5
-      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :warn_and_execute)
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback)
     end
 
     def after_rollback(connection: self.class.connection, &callback)
       raise('expected a block') unless block_given?
-      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback, no_tx_action: :exception)
+      Effective::AfterCommit.register_callback(connection: connection, name: __method__, callback: callback)
     end
   end
 

data/app/models/effective/after_commit.rb

@@ -25,20 +25,11 @@ module Effective
       @handlers[:after_rollback]&.call
     end
 
-    def self.register_callback(connection:, name:, no_tx_action:, callback:)
+    def self.register_callback(connection:, name:, callback:)
       raise ArgumentError, "#{name} expected a block" unless callback
 
-      unless (connection.transaction_open? && connection.current_transaction.joinable?)
-        case no_tx_action
-        when :warn_and_execute
-          warn "#{name}: No transaction open. Executing callback immediately."
-          return callback.call
-        when :execute
-          return callback.call
-        when :exception
-          raise("#{name} is useless outside transaction")
-        end
-      end
+      raise("#{name} is useless outside transaction") unless connection.transaction_open?
+      raise("#{name} is useless outside transaction") unless connection.current_transaction.joinable?
 
       after_commit = Effective::AfterCommit.new("#{name}": callback)
       connection.add_transaction_record(after_commit)

data/app/models/effective/resource.rb

@@ -14,7 +14,7 @@ module Effective
     include Effective::Resources::Paths
     include Effective::Resources::Relation
     include Effective::Resources::Sql
-
+    include Effective::Resources::Tenants
 
     # In practice, this is initialized two ways
     # With a klass and a namespace from effective_datatables

data/app/models/effective/resources/actions.rb

@@ -12,10 +12,17 @@ module Effective
         @controller_path ||= route_name #[namespace, plural_name].compact * '/')
       end
 
+      def engines
+        return ([Rails.application] + Rails::Engine.subclasses.reverse) unless tenant?
+
+        [Rails.application, Tenant.Engine] + Rails::Engine.subclasses.reverse.reject do |klass|
+          tenant_engines_blacklist.any? { |name| klass.name.start_with?(name) }
+        end
+      end
+
       def routes
         @routes ||= begin
           routes = nil
-          engines = [Rails.application] + Rails::Engine.subclasses.reverse
 
           # Check from controller_path. This is generally correct.
           engines.each do |engine|

data/app/models/effective/resources/associations.rb

@@ -150,7 +150,7 @@ module Effective
 
         is_scope = false
 
-        ActiveRecord::Base.transaction do
+        EffectiveResources.transaction(klass) do
           begin
             relation = klass.public_send(name).kind_of?(ActiveRecord::Relation)
           rescue => e

data/app/models/effective/resources/generator.rb

@@ -30,19 +30,19 @@ module Effective
 
       # Tenants
       def tenant_controller_path
-        (Tenant.module_name.downcase + '/' + controller_path) if defined?(Tenant)
+        (Tenant.module_name.downcase + '/' + controller_path) if tenant?
       end
 
       def tenant_namespaced_class_name
-        (Tenant.module_name + '::' + namespaced_class_name) if defined?(Tenant)
+        (Tenant.module_name + '::' + namespaced_class_name) if tenant?
       end
 
       def tenant_namespaced_module_name
-        (Tenant.module_name + '::' + namespaced_module_name) if defined?(Tenant)
+        (Tenant.module_name + '::' + namespaced_module_name) if tenant?
       end
 
       def tenant_class_name
-        (Tenant.module_name + '::' + class_name) if defined?(Tenant)
+        (Tenant.module_name + '::' + class_name) if tenant?
       end
 
     end

data/app/models/effective/resources/init.rb

@@ -11,7 +11,7 @@ module Effective
 
         # Sets the class but also namespaces
         @model_klass = _klass_by_input(input)
-        @model_klass = _klass_by_input(relation) if relation.present?
+        @model_klass = _klass_by_input(relation) unless relation.nil?
 
         # Consider controller_name
         if @model_klass && input.kind_of?(String) && namespace.blank?

data/app/models/effective/resources/klass.rb

@@ -40,7 +40,7 @@ module Effective
       end
 
       def find_tenant_datatable_klass
-        return unless defined?(Tenant)
+        return unless tenant?
 
         "::#{tenant_controller_path.classify.pluralize}Datatable".safe_constantize ||
         "::#{tenant_controller_path.classify}Datatable".safe_constantize ||

data/app/models/effective/resources/naming.rb

@@ -32,11 +32,14 @@ module Effective
 
       def route_name_fallbacks
         mod = class_name.split('::').first.to_s.downcase
+        admin = ('admin' if namespace.present? && namespace.include?('/admin'))
 
         matches = [
           route_name.singularize,
           [*namespace, plural_name].join('/'),
+          [*admin, plural_name].join('/'),
           [*namespace, name].join('/'),
+          [*admin, name].join('/'),
           [*mod, *namespace, plural_name].join('/'),
           [*mod, *namespace, name].join('/')
         ]
@@ -65,16 +68,6 @@ module Effective
       def human_plural_name
         name.pluralize.gsub('::', ' ').underscore.gsub('_', ' ')
       end
-
-      def tenant
-        return nil unless defined?(Tenant)
-        return nil unless klass.present?
-        return nil unless class_name.include?('::')
-
-        name = class_name.split('::').first.downcase.to_sym
-        name if Rails.application.config.tenants[name].present?
-      end
-
     end
   end
 end

data/app/models/effective/resources/paths.rb

@@ -5,8 +5,7 @@ module Effective
     module Paths
 
       def tenant_path
-        return unless tenant.present?
-        Tenant.engine_path(tenant).sub("#{Rails.root}/", '')
+        Tenant.engine_path(tenant).sub("#{Rails.root}/", '') if tenant?
       end
 
       def model_file

data/app/models/effective/resources/tenants.rb

@@ -0,0 +1,24 @@
+module Effective
+  module Resources
+    module Tenants
+
+      def tenant?
+        defined?(::Tenant)
+      end
+
+      def tenant
+        return unless tenant?
+        return nil unless klass.present?
+        return nil unless class_name.include?('::')
+
+        name = class_name.split('::').first.downcase.to_sym
+        name if Rails.application.config.tenants[name].present?
+      end
+
+      def tenant_engines_blacklist
+        return [] unless tenant?
+        Rails.application.config.tenants.map { |name, _| name.to_s.classify }
+      end
+    end
+  end
+end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.9.2'.freeze
+  VERSION = '1.9.6'.freeze
 end

data/lib/effective_resources.rb

@@ -33,6 +33,35 @@ module EffectiveResources
 
   # Utilities
 
+  # This looks up the best class give the name
+  # If the Tenant is present, use those classes first.
+  def self.best(name)
+    klass = if defined?(Tenant)
+      ('::' + Tenant.module_name + '::' + name).safe_constantize ||
+      ('::' + Tenant.module_name + '::Effective::' + name).safe_constantize
+    end
+
+    klass ||= begin
+      ('::' + name).safe_constantize ||
+      ('::Effective::' + name).safe_constantize
+    end
+
+    raise("unable to find best #{name}") if klass.blank?
+
+    klass
+  end
+
+  def self.transaction(resource = nil, &block)
+    connection = (resource if resource.respond_to?(:transaction))
+    connection ||= (resource.class if resource.class.respond_to?(:transaction))
+    connection ||= '::ApplicationRecord'.safe_constantize
+    connection ||= 'ActiveRecord::Base'.safe_constantize
+
+    raise('unable to determine transaction class') unless connection.present?
+
+    connection.transaction { yield }
+  end
+
   def self.truthy?(value)
     if defined?(::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES)  # Rails <5
       ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.9.6
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-04 00:00:00.000000000 Z
+date: 2021-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -184,6 +184,7 @@ files:
 - app/models/effective/resources/paths.rb
 - app/models/effective/resources/relation.rb
 - app/models/effective/resources/sql.rb
+- app/models/effective/resources/tenants.rb
 - app/views/application/_flash.html.haml
 - app/views/application/create.js.erb
 - app/views/application/destroy.js.erb