u-struct 0.9.0 → 1.0.0

data/examples/rgb/color.rb

@@ -2,22 +2,20 @@
 
 module RGB
   Color = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
-    def to_a
-      super.map(&:value)
+    def initialize(r, g, b)
+      super(
+        Number.new(value: r, label: 'red'),
+        Number.new(value: g, label: 'green'),
+        Number.new(value: b, label: 'blue')
+      )
     end
 
-    def to_hex
-      "##{red}#{green}#{blue}"
+    def to_a
+      @to_a ||= super.map(&:value)
     end
-  end
 
-  module Color
-    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')
-      )
+    def to_hex
+      @to_hex ||= "##{red}#{green}#{blue}"
     end
   end
 end

data/examples/rgb/number.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 module RGB
-  Number = Micro::Struct.with(:readonly).new(:value) do
-    def to_s
-      value.to_s(16)
-    end
-  end
-
-  module Number
+  Number = Micro::Struct.with(:readonly).new(:value, :label) 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])
+    def initialize(value, label)
+      super(Input[value, label: label])
+    end
+
+    def to_s
+      @to_s ||= '%02x' % value
+    end
+
+    def inspect
+      "#<RGB::Number #{value}>"
     end
   end
 end

data/examples/rgb_1.rb

@@ -6,36 +6,33 @@ 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
-  def to_hex
-    "##{red.to_s(16)}#{green.to_s(16)}#{blue.to_s(16)}"
+  Number = ->(value) do
+    return value if value.is_a?(::Integer) && value >= 0 && value <= 255
+
+    raise TypeError, "#{value} must be an Integer(>= 0 and <= 255)"
   end
-end
 
-module RGBColor
-  ColorNumber = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
-    value.is_a?(::Integer) && value >= 0 && value <= 255
+  def initialize(r, g, b)
+    super(Number[r], Number[g], Number[b])
   end
 
-  def self.new(r:, g:, b:)
-    __new__(
-      red:   ColorNumber[r, label: 'r'],
-      green: ColorNumber[g, label: 'g'],
-      blue:  ColorNumber[b, label: 'b']
-    )
+  def to_hex
+    '#%02x%02x%02x' % self
   end
 end
 
-rgb_color = RGBColor.new(r: 1, g: 1, b: 255)
+puts
+
+rgb_color = RGBColor.new(red: 1, green: 1, blue: 255)
 
 p rgb_color
 
 puts
-puts format('to_hex: %p', rgb_color.to_hex)
 puts format('to_a: %p', rgb_color.to_a)
+puts format('to_hex: %p', rgb_color.to_hex)
 puts
 
 r, g, b = rgb_color
@@ -43,5 +40,15 @@ r, g, b = rgb_color
 puts format('red: %p', r)
 puts format('green: %p', g)
 puts format('blue: %p', b)
+puts
+
+*rgb = rgb_color
 
-RGBColor.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))
+puts rgb.inspect
+puts
+
+begin
+  RGBColor.new(red: 1, green: -1, blue: 255)
+rescue => exception
+  puts exception # TypeError (-1 must be an Integer(>= 0 and <= 255))
+end

data/examples/rgb_2.rb

@@ -10,22 +10,32 @@ gemfile do
 end
 
 RGBNumber = Micro::Struct.with(:readonly).new(:value) do
-  def to_s
-    value.to_s(16)
-  end
-end
-
-module RGBNumber
   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])
+  def initialize(value)
+    super(Input[value])
+  end
+
+  def to_s
+    '%02x' % value
+  end
+
+  def inspect
+    "#<RGBNumber #{value}>"
   end
 end
 
 RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+  def self.new(r:, g:, b:)
+    __new__(
+      red:   RGBNumber.new(value: r),
+      green: RGBNumber.new(value: g),
+      blue:  RGBNumber.new(value: b)
+    )
+  end
+
   def to_a
     [red.value, green.value, blue.value]
   end
@@ -35,23 +45,15 @@ RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
   end
 end
 
-module RGBColor
-  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
-end
+puts
 
 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 format('to_hex: %p', rgb_color.to_hex)
 puts
 
 r, g, b = rgb_color
@@ -59,5 +61,15 @@ r, g, b = rgb_color
 puts format('red: %p', r)
 puts format('green: %p', g)
 puts format('blue: %p', b)
+puts
+
+*rgb = rgb_color
 
-RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))
+puts rgb.inspect
+puts
+
+begin
+  RGBColor.new(r: 1, g: -1, b: 255)
+rescue => exception
+  puts exception # Kind::Error (-1 expected to be a kind of Integer(>= 0 and <= 255))
+end

data/examples/rgb_3.rb

@@ -12,13 +12,15 @@ end
 require_relative 'rgb/number'
 require_relative 'rgb/color'
 
