introspective_admin 0.1.0 → 1.0.0

data/README.md

@@ -18,7 +18,7 @@
 
 IntrospectiveAdmin is a Rails Plugin for DRYing up ActiveAdmin configurations by
 laying out simple defaults and including nested relations according to the models'
-accepts_nested_attributes_for :relation declarations. 
+accepts_nested_attributes_for :relation declarations.
 
 ## Documentation
 
@@ -28,7 +28,9 @@ In your Gemfile:
 gem 'introspective_admin'
 ```
 
-And bundle install.  In app/admin/my_admin.rb:
+And bundle install.
+
+In app/admin/my_admin.rb:
 
 ```
 class MyAdmin < IntrospectiveAdmin::Base
@@ -39,7 +41,7 @@ class MyAdmin < IntrospectiveAdmin::Base
   def self.exclude_params
     %w(fields to exclude from the admin screen)
   end
-  
+
   register MyModel do
     # It yields the ActiveAdmin DSL context back, allowing further configuration to
     # be added here, just as you would normally, to the Admin::MyModelController
@@ -48,29 +50,32 @@ class MyAdmin < IntrospectiveAdmin::Base
 end
 ```
 
-Registering MyModel will set up the index, show, and form configurations for every attribute, virtual attribute listed in MyAdmin.include_virtual_attributes (e.g. a password field for a Devise model), and nested association on the model excluding those in MyAdmin.exclude_params. It will link to associated records (if they have ActiveAdmin screens), perform eager loading of nested associations, and permit parameters for every non-excluded attribute on the model. 
+Registering MyModel will set up the index, show, and form configurations for every attribute, virtual attribute listed in MyAdmin.include_virtual_attributes (e.g. a password field for a Devise model), and nested association on the model excluding those in MyAdmin.exclude_params. It will link to associated records (if they have ActiveAdmin screens), perform eager loading of nested associations, and permit parameters for every non-excluded attribute on the model.
 
-Customizing select box options for associations is done by adding an 
+Customizing select box options for associations is done by adding an
 "options_for_X" class method on the administrated model:
 
 ```
+app/models/my_model.rb
 class MyModel < ActiveRecord::Base
   belongs_to :parent
   has_many :other_models
   accepts_nested_attributes_for :other_models, :allow_destroy => true
 
   def self.options_for_parent(instance_of_my_model)
-    Parent.order(:appelation).map.{|p| ["#{p.appelation}", p.id] } 
+    Parent.order(:appelation).map.{|p| ["#{p.appelation}", p.id] }
   end
 end
 ```
 
 IntrospectiveAdmin will detect nested polymorphic relations and attempt to handle
-them using virutal attributes that you must add to the model instance, plus a class 
+them using virutal attributes that you must add to the model instance, plus a class
 method for the select box options, using a shared delimiter string for the compound ID.
-E.g. here we use a hyphen: 
+
+E.g. here we use a hyphen:
 
 ```
+app/models/my_model.rb
 class MyModel < ActiveRecord::Base
   belongs_to :poly_model, polymorphic: true
   accepts_nested_attributes_for :poly_model, :allow_destroy => true
