habarico 7.2.0.pre.beta.5

data/lib/habarico/schema/view/wizard_box_parameters.rb

@@ -0,0 +1,13 @@
+module Habarico
+  class WizardBoxParameters
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+
+    # Show previous/next navigation buttons in the box toolbar
+    boolean_attr :show_toolbar_navigation
+
+    # Validate the current step before moving to the next one
+    boolean_attr :validate_steps
+
+  end
+end

data/lib/habarico/search/field_resolver.rb

@@ -0,0 +1,138 @@
+module Habarico
+  module Search
+
+    # A resolved leaf field of a `search_fields` path.
+    #
+    # `model` is the class owning the leaf, `name` the leaf attribute name, `path` the original
+    # (possibly relation-traversing) path, `type` the search classification and `column` the
+    # ActiveRecord column backing the leaf (nil for pure attributes-model attributes).
+    LeafField = Struct.new(:model, :name, :path, :type, :column, keyword_init: true) do
+
+      def label
+        return name.to_s unless model.respond_to?(:human_attribute_name)
+
+        model.human_attribute_name(name)
+      end
+
+      def choices?
+        type == :choices
+      end
+
+      def boolean?
+        type == :boolean
+      end
+
+      def numeric?
+        type == :numeric
+      end
+
+      def text?
+        type == :text
+      end
+
+    end
+
+    # Resolves a `search_fields` path (e.g. `author__name`) against a model and classifies the
+    # leaf field's type. Ruby port of the Python `walk_to_leaf_field` helper, extended with the
+    # type detection used by the search matcher and highlighter - it is the single source of truth
+    # both build on.
+    #
+    # Intermediate hops must be relations (ActiveRecord associations or Habarico references); the
+    # leaf must be an ActiveRecord column or an enum attribute. Unresolvable paths yield `nil`
+    # (mirrors the Python behaviour, so a stale entry never crashes the request); use `resolve!`
+    # to raise instead - handy for catching typos in tests.
+    module FieldResolver
+
+      RELATION_SEPARATOR = '__'.freeze
+      NUMERIC_COLUMN_TYPES = %i[integer float decimal].freeze
+
+      # Returns a LeafField for `path` on `model`, or nil when it cannot be resolved.
+      def self.resolve(model, path)
+        return nil if model.nil? || path.nil?
+
+        # Negative limit keeps trailing empty segments so `title__` is rejected too.
+        parts = path.to_s.split(RELATION_SEPARATOR, -1)
+        return nil if parts.empty? || parts.any?(&:empty?)
+
+        current = model
+        parts[0..-2].each do |part|
+          current = step_into_relation(current, part)
+          return nil if current.nil?
+        end
+
+        build_leaf(current, parts.last, path.to_s)
+      end
+
+      # Like `resolve`, but raises ArgumentError when the path cannot be resolved.
+      def self.resolve!(model, path)
+        resolve(model, path) || raise(ArgumentError, "Cannot resolve search field path #{path.inspect} on #{model.inspect}")
+      end
+
+      # Follows one relation hop, returning the associated model class or nil when `part` is not a
+      # traversable relation. Prefers ActiveRecord associations, falls back to Habarico references.
+      def self.step_into_relation(model, part)
+        if model.respond_to?(:reflect_on_association)
+          reflection = model.reflect_on_association(part.to_sym)
+          return reflection_klass(reflection) if reflection
+        end
+
+        if model.respond_to?(:has_reference?) && model.has_reference?(part) && model.respond_to?(:find_reference)
+          return reference_klass(model.find_reference(part))
+        end
+
+        nil
+      end
+
+      # The target class of an ActiveRecord reflection, or nil for polymorphic associations that
+      # have no single class.
+      def self.reflection_klass(reflection)
+        reflection.klass
+      rescue StandardError
+        nil
+      end
+
+      # The target class of a Habarico reference descriptor (`class_name` may be a Class or String).
+      def self.reference_klass(reference)
+        return nil if reference.nil?
+
+        class_name = reference[:class_name]
+        class_name.is_a?(::String) ? class_name.constantize : class_name
+      rescue NameError
+        nil
+      end
+
+      def self.build_leaf(model, name, path)
+        type = detect_type(model, name)
+        return nil if type.nil?
+
+        LeafField.new(model: model, name: name, path: path, type: type, column: column_for(model, name))
+      end
+
+      # Classifies the leaf field. Enum attributes are choices (regardless of their underlying
+      # column type); otherwise the ActiveRecord column type decides. An unknown leaf yields nil.
+      def self.detect_type(model, name)
+        return :choices if enum?(model, name)
+
+        column = column_for(model, name)
+        return nil if column.nil?
+
+        case column.type
+        when :boolean then :boolean
+        when *NUMERIC_COLUMN_TYPES then :numeric
+        else :text
+        end
+      end
+
+      def self.enum?(model, name)
+        model.respond_to?(:has_enum_attr?) && model.has_enum_attr?(name)
+      end
+
+      def self.column_for(model, name)
+        return nil unless model.respond_to?(:columns_hash)
+
+        model.columns_hash[name.to_s]
+      end
+
+    end
+  end
+end

