structure 2.3.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5fcd89773ec6806567c78ea7eebb3867c128c6766149b81e07d82cc4d76ab1
-  data.tar.gz: 198774e8e6e3d4fea14f387a2862c0d88bd60923866a84a4bbdeaf0fd7be1cd1
+  metadata.gz: af5b8b6dc3dacef6201847123b04742310441ded70ec7952b42d07a668d83f2f
+  data.tar.gz: '00385227416285e5a4d1f2cfcf2cc0e5cb94bb368cf8995b014a7bf3fd91d9c6'
 SHA512:
-  metadata.gz: 052042efbc411e8d09808f5bdfeb5d2994fd25ba45ddec8d45d06d3cc57b6dc2efd84ec840a20d601618bad494e2ba319c89a579f27e7de8f53c8d59849806be
-  data.tar.gz: f73e1be62de7fe8540a12f4bb47ded101cf7d7bc4971ab1dbcbbe6917754ee84a82e3cc7cfdb529fd1b1f4c07d62406caa6e7ed7ab5ab528b9f8bb061120d852
+  metadata.gz: ba80d09a4867a1497133026cc4d4654e03586f677d44d07a7f2387b40fce16e8fc188bc46cc8c768663ded6387b580d3dc210ae884d14530bf62e7e56ec4ace4
+  data.tar.gz: 8a0c8e7d5f9585a946817cc31a3cd831ea0332833030798d178ce81ee1737809226321ac105f106559358aa4ae24753368d808007ef6ab37230b6d6fc98ffe69

data/lib/structure/builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "structure/types"
+
+module Structure
+  # Builder class for accumulating attribute definitions
+  class Builder
+    attr_reader :mappings, :types, :defaults, :after_parse_callback
+
+    def initialize
+      @mappings = {}
+      @types = {}
+      @defaults = {}
+    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
+      @defaults[name] = default unless default.nil?
+
+      if type && block
+        raise ArgumentError, "Cannot specify both type and block for :#{name}"
+      elsif block
+        @types[name] = block
+      elsif type
+        @types[name] = Types.coerce(type)
+      end
+    end
+
+    # Deduced from mappings - maintains order of definition
+    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
+          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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Structure
+  # Type coercion methods for converting values to specific types
+  module Types
+    extend self
+
+    # Rails-style boolean truthy values
+    # Reference: https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html
+    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
+    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 Array
+        if type.length == 1
+          array(type.first)
+        else
+          type
+        end
+      else
+        type
+      end
+    end
+  end
+end

data/lib/structure/version.rb

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

data/lib/structure.rb

@@ -1,151 +1,61 @@
 # frozen_string_literal: true
 
-# A tiny library for lazy parsing data with memoized attributes
+require "structure/builder"
+
+# A library for parsing data into immutable Ruby Data objects with type coercion
 module Structure
   class << self
-    private
-
-    def included(base)
-      if base.is_a?(Class)
-        base.extend ClassMethods
-      else
-        def base.included(base)
-          ::Structure.send(:included, base)
-        end
-      end
-    end
-  end
-
-  def attribute_names
-    self.class.attribute_names
-  end
-
-  def to_a
-    attribute_names.map { |key| [key, send(key)] }
-  end
-
-  def to_h
-    Hash[to_a]
-  end
-
-  alias attributes to_h
+    def new(&block)
+      builder = Builder.new
+      builder.instance_eval(&block) if block
 
-  def inspect
-    detail = if public_methods(false).include?(:to_s)
-               to_s
-             else
-               to_a.map { |key, val| "#{key}=#{val.inspect}" }.join(', ')
-             end
+      data_class = Data.define(*builder.attributes)
 
