has_helpers 5.0.2

data/lib/has_helpers/concerns/restrictions_parseable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Concerns
+    # Shared parsing logic for the restrictions_hash stored on user_organizations.
+    #
+    # The field arrives as a single-encoded JSON string: hqadmin stores it via
+    # `RestrictionsAndPermissions#restrictions` which does `.to_json`, and that
+    # string is what the data sync delivers (hqadmin's own `serialize` unwraps the
+    # extra layer before sending). So a single `JSON.parse` is enough — this mirrors
+    # how readygop consumes it (`user_resource.rb`: `JSON.parse(restrictions_hash || "{}")`).
+    # We also accept a Hash as-is in case the column is jsonb.
+    #
+    # The `.to_json` at the source is the real defect (the field should hold an
+    # object); fixing it there is tracked in a separate ticket. Until then we just
+    # parse the string once.
+    #
+    # Canonical format is a JSON object keyed by resource name:
+    #   {"Client" => {...}, "Team" => {...}}
+    # (The Array form handled by `normalize_restrictions` is a deprecated/bad-data
+    # shape — confirmed not a supported format — kept only as fail-closed defense.)
+    module RestrictionsParseable
+      private
+
+      def parse_raw_restrictions(raw, user_id: nil)
+        return {} if raw.blank?
+        return raw if raw.is_a?(Hash)
+
+        parsed = JSON.parse(raw)
+        parsed.is_a?(Hash) ? parsed : {}
+      rescue JSON::ParserError => e
+        Rails.logger.warn("[HasHelpers][Restrictions] Invalid restrictions_hash for user #{user_id}: #{e.message}")
+        {}
+      end
+
+      def normalize_restrictions(value)
+        case value
+        when Hash
+          value
+        when Array
+          value.each_with_object({}) do |item, acc|
+            next unless item.is_a?(Hash)
+            item.each { |k, v| acc[k] = v }
+          end
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/has_helpers/config.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "has_helpers/index/config"
+
+module HasHelpers
+  class Config < T::Struct
+    prop :index, ::HasHelpers::Index::Config, default: ::HasHelpers::Index::Config.new
+    prop :sync_custom_mapping, Hash, default: {}
+  end
+end

data/lib/has_helpers/constant.rb