data/lib/habarico/search/search_matcher.rb

@@ -0,0 +1,152 @@
+module Habarico
+  module Search
+
+    # Applies a typed fulltext search over a resource's `search_fields`. Ruby port of the Python
+    # `SearchFilter` (MR !198): Habarico owns the whole search query rather than delegating to
+    # the base library's `filter_2!({search:})`, whose `apply_search` matches a separate FiltersModel field
+    # list, cannot traverse relations and always unaccents. Owning it here makes
+    # `Definition#search_fields` the single source of truth shared with SearchHighlighter and lets
+    # `Config.search_unaccent_enabled` govern matching and highlighting consistently.
+    #
+    # Semantics mirror the Python matcher: AND across query words, OR across fields. Per field the
+    # leaf type (from FieldResolver) decides the match:
+    #
+    # - text    -> `lower([unaccent](col)) LIKE %word%`
+    # - choices -> the word is matched against the human-readable enum labels; the resulting raw
+    #              values feed an `IN (...)` lookup (no match -> the field contributes nothing)
+    # - boolean -> matched against the translated Yes/No labels -> `IN (true/false)`
+    # - numeric -> `lower(CAST(col AS text)) LIKE %word%`
+    #
+    # Relations (`author__name`) are reached with `left_outer_joins`; matches are collected as
+    # primary keys and folded back with `where(pk IN ...)` so joins never duplicate rows or skew
+    # kaminari's `total_count`.
+    class SearchMatcher
+
+      # Unicode combining marks, dropped when matching diacritics-insensitively. Lives here, in the
+      # free core, because the free matcher needs it; a pro/enterprise highlighter reuses it from
+      # here rather than the other way round (HAB-812).
+      COMBINING_MARK = /\p{Mn}/
+
+      def initialize(model:, search_fields:, unaccent: nil)
+        @model = model
+        @search_fields = search_fields.to_a
+        @unaccent = unaccent.nil? ? Habarico::Config.search_unaccent_enabled : unaccent
+      end
+
+      # Narrows `scope` to records matching every query word in at least one `search_fields` path.
+      # Returns `scope` unchanged when the query is blank or no search fields are declared.
+      def apply(scope, query)
+        return scope if query.nil?
+
+        words = query.to_s.split(/\s+/).reject(&:empty?)
+        return scope if words.empty? || @search_fields.empty?
+
+        matched = nil
+        words.each do |word|
+          word_ids = ids_for_word(scope, word)
+          matched = matched.nil? ? word_ids : (matched & word_ids)
+          break if matched.empty?
+        end
+
+        scope.where(primary_key => matched || [])
+      end
+
+      private
+
+      def primary_key
+        @model.primary_key
+      end
+
+      # Primary keys of records where any field matches `word` (OR across fields).
+      def ids_for_word(scope, word)
+        @search_fields.each_with_object([]) do |path, acc|
+          leaf = FieldResolver.resolve(@model, path)
+          next if leaf.nil?
+
+          relation = field_relation(scope, path, leaf, word)
+          acc.concat(relation.pluck(primary_key)) unless relation.nil?
+        end.uniq
+      end
+
+      # A relation selecting records where `leaf` matches `word`, or nil when the field cannot
+      # match this word at all (e.g. a choices/boolean word matching no label).
+      def field_relation(scope, path, leaf, word)
+        joined = join_for(scope, path)
+        column = qualified_column(leaf)
+
+        if leaf.choices?
+          values = matching_choice_values(leaf, word)
+          values.empty? ? nil : joined.where("#{column} IN (?)", values)
+        elsif leaf.boolean?
+          values = matching_boolean_values(word)
+          values.empty? ? nil : joined.where("#{column} IN (?)", values)
+        elsif leaf.numeric?
+          joined.where("lower(CAST(#{column} AS text)) LIKE ?", like_pattern(word, unaccent: false))
+        else
+          joined.where("lower(#{text_expr(column)}) LIKE ?", like_pattern(word, unaccent: @unaccent))
+        end
+      end
+
+      # Left-joins the relation hops of `path` so a leaf on a related table can be referenced.
+      def join_for(scope, path)
+        hops = path.to_s.split(FieldResolver::RELATION_SEPARATOR)[0..-2].map(&:to_sym)
+        return scope if hops.empty?
+
+        association = hops.reverse.reduce { |nested, hop| { hop => nested } }
+        scope.left_outer_joins(association)
+      end
+
+      # `table.column` for the leaf, using the leaf's owning table (the joined table for relations).
+      def qualified_column(leaf)
+        "#{leaf.model.table_name}.#{leaf.name}"
+      end
+
+      # Wraps the column in `unaccent(...)` when diacritics-insensitive matching is on.
+      def text_expr(column)
+        @unaccent ? "unaccent(#{column})" : column
+      end
+
+      # A `%word%` LIKE pattern, lowercased and (optionally) accent-stripped to match `text_expr`.
+      def like_pattern(word, unaccent:)
+        normalized = normalize(word, unaccent: unaccent)
+        "%#{normalized}%"
+      end
+
+      # Raw enum values whose human-readable label contains `word`.
+      def matching_choice_values(leaf, word)
+        choices = leaf.model.find_enum_attr(leaf.name)
+        return [] if choices.nil?
+
+        needle = normalize(word, unaccent: @unaccent)
+        choices.values
+               .select { |choice| normalize(choice[:label], unaccent: @unaccent).include?(needle) }
+               .map { |choice| choice[:value] }
+      end
+
+      # Boolean raw values whose translated Yes/No label contains `word`.
+      def matching_boolean_values(word)
+        needle = normalize(word, unaccent: @unaccent)
+        values = []
+        values << true if normalize(yes_label, unaccent: @unaccent).include?(needle)
+        values << false if normalize(no_label, unaccent: @unaccent).include?(needle)
+        values
+      end
+
+      def normalize(value, unaccent:)
+        value = value.to_s.downcase
+        return value unless unaccent
+
+        value.unicode_normalize(:nfkd).each_char.grep_v(COMBINING_MARK).join
+      end
+
+      def yes_label
+        defined?(I18n) ? I18n.t('search.yes', default: 'Yes') : 'Yes'
+      end
+
+      def no_label
+        defined?(I18n) ? I18n.t('search.no', default: 'No') : 'No'
+      end
+
+    end
+  end
+end

