wallaby 5.1.8 → 6.0.1

data/config/routes.rb

@@ -1,36 +0,0 @@
-Wallaby::Engine.routes.draw do
-  # NOTE: For health check if needed
-  # @see Wallaby::BaseController#healthy
-  get 'status', to: 'wallaby/application#healthy'
-
-  with_options to: Wallaby::ResourcesRouter.new do |route|
-    route.root defaults: { action: 'home' }
-
-    # To generate error pages for all supported HTTP status
-    Wallaby::ERRORS.each do |status|
-      code = Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
-      route.get status, defaults: { action: status }
-      route.get code.to_s, defaults: { action: status }
-    end
-
-    # To generate general CRUD resourceful routes
-    # @see Wallaby::ResourcesRouter
-    scope path: ':resources' do
-      # @see Wallaby::AbstractResourcesController#index
-      route.get '', defaults: { action: 'index' }, as: :resources
-      # @see Wallaby::AbstractResourcesController#new
-      route.get 'new', defaults: { action: 'new' }, as: :new_resource
-      # @see Wallaby::AbstractResourcesController#edit
-      route.get ':id/edit', defaults: { action: 'edit' }, as: :edit_resource
-      # @see Wallaby::AbstractResourcesController#show
-      route.get ':id', defaults: { action: 'show' }, as: :resource
-
-      # @see Wallaby::AbstractResourcesController#create
-      route.post '', defaults: { action: 'create' }
-      # @see Wallaby::AbstractResourcesController#update
-      route.match ':id', via: %i(patch put), defaults: { action: 'update' }
-      # @see Wallaby::AbstractResourcesController#destroy
-      route.delete ':id', defaults: { action: 'destroy' }
-    end
-  end
-end

data/lib/adaptors/wallaby/active_record.rb

@@ -1,5 +0,0 @@
-module Wallaby
-  # ActiveRecord mode
-  class ActiveRecord < Mode
-  end
-end

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

@@ -1,132 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    # Modal decorator for ActiveRecord
-    class ModelDecorator < ::Wallaby::ModelDecorator
-      # Data types to exclude for index page
-      INDEX_EXCLUSIVE_DATA_TYPES =
-        %w(binary citext hstore json jsonb text tsvector xml).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
-      # @return [Hash] metadata
-      #   example:
-      #     {
-      #       # 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
-      #       }
-      #     }
-      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 [Hash] metadata
-      def index_fields
-        @index_fields ||= Utils.clone fields
-      end
-
-      # A copy of `fields` for show page
-      # @return [Hash] metadata
-      def show_fields
-        @show_fields  ||= Utils.clone fields
-      end
-
-      # A copy of `fields` for form (new/edit) page
-      # @return [Hash] metadata
-      def form_fields
-        @form_fields  ||= Utils.clone fields
-      end
-
-      # @return [Array<String>] a list of field names for index page
-      def index_field_names
-        @index_field_names ||= begin
-          index_fields.reject do |_field_name, metadata|
-            metadata[:is_association] \
-              || INDEX_EXCLUSIVE_DATA_TYPES.include?(metadata[:type])
-          end.keys
-        end
-      end
-
-      # @return [Array<String>] a list of field names for form (new/edit) page
-      def form_field_names
-        @form_field_names ||= begin
-          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
-      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
-        @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)
-        resource.public_send title_field_finder.find
-      end
-
-      protected
-
-      # @see Wallaby::ModelDecorator::FieldsBuilder
-      def field_builder
-        @field_builder ||= FieldsBuilder.new @model_class
-      end
-
-      # @see Wallaby::ModelDecorator::TitleFieldFinder
-      def title_field_finder
-        @title_field_finder ||=
-          TitleFieldFinder.new @model_class, general_fields
-      end
-
-      delegate :general_fields, :association_fields, to: :field_builder
-
-      # Find out all the foreign keys for a list of 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/adaptors/wallaby/active_record/model_decorator/fields_builder.rb

@@ -1,57 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelDecorator
-      # @private
-      # To search and build the metadata for fields
-      class FieldsBuilder
-        # @param model_class [Class] model 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 = {
-              name: column.name,
-              type: column.type.to_s.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 = {
-              name: name, 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
-
-        # @see Wallaby::ActiveRecord::ModelDecorator::StiBuilder
-        def sti_builder
-          @sti_builder ||= StiBuilder.new(@model_class)
-        end
-
-        # @see Wallaby::ActiveRecord::ModelDecorator::AssociationBuilder
-        def association_builder
-          @association_builder ||= AssociationBuilder.new
-        end
-
-        # @see Wallaby::ActiveRecord::ModelDecorator::PolymorphicBuilder
-        def polymorphic_builder
-          @polymorphic_builder ||= PolymorphicBuilder.new
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelDecorator
-      class FieldsBuilder
-        # @private
-        # 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[: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/adaptors/wallaby/active_record/model_decorator/fields_builder/polymorphic_builder.rb

@@ -1,53 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelDecorator
-      class FieldsBuilder
-        # @private
-        # 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|
-              if polymorphic_defined? model_class, reflection.name
-                list << model_class
-              end
-            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] model 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/adaptors/wallaby/active_record/model_decorator/fields_builder/sti_builder.rb

@@ -1,49 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelDecorator
-      class FieldsBuilder
-        # @private
-        # To build the metadata for sti column
-        class StiBuilder
-          # @param model_class [Class] model 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'.freeze
-            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 ||
-              klass.respond_to?(:abstract_class?) && klass.abstract_class?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelDecorator
-      # @private
-      # Try to find the field that can be used as title
-      class TitleFieldFinder
-        TITLE_FIELD_TYPES = %w(string).freeze
-        TITLE_NAMES = %w(name title string text).freeze
-
-        # @param model_class [Class] model 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.values.find do |metadata|
-            TITLE_NAMES.any? { |v| metadata[:name].index v }
-          end
-          target_field ||= possible_title_fields.values.first
-          target_field ||= { name: @model_class.primary_key }
-          target_field[:name]
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-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) \
-            || schema?(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 [Class] model class
-      # @return [Boolean]
-      def abstract?(model_class)
-        model_class.abstract_class?
-      end
-
-      # Is model class anonymous?
-      # @param [Class] model class
-      # @return [Boolean]
-      def anonymous?(model_class)
-        Utils.anonymous_class? model_class
-      end
-
-      # Is model class the shcema migration class?
-      # @param [Class] model class
-      # @return [Boolean]
-      def schema?(model_class)
-        model_class.name == 'ActiveRecord::SchemaMigration'
-      end
-
-      # Check and see if given model class is intermediate class that generated
-      # for has and belongs to many assocation
-      # @param [Class] model class
-      # @return [Boolean]
-      def habtm?(model_class)
-        model_class.name.index('HABTM')
-      end
-    end
-  end
-end