-    "#<#{self.class.name || '?'} #{detail}>"
-  end
-
-  alias to_s inspect
-
-  def ==(other)
-    if public_methods(false).include?(:<=>)
-      super
-    else
-      attributes == other.attributes
-    end
-  end
-
-  def eql?(other)
-    return false if other.class != self.class
-
-    self == other
-  end
-
-  def freeze
-    attribute_names.each { |key| send(key) }
-    super
-  end
-
-  def marshal_dump
-    attributes.values
-  end
-
-  def marshal_load(data)
-    @mutex = ::Thread::Mutex.new
-    attribute_names.zip(data).each do |key, val|
-      instance_variable_set(:"@#{key}", val)
-    end
-  end
-
-  private
-
-  def with_mutex(&block)
-    @mutex.owned? ? block.call : @mutex.synchronize { block.call }
-  end
-
-  # The class interface
-  module ClassMethods
-    attr_reader :attribute_names
-
-    class << self
-      def extended(base)
-        base.instance_variable_set :@attribute_names, []
-        base.send :override_initialize
+      # Generate predicate methods
+      builder.predicate_methods.each do |predicate_name, attribute_name|
+        data_class.define_method(predicate_name) do
+          send(attribute_name)
+        end
       end
 
-      private :extended
-    end
-
-    def attribute(name, &block)
-      name = name.to_s
-
-      if name.end_with?('?')
-        name = name.chop
-        module_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{name}?
-            #{name}
+      # Capture builder data in closure for parse method
+      mappings = builder.mappings
+      types = builder.types
+      defaults = builder.defaults
+      attributes = builder.attributes
+      after_parse_callback = builder.after_parse_callback
+
+      data_class.define_singleton_method(:parse) do |data = {}, **kwargs|
+        # Merge kwargs into data - kwargs take priority as overrides
+        # Convert kwargs symbol keys to strings to match source_key lookups
+        string_kwargs = kwargs.transform_keys(&:to_s)
+        data = data.merge(string_kwargs)
+
+        final_kwargs = {}
+        attributes.each do |attr|
+          source_key = mappings[attr]
+          value = if data.key?(source_key)
+            data[source_key]
+          elsif data.key?(source_key.to_sym)
+            data[source_key.to_sym]
+          elsif defaults.key?(attr)
+            defaults[attr]
           end
-        CODE
-      end
-
-      module_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}
-          with_mutex do
-            break if defined?(@#{name})
 
-            @#{name} = unmemoized_#{name}
+          # Apply type coercion or transformation
+          if types[attr] && !value.nil?
+            value = types[attr].call(value)
           end
 
-          @#{name}
-        end
-      CODE
-      private define_method "unmemoized_#{name}", block
-      @attribute_names << name
-
-      name.to_sym
-    end
-
-    private
-
-    def override_initialize
-      class_eval do
-        unless method_defined?(:overriding_initialize)
-          define_method :overriding_initialize do |*arguments, &block|
-            @mutex = ::Thread::Mutex.new
-            original_initialize(*arguments, &block)
-          end
+          final_kwargs[attr] = value
         end
 
-        return if instance_method(:initialize) ==
-                  instance_method(:overriding_initialize)
-
-        alias_method :original_initialize, :initialize
-        alias_method :initialize, :overriding_initialize
-        private :overriding_initialize, :original_initialize
+        instance = new(**final_kwargs)
+        after_parse_callback&.call(instance)
+        instance
       end
-    end
-
-    def method_added(name)
-      override_initialize if name == :initialize
-    end
 
-    def inherited(subclass)
-      subclass.instance_variable_set :@attribute_names, attribute_names.dup
+      data_class
     end
   end
 end

metadata

@@ -1,70 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: structure
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Hakan Ensari
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-24 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: 
-email: 
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides a DSL for generating immutable Ruby Data objects with type coercion
+  and data transformation capabilities.
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/structure.rb
+- lib/structure/builder.rb
+- lib/structure/types.rb
 - lib/structure/version.rb
-homepage: 
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -72,15 +30,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Lazy-parse data into attributes in a thread-safe way
+summary: Structure your data
 test_files: []