data/lib/habarico/serializers/meta_serializer.rb

@@ -0,0 +1,42 @@
+module Habarico
+  module Serializers
+    class MetaSerializer
+      include Eluvia::Serializers::FieldsetSerializer
+
+      class SchemaSerializer
+        include Eluvia::Serializers::FieldsetSerializer
+
+        READABLE_FIELDS = %w[name label pk_field_name actions].freeze
+
+        def readable_fields
+          READABLE_FIELDS
+        end
+
+        def read_attribute(record, field_name)
+          record[field_name]
+        end
+      end
+
+      READABLE_FIELDS = %w[repr schema tags trigger_action].freeze
+
+      def initialize(schema_serializer: SchemaSerializer.new)
+        @schema_serializer = schema_serializer
+      end
+
+      def readable_fields
+        READABLE_FIELDS
+      end
+
+      def serialize(data, fields: nil)
+        read_fieldset(fields).to_h { |rest_field| [rest_field.name, read_attribute(data, rest_field.name, rest_field.fieldset)] }
+      end
+
+      def read_attribute(data, field_name, sub_fieldset = nil)
+        return data[field_name] unless field_name == 'schema'
+
+        @schema_serializer.serialize(data['schema'], fields: sub_fieldset&.to_s)
+      end
+
+    end
+  end
+end

