lite-data 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d7ccf91b7250931a7aece3d9395a803039536854c4cceb244f8937bd8804446
+  data.tar.gz: 9dd190fdeecad8b5f699089350ce5a9934767edbdb1146cbdc8ff714adce2c7c
+SHA512:
+  metadata.gz: 789357cc7e35536f018b3bd61395d2ed513cca435f0bd3190e51f15e07692c732e4f571242c96f9ccbe571817fe90ce3a64c7a1483b1e17cb87eaddb1e2833bd
+  data.tar.gz: 8debe38ea903f30f960981bde64b8eaa5377934e717691314f042e331226770a4fd8e350ada9b0a0d5d1141432fabe97c0f96240c04fab32827139a242baa5d7

data/.rubocop.yml

@@ -0,0 +1,72 @@
+plugins:
+  rubocop-rspec
+
+AllCops:
+  NewCops: enable
+
+Style/Documentation:
+  Enabled: false
+
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/ModuleLength:
+  Max: 200
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+
+Layout/LineLength:
+  Exclude:
+    - spec/**/*.rb
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - spec/**/*.rb
+
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Rspec/MultipleExpectations:
+  Max: 3
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/EachWithObject:
+  Enabled: false
+
+Style/HashSyntax:
+  Enabled: false
+
+Lint/BooleanSymbol:
+  Enabled: false
+
+Style/HashConversion:
+  Enabled: false
+
+Style/RedundantArrayConstructor:
+  Enabled: false
+
+Style/RedundantSelfAssignment:
+  Enabled: false
+
+Style/MethodCallWithoutArgsParentheses:
+  Enabled: false
+
+Style/ArgumentsForwarding:
+  Enabled: false
+
+Naming/BlockForwarding:
+  Enabled: false
+

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+group :test do
+  gem 'byebug'
+  gem 'markly'
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+  gem 'simplecov'
+end

data/README.md

@@ -0,0 +1,63 @@
+# Lite::Data
+Easy definition of data classes with subclassing support 
+and flexible constructor signatures.
+
+## Overview
+Closely follows the interface of Ruby 3.2's `Data` class, but adds:
+- Subclassing capability
+- Mixed positional and keyword arguments
+- Module-based design for including in existing classes
+
+## Class definition
+### Defining a data class
+Use `Lite::Data.define(klass, args:, kwargs:)` with arrays for positional 
+and keyword parameters. The following declaration generates a module with
+necessary instance methods and includes it in the target class:
+
+```ruby rspec definition_superclass
+class Foo
+  Lite::Data.define(self, args: [:foo])
+end
+
+expect(Foo.new('FOO').foo).to eq('FOO')
+```
+
+The same works when extending existing data classes:
+```ruby rspec definition_subclass
+class Bar < Foo
+  Lite::Data.define(self, kwargs: [:bar])
+end
+
+expect(Bar.new('FOO', bar: 'BAR').bar).to eq('BAR')
+```
+
+### Argument positioning in subclasses
+By default, new positional arguments are added at the start. Use `:'*'` 
+as a placeholder to control positioning:
+
+```ruby rspec definition_argument_positioning
+class Bax < Bar
+  Lite::Data.define(self, args: [:'*', :bax])
+end
+
+expect(Bax.new('FOO', 'BAX', bar: 'BAR').bax).to eq('BAX')
+```
+
+## Generated methods
+Classes automatically receive:
+- **Comparison**: `==`, `eql?`, `hash`
+- **Cloning**: `with`
+- **Introspection**: `deconstruct`, `deconstruct_keys`, `to_h`
+
+### Destructuring order
+The `deconstruct` method returns values in order of inheritance, 
+each class contributes its members in order of definition, 
+positional first:
+```ruby rspec introspection_deconstruct
+# inheritance chain: Bax < Bar < Foo
+expect(Bax.new('FOO', 'BAX', bar: 'BAR').deconstruct)
+  .to eq(%w[FOO BAR BAX])
+```
+
+# License
+This library is published under MIT license

