u-struct 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0150b18cb61a38d042a0ad2f22c9588c7269c8362a708a8ebf156cc927a312dd
-  data.tar.gz: 0fc97adb461433c7382ee524d3a58c4d134624013c4afa974cade30b46f09109
+  metadata.gz: 7788d4a3412a447721c8d375a1844b9f000816ade2780925835e2a6ca222329c
+  data.tar.gz: 938d1c98f2f495aeca842a29a352e62a5f6565e96d7aed9ad01f27e8cadd08a8
 SHA512:
-  metadata.gz: 708cbec302ef69ec3d6f465ebca2d07eff62ff1a3746b4e7034b21a571e693b27b9e4dad1ada934f4ac37f2565212cc83f111d384eb84573209578aab77beac6
-  data.tar.gz: cec5b4750bcc98d9955fbe27bcca952b2139c36dd90d6f6c98fd3b107f9ef577fdb2e72f34c78871e15d608cdab06c034427efeab67caa5bc2c869bbaeee8026
+  metadata.gz: a9c449b61842f114a0d90ce5b8c69d07c33599727cfb26e15a9d1455f79f7cd308d15b3d7d85f508a30c8b6717bf182b5a00dd960fb814d9cc648823fc882f01
+  data.tar.gz: b201b72d06fde813dfca89ff231a742c1d6fba92883133c4f12419e924830238c507d85f6d8e2e06c303033d3812df42e147acabe7742d5bfbc360163c739d34

data/CHANGELOG.md