data/lib/habarico/serializers/record_serializer.rb

@@ -0,0 +1,33 @@
+module Habarico
+  module Serializers
+    class RecordSerializer
+      include Eluvia::Serializers::FieldsetSerializer
+
+      META_FIELD = 'meta'.freeze
+
+      def initialize(serializer:, meta_serializer:)
+        @serializer = serializer
+        @meta_serializer = meta_serializer
+      end
+
+      def readable_fields
+        @serializer.readable_fields + [META_FIELD]
+      end
+
+      def serialize(record, meta, fields: nil)
+        read_fieldset(fields).each_with_object({}) do |rest_field, result|
+          next if rest_field.name != META_FIELD && !record.respond_to?(rest_field.name)
+
+          result[rest_field.name] = read_attribute(record, rest_field.name, rest_field.fieldset, meta)
+        end
+      end
+
+      def read_attribute(record, field_name, sub_fieldset, meta)
+        return @meta_serializer.serialize(meta, fields: sub_fieldset&.to_s) if field_name == META_FIELD
+
+        @serializer.read_attribute(record, field_name)
+      end
+
+    end
+  end
+end

data/lib/habarico/serializers/serializer.rb

@@ -0,0 +1,61 @@
+module Habarico
+  module Serializers
+    class Serializer
+      include Eluvia::Serializers::FieldsetSerializer
+
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def serialize(record, fields: nil)
+        read_fieldset(fields).each_with_object({}) do |rest_field, result|
+          next unless record.respond_to?(rest_field.name)
+
+          result[rest_field.name] = read_attribute(record, rest_field.name)
+        end
+      end
+
+      def readable_fields
+        field_names
+      end
+
+      def read_attribute(record, field_name)
+        model = @definition.model
+
+        # Handle "belongs to" and "has one" associations
+        if Habarico::ReflectionHelper.is_active_record_class?(model)
+          reflection = model.reflect_on_association(field_name)
+          return record.send(reflection.foreign_key) if reflection && %i[belongs_to has_one].include?(reflection.macro)
+        end
+
+        # Handle enum attribute
+        if model.respond_to?(:has_enum_attr?) && model.has_enum_attr?(field_name)
+          enum_obj = record.send("#{field_name}_obj")
+          return enum_obj ? enum_obj[:value] : nil
+        end
+
+        # Fallback to a standard model attribute
+        record.send(field_name)
+      end
+
+      private
+
+      def field_names
+        (@definition.fields + @definition.read_only_fields).uniq.map { |field| field_name_for(field) }
+      end
+
+      def field_name_for(field)
+        if field.is_a?(Habarico::FieldReference)
+          field.name.to_s
+        elsif field.is_a?(::String) || field.is_a?(::Symbol)
+          field.to_s
+        elsif field.is_a?(::Hash)
+          field.keys.first.to_s
+        else
+          raise Eluvia::Errors::StandardError.new("Unsupported field type: #{field.class.name}")
+        end
+      end
+
+    end
+  end
+end

data/lib/habarico/services/resource_service.rb

