active_element 0.0.3 → 0.0.5

data/lib/active_element/permissions_check.rb

@@ -3,6 +3,8 @@
 module ActiveElement
   # Verifies provided permissions against required permissions.
   class PermissionsCheck
+    include Paintbrush
+
     def initialize(required:, actual:, controller_path:, action_name:, rails_component:)
       @required = required.presence || []
       @actual = normalized(actual)
@@ -18,41 +20,58 @@ module ActiveElement
 
     def message
       return development_environment_message if rails_component.environment == 'development'
-      return "User access granted for permission(s): #{applicable.join(', ')}" if permitted?
+      return permitted_message if permitted?
 
-      "User access forbidden. Missing user permission(s): #{missing.join(', ')}"
+      forbidden_message
     end
 
     def missing
       @missing ||= applicable.reject do |permission|
-        actual.include?(permission.to_s)
-      end.map(&:to_s)
+        next true if permission.fetch(:always, false)
+
+        actual.include?(permission.fetch(:with).to_s)
+      end
     end
 
     def applicable
       @applicable ||= default_permissions + required_permissions
     end
 
+    def applicable_permissions
+      applicable.map { |permission| permission.fetch(:with) }
+    end
+
+    def missing_permissions
+      missing.map { |permission| permission.fetch(:with) }
+    end
+
     private
 
     attr_reader :required, :actual, :controller_name, :action_name, :rails_component
 
     def development_environment_message
-      "Bypassed permission(s) in development environment: #{applicable.join(', ')}"
+      "Bypassed permission(s) in development environment: #{applicable_permissions.join(', ')}"
+    end
+
+    def permitted_message
+      paintbrush { green "User access granted for permission(s): #{cyan applicable_permissions.join(', ')}" }
+    end
+
+    def forbidden_message
+      paintbrush { red "User access forbidden. Missing user permission(s): #{cyan missing_permissions.join(', ')}" }
     end
 
     def default_permissions
       return [] if normalized_action.nil?
 
-      ["can_#{normalized_action}_#{rails_component.application_name}_#{controller_name}"]
+      [{
+        action: normalized_action,
+        with: "can_#{normalized_action}_#{rails_component.application_name}_#{controller_name}"
+      }]
     end
 
     def required_permissions
-      @required_permissions ||= required.map do |permission, options|
-        next nil unless applicable?(options)
-
-        permission
-      end.compact
+      @required_permissions ||= required.select { |options| applicable?(options) }
     end
 
     def normalized_action
@@ -74,28 +93,13 @@ module ActiveElement
     end
 
     def applicable?(options)
-      return true if !options.key?(:only) && !options.key?(:except)
-      return true if only_applicable?(options)
-      return false if except_applicable?(options)
-
-      false
-    end
-
-    def only_applicable?(options)
-      return false unless options.key?(:only)
-
-      normalized(options.fetch(:only)).include?(action_name)
-    end
-
-    def except_applicable?(options)
-      return false unless options.key?(:except)
-
-      normalized(options.fetch(:except)).include?(action_name)
+      options.fetch(:action).to_s == action_name
     end
 
     def raise_unprotected_route_error
       raise UnprotectedRouteError,
-            "#{controller_name.titleize.tr(' ', '')}##{action_name} must be protected with `permit_user`"
+            "#{controller_name.titleize.tr(' ', '')}##{action_name} must be protected with " \
+            '`active_element.permit_action`'
     end
   end
 end