data/bench/comparative.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'byebug'
+
+require_relative '../lib/lite/data'
+
+module Lite
+  module Data
+    module Benchmark
+      module Comparative
+        module Abstract
+          def instantiate(opts)
+            self::Data.new(**opts)
+          end
+
+          def clone(original, opts)
+            original.with(**opts.compact)
+          end
+        end
+
+        module RubyBase
+          extend Abstract
+
+          Data = ::Data.define(:foo, :bar, :bax, :qox)
+        end
+
+        module LiteBase
+          extend Abstract
+
+          class Data
+            Lite::Data.define(self, kwargs: %i[foo bar bax qox])
+          end
+        end
+
+        module LiteSubclass
+          extend Abstract
+
+          class Super
+            Lite::Data.define(self, kwargs: %i[foo bar])
+          end
+
+          class Data < Super
+            Lite::Data.define(self, kwargs: %i[bax qox])
+          end
+        end
+
+        SYMBOLS = %i[a b c d e f g h i j].freeze
+
+        def self.run(n, duplicity: 0) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
+          subjects = [RubyBase, LiteBase, LiteSubclass]
+
+          original_opts = opts
+          idata = 10_000.times.map { Random.rand < duplicity ? original_opts : opts }
+          cdata = idata.map(&:compact)
+
+          subjects.to_a.each do |subject|
+            result = ::Benchmark.measure do
+              n.times { |idx| subject.instantiate(idata[idx % idata.length]) }
+            end
+            puts "#{subject.name} NEW: #{result}"
+
+            original = subject.instantiate(original_opts)
+            result = ::Benchmark.measure do
+              n.times do |idx|
+                subject.clone(original, cdata[idx % cdata.length])
+              end
+            end
+            puts "#{subject.name} CLONE: #{result}"
+          end
+        end
+
+        def self.opts
+          { foo: rand, bar: rand, bax: rand, qox: rand }
+        end
+
+        def self.rand
+          SYMBOLS[Random.rand(11)]
+        end
+      end
+    end
+  end
+end
+
+Lite::Data::Benchmark::Comparative.run(100_000, duplicity: 0.1)

