castkit 0.3.0 → 0.4.0

data/lib/castkit/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "types"
+require "cattri"
 
 module Castkit
   # Configuration container for global Castkit settings.
@@ -8,6 +9,8 @@ module Castkit
   # This includes type registration, validation, and enforcement flags
   # used throughout Castkit's attribute system.
   class Configuration
+    include Cattri
+
     # Default mapping of primitive type definitions.
     #
     # @return [Hash{Symbol => Castkit::Types::Base}]
@@ -36,56 +39,30 @@ module Castkit
       uuid: :string
     }.freeze
 
-    # @return [Hash{Symbol => Castkit::Types::Base}] registered types
-    attr_reader :types
-
-    # Set default plugins that will be used globally in all Castkit::DataObject subclasses.
-    # This is equivalent to calling `enable_plugins` in every class.
-    #
-    # @return [Array<Symbol>] default plugin names to be applied to all DataObject subclasses
-    attr_accessor :default_plugins
-
-    # Whether to raise an error if values should be validated before deserializing, e.g. true -> "true"
-    # @return [Boolean]
-    attr_accessor :enforce_typing
-
-    # Whether to raise an error if access mode is not recognized.
-    # @return [Boolean]
-    attr_accessor :enforce_attribute_access
-
-    # Whether to raise an error if a prefix is defined without `unwrapped: true`.
-    # @return [Boolean]
-    attr_accessor :enforce_unwrapped_prefix
-
-    # Whether to raise an error if an array attribute is missing the `of:` type.
-    # @return [Boolean]
-    attr_accessor :enforce_array_options
-
-    # Whether to raise an error for unknown and invalid type definitions.
-    # @return [Boolean]
-    attr_accessor :raise_type_errors
-
-    # Whether to emit warnings when Castkit detects misconfigurations.
-    # @return [Boolean]
-    attr_accessor :enable_warnings
-
-    # Whether the strict flag is enabled by default for all DataObjects and Contracts.
-    # @return [Boolean]
-    attr_accessor :strict_by_default
+    cattri :types, -> { DEFAULT_TYPES.dup }, expose: :read_write
+    cattri :default_plugins, [], expose: :read_write
+    cattri :enforce_typing, true, expose: :read_write
+    cattri :enforce_attribute_access, true, expose: :read_write
+    cattri :enforce_unwrapped_prefix, true, expose: :read_write
+    cattri :enforce_array_options, true, expose: :read_write
+    cattri :raise_type_errors, true, expose: :read_write
+    cattri :enable_warnings, true, expose: :read_write
+    cattri :strict_by_default, true, expose: :read_write
 
     # Initializes the configuration with default types and enforcement flags.
     #
     # @return [void]
     def initialize
-      @types = DEFAULT_TYPES.dup
-      @enforce_typing = true
-      @enforce_attribute_access = true
-      @enforce_unwrapped_prefix = true
-      @enforce_array_options = true
-      @raise_type_errors = true
-      @enable_warnings = true
-      @strict_by_default = true
-      @default_plugins = []
+      super
+      self.types = DEFAULT_TYPES.dup
+      self.enforce_typing = true
+      self.enforce_attribute_access = true
+      self.enforce_unwrapped_prefix = true
+      self.enforce_array_options = true
+      self.raise_type_errors = true
+      self.enable_warnings = true
+      self.strict_by_default = true
+      self.default_plugins = []
 
       apply_type_aliases!
     end
@@ -136,7 +113,7 @@ module Castkit
     # @return [Castkit::Types::Base]
     # @raise [Castkit::TypeError] if the type is not registered
     def fetch_type(type)
-      @types.fetch(type.to_sym) do
+      types.fetch(type.to_sym) do
         raise Castkit::TypeError, "Unknown type `#{type.inspect}`" if raise_type_errors
       end
     end
@@ -146,14 +123,14 @@ module Castkit
     # @param type [Symbol]
     # @return [Boolean]
     def type_registered?(type)
-      @types.key?(type.to_sym)
+      types.key?(type.to_sym)
     end
 
     # Restores the type registry to its default state.
     #
     # @return [void]
     def reset_types!
-      @types = DEFAULT_TYPES.dup
+      self.types = DEFAULT_TYPES.dup
       apply_type_aliases!
     end
 

data/lib/castkit/contract/base.rb

@@ -2,7 +2,6 @@
 
 require_relative "../core/config"
 require_relative "../core/attribute_types"
-require_relative "../core/registerable"
 require_relative "result"
 
 module Castkit