@@ -90,6 +95,27 @@ class MyModel < ActiveRecord::Base
 end
 ```
 
+ActiveAdmin relies on [Ransack](https://github.com/activerecord-hackery/ransack) to power its searches. You will need
+to explicitly declare attributes and associations to be accessible to ActiveAdmin. You can defeat the purpose by declaring everything accessible via your models' abstract base class, but be sure to exclude sensitive data:
+
+```
+app/models/application_record.rb
+def ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  class << self
+    def ransackable_attributes(auth_object = nil)
+      @ransackable_attributes ||= column_names + _ransackers.keys - %w(password)
+    end
+
+    def ransackable_associations(auth_object = nil)
+      @ransackable_associations ||= reflect_on_all_associations.map { |a| a.name.to_s } + _ransackers.keys
+    end
+  end
+end
+```
+
+
 ## Dependencies
 
 Tool                  | Description

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -14,13 +16,9 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
-
 load 'rails/tasks/statistics.rake'
 
-
-
 Bundler::GemHelper.install_tasks
-

data/introspective_admin.gemspec

@@ -1,44 +1,29 @@
-$:.push File.expand_path("../lib", __FILE__)
-
-# Maintain your gem's version:
-require "introspective_admin/version"
-require "introspective_admin/base"
-
-# Describe your gem and declare its dependencies:
-Gem::Specification.new do |s|
-  s.name        = "introspective_admin"
-  s.version     = IntrospectiveAdmin::VERSION
-  s.authors     = ["Josh Buermann"]
-  s.email       = ["buermann@gmail.com"]
-  s.homepage    = "https://github.com/buermann/introspective_admin"
-  s.summary     = "Set up basic ActiveAdmin screens for an ActiveRecord model."
-  s.description = "Set up basic ActiveAdmin screens for an ActiveRecord model."
-  s.license     = "MIT"
-
-  s.files         = `git ls-files`.split("\n").sort
-  s.test_files    = `git ls-files -- spec/*`.split("\n")
-
-  s.required_ruby_version = '>= 1.9.3'
-
-  s.add_dependency 'rails'
-  s.add_dependency 'activeadmin'
-  s.add_dependency 'sass-rails'
-  s.add_dependency 'sass'
-
-
-  if RUBY_PLATFORM == 'java'
-    s.add_development_dependency "activerecord-jdbcsqlite3-adapter"
-  else
-    s.add_development_dependency "sqlite3", '~> 1.3.6'
-  end
-  s.add_development_dependency "rspec-rails"
-  s.add_development_dependency 'devise'
-  s.add_development_dependency 'devise-async'
-  s.add_development_dependency 'machinist_redux'
-  s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'rufus-mnemo'
-  s.add_development_dependency 'rails-controller-testing'
-  s.add_development_dependency 'sprockets-rails'
-
-end
-
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+# Maintain your gem's version:
+require 'introspective_admin/version'
+require 'introspective_admin/base'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = 'introspective_admin'
+  s.version     = IntrospectiveAdmin::VERSION
+  s.authors     = ['Josh Buermann']
+  s.email       = ['buermann@gmail.com']
+  s.homepage    = 'https://github.com/buermann/introspective_admin'
+  s.summary     = 'Set up basic ActiveAdmin screens for an ActiveRecord model.'
+  s.description = 'Set up basic ActiveAdmin screens for an ActiveRecord model.'
+  s.license     = 'MIT'
+
+  s.files = `git ls-files`.split("\n").sort
+
+  s.required_ruby_version = '>= 3.0', '< 4'
+
+  s.add_dependency 'activeadmin'
+  s.add_dependency 'sass'
+  s.add_dependency 'sass-rails'
+
+  s.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/introspective_admin/base.rb

@@ -1,200 +1,217 @@
-module IntrospectiveAdmin
-  class Base
-    # Generate an active admin interface by introspecting on the models.
-
-    # For polymorphic associations set up virtual 'assign' attributes on the model like so:
-    #
-    # def <polymorphism>_assign
-    #   "#{<polymorphism>_type}-#{<polymorphism>_id}"
-    # end
-    # def <polymorphism>_assign=(value)
-    #   self.<polymorphism>_type,self.<polymorphism>_id = value.split('-')
-    # end
-    #
-    # And designate the selection options in a class method, you can pass the
-    # target model to modify the options list accordingly
-    #
-    # def self.<polymorphism>_options(model=nil)
-    #   (Model.all + SecondModel.all).map { |i| [ i.name, "#{i.class}-#{i.id}"] }
-    # end
-
-    class << self
-
-      def exclude_params
-        [] # do not display the field in the index page and forms.
-      end
-
-      def include_virtual_attributes
-        [] #
-      end
-
-      def polymorphic?(model,column)
-        (model.reflections[column.sub(/_id$/,'')].try(:options)||{})[:polymorphic]
-      end
-
-      def column_list(model, extras=[])
-        model.columns.map {|c|
-          ref_name = c.name.sub(/(_type|_id)$/,'')
-          model.reflections[ref_name] ? ref_name : c.name
-        }.uniq-['created_at','updated_at']-exclude_params+extras
-      end
-
-      def params_list(model, extras=[])
-        model.columns.map {|c|
-          polymorphic?(model,c.name) ? c.name.sub(/_id$/,'')+"_assign" : c.name
-        }+extras
-      end
-
-      def link_record(dsl, record)
-        link_text = record.try(:name) || record.try(:title) || record.class.to_s
-        link_href = begin dsl.send("admin_#{record.class.name.underscore}_path", record.id) rescue false end
-        if link_href
-          dsl.link_to link_text, link_href
-        elsif link_text
-          link_text
-        else
-          record
-        end
-      end
-
-      def register(model, &block)
-        # Defining activeadmin pages will break pending migrations:
-        begin ActiveRecord::Migration.check_pending! rescue return end
-
-        klass         = self
-        model_name    = model.to_s.underscore
-        nested_config = Hash[model.nested_attributes_options.reject {|name,o|
-          klass.exclude_params.include?("#{name}_attributes")
-        }.map {|assoc,options|
-          reflection       = model.reflections[assoc.to_s]
-          reflection_class = reflection.class_name.constantize
-          # merge the options of the nested attribute and relationship declarations
-          options = options.merge(reflection_class.reflections[assoc.to_s].try(:options) || {})
-          options[:class]   = reflection_class
-          options[:columns] = klass.column_list(reflection_class)
-          options[:params]  = klass.params_list(reflection_class)
-          options[:reflection]            = reflection
-          options[:polymorphic_reference] = reflection.options[:as].to_s
-          [assoc, options]
-        }]
-
-        ActiveAdmin.register model do
-          instance_eval &block if block_given? # Evalutate the passed black for overrides to the defaults
-
-          controller do
-            def scoped_collection
-              super.includes super.nested_attributes_options.keys
-            end
-          end
-
-          index do
-            selectable_column
-            cols = model.columns.map(&:name)-klass.exclude_params
-            cols.each_with_index do |c,i|
-              reflection = model.reflections.detect {|k,v| v.foreign_key == c }
-              if reflection
-                column c do |o|
-                  klass.link_record(self,o.send(reflection.first))
-                end
-              else
-                column c
-              end
-            end
-            actions
-          end
-
-          show do
-            instance = self.send(model_name)
-
-            attributes_table do
-              model.columns.each do |c|
-                next if (c.name =~ /password/)
-                reflection = model.reflections.detect {|k,v| v.foreign_key == c.name }
-                if reflection
-                  row c.name do |o|
-                    klass.link_record(self,instance.send(reflection.first))
-                  end
-                else
-                  row c.name
-                end
-
-              end
-
-              nested_config.each do |assoc,options|
-                panel assoc.capitalize do
-                  table_for instance.send(assoc) do
-                    options[:columns].each do |c|
-                      if options[:class].reflections[c]
-                        column( c ) do |r|
-                          klass.link_record(self,r.send(c)) if r
-                        end
-                      else
-                        column c
-                      end
-                    end
-
-                    admin_route = begin url_for(['admin', options[:class].name.underscore]) rescue false end
-                    if admin_route
-                      column 'actions' do |child|
-                        span link_to "View",   url_for(['admin', child])
-                        span link_to "Edit",   url_for(['edit','admin',child])
-                        span link_to "Delete", url_for(['admin',child]), method: :delete, confirm: "Are you sure you want to delete this?"
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          permit_params klass.params_list(model, klass.include_virtual_attributes) + [Hash[nested_config.map{|assoc,o|
-            ["#{assoc}_attributes", o[:params]+[(o[:allow_destroy] ? :_destroy : '')] ]
-          }]]
-
-          form do |f|
-            f.semantic_errors *f.object.errors.messages.keys
-            f.actions
-
-            klass.column_list(model, klass.include_virtual_attributes).each do |column|
-              if column == model.primary_key
-              elsif klass.polymorphic?(model,column)
-                f.input column+"_assign", collection: model.send("#{column}_assign_options")
-              elsif model.respond_to?("options_for_#{column}")
-                f.input column, collection: model.send("options_for_#{column}", f.object)
-              else
-                f.input column
-              end
-            end
-
-            div { '&nbsp'.html_safe }
-
-            nested_config.each do |assoc,options|
-              aclass  = options[:class]
-              columns = options[:columns]-[aclass.primary_key]
-              f.inputs do
-                f.has_many assoc, allow_destroy: options[:allow_destroy] do |r|
-                  columns.each do |c|
-                    if c == model_name || c == options[:polymorphic_reference]
-                      # the join to the parent is implicit
-                    elsif klass.polymorphic?(aclass,c)
-                      r.input "#{c}_assign", collection: aclass.send("#{c}_assign_options")
-                    elsif aclass.reflections[c] && aclass.respond_to?("options_for_#{c}")
-                      # If the class has an options_for_<column> method defined use that
-                      # rather than the default behavior, pass the instance for scoping,
-                      # e.g. UserProjectJob.options_for_job is scoped by the Project's
-                      # jobs:
-                      r.input c, collection: aclass.send("options_for_#{c}",f.object)
-                    else
-                      r.input c
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module IntrospectiveAdmin
+  class Base
+    # Generate an active admin interface by introspecting on the models.
+
+    # For polymorphic associations set up virtual 'assign' attributes on the model like so:
+    #
+    # def <polymorphism>_assign
+    #   "#{<polymorphism>_type}-#{<polymorphism>_id}"
+    # end
+    # def <polymorphism>_assign=(value)
+    #   self.<polymorphism>_type,self.<polymorphism>_id = value.split('-')
+    # end
+    #
+    # And designate the selection options in a class method, you can pass the
+    # target model to modify the options list accordingly
+    #
+    # def self.<polymorphism>_options(model=nil)
+    #   (Model.all + SecondModel.all).map { |i| [ i.name, "#{i.class}-#{i.id}"] }
+    # end
+
+    class << self
+      def exclude_params
+        [] # do not display the field in the index page and forms.
+      end
+
+      def include_virtual_attributes
+        []
+      end
+
+      def polymorphic?(model, column)
+        (model.reflections[column.sub(/_id$/, '')].try(:options) || {})[:polymorphic]
+      end
+
+      def column_list(model, extras = [])
+        model.columns.map { |c|
+          ref_name = c.name.sub(/(_type|_id)$/, '')
+          model.reflections[ref_name] ? ref_name : c.name
+        }.uniq - %w[created_at updated_at] - exclude_params + extras
+      end
+
+      def params_list(model, extras = [])
+        model.columns.map { |c|
+          polymorphic?(model, c.name) ? "#{c.name.sub(/_id$/, '')}_assign" : c.name
+        } + extras
+      end
+
+      def link_record(dsl, record)
+        link_text = record.try(:name) || record.try(:title) || record.class.to_s
+        link_href = begin begin
+          dsl.send("admin_#{record.class.name.underscore}_path", record.id)
+        rescue StandardError
+          false
+        end
+        end
+        if link_href
+          dsl.link_to link_text, link_href
+        elsif link_text
+          link_text
+        else
+          record
+        end
+      end
+
+      def register(model, &block)
+        # Defining activeadmin pages will break pending migrations:
+        begin begin
+          ActiveRecord::Migration.check_all_pending!
+        rescue StandardError
+          return
+        end
+        end
+
+        klass         = self
+        model_name    = model.to_s.underscore
+        nested_config = model.nested_attributes_options.reject { |name, _o|
+          klass.exclude_params.include?("#{name}_attributes")
+        }.to_h do |assoc, options|
+          reflection       = model.reflections[assoc.to_s]
+          reflection_class = reflection.class_name.constantize
+          # merge the options of the nested attribute and relationship declarations
+          options = options.merge(reflection_class.reflections[assoc.to_s].try(:options) || {})
+          options[:class]   = reflection_class
+          options[:columns] = klass.column_list(reflection_class)
+          options[:params]  = klass.params_list(reflection_class)
+          options[:reflection]            = reflection
+          options[:polymorphic_reference] = reflection.options[:as].to_s
+          [assoc, options]
+        end
+
+        ActiveAdmin.register model do
+          instance_eval(&block) if block_given? # Evalutate the passed black for overrides to the defaults
+
+          controller do
+            def scoped_collection
+              super.includes super.nested_attributes_options.keys
+            end
+          end
+
+          index do
+            selectable_column
+            cols = model.columns.map(&:name) - klass.exclude_params
+            cols.each_with_index do |c, _i|
+              reflection = model.reflections.detect { |_k, v| v.foreign_key == c }
+              if reflection
+                column c do |o|
+                  klass.link_record(self, o.send(reflection.first))
+                end
+              else
+                column c
+              end
+            end
+            actions
+          end
+
+          show do
+            instance = send(model_name)
+
+            attributes_table do
+              model.columns.each do |c|
+                next if c.name =~ /password/
+
+                reflection = model.reflections.detect { |_k, v| v.foreign_key == c.name }
+                if reflection
+                  row c.name do |_o|
+                    klass.link_record(self, instance.send(reflection.first))
+                  end
+                else
+                  row c.name
+                end
+              end
+
+              nested_config.each do |assoc, options|
+                panel assoc.capitalize do
+                  table_for instance.send(assoc) do
+                    options[:columns].each do |c|
+                      if options[:class].reflections[c]
+                        column(c) do |r|
+                          klass.link_record(self, r.send(c)) if r
+                        end
+                      else
+                        column c
+                      end
+                    end
+
+                    admin_route = begin begin
+                      url_for(['admin', options[:class].name.underscore])
+                    rescue StandardError
+                      false
+                    end
+                    end
+                    if admin_route
+                      column 'actions' do |child|
+                        span link_to 'View',   url_for(['admin', child])
+                        span link_to 'Edit',   url_for(['edit', 'admin', child])
+                        span link_to 'Delete', url_for(['admin', child]), method: :delete, confirm: 'Are you sure you want to delete this?'
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          permitted_params = klass.params_list(model, klass.include_virtual_attributes) + [nested_config.to_h do |assoc, o|
+            ["#{assoc}_attributes", o[:params] + [(o[:allow_destroy] ? :_destroy : '')]]
+          end]
+          permit_params(*permitted_params)
+
+          form do |f|
+            f.semantic_errors(*f.object.errors.messages.keys)
+            f.actions
+
+            klass.column_list(model, klass.include_virtual_attributes).each do |column|
+              next if column == model.primary_key
+
+              if klass.polymorphic?(model, column)
+                f.input "#{column}_assign", collection: model.send("#{column}_assign_options")
+              elsif model.respond_to?("options_for_#{column}")
+                f.input column, collection: model.send("options_for_#{column}", f.object)
+              else
+                f.input column
+              end
+            end
+
+            div { '&nbsp'.html_safe }
+
+            nested_config.each do |assoc, options|
+              aclass  = options[:class]
+              columns = options[:columns] - [aclass.primary_key]
+              f.inputs do
+                f.has_many assoc, allow_destroy: options[:allow_destroy] do |r|
+                  columns.each do |c|
+                    if c == model_name || c == options[:polymorphic_reference]
+                      # the join to the parent is implicit
+                    elsif klass.polymorphic?(aclass, c)
+                      r.input "#{c}_assign", collection: aclass.send("#{c}_assign_options")
+                    elsif aclass.reflections[c] && aclass.respond_to?("options_for_#{c}")
+                      # If the class has an options_for_<column> method defined use that
+                      # rather than the default behavior, pass the instance for scoping,
+                      # e.g. UserProjectJob.options_for_job is scoped by the Project's
+                      # jobs:
+                      r.input c, collection: aclass.send("options_for_#{c}", f.object)
+                    else
+                      r.input c
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/introspective_admin/version.rb

@@ -1,3 +1,5 @@
-module IntrospectiveAdmin
-  VERSION = "0.1.0"
-end
+# frozen_string_literal: true
+
+module IntrospectiveAdmin
+  VERSION = '1.0.0'
+end

data/lib/introspective_admin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'activeadmin'
 module IntrospectiveAdmin
   autoload :Base, 'introspective_admin/base'

data/lib/tasks/introspective_admin_tasks.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # desc "Explaining what the task does"
 # task :introspective_admin do
 #   # Task goes here