data/lib/lite/data/definer/abstract.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../marker'
+
+module Lite
+  module Data
+    module Definer
+      module Abstract
+        def define(members)
+          Module.new do
+            extend Marker
+
+            attr_reader(*members.members)
+
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def self.members
+                [#{members.members.map { ":#{_1}" }.join(', ')}]
+              end
+
+              def deconstruct
+                #{members.ivars_array}
+              end
+
+              def to_h
+                { #{members.hash_fields} }
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/definer/base.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative 'members/base'
+
+module Lite
+  module Data
+    module Definer
+      module Base
+        extend Abstract
+
+        module InstanceMethods
+          def deconstruct_keys(members)
+            case members
+            when nil then to_h
+            else to_h.slice(*members)
+            end
+          end
+
+          def inspect
+            "#<data #{self.class.name} #{to_h.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')}>"
+          end
+
+          def to_s
+            inspect
+          end
+        end
+
+        def self.define(positional_arguments, keyword_arguments) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          members = Members::Base.instance(positional_arguments, keyword_arguments)
+          mod = super(members)
+
+          mod.include InstanceMethods
+
+          mod.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def initialize(#{members.initialize_signature})
+              #{members.initialize_ivars}
+              freeze
+            end
+
+            def ==(other)
+              return true if self.equal?(other)
+              return false unless self.class == other.class
+
+              #{members.equality}
+            end
+
+            def eql?(other)
+              return true if self.equal?(other)
+              return false unless self.class == other.class
+
+              #{members.hash_equality}
+            end
+
+            def hash
+              [#{['self.class', *members.members].join(', ')}].hash
+            end
+
+            def with(#{members.keyword_signature_defaults})
+              return self if #{members.variables_equal_attributes}
+
+              self.class.send(#{[':new', *members.constructor_arguments].join(', ')})
+            end
+
+            private
+
+            def merged_constructor_arguments(#{members.merged_constructor_arguments_signature})
+              identical &&= #{members.variables_equal_attributes}
+              return identical if identical
+
+              [false, #{members.merged_constructor_arguments}]
+            end
+          RUBY
+
+          mod
+        end
+
+        def self.define_class_methods(base, mod)
+          base.define_singleton_method(:members) { mod.members }
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/definer/members/abstract.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+
+module Lite
+  module Data
+    module Definer
+      module Members
+        class Abstract
+          def self.instance(positional_arguments, keyword_arguments, members)
+            ensure_members_valid!(members)
+            new positional_arguments, keyword_arguments, members
+          end
+
+          def self.ensure_members_valid!(members)
+            raise Error, 'Members must not be empty' if members.empty?
+
+            invalid = members.reject { _1.is_a?(Symbol) }
+            raise Error, "Array of symbols expected, got: #{invalid.map(&:inspect).join(', ')}" unless invalid.empty?
+
+            uniq = members.uniq
+            raise Error, 'Member names must be unique' unless uniq.length == members.length
+          end
+
+          def initialize(positional_arguments, keyword_arguments, members)
+            @positional_arguments = positional_arguments.freeze
+            @keyword_arguments = keyword_arguments.freeze
+            @members = members.freeze
+            freeze
+          end
+
+          attr_reader :positional_arguments, :keyword_arguments, :members
+
+          def initialize_ivars
+            members.map { "@#{_1} = #{_1}" }.join(';')
+          end
+
+          def variables_equal_attributes
+            members.map { "#{_1} == @#{_1}" }.join(' && ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/definer/members/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Data
+    module Definer
+      module Members
+        class Base < Abstract
+          def self.instance(positional_arguments, keyword_arguments)
+            super(
+              positional_arguments,
+              keyword_arguments,
+              positional_arguments + keyword_arguments
+            )
+          end
+
+          def initialize_signature
+            (positional_arguments + keyword_arguments.map { "#{_1}:" }).join(', ')
+          end
+
+          def keyword_signature_defaults
+            members.map { "#{_1}: @#{_1}" }.join(', ')
+          end
+
+          def constructor_arguments
+            (positional_arguments + keyword_arguments.map { "#{_1}: #{_1}" }).join(', ')
+          end
+
+          def ivars_array
+            "[#{members.map { " @#{_1}" }.join(', ')}]"
+          end
+
+          def positional_arguments_array
+            "[#{positional_arguments.join(', ')}]"
+          end
+
+          def keyword_arguments_hash
+            "{ #{keyword_arguments.map { "#{_1}: #{_1}" }.join(', ')} }"
+          end
+
+          def merged_constructor_arguments_signature
+            ['identical', members.map { "#{_1}: @#{_1}" }].join(', ')
+          end
+
+          def merged_constructor_arguments
+            "#{positional_arguments_array}, #{keyword_arguments_hash}"
+          end
+
+          def hash_fields
+            members.map { "#{_1}: @#{_1}" }.join(', ')
+          end
+
+          def equality
+            members.map { "#{_1} == other.#{_1}" }.join(' && ')
+          end
+
+          def hash_equality
+            members.map { "#{_1}.eql?(other.#{_1})" }.join(' && ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/definer/members/subclass.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Data
+    module Definer
+      module Members
+        class Subclass < Abstract
+          def self.instance(positional_arguments, keyword_arguments)
+            positional_arguments = [*positional_arguments, :*] unless positional_arguments.include? :*
+
+            super(
+              positional_arguments,
+              keyword_arguments,
+              (positional_arguments.reject { _1 == :* } + keyword_arguments)
+            )
+          end
+
+          attr_reader :positional_arguments, :keyword_arguments, :members
+
+          def interpolated_positional_arguments(replacement)
+            positional_arguments.map { _1 == :* ? replacement : _1 }
+          end
+
+          def initialize_signature
+            [
+              *interpolated_positional_arguments('*args'),
+              *keyword_arguments.map { "#{_1}:" },
+              '**opts'
+            ].join(', ')
+          end
+
+          def ivars_array
+            "[*super, #{members.map { "@#{_1}" }.join(', ')}]"
+          end
+
+          def merged_constructor_arguments_signature
+            ['identical', members.map { "#{_1}: @#{_1}" }, '**opts'].join(', ')
+          end
+
+          def merged_constructor_arguments
+            positional = interpolated_positional_arguments('*args').join(', ')
+            keyword = [*keyword_arguments.map { "#{_1}: #{_1}" }, '**opts'].join(', ')
+            "[#{positional}], { #{keyword} }"
+          end
+
+          def hash_fields
+            ['**super', *members.map { "#{_1}: @#{_1}" }].join(', ')
+          end
+
+          def equality
+            ['super', *members.map { "#{_1} == other.#{_1}" }].join(' && ')
+          end
+
+          def hash_equality
+            ['super', *members.map { "#{_1}.eql?(other.#{_1})" }].join(' && ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/definer/subclass.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative 'members/subclass'
+
+module Lite
+  module Data
+    module Definer
+      module Subclass
+        extend Abstract
+
+        module InstanceMethods
+          def with(**opts)
+            return self if opts.empty?
+
+            identical, args, opts = merged_constructor_arguments(true, **opts)
+            return self if identical
+
+            self.class.send(:new, *args, **opts)
+          end
+        end
+
+        def self.define(positional_arguments, keyword_arguments) # rubocop:disable Metrics/MethodLength
+          members = Members::Subclass.instance(positional_arguments, keyword_arguments)
+          mod = super(members)
+
+          mod.include InstanceMethods
+
+          mod.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def initialize(#{members.initialize_signature})
+              #{members.initialize_ivars}
+              super *args, **opts
+            end
+
+            def ==(other)
+              #{members.equality}
+            end
+
+            def eql?(other)
+              #{members.hash_equality}
+            end
+
+            def hash
+              [#{['super', *members.members].join(', ')}].hash
+            end
+
+            private
+
+            def merged_constructor_arguments(#{members.merged_constructor_arguments_signature})
+              identical &&= #{members.variables_equal_attributes}
+
+              return true if identical && opts.empty?
+              identical, args, opts = super(identical, **opts)
+              return true if identical
+
+              [false, #{members.merged_constructor_arguments}]
+            end
+          RUBY
+
+          mod
+        end
+
+        def self.define_class_methods(base, mod)
+          base.define_singleton_method(:members) { super() + mod.members }
+        end
+      end
+    end
+  end
+end

data/lib/lite/data/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lite
+  module Data
+    class Error < StandardError; end
+  end
+end

data/lib/lite/data/marker.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lite
+  module Data
+    module Marker
+    end
+  end
+end

data/lib/lite/data/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lite
+  module Data
+    module Version
+      VERSION = '0.0.3'
+    end
+  end
+end

data/lib/lite/data.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'data/definer/base'
+require_relative 'data/definer/subclass'
+
+module Lite
+  module Data
+    private_constant :Definer
+
+    def self.define(base, args: [], kwargs: [])
+      supermod = base.ancestors.find { |klass| klass.is_a?(Marker) }
+      prevent_conflicts!(base, args, kwargs) if supermod
+
+      definer = supermod ? Definer::Subclass : Definer::Base
+      mod = definer.define(args, kwargs)
+      definer.define_class_methods(base, mod)
+      base.include(mod)
+      nil
+    end
+
+    def self.prevent_conflicts!(klass, args, kwargs)
+      duplicates = klass.members & (args + kwargs)
+      raise Error, "Members already declared: #{duplicates.map(&:inspect).join(', ')}" unless duplicates.empty?
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: lite-data
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Tomas Milsimer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-09-05 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Easy definition of data classes with subclassing support
+  and flexible constructor signatures.
+email:
+- tomas.milsimer@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- README.md
+- bench/comparative.rb
+- lib/lite/data.rb
+- lib/lite/data/definer/abstract.rb
+- lib/lite/data/definer/base.rb
+- lib/lite/data/definer/members/abstract.rb
+- lib/lite/data/definer/members/base.rb
+- lib/lite/data/definer/members/subclass.rb
+- lib/lite/data/definer/subclass.rb
+- lib/lite/data/error.rb
+- lib/lite/data/marker.rb
+- lib/lite/data/version.rb
+homepage: https://github.com/lame-impala/lite-data
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Minimalistic data-class definition
+test_files: []