u-struct 0.5.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 393ba5215b21bf91ef0229de920ca0980c44168fcc0e65d539a0f6b4f6a7caa2
-  data.tar.gz: e1ad5cfbd6215982aa8f6e5708d4a6f8cea0a046da9ad82568d0ed8136d58629
+  metadata.gz: '0765309623bfa9eb720102c66cd30f5ba785bdada60af711f19a03a51a7027bd'
+  data.tar.gz: 216dd4920427d682c9e797e5ec0a8631486b5d8c0613391440bd0f94f2778824
 SHA512:
-  metadata.gz: 2d86bb3a75737927e5f74d56e16c7760b8c7b9c3dce7642ebdef058122212dd21c38aec04573722842ea081995b5e03c6a094a1548bf63f1ed709762c6e5ad2c
-  data.tar.gz: 6dee9c1ab9cd6ba5675cf7c1e6cedc128e70fe45aabf52a2b1beb77fb63e9b01c1d70b0775b4393167132371923b5d56a2efed099048e0e3e594b5c199d95ab3
+  metadata.gz: ed911103da03769ac8014a618d713b313e20a19a65074ac1a737f2d4cd1717dbdf521d0f7693665d840bdbff145e518afe3e7ef875b1eef55d2555e198bf8d62
+  data.tar.gz: 683f94804b10f3ff03ed3f6ecbf4ff40c889dacf8dfd964496e8807974f96cbb611399fa21d95d73881a9c20d4dd0296975528cafc59dfbb20128471149c398a

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.9.0] - 2021-12-14
+
+- To-do
+
+## [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

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,21 +1,30 @@
 PATH
   remote: .
   specs:
-    u-struct (0.5.0)
+    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

data/README.md

@@ -22,19 +22,58 @@ Or install it yourself as:
 
 ```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):
-#   .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: *)
+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(...).new(...) {}
+Micro::Struct.with(*features).new(...) {}
 ```
 
 ## Development

data/examples/person_1.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+end
+
+Person = Micro::Struct.new(:first_name, :last_name, optional: :age) do
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+
+puts format('first_name: %p', person.first_name)
+puts format('last_name: %p', person.last_name)
+puts format('name: %p', person.name)
+puts format('age: %p', person.age)
+puts
+
+person.age = rand(18..100)
+
+puts format('age: %p', person.age)

data/examples/person_2.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+end
+
+Person = Micro::Struct.with(:readonly, :instance_copy).new(
+  required: [:first_name, :last_name],
+  optional: [:age]
+) do
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+person = Person.new(first_name: 'Rodrigo', last_name: 'Serradura')
+
+puts format('first_name: %p', person.first_name)
+puts format('last_name: %p', person.last_name)
+puts format('name: %p', person.name)
+puts format('age: %p', person.age)
+puts
+
+rand_age = rand(18..100)
+
+new_person = person.with(age: rand_age)
+
+puts new_person.equal?(person)
+
+puts format('age: %p', person.age)
+puts format('age: %p', new_person.age)
+
+person.age = rand_age

data/examples/rgb/color.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RGB
+  Color = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+    def to_a
+      super.map(&:value)
+    end
+
+    def to_hex
+      "##{red}#{green}#{blue}"
+    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')
+      )
+    end
+  end
+end

data/examples/rgb/number.rb

@@ -0,0 +1,19 @@
+# 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
+    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])
+    end
+  end
+end

data/examples/rgb_1.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+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)}"
+  end
+end
+
+module RGBColor
+  ColorNumber = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
+    value.is_a?(::Integer) && value >= 0 && value <= 255
+  end
+
+  def self.new(r:, g:, b:)
+    __new__(
+      red:   ColorNumber[r, label: 'r'],
+      green: ColorNumber[g, label: 'g'],
+      blue:  ColorNumber[b, label: 'b']
+    )
+  end
+end
+
+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
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGBColor.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

data/examples/rgb_2.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+  gem 'kind'
+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])
+  end
+end
+
+RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
+  def to_a
+    [red.value, green.value, blue.value]
+  end
+
+  def to_hex
+    "##{red}#{green}#{blue}"
+  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
+
+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
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

data/examples/rgb_3.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'u-struct', path: '..'
+  gem 'kind'
+end
+
+require_relative 'rgb/number'
+require_relative 'rgb/color'
+
+rgb_color = RGB::Color.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
+
+r, g, b = rgb_color
+
+puts format('red: %p', r)
+puts format('green: %p', g)
+puts format('blue: %p', b)
+
+RGB::Color.new(r: 1, g: -1, b: 255) # Kind::Error (g: -1 expected to be a kind of Integer(>= 0 and <= 255))

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

@@ -0,0 +1,67 @@
+# 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) if features[:to_proc]
+
+      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
+
+          class << self
+            alias new __new__
+          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)
+        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,51 @@
+# 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[:instance_copy]
+
+      struct
+    end
+
+    private
+
+      def def_to_ary(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def to_ary
+            to_a
+          end
+        RUBY
+      end
+
+      def def_to_hash(struct)
+        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def to_hash
+            to_h
+          end
+        RUBY
+      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.5.0'
+    VERSION = '0.9.0'
   end
 end

data/lib/micro/struct.rb

@@ -1,141 +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 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):
+  # 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.with(...).new(...) {}
+  #   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,
-            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, 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.5.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-03 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,7 +55,19 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/person_1.rb
+- examples/person_2.rb
+- examples/rgb/color.rb
+- examples/rgb/number.rb
+- examples/rgb_1.rb
+- 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/features.rb
+- lib/micro/struct/normalize_names.rb
 - lib/micro/struct/version.rb
 - lib/u-struct.rb
 - u-struct.gemspec
@@ -81,7 +93,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.