-rgb_color = RGB::Color.new(r: 1, g: 1, b: 255)
+puts
+
+rgb_color = RGB::Color.new(red: 1, green: 1, blue: 255)
 
 p rgb_color
 
 puts
-puts format('to_hex: %p', rgb_color.to_hex)
 puts format('to_a: %p', rgb_color.to_a)
+puts format('to_hex: %p', rgb_color.to_hex)
 puts
 
 r, g, b = rgb_color
@@ -26,5 +28,15 @@ r, g, b = rgb_color
 puts format('red: %p', r)
 puts format('green: %p', g)
 puts format('blue: %p', b)
+puts
 
-RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))
+*rgb = rgb_color
+
+puts rgb.inspect
+puts
+
+begin
+  RGB::Color.new(red: 1, green: -1, blue: 255)
+rescue => exception
+  puts exception # Kind::Error (green: -1 expected to be a kind of Integer(>= 0 and <= 255))
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  class Factory
+    module CreateStruct
+      extend self
+
+      def with(members, block, features)
+        struct = ::Struct.new(*members.required_and_optional)
+
+        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.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)
+
+        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_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
+
+      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
+
+    private_constant :CreateStruct
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  class Factory
+    class Members
+      attr_reader :required_and_optional
+
+      Names = ->(values) { NormalizeNames::AsSymbols.(values, context: 'member') }
+
+      def initialize(required_members, required_option, optional_option)
+        @required = Names[required_members] + Names[required_option]
+        @optional = Names[optional_option]
+
+        @required_and_optional = @required + @optional
+      end
+
+      ToEval = ::Struct.new(:required, :optional, :required_and_optional) do
+        def keyword_args
+          required_kargs = "#{required.join(':, ')}#{':' unless required.empty?}"
+          optional_kargs = "#{optional.join(': nil, ')}#{': nil' unless optional.empty?}"
+
+          [required_kargs, optional_kargs].reject(&:empty?).join(', ')
+        end
+
+        def positional_args
+          required_and_optional.join(', ')
+        end
+      end
+
+      def to_eval
+        @to_eval ||= ToEval.new(@required, @optional, required_and_optional)
+      end
+    end
+
+    private_constant :Members
+  end
+end

data/lib/micro/struct/factory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Micro::Struct
+  class Factory
+    require_relative 'factory/members'
+    require_relative 'factory/create_struct'
+
+    def initialize(features)
+      @features = Features.config(features)
+    end
+
+    def new(*required_members, required: nil, optional: nil, &struct_block)
+      members = Members.new(required_members, required, optional)
+
+      CreateStruct.with(members, struct_block, @features)
+    end
+
+    def instance(**members, &block)
+      new(*members.keys, &block).new(**members)
+    end
+  end
+
+  private_constant :Factory
+end

data/lib/micro/struct/features.rb

@@ -2,30 +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 }
+    Names = ->(values) do
+      NormalizeNames::AsSymbols.(values, context: 'feature')
     end
 
-    NormalizeFeatureNames = ->(values) do
-      NormalizeNames::AsSymbols.(values, context: 'feature')
+    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
 
-    def self.require(names)
-      to_enable =
-        NormalizeFeatureNames[names].each_with_object({}) { |name, memo| memo[name] = true }
+    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.9.0'
+    VERSION = '1.0.0'
   end
 end

data/lib/micro/struct.rb

@@ -2,7 +2,7 @@
 
 require_relative 'struct/version'
 require_relative 'struct/features'
-require_relative 'struct/creator'
+require_relative 'struct/factory'
 require_relative 'struct/normalize_names'
 
 module Micro
@@ -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. ;)
   #
@@ -62,7 +63,11 @@ module Micro
     end
 
     def self.with(*features)
-      Creator.new(features)
+      Factory.new(features)
+    end
+
+    def self.instance(**members, &block)
+      with.instance(**members, &block)
     end
   end
 end

data/u-struct.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Create powered Ruby structs.}
   spec.homepage      = 'https://github.com/serradura/u-struct'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = '>= 2.2.0'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/serradura/u-struct'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-struct
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-15 00:00:00.000000000 Z
+date: 2022-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,16 +45,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".vscode/settings.json"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
+- bin/prepare_coverage
 - bin/setup
+- bin/test
 - examples/person_1.rb
 - examples/person_2.rb
 - examples/rgb/color.rb
@@ -63,9 +66,9 @@ files:
 - 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/factory/members.rb
 - lib/micro/struct/features.rb
 - lib/micro/struct/normalize_names.rb
 - lib/micro/struct/version.rb
@@ -86,14 +89,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.17
+rubygems_version: 3.3.4
 signing_key:
 specification_version: 4
 summary: Create powered Ruby structs.

data/Gemfile.lock

@@ -1,31 +0,0 @@
-PATH
-  remote: .
-  specs:
-    u-struct (0.9.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.32