u-struct 0.3.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39ecf73c68816127a9919b2ba6fcfc99c4dec9d10e37a15bbcc8ebee881b468c
-  data.tar.gz: afe359b57dd0561e93309107c1c2bbad3521a70b9fada6dddef02b3d28820bb6
+  metadata.gz: f4b40b69da026b0f45f5514a8d340effc8f7d81489c4f1217237c16641186357
+  data.tar.gz: 6a5cd7b12d2d1b16830a805b9904e5c212c685d5a32108439e8f9f2b8235dfb8
 SHA512:
-  metadata.gz: cb2708d1a4eabab4da1e1832153babae1f756fbd869e9053de7d62a2f829bfe30ec0c50df66f1cf9139e58d1e65f749d1a12b01b19addf904748fe1f6d7997e3
-  data.tar.gz: ad4276c480a8e2225c81ea1a9b02fa53fd9bce94d9a3279d94a7d20dc329cc87921c8869a5fd727dc28db2a0e9489273b6a9f37ebf8b304222a67d366a347fea
+  metadata.gz: 159075d6944696849893dd4f4860613b104b12f3e872c0cac65df62055af61309d9f9256a949693a01df7fb5b514e916755bf0f6f1295874d93b9bc1abb2a2b3
+  data.tar.gz: 12db20998fcd5b1688e4786766630cee699daffacfca72d18e3e769ac387931dd310a46ff511862c7d9d9f2a458ae8667dd3e7623dbfca55802caa41fd3cfbb8

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## [Unreleased]
 
+## [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,13 +1,20 @@
 PATH
   remote: .
   specs:
-    u-struct (0.3.1)
+    u-struct (0.7.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
   x86_64-darwin-19
@@ -16,7 +23,8 @@ 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 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,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
+
+    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,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
+
+    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.3.1'
+    VERSION = '0.7.0'
   end
 end

data/lib/micro/struct.rb

@@ -1,32 +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
+  # 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])
+  #
+  # 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
-    def self.new(*keys, &block)
-      struct = ::Struct.new(*keys, &block)
-
-      struct.send(:private_class_method, :new)
-      struct.send(:alias_method, :to_ary, :to_a)
-      struct.send(:alias_method, :to_hash, :to_h)
-
-      mod = Module.new
-      mod.const_set(:Struct, 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.to_proc
-          ->(hash) { new(**hash) }
-        end
-      RUBY
+    def self.new(*members, required: nil, optional: nil, &block)
+      with.new(*members, required: required, optional: optional, &block)
+    end
 
-      mod
+    def self.with(*features)
+      Creator.new(features)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-struct
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-02 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/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.17
+rubygems_version: 3.2.21
 signing_key:
 specification_version: 4
 summary: Create powered Ruby structs.