u-struct 0.9.0 → 1.0.0

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

@@ -1,67 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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