wallaby-active_record 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92d10c82a2195970de2aa77c1ad8cd776c03fe68c264678e962bab91a01e7e0d
+  data.tar.gz: 629a2839e2e558ca281f2a48777fbfa20a0a7a77a7497ca8b2a185a5d731d8ff
+SHA512:
+  metadata.gz: 71820d2020d94d02e2a02063c70faa630a58ae3e2f6ca0422f043a9f3042cf4eeedf336fe8d8f4fcb37f3c0471715427a34329dfacacd27444deb45aef57d04f
+  data.tar.gz: 392802282ef7e87b47c7018544f1324fea3d6750304d88e0d28b1ccf7a27d869cbd68dfc4ed58d03610f9a48b80b10f0a55f37bfdbb3af82ea7234997d71930c

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2019 Google LLC. http://angular.io/license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Wallaby::ActiveRecord
+
+This gem contains the ActiveRecord ORM adapter for Wallaby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wallaby-active_record'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install wallaby-active_record
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wallaby-rails/wallaby-active_record.
+
+## License
+
+This project is [MIT Licensed](LICENSE)

data/lib/adapters/wallaby/active_record/cancancan_provider.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    # Cancancan provider for ActiveRecord
+    class CancancanProvider < CancancanAuthorizationProvider
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/default_provider.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    # Default provider for ActiveRecord
+    class DefaultProvider < DefaultAuthorizationProvider
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder/association_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      class FieldsBuilder
+        # To build the metadata for associations
+        class AssociationBuilder
+          # Update the metadata
+          # @param metadata [Hash]
+          # @param reflection [ActiveRecord::Reflection]
+          def update(metadata, reflection)
+            type = reflection.macro
+            metadata[:is_association] = true
+            metadata[:sort_disabled] = true
+            metadata[:is_through] = through?(reflection)
+            metadata[:has_scope] = scope?(reflection)
+            metadata[:foreign_key] = foreign_key_for(reflection, type)
+          end
+
+          private
+
+          # @param reflection [ActiveRecord::Reflection]
+          # @param type [Symbol]
+          # @return [String] foreign key
+          def foreign_key_for(reflection, type)
+            if type == :belongs_to || reflection.polymorphic?
+              reflection.foreign_key
+            elsif reflection.collection?
+              # @see https://github.com/rails/rails/blob/92703a9ea5d8b96f30e0b706b801c9185ef14f0e/activerecord/lib/active_record/associations/builder/collection_association.rb#L50
+              reflection.name.to_s.singularize << '_ids'
+            else
+              reflection.association_foreign_key
+            end
+          end
+
+          # @param reflection [ActiveRecord::Reflection]
+          # @return [Boolean] whether it's a through relation
+          def through?(reflection)
+            reflection.is_a? ::ActiveRecord::Reflection::ThroughReflection
+          end
+
+          # @param reflection [ActiveRecord::Reflection]
+          # @return [Boolean] whether it has scope
+          def scope?(reflection)
+            reflection.scope.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder/polymorphic_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      class FieldsBuilder
+        # To build the metadata for polymorphic
+        class PolymorphicBuilder
+          # update the metadata
+          # @param metadata [Hash]
+          # @param reflection [ActiveRecord::Reflection]
+          def update(metadata, reflection)
+            if reflection.polymorphic?
+              metadata[:is_polymorphic] = true
+              metadata[:polymorphic_type] = reflection.foreign_type
+              metadata[:polymorphic_list] = polymorphic_list_for(reflection)
+            else
+              metadata[:class] = reflection.klass
+            end
+          end
+
+          private
+
+          # @param reflection [ActiveRecord::Reflection]
+          # @return [Array<Class>] a list of classes for this polymorphism
+          def polymorphic_list_for(reflection)
+            all_model_class.each_with_object([]) do |model_class, list|
+              list << model_class if polymorphic_defined? model_class, reflection.name
+            end
+          end
+
+          # @return [Array<Class>] a list of all ActiveRecord classes
+          def all_model_class
+            Map
+              .mode_map
+              .select { |_, mode| mode == ::Wallaby::ActiveRecord }.keys
+          end
+
+          # @param model_class [Class]
+          # @param polymorphic_name [String] polymorphic name
+          # @return [Boolean] if polymorphism defined?
+          def polymorphic_defined?(model_class, polymorphic_name)
+            polymorphic_name_sym = polymorphic_name.try(:to_sym)
+            model_class.reflections.any? do |_field_name, reflection|
+              reflection.options[:as].try(:to_sym) == polymorphic_name_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder/sti_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      class FieldsBuilder
+        # To build the metadata for sti column
+        class StiBuilder
+          # @param model_class [Class]
+          def initialize(model_class)
+            @model_class = model_class
+          end
+
+          # update the metadata
+          # @param metadata [Hash]
+          # @param column [ActiveRecord::ConnectionAdapters::Column]
+          def update(metadata, column)
+            return unless @model_class.inheritance_column == column.name
+
+            metadata[:type] = 'sti'
+            metadata[:sti_class_list] = sti_list(find_parent_of(@model_class))
+          end
+
+          private
+
+          # @param klass [Class]
+          # @return [Array<Class>] a list of STI classes for this model
+          def sti_list(klass)
+            list = klass.descendants << klass
+            list.sort_by(&:name)
+          end
+
+          # @param klass [Class]
+          # @return [Class] the top parent class in the STI hierarchy
+          def find_parent_of(klass)
+            parent = klass
+            parent = parent.superclass until top_parent?(parent.superclass)
+            parent
+          end
+
+          # @param klass [Class]
+          # @return [Boolean] whether the class is ActiveRecord base class
+          def top_parent?(klass)
+            klass == ModelFinder.base || ModuleUtils.try_to(klass, :abstract_class?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      # To search and build the metadata for fields
+      class FieldsBuilder
+        # @param model_class [Class]
+        def initialize(model_class)
+          @model_class = model_class
+        end
+
+        # @return [Hash<String, Hash>] a hash for general fields
+        def general_fields
+          @model_class.columns.each_with_object({}) do |column, fields|
+            metadata = {
+              type: to_type(column).freeze,
+              label: @model_class.human_attribute_name(column.name)
+            }
+            sti_builder.update(metadata, column)
+            fields[column.name] = metadata
+          end
+        end
+
+        # @return [Hash<String, Hash>] a hash for general fields
+        def association_fields
+          @model_class.reflections.each_with_object({}) do |(name, ref), fields|
+            metadata = {
+              type: ref.macro.to_s,
+              label: @model_class.human_attribute_name(name)
+            }
+            association_builder.update(metadata, ref)
+            polymorphic_builder.update(metadata, ref)
+            fields[name] = metadata
+          end
+        end
+
+        protected
+
+        # Detect active_storage type
+        # @param column [ActiveRecord::ConnectionAdapters::Column]
+        # @return [String] field type
+        def to_type(column)
+          return 'active_storage' if @model_class.respond_to?("with_attached_#{column.name}")
+
+          column.type.to_s
+        end
+
+        # @return [Wallaby::ActiveRecord::ModelDecorator::StiBuilder]
+        def sti_builder
+          @sti_builder ||= StiBuilder.new(@model_class)
+        end
+
+        # @return [Wallaby::ActiveRecord::ModelDecorator::AssociationBuilder]
+        def association_builder
+          @association_builder ||= AssociationBuilder.new
+        end
+
+        # @return [Wallaby::ActiveRecord::ModelDecorator::PolymorphicBuilder]
+        def polymorphic_builder
+          @polymorphic_builder ||= PolymorphicBuilder.new
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator/title_field_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      # Try to find the field that can be used as title
+      class TitleFieldFinder
+        TITLE_FIELD_TYPES = %w(string).freeze
+
+        # @param model_class [Class]
+        # @param fields [Hash] fields metadata
+        def initialize(model_class, fields)
+          @model_class  = model_class
+          @fields       = fields
+        end
+
+        # @return [String] field name that can be used as title
+        def find
+          possible_title_fields = @fields.select do |_field_name, metadata|
+            TITLE_FIELD_TYPES.include? metadata[:type]
+          end
+          target_field = possible_title_fields.keys.find do |field_name|
+            TITLE_NAMES.any? { |v| field_name.to_s.index v }
+          end
+          target_field \
+            || possible_title_fields.keys.first \
+            || @model_class.primary_key
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_decorator.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    # Modal decorator for ActiveRecord
+    class ModelDecorator < ::Wallaby::ModelDecorator
+      # Data types to exclude for index page
+      INDEX_EXCLUSIVE_DATA_TYPES =
+        (['', 'medium', 'long'] * 2)
+        .zip(%w(blob text) * 3).map(&:join)
+        .concat(%w(binary citext hstore json jsonb tsvector xml)).freeze
+
+      # Class to exclude for show page
+      SHOW_EXCLUSIVE_CLASS_NAMES = %w(ActiveStorage::Attachment ActiveStorage::Blob).freeze
+
+      # Data types to exclude for form page
+      FORM_EXCLUSIVE_DATA_TYPES = %w(created_at updated_at).freeze
+
+      # Origin metadata directly coming from ActiveRecord.
+      #
+      # It needs to be frozen so that we can keep the metadata integrity
+      # @example sample fields:
+      #   model_decorator.fields
+      #   # =>
+      #   {
+      #     # general field
+      #     id: { name: 'id', type: 'integer', label: 'Id' },
+      #     # association field
+      #     category: {
+      #       'name' => 'category',
+      #       'type' => 'belongs_to',
+      #       'label' => 'Category',
+      #       'is_association' => true,
+      #       'is_through' => false,
+      #       'has_scope' => false,
+      #       'foreign_key' => 'category_id',
+      #       'class' => Category
+      #     }
+      #   }
+      # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+      def fields
+        @fields ||= ::ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
+          # NOTE: There is a chance that people create ActiveRecord class
+          # before they do the migration, so initialising the fields will raise
+          # all kinds of error. Therefore, we need to check the table existence
+          if @model_class.table_exists?
+            hash.merge! general_fields
+            hash.merge! association_fields
+            hash.except!(*foreign_keys_from_associations)
+          end
+        end.freeze
+      end
+
+      # A copy of {#fields} for index page
+      # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+      def index_fields
+        @index_fields ||= Utils.clone fields
+      end
+
+      # A copy of {#fields} for show page
+      # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+      def show_fields
+        @show_fields ||= Utils.clone fields
+      end
+
+      # A copy of {#fields} for form (new/edit) page
+      # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+      def form_fields
+        @form_fields ||= Utils.clone fields
+      end
+
+      # @return [Array<String>] a list of field names for index page (note: only primitive SQL types are included).
+      def index_field_names
+        @index_field_names ||=
+          index_fields.reject do |_field_name, metadata|
+            metadata[:is_association] \
+              || INDEX_EXCLUSIVE_DATA_TYPES.include?(metadata[:type])
+          end.keys
+      end
+
+      # @return [Array<String>] a list of field names for show page (note: **ActiveStorage** fields are excluded).
+      def show_field_names
+        @show_field_names ||=
+          show_fields.reject do |_field_name, metadata|
+            SHOW_EXCLUSIVE_CLASS_NAMES.include? metadata[:class].try(:name)
+          end.keys
+      end
+
+      # @return [Array<String>] a list of field names for form (new/edit) page (note: complex fields are excluded).
+      def form_field_names
+        @form_field_names ||=
+          form_fields.reject do |field_name, metadata|
+            field_name == primary_key \
+              || FORM_EXCLUSIVE_DATA_TYPES.include?(field_name) \
+              || metadata[:has_scope] || metadata[:is_through]
+          end.keys
+      end
+
+      # @return [ActiveModel::Errors] errors for resource
+      def form_active_errors(resource)
+        resource.errors
+      end
+
+      # @return [String] primary key for the resource
+      def primary_key
+        @primary_key ||= @model_class.primary_key
+      end
+
+      # To guess the title for resource.
+      #
+      # It will go through the fields and try to find out the one that looks
+      # like a name or text to represent this resource. Otherwise, it will fall
+      # back to primary key.
+      #
+      # @param resource [Object]
+      # @return [String] the title of given resource
+      def guess_title(resource)
+        ModuleUtils.try_to resource, title_field_finder.find
+      end
+
+      protected
+
+      # @return [Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder]
+      def field_builder
+        @field_builder ||= FieldsBuilder.new @model_class
+      end
+
+      # @return [Wallaby::ActiveRecord::ModelDecorator::TitleFieldFinder]
+      def title_field_finder
+        @title_field_finder ||=
+          TitleFieldFinder.new @model_class, general_fields
+      end
+
+      # @!method general_fields
+      #   (see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#general_fields)
+      #   @see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#general_fields
+
+      # @!method association_fields
+      #   (see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#association_fields)
+      #   @see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#association_fields
+      delegate :general_fields, :association_fields, to: :field_builder
+
+      # Find out all the foreign keys for association fields
+      # @param fields [Hash] metadata of fields
+      # @return [Array<String>] a list of foreign keys
+      def foreign_keys_from_associations(fields = association_fields)
+        fields.each_with_object([]) do |(_field_name, metadata), keys|
+          keys << metadata[:foreign_key] if metadata[:foreign_key]
+          keys << metadata[:polymorphic_type] if metadata[:polymorphic_type]
+          keys
+        end
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_finder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    # Model finder
+    class ModelFinder < ::Wallaby::ModelFinder
+      # @return [Array<Class>] a list of ActiveRecord subclasses
+      def all
+        self.class.base.descendants.reject do |model_class|
+          abstract?(model_class) || anonymous?(model_class) || habtm?(model_class)
+        end.sort_by(&:to_s)
+      end
+
+      # This is only for ActiveRecord
+      # @return [ApplicationRecord, ActiveRecord::Base] base ActiveRecord class
+      def self.base
+        return ::ApplicationRecord if defined? ::ApplicationRecord
+
+        ::ActiveRecord::Base
+      end
+
+      private
+
+      # Is model class abstract?
+      # @param model_class [Class]
+      # @return [Boolean]
+      def abstract?(model_class)
+        model_class.abstract_class?
+      end
+
+      # @see Wallaby::ModuleUtils.anonymous_class?
+      def anonymous?(model_class)
+        ModuleUtils.anonymous_class? model_class
+      end
+
+      # Check and see if given model class is intermediate class that generated
+      # for has and belongs to many assocation
+      # @param model_class [Class]
+      # @return [Boolean]
+      def habtm?(model_class)
+        model_class.name.index('HABTM')
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_pagination_provider.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    # Model pagination provider
+    class ModelPaginationProvider < ::Wallaby::ModelPaginationProvider
+      # Check if collection has pagination feature
+      # @return [Boolean]
+      def paginatable?
+        # `total_count` is a method that kaminari uses
+        (@collection && @collection.respond_to?(:total_count)).tap do |paginatable|
+          next if paginatable
+
+          Rails.logger.warn I18n.t('errors.activerecord.paginatable', collection: @collection.inspect)
+        end
+      end
+
+      # @return [Integer] total count for the query
+      def total
+        @collection.total_count
+      end
+
+      # @return [Integer] page size from parameters or configuration
+      def page_size
+        @params[:per].try(:to_i) || Wallaby.configuration.pagination.page_size
+      end
+
+      # @return [Integer] page number from parameters
+      def page_number
+        [@params[:page].to_i, 1].max
+      end
+    end
+  end
+end

data/lib/adapters/wallaby/active_record/model_service_provider/normalizer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      # Normalize the values for a model
+      class Normalizer
+        # @param model_decorator [Wallaby::ModelDecorator]
+        def initialize(model_decorator)
+          @model_decorator = model_decorator
+        end
+
+        # @param params [ActionController::Parameters]
+        def normalize(params)
+          params.each do |field_name, values|
+            metadata =
+              @model_decorator.metadata_of(field_name).presence || @model_decorator.form_metadata_of(field_name)
+            type = metadata[:type].try(:[], /range|point|binary/)
+            next unless type
+
+            public_send "normalize_#{type}_values", params, field_name, values
+          end
+          params
+        end
+
+        # Turn values into range
+        # @param params [ActionController::Parameters]
+        # @param field_name [String]
+        # @param values [Array]
+        def normalize_range_values(params, field_name, values)
+          normalized = Array(values).map(&:presence).compact
+          params[field_name] = (normalized.present? && values.length == 2) && (values.first...values.last) || nil
+        end
+
+        # Turn values into points
+        # @param params [ActionController::Parameters]
+        # @param field_name [String]
+        # @param values [Array]
+        def normalize_point_values(params, field_name, values)
+          normalized = Array(values).map(&:presence).compact
+          params[field_name] = normalized.present? && values.map(&:to_f) || nil
+        end
+
+        # Turn values into binary
+        # @param params [ActionController::Parameters]
+        # @param field_name [String]
+        # @param values [Object]
+        def normalize_binary_values(params, field_name, values)
+          params[field_name] = values.is_a?(::ActionDispatch::Http::UploadedFile) && values.read || nil
+        end
+      end
+    end
+  end
+end