@@ -1,45 +1,496 @@
+# Changelog <!-- omit in toc -->
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+- [[Unreleased]](#unreleased)
+- [[0.12.0] - 2021-12-22](#0120---2021-12-22)
+  - [Added](#added)
+- [[0.11.0] - 2021-12-19](#0110---2021-12-19)
+  - [Added](#added-1)
+- [[0.10.0] - 2021-12-15](#0100---2021-12-15)
+  - [Changed](#changed)
+- [[0.9.0] - 2021-12-14](#090---2021-12-14)
+  - [Added](#added-2)
+  - [Changed](#changed-1)
+- [[0.8.0] - 2021-12-05](#080---2021-12-05)
+  - [Added](#added-3)
+- [[0.7.0] - 2021-12-04](#070---2021-12-04)
+  - [Added](#added-4)
+  - [Changed](#changed-2)
+- [[0.6.0] - 2021-12-03](#060---2021-12-03)
+  - [Added](#added-5)
+- [[0.5.0] - 2021-12-02](#050---2021-12-02)
+  - [Added](#added-6)
+- [[0.4.0] - 2021-12-02](#040---2021-12-02)
+  - [Added](#added-7)
+- [[0.3.1] - 2021-12-02](#031---2021-12-02)
+  - [Fixed](#fixed)
+- [[0.3.0] - 2021-12-02](#030---2021-12-02)
+  - [Added](#added-8)
+- [[0.2.0] - 2021-12-02](#020---2021-12-02)
+  - [Added](#added-9)
+- [[0.1.0] - 2021-12-02](#010---2021-12-02)
+  - [Added](#added-10)
+
 ## [Unreleased]
 
+[⬆️ &nbsp;Back to Top](#changelog-)
+
+## [0.12.0] - 2021-12-22
+
+### Added 
+
+- Add `Micro::Struct.instance` to create a struct instance from a given hash. 
+  This could be useful to create constants or a singleton value.
+
+  ```ruby
+  person1 = Micro::Struct.instance(first_name: 'Rodrigo', last_name: 'Serradura')
+  # => #<struct  first_name="Rodrigo", last_name="Serradura">
+
+  person1.first_name = 'John'
+
+  person1.first_name # => "John" 
+  ```
+
+  You can use the instance method after defining some struct feature.
+
+  ```ruby
+  person2 = Micro::Struct.with(:readonly).instance(first_name: 'Rodrigo', last_name: 'Serradura')
+  # => #<struct  first_name="Rodrigo", last_name="Serradura">
+
+  person2.first_name = 'John'
+  # NoMethodError (private method `first_name=' called for #<struct first_name="Rodrigo", last_name="Serradura">)
+  ```
+  You can use pass a block to define some custom behavior to the struct instance.
+
+  ```ruby
+  person3 = Micro::Struct.instance(first_name: 'Rodrigo', last_name: 'Serradura') do
+    def name
+      "#{first_name} #{last_name}"
+    end
+  end
+
+  person4 = Micro::Struct.with(:readonly).instance(first_name: 'Rodrigo', last_name: 'Serradura') do
+    def name
+      "#{first_name} #{last_name}"
+    end
+  end
+
+  person3.name # => "Rodrigo Serradura"
+  person4.name # => "Rodrigo Serradura"
+  ```
+
+- Add `Micro::Struct.with(:exposed_features)` to expose the struct's configured features. 
+  Via the methods: `.features` and `.__features__`.
+
+```ruby
+Person = Micro::Struct.with(:exposed_features, :readonly, :to_proc).new(:name)
+
+Person.features
+# => #<struct Micro::Struct::Features::Exposed
+#      names=[:readonly, :to_proc],
+#      options={:to_ary=>false, :to_hash=>false, :to_proc=>true, :readonly=>true, :instance_copy=>false}>
+
+Person.__features__.equal?(Person.features) # `.__features__` is an alias of `.features` method
+
+Person.features.names   # => [:readonly, :to_proc]
+Person.features.options # => {:to_ary=>false, :to_hash=>false, :to_proc=>true, :readonly=>true, :instance_copy=>false}
+
+Person.features.option?(:to_proc)  # => true
+Person.features.option?(:readonly) # => true
+
+Person.features.options?(:to_proc)  # => true
+Person.features.options?(:readonly) # => true
+
+Person.features.options?(:to_proc, :readonly) # => true
+Person.features.options?(:to_ary, :readonly)  # => false
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
+## [0.11.0] - 2021-12-19
+
+### Added 
+
+- Reduce the required Ruby version to `>= 2.2.0`.
+- Set up a CI with Github actions.
+- Test the codebase against the Ruby versions: `2.2`, `2.3`, `2.4`, `2.5`, `2.6`, `2.7`, `3.0` and `3.1.0-preview1`.
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
 ## [0.10.0] - 2021-12-15
 
-- To-do
+### Changed
+
+- Make `Micro::Struct.new` return a Ruby struct instead of a module.
+
+```ruby
+module RGB
+  Number = ::Struct.new(:value) { def to_s; '%02x' % value; end }
+
+  Color = Micro::Struct.new(:red, :green, :blue) do
+    def self.new(r, g, b)
+      __new__(
+        red: Number.new(r),
+        green: Number.new(g),
+        blue: Number.new(b),
+      )
+    end
+
+    def to_hex
+      "##{red}#{green}#{blue}"
+    end
+  end
+end
+
+rgb_color = RGB::Color.new(1,5,255)
+# => #<struct RGB::Color red=#<struct RGB::Number value=1>, green=#<struct RGB::Number value=5>, blue=#<struct RGB::Number value=255>>
+
+rgb_color.to_hex
+# => "#0105ff"
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.9.0] - 2021-12-14
 
-- To-do
+### Added
+
+- Add `__new__` method and make `.new` its alias. You can use `__new__` when overwriting the module's `new`.
+
+```ruby
+module RGB
+  Number = ::Struct.new(:value) { def to_s; '%02x' % value; end }
+
+  Color = Micro::Struct.new(:red, :green, :blue) do
+    def to_hex
+      "##{red}#{green}#{blue}"
+    end
+  end
+
+  module Color
+    def self.new(r, g, b)
+      __new__(
+        red: Number.new(r),
+        green: Number.new(g),
+        blue: Number.new(b),
+      )
+    end
+  end
+end
+
+rgb_color = RGB::Color.new(1,5,255)
+# => #<struct RGB::Color::Struct red=#<struct RGB::Number value=1>, green=#<struct RGB::Number value=5>, blue=#<struct RGB::Number value=255>>
+
+rgb_color.to_hex
+# => "#0105ff"
+```
+
+### Changed
+
+- Change `:readonly` feature, now it doesn't require the `:instance_copy` by default.
+  So, If you want both features, you will need to declare them together.
+
+```ruby
+Person = Micro::Struct.with(:readonly).new(:name)
+Persona = Micro::Struct.with(:readonly, :instance_copy).new(:name)
+
+person = Person.new(name: 'Rodrigo')
+persona = Persona.new(name: 'Serradura')
+
+person.respond_to?(:name=)  # false
+persona.respond_to?(:name=) # false
+
+person.respond_to?(:with)  # false
+persona.respond_to?(:with) # true
+```
+
+- Change `:to_ary` to invoke the `#to_a` method instead of defining it as an alias.
+- Change `:to_hash` to invoke the `#to_h` method instead of defining it as an alias.
+
+```ruby
+module RGB
+  Number = ::Struct.new(:value) { def to_s; '%02x' % value; end }
+
+  Color = Micro::Struct.with(:readonly, :to_ary, :to_hash).new(:red, :green, :blue) do
+    def initialize(r, g, b)
+      super(Number.new(r), Number.new(g), Number.new(b))
+    end
+
+    def to_hex
+      "##{red}#{green}#{blue}"
+    end
+
+    def to_a
+      [red, green, blue].map(&:value)
+    end
+
+    def to_h
+      { r: red.value, g: green.value, b: blue.value }
+    end
+  end
+end
+
+rgb_color = RGB::Color.new(red: 1, green: 5, blue: 255)
+#  => #<struct RGB::Color::Struct red=#<struct RGB::Number value=1>, green=#<struct RGB::Number value=5>, blue=#<struct RGB::Number value=255>>
+
+rgb_color.to_hex  # => "#0105ff"
+rgb_color.to_ary  # => [1, 5, 255]
+rgb_color.to_hash # => {:r=>1, :g=>5, :b=>255}
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.8.0] - 2021-12-05
 
-- To-do
+### Added
+
+- Add `.===` to the module, it delegates the calling to its struct.
+
+```ruby
+Person = Micro::Struct.new(:name)
+
+person = Person.new(name: 'Rodrigo Serradura')
+# => #<struct Person::Struct name="Rodrigo Serradura">
+
+Person === person
+# => true
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.7.0] - 2021-12-04
 
-- To-do
+### Added
+
+- Add `required:` option to define required struct members.
+
+```ruby
+# All of the alternatives have the same equivalence.
+
+Person = Micro::Struct.new(:first_name, :last_name)
+
+Person = Micro::Struct.new(required: [:first_name, :last_name])
+
+Person = Micro::Struct.new(:first_name, required: :last_name)
+```
+
+### Changed
+
+- Remove the `_` from the `optional:` option.
+
+```ruby
+Person = Micro::Struct.new(
+  required: [:first_name, :last_name],
+  optional: :age
+)
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.6.0] - 2021-12-03
 
-- To-do
+### Added
+
+- Add the capability to create a struct with optional members.
+
+```ruby
+Person = Micro::Struct.new(:first_name, _optional: :last_name)
+
+Person.new
+# ArgumentError (missing keyword: :first_name)
+
+Person.new(first_name: 'Rodrigo')
+# => #<struct Person::Struct first_name="Rodrigo", last_name=nil>
+
+# --
+
+Persona = Micro::Struct.new(_optional: [:first_name, :last_name])
+
+Persona.new
+# => #<struct Persona::Struct first_name=nil, last_name=nil>
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
+## [0.5.0] - 2021-12-02
+
+### Added
+
+- Add new feature `:instance_copy`. It instantiates a struct of the same kind from its current state.
+
+```ruby
+Person = Micro::Struct.with(:instance_copy).new(:first_name, :last_name)
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+# => #<struct Person::Struct first_name="Rodrigo", last_name="Serradura">
+
+person.first_name = 'John'
+# => "John"
+
+person.inspect
+# => #<struct Person::Struct first_name="John", last_name="Serradura">
+
+new_person = person.with(last_name: 'Doe')
+# => #<struct Person::Struct first_name="John", last_name="Doe">
+
+person === new_person     # => false
+person.equal?(new_person) # => false
+
+person.last_name     # => "Serradura"
+new_person.last_name # => "Doe"
+```
+
+- Add new feature `:readonly`. It sets members' writers private and requires the `:instance_copy` feature.
+
+```ruby
+Person = Micro::Struct.with(:readonly).new(:name)
+
+person = Person.new(name: 'Rodrigo Serradura')
+# => #<struct Person::Struct name="Rodrigo Serradura">
+
+person.name = 'John Doe'
+# NoMethodError (private method `name=' called for #<struct Person::Struct name="Rodrigo Serradura">)
+
+new_person = person.with(name: 'John Doe')
+# => #<struct Person::Struct name="John Doe">
+
+person === new_person     # => false
+person.equal?(new_person) # => false
+
+person.name     # => "Rodrigo Serradura"
+new_person.name # => "John Doe"
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
+## [0.4.0] - 2021-12-02
+
+### Added
 
-## [0.5.0] - 2021-12-03
+- Add `.members` to the module, it delegates the calling to its struct.
 
-- To-do
+```ruby
+Person = Micro::Struct.new(:first_name, :last_name)
 
-## [0.4.0] - 2021-12-03
+Person.members # => [:first_name, :last_name]
+```
 
-- To-do
+- Add `Micro::Struct.with()` to enable or disable the creation of structs with custom features.
+  So now, you can create the structs with one, some, or all features. They are: `to_ary`, `to_hash`, `to_proc`.
+
+```ruby
+Person = Micro::Struct.with(:to_ary).new(:name)
+
+person = Person.new(name: 'Rodrigo')
+# => #<struct Person::Struct name="Rodrigo">
+
+person.respond_to?(:to_ary)  # => true
+person.respond_to?(:to_hash) # => false
+
+Person.respond_to?(:to_proc) # => false
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.3.1] - 2021-12-02
 
-- To-do
+### Fixed
+
+- Fix the spec.files config of `u-struct.gemspec`.
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.3.0] - 2021-12-02
 
-- To-do
+### Added
+
+- Add `lib/u-struct.rb` to allow the bundler to require the gem in an automatic way.
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.2.0] - 2021-12-02
 
-- To-do
+### Added
+
+- Add `to_hash` as an alias of Struct's `to_h`.
+
+```ruby
+Person = Micro::Struct.new(:first_name, :last_name)
+
+def print_first_and_last_name(first_name:, last_name:)
+  puts "#{first_name} #{last_name}"
+end
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+
+print_first_and_last_name(**person) # Rodrigo Serradura
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
 
 ## [0.1.0] - 2021-12-02
 
-- Initial release
+### Added
+
+- Create a module containing a Ruby struct with some custom features.
+  - The module's `.new` method receives the struct arguments as keyword arguments.
+  - The module's `.new` can receive a block as a regular `Struct` to add some custom behavior.
+  - The module's `to_proc` can instantiate the struct by receiving a hash.
+  - The module's struct has its initializer set up as private.
+  - Add `to_ary` as an alias of module's struct `to_a`.
+
+```ruby
+Person = Micro::Struct.new(:first_name, :last_name) do
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+# == Module's .new ==
+
+Person.new
+# ArgumentError (missing keywords: :first_name, :last_name)
+
+Person.new(first_name: 'Rodrigo')
+# ArgumentError (missing keyword: :last_name)
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+# => #<struct Person::Struct first_name="Rodrigo", last_name="Serradura">
+
+# == Struct's block - it sets up custom behavior ==
+
+person.name # => "Rodrigo Serradura"
+
+# == Struct's #to_ary ==
+
+first_name, last_name = person
+
+p first_name # => "Rodrigo"
+p last_name  # => "Serradura"
+
+*first_and_last_name = person
+
+p first_and_last_name # => ["Rodrigo", "Serradura"]
+
+# == Module's .to_proc ==
+
+[
+  {first_name: 'John', last_name: 'Doe'},
+  {first_name: 'Mary', last_name: 'Doe'}
+].map(&Person)
+# => [
+#  #<struct Person::Struct first_name="John", last_name="Doe">,
+#  #<struct Person::Struct first_name="Mary", last_name="Doe">
+# ]
+
+# == Struct's private initializer ==
+
+Person::Struct.new
+# => NoMethodError (private method `new' called for Person::Struct:Class)
+```
+
+[⬆️ &nbsp;Back to Top](#changelog-)

data/README.md

@@ -64,13 +64,14 @@ Micro::Struct.new(
 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)
+# .with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy, :exposed_features)
 
 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)
+Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy, :exposed_features).new(:name)
 
 # All of the possible combinations to create a Ruby Struct. ;)
 

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

@@ -1,88 +1,107 @@
 # frozen_string_literal: true
 
-class Micro::Struct::Factory
-  module CreateStruct
-    extend self
+module Micro::Struct
+  class Factory
+    module CreateStruct
+      extend self
 
-    def with(members, block, features)
-      struct = ::Struct.new(*members.required_and_optional)
+      def with(members, block, features)
+        struct = ::Struct.new(*members.required_and_optional)
 
-      ClassScope.def_new(struct, members)
-      ClassScope.def_to_proc(struct)         if features[:to_proc]
-      ClassScope.def_private_writers(struct) if features[:readonly]
+        ClassScope.def_new(struct, members)
+      
+        ClassScope.def_features(struct, features) if features.is_a?(Features::Exposed)
+        ClassScope.def_to_proc(struct)            if features.option?(:to_proc)
+        ClassScope.def_private_writers(struct)    if features.option?(:readonly)
 
-      InstanceScope.def_with(struct)    if features[:instance_copy]
-      InstanceScope.def_to_ary(struct)  if features[:to_ary]
-      InstanceScope.def_to_hash(struct) if features[:to_hash]
+        InstanceScope.def_with(struct)    if features.option?(:instance_copy)
+        InstanceScope.def_to_ary(struct)  if features.option?(:to_ary)
+        InstanceScope.def_to_hash(struct) if features.option?(:to_hash)
 
-      ClassScope.evaluate(struct, block)
+        ClassScope.evaluate(struct, block)
 
-      struct
-    end
-
-    module ClassScope
-      def self.def_new(struct, members)
-        # 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(#{members.to_eval.keyword_args})                         # def new(a:, b:, c: nil) do
-              instance = allocate                                            #   instance = allocate
-              instance.send(:initialize, #{members.to_eval.positional_args}) #   instance.send(:initialize, a, b, c)
-              instance                                                       #   instance
-            end                                                              # end
-
-            alias __new__ new
-          end
-        RUBY
-      end
-
-      def self.def_to_proc(struct)
-        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.to_proc
-            ->(hash) { new(**hash) }
-          end
-        RUBY
+        struct
       end
 
-      def self.def_private_writers(struct)
-        struct.send(:private, *struct.members.map { |member| "#{member}=" })
+      module ClassScope
+        def self.def_new(struct, members)
+          # 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(#{members.to_eval.keyword_args})                         # def new(a:, b:, c: nil) do
+                instance = allocate                                            #   instance = allocate
+                instance.send(:initialize, #{members.to_eval.positional_args}) #   instance.send(:initialize, a, b, c)
+                instance                                                       #   instance
+              end                                                              # end
+
+              alias __new__ new
+            end
+          RUBY
+        end
+
+        def self.def_features(struct, features)
+          struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            class << self
+              attr_accessor :__features__
+
+              alias features __features__
+            end
+          RUBY
+
+          struct.__features__ = features
+
+          struct.send(:private_class_method, :__features__=)
+        end
+
+        def self.def_to_proc(struct)
+          struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def self.to_proc
+              ->(hash) { new(**hash) }
+            end
+          RUBY
+        end
+
+        def self.def_private_writers(struct)
+          struct.send(:private, :[]=)
+          struct.send(:private, *struct.members.map { |member| "#{member}=" })
+        end
+
+        def self.evaluate(struct, block)
+          struct.class_eval(&block) if block
+        end
       end
 
-      def self.evaluate(struct, block)
-        struct.class_eval(&block) if block
+      module InstanceScope
+        def self.def_to_ary(struct)
+          struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def to_ary
+              to_a
+            end
+          RUBY
+        end
+
+        def self.def_to_hash(struct)
+          struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def to_hash
+              to_h
+            end
+          RUBY
+        end
+
+        def self.def_with(struct)
+          struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def with(**members)
+              self.class.new(**to_h.merge(members))
+            end
+          RUBY
+        end
       end
     end
 
-    module InstanceScope
-      def self.def_to_ary(struct)
-        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def to_ary
-            to_a
-          end
-        RUBY
-      end
-
-      def self.def_to_hash(struct)
-        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def to_hash
-            to_h
-          end
-        RUBY
-      end
-
-      def self.def_with(struct)
-        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def with(**members)
-            self.class.new(**to_h.merge(members))
-          end
-        RUBY
-      end
-    end
+    private_constant :CreateStruct
   end
-
-  private_constant :CreateStruct
 end

data/lib/micro/struct/factory.rb

@@ -6,7 +6,7 @@ module Micro::Struct
     require_relative 'factory/create_struct'
 
     def initialize(features)
-      @features = Features.require(features)
+      @features = Features.config(features)
     end
 
     def new(*required_members, required: nil, optional: nil, &struct_block)
@@ -14,6 +14,10 @@ module Micro::Struct
 
       CreateStruct.with(members, struct_block, @features)
     end
+
+    def instance(**members, &block)
+      new(*members.keys, &block).new(**members)
+    end
   end
 
   private_constant :Factory

data/lib/micro/struct/features.rb

@@ -2,29 +2,53 @@
 
 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
-
     Names = ->(values) do
       NormalizeNames::AsSymbols.(values, context: 'feature')
     end
 
-    def self.require(values)
-      to_enable = Names[values].each_with_object({}) { |name, memo| memo[name] = true }
+    module Options
+      def self.check(to_ary:, to_hash:, to_proc:, readonly:, instance_copy:, exposed_features:)
+        { to_ary: to_ary,
+          to_hash: to_hash,
+          to_proc: to_proc, 
+          readonly: readonly,
+          instance_copy: instance_copy,
+          exposed_features: exposed_features }
+      end
+
+      With = ->(bool, names) { names.each_with_object({}) { |name, memo| memo[name] = bool } }
+
+      DISABLED = With.(false, method(:check).parameters.map(&:last)).freeze
+
+      def self.from_names(values)
+        enabled = With.(true, values)
+
+        check(**DISABLED.merge(enabled))
+      end
+    end
+
+    Config = ::Struct.new(:names, :options) do
+      def option?(name)
+        options.fetch(name)
+      end
+      
+      def options?(*names)
+        names.all? { |name| option?(name) }
+      end
+    end
+
+    Exposed = Class.new(Config)
+
+    def self.config(values)
+      names = Names[values]
+      options = Options.from_names(names)
+
+      return Config.new(names, options) unless options[:exposed_features]
+
+      names.delete(:exposed_features)
+      options.delete(:exposed_features)
 
-      Check.(**DISABLED.merge(to_enable))
+      Exposed.new(names.freeze, options.freeze).freeze
     end
   end
 

data/lib/micro/struct/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Struct
-    VERSION = '0.11.0'
+    VERSION = '0.12.0'
   end
 end

data/lib/micro/struct.rb

@@ -31,13 +31,14 @@ module Micro
   #   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)
+  # .with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy, :exposed_features)
   #
   #   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)
+  #   Micro::Struct.with(:to_ary, :to_hash, :to_proc, :readonly, :instance_copy, :exposed_features).new(:name)
   #
   # All of the possible combinations to create a Ruby Struct. ;)
   #
@@ -64,5 +65,9 @@ module Micro
     def self.with(*features)
       Factory.new(features)
     end
+
+    def self.instance(**members, &block)
+      with.instance(**members, &block)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-struct
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-19 00:00:00.000000000 Z
+date: 2021-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler