u-struct 0.4.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ebbd60464f2e2d2efd428b0091d68820ef2b5d1a4bc73bed1a474d22f2f0fac
-  data.tar.gz: 1965a2b7bd8da50c6c5c31acff5c950590146c060ced14e732d3a5b646dafd8f
+  metadata.gz: bebaeb99b56b26288a87f8907532e194a4388563a11ed486c90d203c34d9e951
+  data.tar.gz: 66d1f615dcaa99c713d24b7ea375f00293396fe91d2314be223a487cfa90caa8
 SHA512:
-  metadata.gz: b7274b8401d134cc21408447b87a54472f5f5cdea5263c3ca24e1a4feab6c0104deea8ff1985edb49a3e58d6e91e27f52b908d6fa2974b26ed6472916ebc4cb9
-  data.tar.gz: 62238f702e13aaa61d13bcb6213819d79b67e373b3f768cf0675526baa7bf73aa7d1e6c8130d84072f8a6a124923de28318b34b2a44ae17b0de573513c557acf
+  metadata.gz: 4131a340a7a5981a60a177a2a1c59846f12693053eb80cd77e289e83a3602e10df31b694c8bb8a0fbb9a8d60886ce4b0e27424cce27a1ae2e513570d981c0c67
+  data.tar.gz: 2ed2f7a1a80265ace687639e575f5395f3cb1c663ac0c4b5dc044a52a2ba321540942523a6a7f0b9377df6d2a4569e029b35a8f1345e861ab23cd0f5cd0d885b

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 ## [Unreleased]
 
+## [0.8.0] - 2021-12-05
+
+- To-do
+
+## [0.7.0] - 2021-12-04
+
+- To-do
+
+## [0.6.0] - 2021-12-03
+
+- To-do
+
+## [0.5.0] - 2021-12-03
+
+- To-do
+
+## [0.4.0] - 2021-12-03
+
+- To-do
+
+## [0.3.1] - 2021-12-02
+
+- To-do
+
+## [0.3.0] - 2021-12-02
+
+- To-do
+
+## [0.2.0] - 2021-12-02
+
+- To-do
+
 ## [0.1.0] - 2021-12-02
 
 - Initial release

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,22 +1,31 @@
 PATH
   remote: .
   specs:
-    u-struct (0.4.0)
+    u-struct (0.8.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
-   2.2.26
+   2.2.32

data/README.md

@@ -1,8 +1,6 @@
 # Micro::Struct
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/micro/struct`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Create powered Ruby structs.
 
 ## Installation
 
@@ -22,7 +20,61 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+# Like in a regular Struct, you can define one or many attributes.
+# 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.
+
+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])
+
+# 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.
+
+Micro::Struct.new(:name) {}
+
+# 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: *)
+Micro::Struct.new(required: *) {}
+
+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(...) {}
+```
 
 ## Development
 

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Micro::Struct::Creator
+  module CreateModule
+    extend self
+
+    def with(required_members, optional_members, features)
+      container = Module.new
+
+      def_initialize(container, required_members, optional_members)
+      def_triple_eq(container)
+      def_members(container)
+      def_to_proc(container, features)
+
+      container
+    end
+
+    private
+
+      def def_initialize(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(', ')
+
+        # The .new() method will require all required keyword arguments.
+        # We are doing this because the Struct constructor keyword init option treats everything as optional.
+        #
+        container.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def self.new(#{method_arguments})        # def self.new(a:, b:) do
+          Struct.send(:new, #{struct_arguments}) #   Struct.send(:new, a, b)
+        end                                      # end
+        RUBY
+      end
+
+      def def_triple_eq(container)
+        container.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def self.===(other)
+          Struct === other
+        end
+        RUBY
+      end
+
+      def def_members(container)
+        container.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def self.members
+          Struct.members
+        end
+        RUBY
+      end
+
+      def def_to_proc(container, features)
+        return unless features[:to_proc]
+
+        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
+
+    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]
+
+      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,33 @@
+# 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
+
+    NormalizeFeatureNames = ->(values) do
+      NormalizeNames::AsSymbols.(values, context: 'feature')
+    end
+
+    def self.require(names)
+      to_enable =
+        NormalizeFeatureNames[names].each_with_object({}) { |name, memo| memo[name] = true }
+
+      Check.(**DISABLED.merge(to_enable))
+    end
+  end
+
+  private_constant :Features
+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.4.0'
+    VERSION = '0.8.0'
   end
 end

data/lib/micro/struct.rb

@@ -1,112 +1,68 @@
 # frozen_string_literal: true
 
 require_relative 'struct/version'
+require_relative 'struct/features'
+require_relative 'struct/creator'
+require_relative 'struct/normalize_names'
 
 module Micro
-  # Micro::Struct.new(:first_name, :last_name, ...)
+  # Like in a regular Struct, you can define one or many attributes.
+  # But all of them will be required by default.
   #
-  # Micro::Struct.with(:to_ary).new(:name) # or .with(:to_hash), .with(:to_proc)
+  #   Micro::Struct.new(:first_name, :last_name, ...)
   #
-  # Micro::Struct.with(:to_ary, :to_hash).new(:name)
+  # Use the `optional:` arg if you want some optional attributes.
   #
-  # Micro::Struct.with(:to_ary, :to_hash, :to_proc).new(:name)
+  #   Micro::Struct.new(:first_name, :last_name, optional: :gender)
   #
-  # Micro::Struct.new(:name) {}
+  # Using `optional:` to define all attributes are optional.
   #
-  # Micro::Struct.with(...).new(: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.
+  #
+  #   Micro::Struct.new(:name) {}
+  #
+  # 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(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: *) {}
+  #
+  # 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 }.freeze
-
-        Expose = ->(to_ary:, to_hash:, to_proc:) do
-          { to_ary: to_ary,
-            to_hash: to_hash,
-            to_proc: to_proc }
-        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_module do |mod|
-          def_struct(mod, members, block) do |struct|
-            def_initialize(mod, struct)
-            def_to_ary(struct)
-            def_to_hash(struct)
-            def_to_proc(mod)
-          end
-        end
-      end
-
-      private
-
-      def def_module(&block)
-        Module.new.tap(&block)
-      end
-
-      def def_struct(mod, members, block)
-        struct = ::Struct.new(*members, &block)
-        struct.send(:private_class_method, :new)
-
-        mod.const_set(:Struct, struct)
-
-        yield struct
-      end
-
-      def def_initialize(mod, 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.
-        mod.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_to_proc(mod)
-        return unless @features[:to_proc]
-
-        mod.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, required: nil, optional: nil, &block)
+      with.new(*members, required: required, 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.4.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-03 00:00:00.000000000 Z
+date: 2021-12-05 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/normalize_names.rb
 - lib/micro/struct/version.rb
 - lib/u-struct.rb
 - u-struct.gemspec
@@ -81,7 +86,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.