@@ -0,0 +1,69 @@
+module Habarico
+  class ResourceService
+    include Singleton
+
+    def get_controller_class(resource_path)
+      return nil if resource_path.blank?
+      controller_class_name = ''
+      controller_class_name += "#{Habarico::Config.routing_scope.camelize}::" if Habarico::Config.routing_scope.present?
+      controller_class_name += resource_path.map { |part| part.to_s.camelize }.join('::') + 'Controller' # rubocop:disable Style/StringConcatenation -- would be less readable
+      controller_class_name.constantize
+    rescue NameError
+      raise Eluvia::Errors::NotFound.new("Controller class #{controller_class_name} not found for resource #{resource_path.join('.')}")
+    end
+
+    def get_definition(resource_path)
+      return nil if resource_path.blank?
+      get_controller_class(resource_path)&.definition
+    end
+
+    def get_resource_path(resource_name)
+      return nil if resource_name.blank?
+      flatten_specs(Habarico::Config.resources).find { |resource_path| resource_path.last == resource_name.to_sym }
+    end
+
+    def get_resources_paths
+      flatten_specs(Habarico::Config.resources)
+    end
+
+    def find_resource_name_by_model_class_or_instance(model_class_or_instance)
+      return nil if model_class_or_instance.blank?
+      if Habarico::ReflectionHelper.is_active_record_class?(model_class_or_instance)
+        return find_resource_name_by_model_class(model_class_or_instance)
+      end
+      if Habarico::ReflectionHelper.is_active_record_instance?(model_class_or_instance)
+        return find_resource_name_by_model_class(model_class_or_instance.class)
+      end
+      nil
+    end
+
+    def find_resource_name_by_model_class(model_class)
+      return nil if model_class.blank?
+      get_resources_paths.each do |resource_path|
+        controller_class = get_controller_class(resource_path)
+        if controller_class && controller_class.definition.model == model_class # match model class
+          return resource_path.last # return resource name
+        end
+      end
+      nil
+    end
+
+    private
+
+    def flatten_specs(specs, namespaces = [])
+      result = []
+      specs.each do |resource_or_namespace|
+        if resource_or_namespace.is_a?(Hash)
+          resource_or_namespace.each do |namespace_name, specs_2|
+            result += flatten_specs(specs_2, namespaces + [namespace_name])
+          end
+        else
+          resource_name = resource_or_namespace
+          result << (namespaces + [resource_name])
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/habarico/services/routing_service.rb