@@ -0,0 +1,578 @@
+# typed: false
+# frozen_string_literal: true
+
+require "delegate"
+
+module HasHelpers
+  # This module can be included into any standard ActiveRecord model to make its records
+  # available as databased-backed "constants". The definition of these records is contained
+  # in the individual model classes.
+  #
+  #=== Seeding Constants
+  # Each Constant class contains its own constant definitions and the appropriate database
+  # records can be seeded by calling the `.seed!` method. This can easily be done in a migration
+  # For example:
+  #
+  #   # app/constants/my_const.rb
+  #   class MyConst < ActiveRecord::Base
+  #     include HasHelpers::Constant
+  #     define_constants "Foo", "Bar"
+  #   end
+  #
+  #   # db/migrate/20190226170740_seed_my_const.rb
+  #   ::MyConst.seed!
+  #
+  # However, care must be given to avoid referencing Constants in code which is executed
+  # during application load. Referencing a Constant for which there is no matching record
+  # in the database will cause an exception.  In a Rails application such a situation would
+  # make it impossible to run the `db:seed` Rake task.
+  #
+  #   class Foo
+  #     validates :attr, inclusion: MyConst::ALL.map(&:name)  # <- This will cause an exception unless all MyConst records have been seeded.
+  #
+  # To avoid that problem you should structure your code to only use constants _after_
+  # the applications has been loaded. See also the notes below regarding [Lazy Attributes](#lazy-attributes).
+  #
+  #==== Constant Names Without Referencing Constants
+  # It is possible to access the names of the constant records using just the configuration.
+  # A list of constant names is return by calling `.constant_names` on a Constant class.
+  # This does not rely on having database records seeded and can thus be used in cases
+  # where records may not have been seeded. While this approach is currently limited
+  # it does provide a working alternative to the broken example above.
+  #
+  #   class Foo
+  #     validates :attr, inclusion: MyConst.constant_names  # <- This will work regardless of whether the MyConst records have been seeded.
+  #
+  #=== Examples
+  #   class FujitaScale
+  #     include HasHelpers::Constant
+  #     define_constants "F1", "F2", "F3", "F4", "F5"
+  #   end
+  #
+  #   FujitaScale::F1   # => <FujitaScale name="F1">
+  #   FujitaScale::ALL  # => [<FujitaScale name="F1">, <FujitaScale name="F2">, <FujitaScale name="F3">, <FujitaScale name="F4">, <FujitaScale name="F5">]
+  #
+  #   class Alignment
+  #     include HasHelpers::Constant
+  #
+  #     # See also the section on Shared Attributes below.
+  #     define_constants(
+  #       "Top".to_constant(type: "Vertical"),
+  #       "Middle".to_constant(type: "Vertical"),
+  #       "Bottom".to_constant(type: "Vertical"),
+  #
+  #       "Left".to_constant(type: "Horizontal"),
+  #       "Center".to_constant(type: "Horizontal"),
+  #       "Right".to_constant(type: "Horizontal")
+  #     )
+  #
+  #     define_constant_group "VERTICAL" do
+  #       [TOP, MIDDLE, BOTTOM]
+  #     end
+  #
+  #     define_constant_group("HORIZONTAL") { [LEFT, CENTER, RIGHT] }  # Terser syntax
+  #   end
+  #
+  #   Alignment::HORIZONTAL  # => [<Alignment name="Left" type="Horizontal">, <Alignment name="Center" type="Horizontal">, <Alignment name="Right" type="Horizontal">]
+  #   Alignment::TOP         # => <Alignment name="Top" type="Vertical">
+  #
+  #=== Key Attribute
+  # When defining a constant a value for the `key` attribute is automatically generated
+  # from the given name. From the examples above the `Alignment` constant with the name
+  # "Top" is assigned the key `TOP`. That means that `Alignment::TOP` will be Ruby constant
+  # through which users should reference.
+  #
+  # In some cases the given name of the defined constant is not convertible to a valid
+  # key (Ruby constant name), or the resulting key is not desirable. In these cases it
+  # is possible to explicitly set the key value.
+  #
+  #   class AgeBand
+  #     include HasHelpers::Constant
+  #     define_constant "0-17".to_constant(key: "ZERO_TO_SEVENTEEN")  # Explicit key
+  #
+  #=== Shared Attributes
+  # Sometimes many constants will have attributes in common. Such common attributes may
+  # be assigned by passing them into a `define_constants` call. In this case each constant
+  # definition will be assigned the common attributes.
+  #
+  # The constants from the previous example can be rewritten as the following:
+  #
+  #   define_constants "Top", "Middle", "Bottom", type: "Vertical"
+  #   define_constants "Left", "Center", "Right", type: "Horizontal"
+  #
+  #=== Lazy Attributes
+  # If attributes need to be dynamically resolved, then wrap them in a block. This allows
+  # a constant definition to reference another constant without needing to load the other
+  # constant immediately.
+  #
+  #   class Registration
+  #     define_constants(
+  #       # Do not force the Exam::S4 constant to be loaded immediatily.
+  #       "Registered Options Principal".to_constant(abbreviation: "OP", exam: proc { ::Exam::S4 })
+  #
+  #       # The +:key+ option must _not_ be lazy! If +:name+ is given without +:key+ then +:name+ must likewise _not_ be lazy.
+  #       "Registered Options Principal".to_constant(key: "OP", abbreviation: "OP", exam: proc { ::Exam::S4} }
+  module Constant
+    extend T::Helpers
+
+    # Container class for a constant definition. Attributes are accessible via reader methods.
+    #=== Examples
+    #   definition = Definition.new(name: "Kansas", abbreviation: "KS")
+    #   definition.name          # => "Kansas"
+    #   definition.abbreviation  # => "KS"
+    #   definition.attributes    # => { name: "Kansas", abbreviation: "KS" }
+    #
+    #   # Lazy block -- this is useful for creating groups or other constants which
+    #   # we do not want to load immediately.
+    #   Definition.new(name: "Annuity") { [ADDITIONAL, INITIAL, RENEWAL, TRIAL, BONUS] }
+    #
+    class Definition
+      ERROR_MSG_MISSING_KEY = "At least one option from :name and :key is required"
+
+      attr_writer :attrs, :key
+      attr_accessor :block, :group_foreign_key, :persisted_parent, :include_parent_group_id
+
+      #=== Options
+      # +__attrs__+: Data attributes. These will be used to look up the constant.
+      def initialize(key: nil, name: nil, group_foreign_key: nil, **attrs, &block)
+        raise ArgumentError, ERROR_MSG_MISSING_KEY unless name || key
+        self.attrs = attrs
+        self.key = key
+        self.group_foreign_key = group_foreign_key
+        self.persisted_parent = !!group_foreign_key
+        attrs[:name] = name if name
+        self.block = block
+      end
+
+      # Returns a hash of attributes which define the constant. Some attributes
+      # may be "lazy", meaning they are wrapped inside a Proc. To get the attributes
+      # with their final evaluated values pass use the force_eval option, e.g.
+      # `attr(force_eval: true)`
+      def attrs(force_eval: false)
+        if force_eval
+          attrs.each do |k, v|
+            # Evaluate each lazy attribute by calling its proc and storing the result
+            if v.respond_to?(:call)
+              attrs[k] = v.call
+            end
+          end
+          attrs
+        else
+          @attrs ||= {}
+        end
+      end
+
+      def key # Note that this may hide the original key value specified in the attributes.
+        (@key || name.to_s.constant_case).to_sym # Return a symbol for easy comparison with the argument to const_missing, which is a symbol
+      end
+
+      def name
+        @attrs[:name]
+      end
+
+      def lazy?
+        @block.present?
+      end
+
+      def evaluate
+        @block.call
+      end
+
+      def persisted_parent?
+        @persisted_parent
+      end
+
+      def to_s
+        name
+      end
+
+      def to_constant
+        self
+      end
+
+      def load(klass = nil)
+        lazy? && !persisted_parent? ? evaluate : load_record(klass)
+      end
+
+      def seed!(klass)
+        find_by_attrs = attrs(force_eval: true)
+        find_by_attrs[:id] = default_id(klass) if klass.simple
+        find_by_attrs[:option_type] = default_option_type(klass) if klass.has_attribute? :option_type
+        # Leaving out the group_foreign_key attr from the query for the cases where we're seeding after modifying it.
+        # Including it would cause those queries to fail and it would try to initialize a new constant without it being necessary.
+        returned = klass.where(find_by_attrs.with_indifferent_access.except(self.group_foreign_key)).first_or_initialize.tap do |constant|
+          constant.assign_attributes(find_by_attrs.with_indifferent_access.slice(self.group_foreign_key)) if find_by_attrs.with_indifferent_access.key?(self.group_foreign_key)
+        end
+        returned.save!
+        returned
+      end
+
+      def meta
+        @meta ||= OpenStruct.new
+      end
+
+      private
+
+      def default_id(klass)
+        "#{klass.name}::::#{name}"
+      end
+
+      def default_option_type(klass)
+        "#{klass}"
+      end
+
+      def load_record(klass)
+        attributes = attrs(force_eval: true).symbolize_keys
+        record = if klass.simple
+          rec = klass.new(id: default_id(klass), **attributes)
+          rec.option_type = default_option_type(klass) if klass.has_attribute? :option_type
+          # We can assume the record is persisted here, but because it was
+          # not loaded from the database, the object returns `false` from
+          # `#persisted?`. So rails does not try to save this record again,
+          # we need to set "@new_record" to `false`.
+          rec.instance_variable_set("@new_record", false)
+          rec
+        else
+          klass.find_by(attributes)
+        end
+
+        if record
+          record.definition = self
+          record # return the record
+        else
+          raise(NameError, "the constant #{ klass.name }::#{ key } does not exist\n- Make sure the corresponding record is in the database. You may need to run `rake db:seed`")
+        end
+      end
+    end
+
+    class Proxy < BasicObject
+      instance_methods.select { |m| m !~ /__.*__/ }.each { |m| undef_method(m) }
+
+      def initialize(klass, constant_name)
+        @klass = klass
+        @constant_name = constant_name
+        @mutex = ::Mutex.new
+      end
+
+      def __getobj__
+        @mutex.synchronize do  # Make sure this does not get evaluated simultaneously across threads.
+          @__getobj__ ||= begin
+                     @klass.send(:remove_const, @constant_name) if @klass.const_defined?(@constant_name, false) # Remove the Proxy object (self) which has served as a constant place-holder.
+                     @klass.const_get(@constant_name, false)
+                   end
+        end
+      end
+
+      # Delegate all methods to the underlying object.
+      def method_missing(method_name, *args, **kwargs, &block)
+        __getobj__.send(method_name, *args, **kwargs, &block)
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    def self.included(klass)
+      klass.include(InstanceMethods) # Use include rather than prepend so to not override user-defined instance methods on the class.
+    end
+
+    module InstanceMethods
+      def to_renderable
+        name.to_s.to_text_node
+      end
+
+      def definition=(definition)
+        @definition = definition
+      end
+
+      def definition
+        @definition
+      end
+
+      def is_parent?
+        !!definition&.persisted_parent || self.class.is_parent?(self)
+      end
+
+      def meta
+        definition && definition.meta
+      end
+    end
+
+    module ClassMethods
+      # An abstract constant class is a class that constant classes inherit from
+      # but does not have any constants of its own. This prevents the `ALL` constant
+      # from being defined on an ancestor, which can cause problems for its descendants.
+      attr_accessor :abstract_constant_class
+
+      # Set `self.simple = true` if a constant is unique by type and name only.
+      # This enables a few optimizations:
+      #   1) The constant never has to be loaded from the db
+      #   2) The constant can be set just by the name
+      #     Ex: `advisor.status = "Active"` is enough information to determine which constant to use.
+      attr_writer :simple, :grouped
+
+      # grouped it is used to filter constants with group_id = nil
+      # as default scope.
+      def grouped
+        @grouped || false
+      end
+
+      def simple
+        @simple || (superclass.respond_to?(:simple) && superclass.simple)
+      end
+
+      def supports_grouping?
+        !!reflect_on_association(:group_children)
+      end
+
+      def is_parent?(klass)
+        __parent_constants__.any? { |c| c.name === klass.name }
+      end
+
+      # Method to be able to reference a constant via Active Record
+      # Handles a GET request
+      # @param constant_name [CONSTANT] the constant being requested
+      # @return [Array, ActiveRecord] the active record model looked
+      def const_missing(constant_name)
+        constant_name = constant_name.to_sym
+        if constant_name == :ALL && !self.abstract_constant_class # Special case for ::ALL
+          const_set(:ALL, __regular_constant_definitions__.map { |definition| __fetch_const_from_definition__(definition) })
+        elsif constant_name == :ALL_GROUPS && !self.abstract_constant_class # Special case for :ALL_GROUPS
+          const_set(:ALL_GROUPS, __parent_constants__.map { |definition| __fetch_const_from_definition__(definition) })
+        elsif __constants__.has_key?(constant_name)
+          const_set(constant_name, __constants__[constant_name].load(self))
+        else
+          super
+        end
+      end
+
+      # Returns constant definitions
+      def define_constants(*constant_definitions, key_prefix: nil, **attrs)
+        constant_definitions.map(&:to_constant).tap do |definitions|
+          definitions.each do |constant_definition|
+            constant_definition.attrs.merge!(attrs)
+            constant_definition.key = "#{ key_prefix.constant_case }_#{ constant_definition.key }" if key_prefix
+
+            existing_attrs = __constants__[constant_definition.key]&.attrs || {}
+            constant_definition.attrs = existing_attrs.merge!(constant_definition.attrs)
+            __constants__[constant_definition.key] = constant_definition # Register the definition in the look-up hash
+
+            # This gets a bit complicated, but in short we need a way to prevent Ruby from returning
+            # a constant which is defined in an ancestor module. E.g. if `IMO` is a top-level class
+            # then we don't want `MyConstant::IMO` to return that top-level class.
+            # To stop this undesired behavior the code below sets the constant on the current class
+            # to be a proxy. When that Proxy is evaluated it will set load the constant as expected.
+            remove_const(constant_definition.key) if const_defined?(constant_definition.key, false)
+            const_set(constant_definition.key, Proxy.new(self, constant_definition.key))
+          end
+        end
+      end
+
+      def define_constant(constant_definition, **attrs)
+        define_constants(constant_definition, **attrs).first
+      end
+
+      # Defines a single constant group
+      #
+      # Constants in the group can be either actual ruby constants, constant definitions, or strings.
+      #
+      # If they're actual ruby constants, then they should go in a block that's
+      # passed into either the to_constant method of the parent or the
+      # define_constant_group method.
+      #
+      # If they're strings or constant definitions, then they should go in the constants parameter.
+      #
+      # The group_name parameter is used to set a custom group name. This is only
+      # used when the group is persisted in the database. If the group is
+      # persisted and no group_name is given, then it defaults to #{parent.key.upcase}_GROUP
+      #
+      # The group_foreign_key parameter determines whether or not the group association is
+      # persisted into the database. If it's nil, then the group exists only in
+      # memory, otherwise both the children and the parent will have the
+      # column specified by the group_foreign_key set to the parent's id.
+      #
+      # The include_parent_group_id parameter is used to set the group_id of the parent (false by default)
+      # This behavior sometimes is needed.
+      #
+      #=== Examples
+      #
+      #   # This shows the different ways to put constants in a group
+      #   define_constants('Lapsed', 'Reversed', 'Returned', 'Replaced')
+      #   define_constant_group(
+      #     'Closed'.to_constant { [LAPSED, REVERSED] }, # Closed is the parent, LAPSED and REVERSE are in the group
+      #     group_name: "CLOSED_STATUSES", # CLOSED evaluates to the parent closed status, while CLOSED_STATUSES gives the constants in the group.
+      #     group_foreign_key: :group_id, # All constants in the group will have their group_id set to CLOSED.id
+      #     constants: ['DECLINED', 'SURRENDERED']
+      #   ) { [RETURNED, REPLACED] } # RETURNED and REPLACED are in the group
+      #
+      #   define_constant_group "POLICIES" do
+      #     [AMENDMENT_FORM, APPLICATIONS, AWAIT_FUNDING, TENTHIRTYFIVE_FORM]
+      #   end
+      def define_constant_group(parent, group_name: nil, group_foreign_key: nil, constants: nil, include_parent_group_id: true, &block)
+        child_defs = constants ? Array(constants).map(&:to_constant).each { |child| child.group_foreign_key = group_foreign_key } : nil
+        child_defs = define_constants(*child_defs.map(&:to_constant)) if child_defs&.any?
+        group_block = group_proc(child_defs, parent, block)
+        parent_definition = parent.to_constant.tap do |parent_def|
+          parent_def.group_foreign_key = group_foreign_key
+          parent_def.persisted_parent = !!group_foreign_key
+          parent_def.block = group_block if group_block
+          parent_def.include_parent_group_id = include_parent_group_id
+        end
+
+        if group_foreign_key
+          # When the parent is an actual constant in the database, we assign a separate name for the group
+          # so that parent constant still evaluates to its record.
+          group_name ||= "#{parent.to_s.constant_case}_GROUP"
+          group_definition = group_name.to_constant.tap do |group|
+            group.block = proc do
+              child_constants = group_block.call
+              [__fetch_const_from_definition__(parent_definition), *child_constants].uniq
+            end
+          end
+
+          if self.reflect_on_association(:children).nil?
+            self.has_many :group_children, class_name: self.name, foreign_key: "#{group_foreign_key}"
+            self.belongs_to :group_parent, class_name: self.name, foreign_key: "#{group_foreign_key}", optional: true
+          end
+
+          define_constant(group_definition)
+        end
+        define_constant(parent_definition)
+      end
+
+      def group_proc(const_defs, parent, block)
+        existing_parent_block = parent.to_constant.block
+        proc do
+          grouped_constants = []
+          grouped_constants << existing_parent_block.call if existing_parent_block
+          grouped_constants << __defs_to_consts__(const_defs) if const_defs
+          grouped_constants << block.call if block
+          grouped_constants.flatten!
+          grouped_constants = grouped_constants.first if grouped_constants.one? && grouped_constants.first.is_a?(::Hash)
+          grouped_constants
+        end
+      end
+
+      def constant_names
+        __regular_constant_definitions__.map(&:name)
+      end
+
+      # Load the seeds for this constant.
+      # Note, if the current constant depends on other constants, then those should be loaded first.
+      # Do so by overriding the `.seed!` method, loading the dependencies, and then calling super.
+      #
+      #   class Registration
+      #     def self.seed!
+      #       ::Exam.seed!  # Load Exams before Registrations.
+      #       super
+      #     end
+      def seed!
+        self.grouped = false
+        __regular_constant_definitions__.each { |definition| definition.seed!(self) }
+        set_parent_child_associations
+        nil # Returns this rather than the enumerator from the previous line.
+      end
+
+      def set_parent_child_associations
+        __parent_constants__.each do |parent_definition|
+          parent_instance = parent_definition.load(self)
+          parent_instance.reload if parent_definition.include_parent_group_id
+          parent_definition.attrs["#{parent_definition.group_foreign_key}"] = parent_instance.id
+          parent_instance.send("#{parent_definition.group_foreign_key}=", parent_instance.id)
+          parent_instance.save!
+          children = parent_definition.evaluate
+          children.each do |child_instance|
+            foreign_key = parent_definition.group_foreign_key
+            # Simple constants are created w/o fetching from the db.
+            # Since we're saving the constant, we need to load from the database so attributes are up-to-date
+            child_instance.reload if simple
+            child_instance.public_send("#{foreign_key}=", parent_instance.id)
+            child_instance.save!
+            child_def = child_instance.definition
+            child_def.attrs["#{foreign_key}"] = parent_instance.id
+            __constants__[child_def.key] = child_def
+          end
+        end
+      end
+
+      # Accepts a query string and returns the matching record, if any.
+      # If there is an ambiguity which causes more than one record to be
+      # match then an error will be raised. For such cases it may be
+      # necessary to override this method and provide a way to disambiguate lookups.
+      #
+      # === Examples
+      #    # Lookup by name
+      #    FujitaScale.lookup("F1")        # => <FujitaScale name="F1">
+      #    FujitaScale.lookup(name: "F1")  # => <FujitaScale name="F1">
+      #
+      #    # Lookup by an attribute other than name
+      #    FujitaScale.lookup(key: :F1)      # => <FujitaScale name="F1">
+      #    State.lookup(abbreviation: "KS")  # => <State name="Kansas" abbreviation="KS">
+      #
+      #    # Lookup by incorrect name (does not exist)
+      #    FujitaScale.lookup("F14")       # => nil
+      #
+      #    # Ambiguous lookup (multiple matches)
+      #    Alignment.lookup(type: "Horizontal")  # => Error!
+      def lookup(query = nil, name: query, id: nil, key: nil, case_sensitive: false, **attrs)
+        if name || id || key || attrs.any? # Perform lookup if any criterion is present. Otherwise nil is returned.
+          matches = Enumerator.new do |yielder|
+            already_yielded = false
+            case_converter = case_sensitive ? :itself : :downcase
+            __constants__.
+              lazy.
+              select do |constant_key, definition|
+              (!name || definition.name.send(case_converter) == name.send(case_converter)) &&
+                (!key || key.to_s == constant_key.to_s) &&
+                attrs.all? { |k, v| definition.attrs(force_eval: true)[k] == v }
+            end.
+              each do |_, definition|
+              raise "Lookup matched more than one record" if already_yielded
+
+              const = __fetch_const_from_definition__(definition)
+
+              # We can't lookup by id until after loading constants
+              if !id || (!const.is_a?(Array) && const.id.to_s == id.to_s)
+                yielder << const
+                already_yielded = true
+
+                # Break early if we find a matching record with an id.
+                # An id will be unique so we don't care about raising
+                # an error when there are more than one matched record.
+                break if id
+              end
+            end
+          end
+          matches.to_a.first
+        end
+      end
+
+      private
+
+      def __constants__
+        @__constants__ ||= {}
+      end
+
+      def __parent_constants__
+        __regular_constant_definitions__.select(&:persisted_parent)
+      end
+
+      def __regular_constant_definitions__
+        __constants__.map { |_, definition| definition }.reject do |definition|
+          definition.lazy? && !definition.persisted_parent?
+        end.sort_by do |definition|
+          definition.persisted_parent? ? 0 : 1
+        end
+      end
+
+      def __fetch_const_from_definition__(definition)
+        const_get(definition.to_constant.key)
+      end
+
+      def __defs_to_consts__(definitions)
+        definitions.map { |definition| __fetch_const_from_definition__(definition) }
+      end
+    end
+
+    mixes_in_class_methods(ClassMethods)
+  end
+end

data/lib/has_helpers/constraints.rb

@@ -0,0 +1,10 @@
+# typed: strong
+# frozen_string_literal: true
+
+module HasHelpers::Constraints
+  ARRAY_LIMIT = 100
+  JSON_LIMIT = 10_000
+  TEXT_LIMIT = 10_000
+  NOTE_LIMIT = 20_000
+  LIMIT_ERROR_MSG = "Exceeds the storage limit"
+end

data/lib/has_helpers/core_ext/array.rb

@@ -0,0 +1,28 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  module CoreExt
+    module Array
+      #=== Examples
+      #   ["Initial", "Renewal", "Trial"].to_constant
+      #   ["Initial", "Renewal", "Trial", :type => "Annuity"].to_constant
+      def to_constant
+        _to_constant(*self)
+      end
+
+      def to_renderable
+        to_enum
+      end
+
+      private
+
+      def _to_constant(*constant_names)
+        options = constant_names.extract_options!
+        constant_names.map { |name| name.to_constant(**options) }
+      end
+    end
+  end
+end
+
+::Array.include(::HasHelpers::CoreExt::Array)