data/lib/active_element/permissions_report.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Generates a report of all permissions used by a given application. Used by `rake active_element:permissions`
+  # to provide a convenient interface to listing all required permissions so that they can be provisioned to
+  # users as needed.
+  class PermissionsReport
+    include Paintbrush
+
+    COLOR_MAP = { list: :cyan, view: :blue, create: :green, delete: :red, edit: :yellow, text: :white }.freeze
+
+    def initialize
+      ActiveElement.eager_load_controllers
+      ActiveElement.eager_load_models
+      @buffer = []
+    end
+
+    def report
+      generate
+      buffer.join("\n")
+    end
+
+    private
+
+    attr_reader :buffer
+
+    def generate
+      buffer << paintbrush { blue "\nThe following user permissions are used by this application:\n" }
+      permissions.each do |permission|
+        buffer << paintbrush { white "    * #{public_send(color(permission), permission)}" }
+      end
+      buffer << "\n"
+    end
+
+    def color(permission)
+      COLOR_MAP.find do |action, _|
+        permission.include?("_#{action}_")
+      end&.last || :purple
+    end
+
+    def permissions
+      routes.map(&:permissions).flatten.sort.uniq + text_search_permissions
+    end
+
+    def text_search_permissions
+      ActiveElement::Components::TextSearch.authorized_text_searches.map do |model, with, providing|
+        (Array(with) + Array(providing)).map do |field|
+          ActiveElement::Components::TextSearch::Authorization.permission_for(model: model, field: field)
+        end
+      end.flatten.uniq
+    end
+
+    def routes
+      ActiveElement::Routes.new(rails_component: ActiveElement::RailsComponent.new(Rails))
+    end
+  end
+end

data/lib/active_element/route.rb

@@ -49,7 +49,7 @@ module ActiveElement
     end
 
     def permissions
-      permissions_check.applicable.map(&:to_s)
+      permissions_check.applicable.map { |permission| permission.fetch(:with).to_s }
     end
 
     def rails_route?

data/lib/active_element/routes.rb

@@ -41,7 +41,7 @@ module ActiveElement
 
     def descendants_with_permissions
       @descendants_with_permissions ||= descendants.map do |controller_class|
-        [controller_class.new, controller_class.active_element_permissions]
+        [controller_class.new, controller_class.active_element.permissions]
       end.compact
     end
 

data/lib/active_element/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveElement
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

data/lib/active_element.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require 'rouge'
 require 'kaminari'
 require 'sassc'
 require 'bootstrap'
 require 'active_record'
-# require 'rspec/documentation' # FIXME: Load dynamically when running rspec documentation command.
+require 'paintbrush'
 
 require_relative 'active_element/version'
-require_relative 'active_element/active_record_text_search_authorization'
-require_relative 'active_element/colorized_string'
 require_relative 'active_element/active_menu_link'
 require_relative 'active_element/permissions_check'
+require_relative 'active_element/permissions_report'
+require_relative 'active_element/controller_interface'
 require_relative 'active_element/controller_action'
 require_relative 'active_element/rails_component'
 require_relative 'active_element/route'
@@ -30,6 +29,8 @@ module ActiveElement
   class << self
     attr_writer :application_name, :navbar_items
 
+    include Paintbrush
+
     def application_title
       @application_name || RailsComponent.new(Rails).application_name.titleize
     end
@@ -38,6 +39,14 @@ module ActiveElement
       @navbar_items || inferred_navbar_items(user)
     end
 