@@ -0,0 +1,160 @@
+module Habarico
+  class RoutingService
+    include Singleton
+
+    # Opt-in contrib modules register extra route blocks. They are drawn at the admin-site
+    # root - beside schema/search - which for a grouped resource config (e.g.
+    # `{ admin: [...] }`) means under the top-level group's path, and for a flat resource
+    # list means directly under `routing_url_prefix`. This mirrors the Python AdminSite,
+    # where user-preferences sits next to schema/search. See draw_extension_routes.
+    @extension_route_blocks = []
+
+    # Route blocks drawn *inside* every resource's own `resources ... do` block, where a feature
+    # can add member/collection routes to each resource (the aggregate endpoint does). Registered
+    # by a pro/enterprise gem; empty in a free-only install - see draw_resource_extension_routes.
+    @resource_extension_route_blocks = []
+
+    class << self
+      attr_reader :extension_route_blocks, :resource_extension_route_blocks
+
+      def register_route_block(&block)
+        extension_route_blocks << block
+      end
+
+      # Registers a block drawn inside each resource's route block. The block is instance_exec'd
+      # in the Rails mapper, so it may use `collection` / `member` exactly as core's own route
+      # helpers do, and receives the resource name.
+      def register_resource_route_block(&block)
+        resource_extension_route_blocks << block
+      end
+
+      # Draws the registered per-resource blocks. Called once per resource, before core's own
+      # routes: a collection route added here must not be shadowed by the member `GET /:id/schema`
+      # route, which has no `:id` constraint and would otherwise match it first.
+      def draw_resource_extension_routes(mapper, resource_name)
+        resource_extension_route_blocks.each do |block|
+          mapper.instance_exec(resource_name, &block)
+        end
+      end
+
+      # Draws the registered extension blocks in the given routing mapper, at the admin-site
+      # root so they sit beside schema/search - matching the Python AdminSite. When the
+      # resources are wrapped in a top-level group the site root is that group's path, so
+      # re-open it here; for a flat resource list it is the url prefix itself. This is a
+      # path-only `scope` (not a `namespace`) on purpose: the contrib controllers live in the
+      # gem, not under the host's module, so no module prefix may be applied to them.
+      def draw_extension_routes(mapper)
+        top_group = Habarico::Config.resources.find { |spec| spec.is_a?(Hash) }&.keys&.first
+        return draw_extension_route_blocks(mapper) unless top_group
+
+        mapper.scope(top_group) { draw_extension_route_blocks(mapper) }
+      end
+
+      private
+
+      # The blocks are written against the routing mapper DSL, so they must be evaluated in
+      # the mapper's context (`scope` above only changes the mapper state, not `self`).
+      def draw_extension_route_blocks(mapper)
+        extension_route_blocks.each { |route_block| mapper.instance_exec(&route_block) }
+      end
+    end
+
+    def draw_routes
+      Rails.application.routes.draw do
+        def _draw_routes(specs)
+          specs.each do |resource_or_namespace|
+            if resource_or_namespace.is_a?(Hash)
+              resource_or_namespace.each do |namespace_name, specs_2|
+                namespace namespace_name do
+                  _draw_routes(specs_2)
+                end
+              end
+            else
+              get 'schema', to: '/habarico/global_schema#index'
+              _draw_resource_routes(resource_or_namespace)
+            end
+          end
+        end
+
+        def _draw_resource_routes(resource_name)
+          resources resource_name, only: %i[index show create update destroy] do
+            # Must be drawn before `_draw_schema_routes`: its member route `GET /:id/schema` has no `:id`
+            # constraint, so it would otherwise greedily match a contributed collection route too (with
+            # `:id` == "aggregate", say) and shadow it, since Rails resolves ambiguous matches by
+            # registration order.
+            Habarico::RoutingService.draw_resource_extension_routes(self, resource_name)
+            _draw_actions_routes(resource_name)
+            _draw_schema_routes
+          end
+        end
+
+        def _draw_actions_routes(resource_name)
+          resource_path = Habarico::ResourceService.instance.get_resource_path(resource_name)
+          controller_class = Habarico::ResourceService.instance.get_controller_class(resource_path)
+          registered_actions = controller_class.registered_actions
+
+          # Member actions
+          member_actions = registered_actions.select { |action| action[:is_detail] }
+          unless member_actions.empty?
+            member do
+              member_actions.each do |action|
+                _draw_action_routes(action, is_member: true)
+              end
+            end
+          end
+
+          # Collection actions
+          collection_actions = registered_actions.reject { |action| action[:is_detail] }
+          unless collection_actions.empty?
+            collection do
+              collection_actions.each do |action|
+                _draw_action_routes(action, is_member: false)
+              end
+            end
+          end
+        end
+
+        def _draw_action_routes(action, is_member: true)
+          if action[:method] == :get
+            get action[:name]
+          elsif action[:method] == :post
+            post action[:name]
+          elsif action[:method] == :put
+            put action[:name]
+          elsif action[:method] == :patch
+            patch action[:name]
+          elsif action[:method] == :delete
+            delete action[:name]
+          else
+            raise Eluvia::Errors::StandardError.new("Unsupported HTTP method #{action[:method]} for action #{action[:name]}")
+          end
+          get "#{action[:name]}/schema", to: "/habarico/action_schema##{is_member ? 'show' : 'index'}"
+        end
+
+        def _draw_schema_routes
+          collection do
+            get :schema, to: '/habarico/local_schema#index'
+          end
+          member do
+            get :schema, to: '/habarico/local_schema#show'
+          end
+        end
+
+        scope Habarico::Config.routing_url_prefix do
+          if Habarico::Config.routing_scope
+            scope module: Habarico::Config.routing_scope do
+              _draw_routes(Habarico::Config.resources)
+            end
+          else
+            _draw_routes(Habarico::Config.resources)
+          end
+
+          # Opt-in contrib extension routes (e.g. user-preferences) - see
+          # RoutingService.draw_extension_routes for the placement rules.
+          Habarico::RoutingService.draw_extension_routes(self)
+        end
+      end
+    end
+
+  end
+end