u-struct 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 393ba5215b21bf91ef0229de920ca0980c44168fcc0e65d539a0f6b4f6a7caa2
-  data.tar.gz: e1ad5cfbd6215982aa8f6e5708d4a6f8cea0a046da9ad82568d0ed8136d58629
+  metadata.gz: 52450d53b7accc5aa4c83682dfc6557d3f5fa4d7879648c189701198548e0ace
+  data.tar.gz: 4a25f913523f7aa9e79e96e49cafd33cff2ec748dac79d0bca611cd67aa304e3
 SHA512:
-  metadata.gz: 2d86bb3a75737927e5f74d56e16c7760b8c7b9c3dce7642ebdef058122212dd21c38aec04573722842ea081995b5e03c6a094a1548bf63f1ed709762c6e5ad2c
-  data.tar.gz: 6dee9c1ab9cd6ba5675cf7c1e6cedc128e70fe45aabf52a2b1beb77fb63e9b01c1d70b0775b4393167132371923b5d56a2efed099048e0e3e594b5c199d95ab3
+  metadata.gz: 1bd5940255d259aeebbe5207a0a397bfade550bbc0e4bf719233ef18c2ba8f3fb483b96fb932fd775f7b98c35af184292b5f7392b32ebf0456888379b13c857c
+  data.tar.gz: 0ca2437cf6a48c090cc176324477b579c394b11c8c451a14a11c62a9509e5b3f6f722f1318d777e4db610cf4ab004b7f820dba169544fca0c31fb6033d03cf76

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.6.0] - 2021-12-03
+
+- To-do
+
 ## [0.5.0] - 2021-12-03
 
 - To-do

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    u-struct (0.5.0)
+    u-struct (0.6.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -22,19 +22,45 @@ 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.
+
 Micro::Struct.new(:first_name, :last_name, ...)
 
+# Use the `_optional:` arg if you want some optional attributes.
+
+Micro::Struct.new(:first_name, :last_name, _optional: :gender)
+
+# Using `_optional:` to define all attributes are optional.
+
+Micro::Struct.new(_optional: [:first_name, :last_name])
+
 # You can also pass a block to define custom methods.
+
 Micro::Struct.new(:name) {}
 
-# Available features (use one, many or all):
-#   .with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy)
+# Available features (use one, many, or all) to create Structs with a special behavior:
+# .with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy)
 
 Micro::Struct.with(:to_ary).new(:name)
 Micro::Struct.with(:to_ary, :to_hash).new(:name)
 Micro::Struct.with(:to_ary, :to_hash, :to_proc).new(:name)
+Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly).new(:name)
+Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy).new(:name)
+
+# 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, _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(...).new(...) {}
+Micro::Struct.with(*features).new(...) {}
 ```
 
 ## Development

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

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,29 @@
+# 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/features.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  module Features
+    DISABLED =
+      { to_ary: false,
+        to_hash: false,
+        to_proc: false,
+        readonly: false,
+        instance_copy: false
+      }.freeze
+
+    Check = ->(to_ary:, to_hash:, to_proc:, readonly:, instance_copy:) do
+      { to_ary: to_ary,
+        to_hash: to_hash,
+        to_proc: to_proc,
+        readonly: readonly,
+        instance_copy: instance_copy }
+    end
+
+    ValidateFeatureNames = ->(values) do
+      Validate::Names.(values, label: 'feature')
+    end
+
+    def self.require(names)
+      features_to_enable =
+        ValidateFeatureNames[names].each_with_object({}) { |name, memo| memo[name] = true }
+
+      Check.(**DISABLED.merge(features_to_enable))
+    end
+  end
+
+  private_constant :Features
+end

data/lib/micro/struct/validate.rb

@@ -0,0 +1,17 @@
+# 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

data/lib/micro/struct/version.rb

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

data/lib/micro/struct.rb

@@ -1,141 +1,58 @@
 # frozen_string_literal: true
 
 require_relative 'struct/version'
+require_relative 'struct/features'
+require_relative 'struct/creator'
+require_relative 'struct/validate'
 
 module Micro
   # Like in a regular Struct, you can define one or many attributes.
+  # But all of will be required by default.
+  #
   #   Micro::Struct.new(:first_name, :last_name, ...)
   #
+  # Use the `_optional:` arg if you want some optional attributes.
+  #
+  #   Micro::Struct.new(:first_name, :last_name, _optional: :gender)
+  #
+  # Using `_optional:` to define all attributes are optional.
+  #
+  #   Micro::Struct.new(_optional: [:first_name, :last_name])
+  #
   # You can also pass a block to define custom methods.
+  #
   #   Micro::Struct.new(:name) {}
   #
-  # Available features (use one, many or all):
+  # Available features (use one, many, or all) to create Structs with a special behavior:
   # .with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy)
   #
   #   Micro::Struct.with(:to_ary).new(:name)
   #   Micro::Struct.with(:to_ary, :to_hash).new(:name)
   #   Micro::Struct.with(:to_ary, :to_hash, :to_proc).new(:name)
+  #   Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly).new(:name)
+  #   Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy).new(:name)
+  #
+  # 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.with(...).new(...) {}
+  #   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
-    class Creator
-      module Features
-        DISABLED =
-          { to_ary: false,
-            to_hash: false,
-            to_proc: false,
-            readonly: false,
-            instance_copy: false
-          }.freeze
-
-        Expose = ->(to_ary:, to_hash:, to_proc:, readonly:, instance_copy:) do
-          { to_ary: to_ary,
-            to_hash: to_hash,
-            to_proc: to_proc,
-            readonly: readonly,
-            instance_copy: instance_copy }
-        end
-
-        def self.check(names)
-          features_to_enable =
-            Array(names).each_with_object({}) { |name, memo| memo[name] = true }
-
-          Expose.(**DISABLED.merge(features_to_enable))
-        end
-      end
-
-      def initialize(features)
-        @features = Features.check(features)
-      end
-
-      def new(*members, &block)
-        def_container do |container|
-          def_struct(container, members, block) do |struct|
-            def_initialize(container, struct)
-
-            def_to_ary(struct)
-            def_to_hash(struct)
-            def_readonly(struct)
-            def_instance_copy(struct)
-          end
-
-          def_to_proc(container)
-        end
-      end
-
-      private
-
-      def def_container(&block)
-        Module.new.tap(&block)
-      end
-
-      def def_struct(container, members, block)
-        struct = ::Struct.new(*members, &block)
-        struct.const_set(:Container, container)
-        struct.send(:private_class_method, :new)
-
-        container.const_set(:Struct, struct)
-
-        yield struct
-      end
-
-      def def_initialize(container, struct)
-        # The .new() method will require all of the Struct's keyword arguments.
-        # We are doing this because Struct's keyword_init option doesn't do that.
-        container.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)    #
-          def self.new(#{struct.members.join(':, ')}:)      # def self.new(a:, b:) do
-            Struct.send(:new, #{struct.members.join(', ')}) #   Struct.send(:new, a, b)
-          end                                               # end
-
-          def self.members
-            Struct.members
-          end
-        RUBY
-      end
-
-      def def_to_ary(struct)
-        struct.send(:alias_method, :to_ary, :to_a) if @features[:to_ary]
-      end
-
-      def def_to_hash(struct)
-        struct.send(:alias_method, :to_hash, :to_h) if @features[:to_hash]
-      end
-
-      def def_readonly(struct)
-        return unless @features[:readonly]
-
-        struct.send(:private, *struct.members.map { |member| "#{member}=" })
-      end
-
-      def def_instance_copy(struct)
-        return unless (@features[:readonly] || @features[:instance_copy])
-
-        struct.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def with(**members)
-            self.class.const_get(:Container, false).new(**to_h.merge(members))
-          end
-        RUBY
-      end
-
-      def def_to_proc(container)
-        return unless @features[:to_proc]
-
-        container.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def self.to_proc
-            ->(hash) { new(**hash) }
-          end
-        RUBY
-      end
-    end
-
-    def self.new(*members, &block)
-      with.new(*members, &block)
+    def self.new(*members, _optional: nil, &block)
+      with.new(*members, _optional: _optional, &block)
     end
 
     def self.with(*features)
       Creator.new(features)
     end
-
-    private_constant :Creator
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-struct
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-03 00:00:00.000000000 Z
+date: 2021-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,6 +56,11 @@ files:
 - bin/console
 - bin/setup
 - 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/features.rb
+- lib/micro/struct/validate.rb
 - lib/micro/struct/version.rb
 - lib/u-struct.rb
 - u-struct.gemspec