u-struct 0.6.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52450d53b7accc5aa4c83682dfc6557d3f5fa4d7879648c189701198548e0ace
-  data.tar.gz: 4a25f913523f7aa9e79e96e49cafd33cff2ec748dac79d0bca611cd67aa304e3
+  metadata.gz: ed0c19c23a4cbdd7282390be2590b7b9ae8b025badd32ffbaae9adf128d79667
+  data.tar.gz: b18729b71798828d9ba517f635e3b2b8e6baff640724b0837bac66be14e72ed8
 SHA512:
-  metadata.gz: 1bd5940255d259aeebbe5207a0a397bfade550bbc0e4bf719233ef18c2ba8f3fb483b96fb932fd775f7b98c35af184292b5f7392b32ebf0456888379b13c857c
-  data.tar.gz: 0ca2437cf6a48c090cc176324477b579c394b11c8c451a14a11c62a9509e5b3f6f722f1318d777e4db610cf4ab004b7f820dba169544fca0c31fb6033d03cf76
+  metadata.gz: '0519e4b525fb8e62021c8ec5e518f503c6f14d865f48942c9dd145864f08ca2c3cbfb5c65fae703c3f91c3730ffd04881890d950c335ecc14789cdb28f24a541'
+  data.tar.gz: c0068d5051527141d7d1bfd59de4cd5e7b026abbbb5abe2d0a9b45b0a74de674e51bda16d483400f1cdeb9284a7bdb6093ba5989d8eb940e4a431e70bed12ee7

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.10.0] - 2021-12-15
+
+- To-do
+
+## [0.9.0] - 2021-12-14
+
+- To-do
+
+## [0.8.0] - 2021-12-05
+
+- To-do
+
+## [0.7.0] - 2021-12-04
+
+- To-do
+
 ## [0.6.0] - 2021-12-03
 
 - To-do

data/Gemfile

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in micro-struct.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+gem 'rake', '~> 13.0'
 
-gem "minitest", "~> 5.0"
+gem 'minitest', '~> 5.0'
+gem 'simplecov', '~> 0.21.2'

data/Gemfile.lock

@@ -1,21 +1,30 @@
 PATH
   remote: .
   specs:
-    u-struct (0.6.0)
+    u-struct (0.10.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    docile (1.4.0)
     minitest (5.14.4)
     rake (13.0.6)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
 
 PLATFORMS
+  ruby
   x86_64-darwin-19
 
 DEPENDENCIES
   bundler
   minitest (~> 5.0)
   rake (~> 13.0)
+  simplecov (~> 0.21.2)
   u-struct!
 
 BUNDLED WITH

data/README.md

@@ -22,17 +22,24 @@ Or install it yourself as:
 
 ```ruby
 # Like in a regular Struct, you can define one or many attributes.
-# But all of will be required by default.
+# But all of them will be required by default.
 
 Micro::Struct.new(:first_name, :last_name, ...)
 
-# Use the `_optional:` arg if you want some optional attributes.
+# Use the `optional:` arg if you want some optional attributes.
 
-Micro::Struct.new(:first_name, :last_name, _optional: :gender)
+Micro::Struct.new(:first_name, :last_name, optional: :gender)
 
-# Using `_optional:` to define all attributes are optional.
+# Using `optional:` to define all attributes are optional.
 
-Micro::Struct.new(_optional: [:first_name, :last_name])
+Micro::Struct.new(optional: [:first_name, :last_name])
+
+# Use the `required:` arg to define required attributes.
+
+Micro::Struct.new(
+  required: [:first_name, :last_name],
+  optional: [:gender, :age]
+)
 
 # You can also pass a block to define custom methods.
 
@@ -52,11 +59,17 @@ Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy).new(:
 Micro::Struct.new(*required)
 Micro::Struct.new(*required) {}
 
-Micro::Struct.new(_optional: *)
-Micro::Struct.new(_optional: *) {}
+Micro::Struct.new(optional: *)
+Micro::Struct.new(optional: *) {}
+
+Micro::Struct.new(required: *)
+Micro::Struct.new(required: *) {}
+
+Micro::Struct.new(*required, optional: *)
+Micro::Struct.new(*required, optional: *) {}
 
-Micro::Struct.new(*required, _optional: *)
-Micro::Struct.new(*required, _optional: *) {}
+Micro::Struct.new(required: *, optional: *)
+Micro::Struct.new(required: *, optional: *) {}
 
 # Any options above can be used by the `.new()` method of the struct creator returned by the `.with()` method.
 

data/examples/person_1.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+end
+
+Person = Micro::Struct.new(:first_name, :last_name, optional: :age) do
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+
+puts format('first_name: %p', person.first_name)
+puts format('last_name: %p', person.last_name)
+puts format('name: %p', person.name)
+puts format('age: %p', person.age)
+puts
+
+person.age = rand(18..100)
+
+puts format('age: %p', person.age)

data/examples/person_2.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+end
+
+Person = Micro::Struct.with(:readonly, :instance_copy).new(
+  required: [:first_name, :last_name],
+  optional: [:age]
+) do
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+
+puts format('first_name: %p', person.first_name)
+puts format('last_name: %p', person.last_name)
+puts format('name: %p', person.name)
+puts format('age: %p', person.age)
+puts
+
+rand_age = rand(18..100)
+
+new_person = person.with(age: rand_age)
+
+puts new_person.equal?(person)
+
+puts format('age: %p', person.age)
+puts format('age: %p', new_person.age)
+
+person.age = rand_age

data/examples/rgb/color.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RGB
+  Color = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+    def self.new(r:, g:, b:)
+      __new__(
+        red:   Number.new(r, label: 'r'),
+        green: Number.new(g, label: 'g'),
+        blue:  Number.new(b, label: 'b')
+      )
+    end
+
+    def to_a
+      super.map(&:value)
+    end
+
+    def to_hex
+      "##{red}#{green}#{blue}"
+    end
+  end
+end

data/examples/rgb/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RGB
+  Number = Micro::Struct.with(:readonly).new(:value) do
+    Input = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
+      value.is_a?(::Integer) && value >= 0 && value <= 255
+    end
+
+    def self.new(value, label:)
+      __new__(value: Input[value, label: label])
+    end
+
+    def to_s
+      value.to_s(16)
+    end
+  end
+end

data/examples/rgb_1.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+  gem 'kind'
+end
+
+RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+  Number = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
+    value.is_a?(::Integer) && value >= 0 && value <= 255
+  end
+
+  def self.new(r:, g:, b:)
+    __new__(
+      red:   Number[r, label: 'r'],
+      green: Number[g, label: 'g'],
+      blue:  Number[b, label: 'b']
+    )
+  end
+
+  def to_hex
+    "##{red.to_s(16)}#{green.to_s(16)}#{blue.to_s(16)}"
+  end
+end
+
+rgb_color = RGBColor.new(r: 1, g: 1, b: 255)
+
+p rgb_color
+
+puts
+puts format('to_hex: %p', rgb_color.to_hex)
+puts format('to_a: %p', rgb_color.to_a)
+puts
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGBColor.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

data/examples/rgb_2.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+  gem 'kind'
+end
+
+RGBNumber = Micro::Struct.with(:readonly).new(:value) do
+  Input = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
+    value.is_a?(::Integer) && value >= 0 && value <= 255
+  end
+
+  def self.new(value, label:)
+    __new__(value: Input[value, label: label])
+  end
+
+  def to_s
+    value.to_s(16)
+  end
+end
+
+RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+  def self.new(r:, g:, b:)
+    __new__(
+      red:   RGBNumber.new(r, label: 'r'),
+      green: RGBNumber.new(g, label: 'g'),
+      blue:  RGBNumber.new(b, label: 'b')
+    )
+  end
+
+  def to_a
+    [red.value, green.value, blue.value]
+  end
+
+  def to_hex
+    "##{red}#{green}#{blue}"
+  end
+end
+
+rgb_color = RGBColor.new(r: 1, g: 1, b: 255)
+
+p rgb_color
+
+puts
+puts format('to_hex: %p', rgb_color.to_hex)
+puts format('to_a: %p', rgb_color.to_a)
+puts
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

data/examples/rgb_3.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+  gem 'kind'
+end
+
+require_relative 'rgb/number'
+require_relative 'rgb/color'
+
+rgb_color = RGB::Color.new(r: 1, g: 1, b: 255)
+
+p rgb_color
+
+puts
+puts format('to_hex: %p', rgb_color.to_hex)
+puts format('to_a: %p', rgb_color.to_a)
+puts
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

data/lib/micro/struct/factory/create_struct.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Micro::Struct::Factory
+  module CreateStruct
+    extend self
+
+    def with(required_members, optional_members, features, &block)
+      struct = ::Struct.new(*(required_members + optional_members))
+
+      def_initialize(struct, required_members, optional_members)
+      def_to_ary(struct) if features[:to_ary]
+      def_to_hash(struct) if features[:to_hash]
+      def_to_proc(struct) if features[:to_proc]
+      def_readonly(struct) if features[:readonly]
+      def_instance_copy(struct) if features[:instance_copy]
+
+      struct.class_eval(&block) if block
+
+      struct
+    end
+
+    private
+
+      def def_initialize(struct, required_members, optional_members)
+        required = "#{required_members.join(':, ')}#{':' unless required_members.empty?}"
+        optional = "#{optional_members.join(': nil, ')}#{': nil' unless optional_members.empty?}"
+
+        keywords_arguments = [required, optional].reject(&:empty?).join(', ')
+        positional_arguments = (required_members + optional_members).join(', ')
+
+        # The .new() method will require all required keyword arguments.
+        # We are doing this because the Struct constructor keyword init option treats everything as optional.
+        #
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          class << self
+            undef_method :new
+
+            def new(#{keywords_arguments})                        # def new(a:, b:, c: nil) do
+              instance = allocate                                 #   instance = allocate
+              instance.send(:initialize, #{positional_arguments}) #   instance.send(:initialize, a, b, c)
+              instance                                            #   instance
+            end                                                   # end
+
+            alias __new__ new
+          end
+        RUBY
+      end
+
+      def def_to_ary(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def to_ary
+            to_a
+          end
+        RUBY
+      end
+
+      def def_to_hash(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def to_hash
+            to_h
+          end
+        RUBY
+      end
+
+      def def_readonly(struct)
+        struct.send(:private, *struct.members.map { |member| "#{member}=" })
+      end
+
+      def def_instance_copy(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def with(**members)
+            self.class.new(**to_h.merge(members))
+          end
+        RUBY
+      end
+
+      def def_to_proc(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def self.to_proc
+            ->(hash) { new(**hash) }
+          end
+        RUBY
+      end
+  end
+
+  private_constant :CreateStruct
+end

data/lib/micro/struct/factory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  class Factory
+    require_relative 'factory/create_struct'
+
+    def initialize(features)
+      @features = Features.require(features)
+    end
+
+    NormalizeMemberNames = ->(values) do
+      NormalizeNames::AsSymbols.(values, context: 'member')
+    end
+
+    def new(*members, required: nil, optional: nil, &block)
+      optional_members = NormalizeMemberNames[optional]
+      required_members = NormalizeMemberNames[members] + NormalizeMemberNames[required]
+
+      CreateStruct.with(required_members, optional_members, @features, &block)
+    end
+  end
+
+  private_constant :Factory
+end

data/lib/micro/struct/features.rb

@@ -7,8 +7,7 @@ module Micro::Struct
         to_hash: false,
         to_proc: false,
         readonly: false,
-        instance_copy: false
-      }.freeze
+        instance_copy: false }.freeze
 
     Check = ->(to_ary:, to_hash:, to_proc:, readonly:, instance_copy:) do
       { to_ary: to_ary,
@@ -18,15 +17,15 @@ module Micro::Struct
         instance_copy: instance_copy }
     end
 
-    ValidateFeatureNames = ->(values) do
-      Validate::Names.(values, label: 'feature')
+    NormalizeFeatureNames = ->(values) do
+      NormalizeNames::AsSymbols.(values, context: 'feature')
     end
 
     def self.require(names)
-      features_to_enable =
-        ValidateFeatureNames[names].each_with_object({}) { |name, memo| memo[name] = true }
+      to_enable =
+        NormalizeFeatureNames[names].each_with_object({}) { |name, memo| memo[name] = true }
 
-      Check.(**DISABLED.merge(features_to_enable))
+      Check.(**DISABLED.merge(to_enable))
     end
   end
 

data/lib/micro/struct/normalize_names.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  module NormalizeNames
+    module AsSymbols
+      REGEXP = /\A[_A-Za-z]\w*\z/.freeze
+      Invalid = ->(context, val) { raise NameError.new("invalid #{context} name: #{val}") }
+      AsSymbol = ->(context, val) { REGEXP =~ val ? val.to_sym : Invalid[context, val] }.curry
+
+      def self.call(values, context:)
+        Array(values).map(&AsSymbol[context])
+      end
+    end
+  end
+
+  private_constant :NormalizeNames
+end

data/lib/micro/struct/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Struct
-    VERSION = '0.6.0'
+    VERSION = '0.10.0'
   end
 end

data/lib/micro/struct.rb

@@ -2,22 +2,29 @@
 
 require_relative 'struct/version'
 require_relative 'struct/features'
-require_relative 'struct/creator'
-require_relative 'struct/validate'
+require_relative 'struct/factory'
+require_relative 'struct/normalize_names'
 
 module Micro
   # Like in a regular Struct, you can define one or many attributes.
-  # But all of will be required by default.
+  # But all of them will be required by default.
   #
   #   Micro::Struct.new(:first_name, :last_name, ...)
   #
-  # Use the `_optional:` arg if you want some optional attributes.
+  # Use the `optional:` arg if you want some optional attributes.
   #
-  #   Micro::Struct.new(:first_name, :last_name, _optional: :gender)
+  #   Micro::Struct.new(:first_name, :last_name, optional: :gender)
   #
-  # Using `_optional:` to define all attributes are optional.
+  # Using `optional:` to define all attributes are optional.
   #
-  #   Micro::Struct.new(_optional: [:first_name, :last_name])
+  #   Micro::Struct.new(optional: [:first_name, :last_name])
+  #
+  # Use the `required:` arg to define required attributes.
+  #
+  #   Micro::Struct.new(
+  #     required: [:first_name, :last_name],
+  #     optional: [:gender, :age]
+  #   )
   #
   # You can also pass a block to define custom methods.
   #
@@ -34,25 +41,28 @@ module Micro
   #
   # All of the possible combinations to create a Ruby Struct. ;)
   #
-  #   Micro::Struct.new(*required)
-  #   Micro::Struct.new(*required) {}
+  #   Micro::Struct.new(optional: *)
+  #   Micro::Struct.new(optional: *) {}
+  #
+  #   Micro::Struct.new(required: *)
+  #   Micro::Struct.new(required: *) {}
   #
-  #   Micro::Struct.new(_optional: *)
-  #   Micro::Struct.new(_optional: *) {}
+  #   Micro::Struct.new(*required, optional: *)
+  #   Micro::Struct.new(*required, optional: *) {}
   #
-  #   Micro::Struct.new(*required, _optional: *)
-  #   Micro::Struct.new(*required, _optional: *) {}
+  #   Micro::Struct.new(required: *, optional: *)
+  #   Micro::Struct.new(required: *, optional: *) {}
   #
   # Any options above can be used by the `.new()` method of the struct creator returned by the `.with()` method.
   #
   #   Micro::Struct.with(*features).new(...) {}
   module Struct
-    def self.new(*members, _optional: nil, &block)
-      with.new(*members, _optional: _optional, &block)
+    def self.new(*members, required: nil, optional: nil, &block)
+      with.new(*members, required: required, optional: optional, &block)
     end
 
     def self.with(*features)
-      Creator.new(features)
+      Factory.new(features)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-struct
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-04 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,12 +55,18 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/person_1.rb
+- examples/person_2.rb
+- examples/rgb/color.rb
+- examples/rgb/number.rb
+- examples/rgb_1.rb
+- examples/rgb_2.rb
+- examples/rgb_3.rb
 - lib/micro/struct.rb
-- lib/micro/struct/creator.rb
-- lib/micro/struct/creator/create_module.rb
-- lib/micro/struct/creator/create_struct.rb
+- lib/micro/struct/factory.rb
+- lib/micro/struct/factory/create_struct.rb
 - lib/micro/struct/features.rb
-- lib/micro/struct/validate.rb
+- lib/micro/struct/normalize_names.rb
 - lib/micro/struct/version.rb
 - lib/u-struct.rb
 - u-struct.gemspec
@@ -86,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.21
+rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
 summary: Create powered Ruby structs.

data/lib/micro/struct/creator/create_module.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class Micro::Struct::Creator
-  module CreateModule
-    extend self
-
-    def with(required_members, optional_members, features)
-      container = Module.new
-
-      def_initialize_and_members(container, required_members, optional_members)
-
-      def_to_proc(container) if features[:to_proc]
-
-      container
-    end
-
-    private
-
-      def def_initialize_and_members(container, required_members, optional_members)
-        required = "#{required_members.join(':, ')}#{':' unless required_members.empty?}"
-        optional = "#{optional_members.join(': nil, ')}#{': nil' unless optional_members.empty?}"
-
-        method_arguments = [required, optional].reject(&:empty?).join(', ')
-        struct_arguments = (required_members + optional_members).join(', ')
-
-        container.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          # The .new() method will require all required keyword arguments.
-          # We are doing this because the Struct constructor keyword init option treats everything as optional.
-          #
-          def self.new(#{method_arguments})        # def self.new(a:, b:) do
-            Struct.send(:new, #{struct_arguments}) #   Struct.send(:new, a, b)
-          end                                      # end
-
-          def self.members
-            Struct.members
-          end
-        RUBY
-      end
-
-      def def_to_proc(container)
-        container.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def self.to_proc
-            ->(hash) { new(**hash) }
-          end
-        RUBY
-      end
-  end
-
-  private_constant :CreateModule
-end

data/lib/micro/struct/creator/create_struct.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-class Micro::Struct::Creator
-  module CreateStruct
-    extend self
-
-    def with(required_members, optional_members, features, &block)
-      struct = ::Struct.new(*(required_members + optional_members), &block)
-      struct.send(:private_class_method, :new)
-
-      def_to_ary(struct) if features[:to_ary]
-      def_to_hash(struct) if features[:to_hash]
-      def_readonly(struct) if features[:readonly]
-      def_instance_copy(struct) if features[:readonly] || features[:instance_copy]
-
-      struct
-    end
-
-    private
-
-      def def_to_ary(struct)
-        struct.send(:alias_method, :to_ary, :to_a)
-      end
-
-      def def_to_hash(struct)
-        struct.send(:alias_method, :to_hash, :to_h)
-      end
-
-      def def_readonly(struct)
-        struct.send(:private, *struct.members.map { |member| "#{member}=" })
-      end
-
-      def def_instance_copy(struct)
-        struct.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def with(**members)
-            self.class.const_get(:Container, false).new(**to_h.merge(members))
-          end
-        RUBY
-      end
-  end
-
-  private_constant :CreateStruct
-end

data/lib/micro/struct/creator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Micro::Struct
-  class Creator
-    require_relative 'creator/create_module'
-    require_relative 'creator/create_struct'
-
-    def initialize(features)
-      @features = Features.require(features)
-    end
-
-    ValidateMemberNames = ->(values) do
-      Validate::Names.(values, label: 'member')
-    end
-
-    def new(*members, _optional: nil, &block)
-      required_members = ValidateMemberNames[members]
-      optional_members = ValidateMemberNames[_optional]
-
-      container = CreateModule.with(required_members, optional_members, @features)
-      struct = CreateStruct.with(required_members, optional_members, @features, &block)
-
-      container.const_set(:Struct, struct)
-      struct.const_set(:Container, container)
-    end
-  end
-
-  private_constant :Creator
-end

data/lib/micro/struct/validate.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Micro::Struct
-  module Validate
-    module Names
-      REGEXP = /\A[_A-Za-z]\w*\z/.freeze
-      Invalid = ->(label, val) { raise NameError.new("invalid #{label} name: #{val}") }
-      AsSymbol = ->(label, val) { REGEXP =~ val ? val.to_sym : Invalid[label, val] }.curry
-
-      def self.call(values, label:)
-        Array(values).map(&Names::AsSymbol[label])
-      end
-    end
-  end
-
-  private_constant :Validate
-end