+    def warning(message)
+      warn "#{log_tag} #{paintbrush { yellow(message) }}"
+    end
+
+    def log_tag
+      paintbrush { cyan "[#{blue 'ActiveElement'}]" }
+    end
+
     def active_path_class(user:, current_navbar_item:, current_path:, controller_path:, action_name:)
       if ActiveMenuLink.new(
         rails_component: RailsComponent.new(Rails),
@@ -71,12 +80,17 @@ module ActiveElement
       false
     end
 
+    def eager_load_models
+      eager_load(:models)
+    end
+
     def eager_load_controllers
-      Pathname.new(__dir__)
-              .join('../app/controllers/active_element')
-              .glob('**/*_controller.rb')
-              .each { |path| require path }
-      Rails.root.join('app/controllers/admin/').glob('**/*_controller.rb').each { |path| require path }
+      eager_load(:controllers)
+    end
+
+    def eager_load(resource)
+      suffix = resource == :controllers ? '_controller' : nil
+      Rails.root.join("app/#{resource}").glob("**/*#{suffix}.rb").each { |path| require path }
     end
 
     private
@@ -90,7 +104,7 @@ module ActiveElement
 
     def user_routes(user)
       ActiveElement::Routes.new(
-        permissions: user.permissions,
+        permissions: user&.permissions,
         rails_component: ActiveElement::RailsComponent.new(Rails)
       )
     end

data/lib/tasks/active_element.rake

@@ -3,21 +3,6 @@
 namespace :active_element do
   desc 'Displays all permissions used by this application'
   task permissions: :environment do
-    ActiveElement.eager_load_controllers
-    routes = ActiveElement::Routes.new(rails_component: ActiveElement::RailsComponent.new(Rails))
-    permissions = routes.map(&:permissions).flatten.sort.uniq
-    $stdout.puts ActiveElement::ColorizedString.new(
-      "\nThe following user permissions are used by this application:\n",
-      color: :light_blue
-    ).value
-    permissions.each do |permission|
-      color = { list: :cyan, view: :blue, create: :green, delete: :red, edit: :yellow }.find do |action, _|
-        permission.include?("_#{action}_")
-      end&.last || :purple
-      $stdout.puts('    ' \
-                   "#{ActiveElement::ColorizedString.new('*', color: :white).value} " \
-                   "#{ActiveElement::ColorizedString.new(permission, color: color).value}")
-    end
-    $stdout.puts
+    $stdout.puts ActiveElement::PermissionsReport.new.report
   end
 end

data/rspec-documentation/pages/Components/Tables.md

@@ -15,7 +15,7 @@ collection = [
   User.new(name: 'Jane', email: 'jane@example.org')
 ]
 
-html = active_element_component.table collection: collection, fields: [:name, :email]
+html = active_element.component.table collection: collection, fields: [:name, :email]
 
 it_documents html do
   expect(html).to include 'John'
@@ -32,7 +32,7 @@ end
 
 item = User.new(name: 'John', email: 'john@example.com', overview: 'Writes Ruby code for a living.')
 
-html = active_element_component.table item: item, fields: [:name, :email, :password, :secret]
+html = active_element.component.table item: item, fields: [:name, :email, :password, :secret]
 
 it_documents html do
   expect(html).to include 'John'

data/rspec-documentation/spec_helper.rb

@@ -30,6 +30,6 @@ RSpec::Documentation.configure do |config|
       end
     end
 
-    context.active_element_component = ActiveElement::Component.new(StubbedController.new)
+    context.active_element.component = ActiveElement::Component.new(StubbedController.new)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_element
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Bob Farrell
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-23 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bootstrap
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.3.0alpha3
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: kaminari
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: kaminari
+  name: paintbrush
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -118,14 +118,15 @@ files:
 - app/assets/javascripts/active_element/form.js
 - app/assets/javascripts/active_element/json_field.js
 - app/assets/javascripts/active_element/pagination.js
-- app/assets/javascripts/active_element/search_field.js
+- app/assets/javascripts/active_element/popover.js
 - app/assets/javascripts/active_element/secret.js
 - app/assets/javascripts/active_element/setup.js
+- app/assets/javascripts/active_element/text_search_field.js
 - app/assets/javascripts/active_element/theme.js
+- app/assets/javascripts/active_element/toast.js
 - app/assets/stylesheets/active_element/_variables.scss
 - app/assets/stylesheets/active_element/application.scss
 - app/controllers/active_element/application_controller.rb
-- app/controllers/active_element/text_searches_controller.rb
 - app/views/active_element/components/_horizontal_tabs.html.erb
 - app/views/active_element/components/_vertical_tabs.html.erb
 - app/views/active_element/components/button.html.erb
@@ -175,8 +176,6 @@ files:
 - config/routes.rb
 - lib/active_element.rb
 - lib/active_element/active_menu_link.rb
-- lib/active_element/active_record_text_search_authorization.rb
-- lib/active_element/colorized_string.rb
 - lib/active_element/component.rb
 - lib/active_element/components.rb
 - lib/active_element/components/button.rb
@@ -189,6 +188,11 @@ files:
 - lib/active_element/components/secret_fields.rb
 - lib/active_element/components/tab.rb
 - lib/active_element/components/tabs.rb
+- lib/active_element/components/text_search.rb
+- lib/active_element/components/text_search/active_record_authorization.rb
+- lib/active_element/components/text_search/authorization.rb
+- lib/active_element/components/text_search/component.rb
+- lib/active_element/components/text_search/sql.rb
 - lib/active_element/components/translations.rb
 - lib/active_element/components/util.rb
 - lib/active_element/components/util/association_mapping.rb
@@ -199,9 +203,12 @@ files:
 - lib/active_element/components/util/form_value_mapping.rb
 - lib/active_element/components/util/i18n.rb
 - lib/active_element/components/util/record_mapping.rb
+- lib/active_element/components/util/record_path.rb
 - lib/active_element/controller_action.rb
+- lib/active_element/controller_interface.rb
 - lib/active_element/engine.rb
 - lib/active_element/permissions_check.rb
+- lib/active_element/permissions_report.rb
 - lib/active_element/rails_component.rb
 - lib/active_element/route.rb
 - lib/active_element/routes.rb

data/app/controllers/active_element/text_searches_controller.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveElement
-  # Used by auto-complete search field for executing a text search on the provided model and
-  # attributes.
-  #
-  # The user must have the permission `can_create_<application_name>_active_element_text_searches`.
-  #
-  # A model must call `authorize_active_element_text_search_for` to enable text search. e.g.:
-  #
-  # class MyModel < ApplicationRecord
-  #   authorize_active_element_text_search_for :name, exposes: [:email]
-  # end
-  #
-  # This will allow searching on the `name` column and permits returning each matching record's
-  # `:email` column's value.
-  #
-  # TODO: Refactor logic into separate classes.
-  # rubocop:disable Metrics/ClassLength
-  class TextSearchesController < ApplicationController
-    DEFAULT_LIMIT = 50
-
-    before_action :verify_parameters
-    before_action :verify_model
-
-    def create
-      render json: { results: results, request_id: params[:request_id] }
-    end
-
-    private
-
-    def verify_parameters
-      return if %i[model attributes value query].all? { |parameter| params[parameter].present? }
-
-      render json: { message: 'Must provide parameters: [model, attributes, value, query] for text search.' },
-             status: :unprocessable_entity
-    end
-
-    def verify_model
-      return if [model, search_columns, value_column].all?(&:present?) && authorized?
-
-      render json: { message: verify_fail_message }, status: :unprocessable_entity
-    end
-
-    def verify_fail_message
-      requested = %i[model attributes value].index_with { |key| params[key] }
-                                            .compact_blank
-                                            .map { |key, value| "#{key}: #{value}" }
-      "Unpermitted or unavailable search for: { #{requested.join(', ')} }"
-    end
-
-    def results
-      @results ||= model.where(*whereclause)
-                        .limit(limit)
-                        .pluck(value_column.name, *search_columns.map(&:name))
-                        .map { |value, *attributes| result(value, attributes) }
-    end
-
-    def result(value, attributes)
-      { value: value, attributes: attributes.reject { |attribute| attribute == value } }
-    end
-
-    def model
-      @model ||= params[:model].camelize(:upper).safe_constantize
-    end
-
-    def query
-      params[:query]
-    end
-
-    def value_column
-      return nil if params[:value].blank?
-
-      @value_column ||= model&.columns&.find { |column| column.name == params[:value] }
-    end
-
-    def search_columns
-      return nil if params[:attributes].blank?
-
-      @search_columns ||= params[:attributes].map { |attribute| column_for(attribute) }.compact
-    end
-
-    def column_for(attribute)
-      matched_column = model&.columns&.find { |column| column.name == attribute }
-      return nil if matched_column.blank?
-
-      compatible_column?(matched_column) ? matched_column : nil
-    end
-
-    def authorized?
-      model.authorized_active_element_text_search_fields&.any? do |field, exposed|
-        exposed = [exposed] unless exposed.is_a?(Array)
-        authorized_field?(field, exposed)
-      end
-    end
-
-    def authorized_field?(field, exposed)
-      return false unless search_columns.map { |column| column.name.to_sym }.include?(field.to_sym)
-      return false unless exposed&.map(&:to_sym)&.include?(value_column.name.to_sym)
-
-      true
-    end
-
-    def whereclause
-      clauses = search_columns.map { |column| "#{column.name} #{operator(column)} ?" }
-      [clauses.join(' OR '), search_columns.map { |column| search_param(column) }].flatten
-    end
-
-    def operator(column)
-      case column.type
-      when :string
-        model.connection.adapter_name == 'SQLite' ? 'LIKE' : 'ILIKE'
-      else
-        '='
-      end
-    end
-
-    def compatible_column?(column) # rubocop:disable Metrics/MethodLength
-      case column.type
-      when :string
-        true
-      when :integer
-        integer?
-      when :float
-        float?
-      when :decimal
-        decimal?
-      else
-        Rails.logger.info("Skipping query `#{query}` for incompatible column: #{column.name}")
-        false
-      end
-    end
-
-    def integer?
-      Integer(query)
-      true
-    rescue ArgumentError
-      false
-    end
-
-    def float?
-      Float(query)
-      true
-    rescue ArgumentError
-      false
-    end
-
-    def decimal?
-      BigDecimal(query)
-      true
-    rescue ArgumentError
-      false
-    end
-
-    def search_param(column)
-      case column.type
-      when :string
-        "#{query}%"
-      else
-        query
-      end
-    end
-
-    def limit
-      DEFAULT_LIMIT
-    end
-
-    def permissions_check
-      @permissions_check ||= PermissionsCheck.new(
-        required: [],
-        actual: current_user.permissions,
-        controller_path: controller_path,
-        action_name: action_name,
-        rails_component: rails_component
-      )
-    end
-
-    def required_permissions
-      application_name = rails_component.application_name
-      permission = "can_text_search_#{application_name}_#{params[:model]&.pluralize}"
-      [[permission, { only: :create }]]
-    end
-
-    def rails_component
-      @rails_component ||= RailsComponent.new(Rails)
-    end
-  end
-  # rubocop:enable Metrics/ClassLength
-end

data/lib/active_element/active_record_text_search_authorization.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-ActiveRecord::Base.class_eval do
-  class << self
-    attr_reader :authorized_active_element_text_search_fields
-
-    def authorize_active_element_text_search_for(field, exposes:)
-      @authorized_active_element_text_search_fields ||= []
-      @authorized_active_element_text_search_fields << [field, exposes]
-    end
-  end
-end

data/lib/active_element/colorized_string.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveElement
-  # Wraps strings in terminal escape codes to provide colourisation in (e.g.) logging output.
-  class ColorizedString
-    COLOR_CODES = {
-      cyan: '36',
-      red: '31',
-      green: '32',
-      blue: '34',
-      purple: '35',
-      yellow: '33',
-      light_gray: '37',
-      light_blue: '1;34',
-      white: '1;37'
-    }.freeze
-
-    def initialize(string, color:)
-      @string = string
-      @color = color
-    end
-
-    def value
-      return string unless Rails.env.development? || Rails.env.test?
-
-      "\e[#{COLOR_CODES.fetch(color)}m#{string}\e[0m"
-    end
-
-    private
-
-    attr_reader :string, :color
-  end
-end