@@ -33,22 +32,13 @@ module Castkit
     class Base
       extend Castkit::Core::Config
       extend Castkit::Core::AttributeTypes
-      extend Castkit::Core::Registerable
 
       ATTRIBUTE_OPTIONS = %i[
         required aliases min max format of validator unwrapped prefix force_type
       ].freeze
 
       class << self
-        # Registers the current class under `Castkit::Contracts`.
-        #
-        # @param as [String, Symbol, nil] The constant name to use (PascalCase). Defaults to the name used when building
-        #   the contract. If no name was provided, an error is raised.
-        # @return [Class] the registered contract class
-        # @raise [Castkit::Error] If a name cannot be resolved.
-        def register!(as: nil)
-          super(namespace: :contracts, as: as || definition[:name])
-        end
+        include Cattri
 
         # Defines an attribute for the contract.
         #
@@ -83,15 +73,9 @@ module Castkit
           Castkit::Contract::Result.new(definition[:name].to_s, input)
         end
 
-        # Returns internal contract metadata.
-        #
-        # @return [Hash]
-        def definition
-          @definition ||= {
-            name: :ephemeral,
-            attributes: {}
-          }
-        end
+        cattri :definition,
+               -> { { name: :ephemeral, attributes: {} } },
+               scope: :class, expose: :read_write
 
         # Returns the defined attributes.
         #
@@ -129,8 +113,8 @@ module Castkit
         def define_from_source(name, source)
           source_attributes = source.attributes.dup
 
