structure 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af5b8b6dc3dacef6201847123b04742310441ded70ec7952b42d07a668d83f2f
-  data.tar.gz: '00385227416285e5a4d1f2cfcf2cc0e5cb94bb368cf8995b014a7bf3fd91d9c6'
+  metadata.gz: c798ddd0dce500c2053077d3964ffe907c1f13fa0b1b9f9394c18a1cc9829b31
+  data.tar.gz: 2c82c99faa38aeb774415121d793ff2205a628aecab194fe60a36746efcb983f
 SHA512:
-  metadata.gz: ba80d09a4867a1497133026cc4d4654e03586f677d44d07a7f2387b40fce16e8fc188bc46cc8c768663ded6387b580d3dc210ae884d14530bf62e7e56ec4ace4
-  data.tar.gz: 8a0c8e7d5f9585a946817cc31a3cd831ea0332833030798d178ce81ee1737809226321ac105f106559358aa4ae24753368d808007ef6ab37230b6d6fc98ffe69
+  metadata.gz: f3ec870b530f010c1356ee2ecadb6ca6e2880e29b4f15b80e395812aad8d342737a547811c442c737c50ff1b4b6dc98a2496ae2aa7df6e657d76198bb964b82a
+  data.tar.gz: 30bafd22ee1ed82b7e5e5d702617200a31689fccad006df1e884d66d99b43c8b85ad9ae99004ca2b9a271f8b721a86c200553a289adc24496abf691b6f63573f

data/lib/structure/builder.rb

@@ -13,6 +13,25 @@ module Structure
       @defaults = {}
     end
 
+    # DSL method for defining attributes with optional type coercion
+    #
+    # @param name [Symbol] The attribute name
+    # @param type [Class, Symbol, Array, nil] Type for coercion (e.g., String, :boolean, [String])
+    # @param from [String, nil] Source key in the data hash (defaults to name.to_s)
+    # @param default [Object, nil] Default value if attribute is missing
+    # @yield [value] Block for custom transformation
+    # @raise [ArgumentError] If both type and block are provided
+    #
+    # @example With type coercion
+    #   attribute :age, Integer
+    #
+    # @example With custom source key
+    #   attribute :created_at, Time, from: "CreatedAt"
+    #
+    # @example With transformation block
+    #   attribute :price do |value|
+    #     Money.new(value["amount"], value["currency"])
+    #   end
     def attribute(name, type = nil, from: nil, default: nil, &block)
       # Always store in mappings - use attribute name as default source
       @mappings[name] = from || name.to_s
@@ -27,23 +46,30 @@ module Structure
       end
     end
 
-    # Deduced from mappings - maintains order of definition
+    # Defines a callback to run after parsing
+    #
+    # @yield [instance] Block that receives the parsed instance
+    # @return [void]
+    #
+    # @example Validation
+    #   after_parse do |order|
+    #     raise "Invalid order" if order.total < 0
+    #   end
+    def after_parse(&block)
+      @after_parse_callback = block
+    end
+
     def attributes
       @mappings.keys
     end
 
-    # Deduced from types that are boolean
     def predicate_methods
       @types.filter_map do |name, type_lambda|
-        if type_lambda == Types.boolean
+        if type_lambda == Types.boolean && !name.to_s.end_with?("?")
           predicate_name = "#{name}?"
           [predicate_name.to_sym, name]
         end
       end.to_h
     end
-
-    def after_parse(&block)
-      @after_parse_callback = block
-    end
   end
 end

data/lib/structure/types.rb

@@ -10,41 +10,32 @@ module Structure
     BOOLEAN_TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"].freeze
     private_constant :BOOLEAN_TRUTHY
 
-    # Boolean conversion
-    # Memoized so predicate method detection works via object identity comparison
     def boolean
       @boolean ||= ->(val) { BOOLEAN_TRUTHY.include?(val) }
     end
 
-    # Generic handler for classes with kernel methods (String, Integer, Float, etc.)
-    def kernel(type)
-      ->(val) { Kernel.send(type.name, val) }
-    end
-
-    # Handler for classes with parse methods (e.g., Date, Time, URI, nested Structure classes)
-    def parseable(type)
-      ->(val) { type.parse(val) }
-    end
-
-    # Create coercer for array elements
-    def array(element_type)
-      element_coercer = coerce(element_type)
-      ->(array) { array.map { |element| element_coercer.call(element) } }
-    end
-
     # Main factory method for creating type coercers
+    #
+    # @param type [Class, Symbol, Array] Type specification
+    # @return [Proc, Object] Coercion proc or the type itself if no coercion available
+    #
+    # @example Boolean type
+    #   coerce(:boolean) # => boolean proc
+    #
+    # @example Kernel types
+    #   coerce(Integer) # => proc that calls Kernel.Integer
+    #
+    # @example Parseable types
+    #   coerce(Date) # => proc that calls Date.parse
+    #
+    # @example Array types
+    #   coerce([String]) # => proc that coerces array elements to String
     def coerce(type)
       case type
       when :boolean
         boolean
-      when Class, Module
-        if type.name && Kernel.respond_to?(type.name)
-          kernel(type)
-        elsif type.respond_to?(:parse)
-          parseable(type)
-        else
-          type
-        end
+      when :self
+        self_referential
       when Array
         if type.length == 1
           array(type.first)
@@ -52,7 +43,37 @@ module Structure
           type
         end
       else
-        type
+        # Handle Class, Module, and any other types
+        if type.respond_to?(:parse)
+          parseable(type)
+        elsif type.respond_to?(:name) && type.name && Kernel.respond_to?(type.name)
+          kernel(type)
+        else
+          type
+        end
+      end
+    end
+
+    private
+
+    def self_referential
+      proc { |val| parse(val) }
+    end
+
+    def kernel(type)
+      ->(val) { Kernel.send(type.name, val) }
+    end
+
+    def parseable(type)
+      ->(val) { type.parse(val) }
+    end
+
+    def array(element_type)
+      if element_type == :self
+        proc { |array| array.map { |element| parse(element) } }
+      else
+        element_coercer = coerce(element_type)
+        ->(array) { array.map { |element| element_coercer.call(element) } }
       end
     end
   end

data/lib/structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Structure
-  VERSION = "3.1.0"
+  VERSION = "3.2.0"
 end

data/lib/structure.rb

@@ -5,6 +5,20 @@ require "structure/builder"
 # A library for parsing data into immutable Ruby Data objects with type coercion
 module Structure
   class << self
+    # Creates a new Data class with attribute definitions and type coercion
+    #
+    # @yield [Builder] Block for defining attributes using the DSL
+    # @return [Class] A Data class with a parse method
+    #
+    # @example Basic usage
+    #   Person = Structure.new do
+    #     attribute :name, String
+    #     attribute :age, Integer
+    #   end
+    #
+    #   person = Person.parse(name: "Alice", age: "30")
+    #   person.name # => "Alice"
+    #   person.age  # => 30
     def new(&block)
       builder = Builder.new
       builder.instance_eval(&block) if block
@@ -44,7 +58,13 @@ module Structure
 
           # Apply type coercion or transformation
           if types[attr] && !value.nil?
-            value = types[attr].call(value)
+            type_or_proc = types[attr]
+            # Use instance_exec for non-lambda procs (self-referential types)
+            value = if type_or_proc.is_a?(Proc) && !type_or_proc.lambda?
+              instance_exec(value, &type_or_proc)
+            else
+              type_or_proc.call(value)
+            end
           end
 
           final_kwargs[attr] = value

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Hakan Ensari