-          @definition = {
-            name: name,
+          self.definition = {
+            name: name.to_sym,
             attributes: source_attributes.transform_values do |attr|
               Castkit::Attribute.new(attr.field, attr.type, **attr.options.slice(*ATTRIBUTE_OPTIONS))
             end
@@ -143,7 +127,8 @@ module Castkit
         # @yield [block]
         # @return [void]
         def define_from_block(name, &block)
-          definition[:name] = name
+          contract_name = name ? name.to_sym : :ephemeral
+          self.definition = { name: contract_name, attributes: {} }
 
           @__castkit_contract_dsl = true
           instance_eval(&block)

data/lib/castkit/contract/result.rb

@@ -7,14 +7,16 @@ module Castkit
     # Provides access to the validation outcome, including whether it succeeded or failed,
     # and includes the full list of errors if any.
     class Result
+      include Cattri
+
       # @return [Symbol] the name of the contract
-      attr_reader :contract
+      cattri :contract, nil, expose: :read
 
       # @return [Hash{Symbol => Object}] the validated input
-      attr_reader :input
+      cattri :input, nil, expose: :read
 
       # @return [Hash{Symbol => Object}] the validation error hash
-      attr_reader :errors
+      cattri :errors, {}, expose: :read
 
       # Initializes a new result object.
       #
@@ -22,9 +24,11 @@ module Castkit
       # @param input [Hash{Symbol => Object}] the validated input
       # @param errors [Hash{Symbol => Object}] the validation errors
       def initialize(contract, input, errors: {})
-        @contract = contract.to_sym.freeze
-        @input = input.freeze
-        @errors = errors.freeze
+        super()
+
+        cattri_variable_set(:contract, contract.to_sym.freeze)
+        cattri_variable_set(:input, input.freeze)
+        cattri_variable_set(:errors, errors.freeze)
       end
 
       # A debug-friendly representation of the validation result.

data/lib/castkit/contract/validator.rb

@@ -188,7 +188,11 @@ module Castkit
       # @return [Object, nil]
       def resolve_input_value(input, attribute)
         attribute.key_path(with_aliases: true).each do |path|
-          value = path.reduce(input) { |memo, key| memo.is_a?(Hash) ? memo[key] : nil }
+          value = path.reduce(input) do |memo, key|
+            next memo unless memo.is_a?(Hash)
+
+            memo.key?(key) ? memo[key] : memo[key.to_s]
+          end
           return value unless value.nil?
         end
 

data/lib/castkit/core/attribute_types.rb

@@ -86,7 +86,9 @@ module Castkit
       #
       # @param field [Symbol]
       # @param options [Hash]
-      def hash(field, **options)
+      def hash(field = nil, **options)
+        return super() if field.nil?
+
         attribute(field, :hash, **options)
       end
 

data/lib/castkit/core/attributes.rb

@@ -1,48 +1,60 @@
 # frozen_string_literal: true
 
+require "cattri"
+
 module Castkit
   module Core
     # Provides DSL and implementation for declaring attributes within a Castkit::DataObject.
     #
-    # Includes support for regular, composite, transient, readonly/writeonly, and grouped attribute definitions.
-    module Attributes
-      # Declares an attribute with the given type and options.
+    # Supports reusable attribute definitions, transient fields, composite readers, and
+    # grouped declarations such as `readonly`, `optional`, and `transient` blocks.
+    #
+    # This module is included into `Castkit::DataObject` and handles attribute registration,
+    # accessor generation, and typed writing behavior.
+    module Attributes # rubocop:disable Metrics/ModuleLength
+      def self.extended(base)
+        base.include(Cattri)
+      end
+
+      # Declares an attribute on the data object.
       #
+      # Accepts either inline options or a reusable attribute definition (`using` or `definition`).
       # If `:transient` is true, defines only standard accessors and skips serialization logic.
       #
-      # @param field [Symbol]
-      # @param type [Symbol, Class]
-      # @param options [Hash]
+      # @param field [Symbol] the attribute name
+      # @param type [Symbol, Class] the attribute's declared type
+      # @param definition [Hash, nil] an optional pre-built definition object (`{ type:, options: }`)
+      # @param using [Castkit::Attributes::Base, nil] an optional class-based definition (`.definition`)
+      # @param options [Hash] additional options like `default`, `access`, `required`, etc.
       # @return [void]
-      # @raise [Castkit::DataObjectError] if the attribute is already defined
-      def attribute(field, type, **options)
+      # @raise [Castkit::DataObjectError] if attribute already defined or type mismatch
+      def attribute(field, type = nil, definition = nil, using: nil, **options)
         field = field.to_sym
         raise Castkit::DataObjectError, "Attribute '#{field}' already defined" if attributes.key?(field)
 
-        options = build_options(options)
+        type, options = use_definition(field, definition || using&.definition, type, options)
         return define_attribute(field, type, **options) unless options[:transient]
 
-        attr_accessor field
+        define_transient_accessor(field)
       end
 
-      # Declares a computed (composite) attribute.
-      #
-      # The provided block defines the read behavior.
+      # Declares a composite (computed) attribute.
       #
-      # @param field [Symbol]
-      # @param type [Symbol, Class]
-      # @param options [Hash]
-      # @yieldreturn [Object] evaluated composite value
+      # @param field [Symbol] the name of the attribute
+      # @param type [Symbol, Class] the attribute type
+      # @param options [Hash] additional attribute options
+      # @yieldreturn [Object] the value to return when the reader is called
+      # @return [void]
       def composite(field, type, **options, &block)
         attribute(field, type, **options, composite: true)
         define_method(field, &block)
       end
 
-      # Declares a group of transient attributes within the given block.
+      # Declares a group of transient attributes within a block.
       #
-      # These attributes are not serialized or included in `to_h`.
+      # These attributes are excluded from serialization (`to_h`) and not stored.
       #
-      # @yield defines one or more transient attributes via `attribute`
+      # @yield a block containing `attribute` calls
       # @return [void]
       def transient(&block)
         @__transient_context = true
@@ -51,126 +63,161 @@ module Castkit
         @__transient_context = nil
       end
 
-      # Declares a group of readonly attributes within the given block.
+      # Declares a group of readonly attributes (accessible for read only).
       #
-      # @param options [Hash] shared options for attributes inside the block
-      # @yield defines attributes with `access: [:read]`
+      # @param options [Hash] shared options for all attributes inside the block
+      # @yield a block containing `attribute` calls
       # @return [void]
       def readonly(**options, &block)
         with_access([:read], options, &block)
       end
 
-      # Declares a group of writeonly attributes within the given block.
+      # Declares a group of writeonly attributes (accessible for write only).
       #
-      # @param options [Hash] shared options for attributes inside the block
-      # @yield defines attributes with `access: [:write]`
+      # @param options [Hash] shared options for all attributes inside the block
+      # @yield a block containing `attribute` calls
       # @return [void]
       def writeonly(**options, &block)
         with_access([:write], options, &block)
       end
 
-      # Declares a group of required attributes within the given block.
+      # Declares a group of required attributes.
       #
-      # @param options [Hash] shared options for attributes inside the block
-      # @yield defines attributes with `required: true`
+      # @param options [Hash] shared options for all attributes inside the block
+      # @yield a block containing `attribute` calls
       # @return [void]
       def required(**options, &block)
         with_required(true, options, &block)
       end
 
-      # Declares a group of optional attributes within the given block.
+      # Declares a group of optional attributes.
       #
-      # @param options [Hash] shared options for attributes inside the block
-      # @yield defines attributes with `required: false`
+      # @param options [Hash] shared options for all attributes inside the block
+      # @yield a block containing `attribute` calls
       # @return [void]
       def optional(**options, &block)
         with_required(false, options, &block)
       end
 
-      # Returns all declared non-transient attributes.
+      # Returns all non-transient attributes defined on the class.
       #
       # @return [Hash{Symbol => Castkit::Attribute}]
       def attributes
-        @attributes ||= {}
+        cattri_variable_memoize(:__castkit_attributes_registry) { {} }
       end
 
-      # Alias for `composite`
+      def inherited(subclass)
+        super
+
+        parent_attributes = cattri_variable_get(:__castkit_attributes_registry)
+        subclass.cattri_variable_set(:__castkit_attributes_registry, parent_attributes.dup) if parent_attributes
+      end
+
+      # Alias for {#attribute}
+      #
+      # @see #attribute
+      alias attr attribute
+
+      # Alias for {#composite}
       #
       # @see #composite
       alias property composite
 
       private
 
-      # Defines a full attribute, including accessor methods and type logic.
+      # Applies a reusable definition to the current attribute call.
+      #
+      # Ensures the declared type matches and merges options.
+      #
+      # @param field [Symbol] the attribute name
+      # @param definition [Hash{Symbol => Object}, nil]
+      # @param type [Symbol, Class]
+      # @param options [Hash]
+      # @return [Array<(Symbol, Hash)>] the final type and options
+      # @raise [Castkit::DataObjectError] if type mismatch occurs
+      def use_definition(field, definition, type, options)
+        type ||= definition&.fetch(:type, nil)
+        raise Castkit::AttributeError, "Attribute `#{field}  has no type" if type.nil?
+
+        if definition && type != definition[:type]
+          raise Castkit::AttributeError,
+                "Attribute `#{field}` type mismatch: expected #{definition[:type].inspect}, got #{type.inspect}"
+        end
+
+        options = definition[:options].merge(options) if definition
+        [type, build_options(options)]
+      end
+
+      # Instantiates and stores a Castkit::Attribute, defining accessors as needed.
       #
       # @param field [Symbol]
       # @param type [Symbol, Class]
       # @param options [Hash]
+      # @return [void]
       def define_attribute(field, type, **options)
         attribute = Castkit::Attribute.new(field, type, **options)
         attributes[field] = attribute
 
-        if attribute.full_access?
-          attr_reader field
-
-          define_typed_writer(field, attribute)
-        elsif attribute.writeable?
-          define_typed_writer(field, attribute)
-        elsif attribute.readable?
-          attr_reader field
-        end
+        define_accessors(attribute)
       end
 
-      # Defines a type-aware writer method for the attribute.
+      # Creates readers/writers for a defined attribute using Cattri.
       #
-      # @param field [Symbol]
       # @param attribute [Castkit::Attribute]
-      def define_typed_writer(field, attribute)
-        define_method("#{field}=") do |value|
-          deserialized_value = Castkit.type_caster(attribute.type).call(
-            value,
-            options: attribute.options,
-            context: attribute.field
-          )
-
-          instance_variable_set("@#{field}", deserialized_value)
+      # @return [void]
+      def define_accessors(attribute)
+        expose = exposure_for(attribute)
+        return if expose == :none
+
+        if attribute.writeable?
+          cattri(attribute.field, nil, expose: expose) do |value|
+            Castkit.type_caster(attribute.type.to_sym).call(
+              value,
+              options: attribute.options,
+              context: attribute.field
+            )
+          end
+        else
+          cattri(attribute.field, nil, expose: expose)
         end
       end
 
-      # Applies scoped access control to all attributes declared in the given block.
+      # Applies a temporary `access` context to all attributes within a block.
       #
-      # @param access [Array<Symbol>] e.g., [:read] or [:write]
+      # @param access [Array<Symbol>] e.g. `[:read]` or `[:write]`
       # @param options [Hash]
-      # @yield the block containing one or more `attribute` calls
+      # @yield the block containing `attribute` calls
+      # @return [void]
       def with_access(access, options = {}, &block)
         @__access_context = access
         @__block_options = options
+
         instance_eval(&block)
       ensure
         @__access_context = nil
         @__block_options = nil
       end
 
-      # Applies scoped required/optional flag to all attributes declared in the given block.
+      # Applies a temporary `required` context to all attributes within a block.
       #
       # @param flag [Boolean]
       # @param options [Hash]
-      # @yield the block containing one or more `attribute` calls
+      # @yield the block containing `attribute` calls
+      # @return [void]
       def with_required(flag, options = {}, &block)
         @__required_context = flag
         @__block_options = options
+
         instance_eval(&block)
       ensure
         @__required_context = nil
         @__block_options = nil
       end
 
-      # Builds effective options for the current attribute definition.
-      #
-      # Merges scoped flags like `required`, `access`, and `transient` if present.
+      # Merges any current context flags (e.g., required, access) into the options hash.
       #
       # @param options [Hash]
-      # @return [Hash]
+      # @return [Hash] effective options for the attribute
       def build_options(options)
         base = @__block_options || {}
         base = base.merge(required: @__required_context) unless @__required_context.nil?
@@ -179,6 +226,26 @@ module Castkit
 
         base.merge(options)
       end
+
+      # Maps Castkit access flags onto Cattri's expose option.
+      #
+      # @param attribute [Castkit::Attribute]
+      # @return [Symbol]
+      def exposure_for(attribute)
+        return :read_write if attribute.full_access?
+        return :write if attribute.writeable?
+        return :read if attribute.readable?
+
+        :none
+      end
+
+      # Defines read/write accessors for transient attributes.
+      #
+      # @param field [Symbol]
+      # @return [void]
+      def define_transient_accessor(field)
+        cattri(field, nil, expose: :read_write)
+      end
     end
   end
 end

data/lib/castkit/core/config.rb

@@ -5,6 +5,17 @@ module Castkit
     # Provides per-class configuration for a Castkit::DataObject,
     # including root key handling, strict mode, and unknown key behavior.
     module Config
+      def self.extended(base)
+        super
+
+        base.include(Cattri) unless base.is_a?(Class) && base < Cattri
+        return unless base.respond_to?(:cattri)
+
+        base.cattri :strict_flag, nil, scope: :class, expose: :read_write
+        base.cattri :warn_on_unknown_flag, nil, scope: :class, expose: :read_write
+        base.cattri :allow_unknown_flag, nil, scope: :class, expose: :read_write
+      end
+
       # Sets or retrieves strict mode behavior.
       #
       # In strict mode, unknown keys during deserialization raise errors. If unset, falls back
@@ -13,11 +24,9 @@ module Castkit
       # @param value [Boolean, nil]
       # @return [Boolean]
       def strict(value = nil)
-        if value.nil?
-          @strict.nil? ? Castkit.configuration.strict_by_default : @strict
-        else
-          @strict = !!value
-        end
+        return (strict_flag.nil? ? Castkit.configuration.strict_by_default : strict_flag) if value.nil?
+
+        self.strict_flag = !!value
       end
 
       # Enables or disables ignoring unknown keys during deserialization.
@@ -27,7 +36,7 @@ module Castkit
       # @param value [Boolean]
       # @return [void]
       def ignore_unknown(value = nil)
-        @strict = !value
+        self.strict_flag = !value
       end
 
       # Sets or retrieves whether to emit warnings when unknown keys are encountered.
@@ -35,7 +44,7 @@ module Castkit
       # @param value [Boolean, nil]
       # @return [Boolean, nil]
       def warn_on_unknown(value = nil)
-        value.nil? ? @warn_on_unknown : (@warn_on_unknown = value)
+        value.nil? ? warn_on_unknown_flag : (self.warn_on_unknown_flag = value)
       end
 
       # Sets or retrieves whether to allow unknown keys when they are encountered.
@@ -43,7 +52,7 @@ module Castkit
       # @param value [Boolean, nil]
       # @return [Boolean, nil]
       def allow_unknown(value = nil)
-        value.nil? ? @allow_unknown : (@allow_unknown = value)
+        value.nil? ? allow_unknown_flag : (self.allow_unknown_flag = value)
       end
 
       # Returns a relaxed version of the current class with strict mode off.
@@ -63,11 +72,12 @@ module Castkit
       #
       # @return [Hash{Symbol => Boolean}]
       def validation_rules
-        @validation_rules ||= {
-          strict: strict,
-          allow_unknown: allow_unknown,
-          warn_on_unknown: warn_on_unknown
-        }
+        @validation_rules ||= {}
+        @validation_rules[:strict] = strict
+        @validation_rules[:allow_unknown] = allow_unknown
+        @validation_rules[:warn_on_unknown] = warn_on_unknown
+
+        @validation_rules
       end
     end
   end