u-struct 0.11.0 → 1.1.0

data/Rakefile

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
 task default: :test

data/bin/console

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "micro/struct"
+require 'bundler/setup'
+require 'micro/struct'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -11,5 +11,5 @@ require "micro/struct"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/bin/prepare_coverage

@@ -1,23 +1,21 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 # Borrowed from https://gist.github.com/qortex/7e7c49f3731391a91ee898336183acef
 
 # Temporary hack to get CodeClimate to work with SimpleCov 0.18 JSON format until issue is fixed
 # upstream: https://github.com/codeclimate/test-reporter/issues/413
 
-require "json"
+require 'json'
 
-filename = "coverage/.resultset.json"
+filename = 'coverage/.resultset.json'
 contents = JSON.parse(File.read(filename))
 
 def remove_lines_key(obj)
-  case obj
-  when Hash
-    obj.transform_values do |val|
-      val.is_a?(Hash) && val.key?("lines") ? val["lines"] : remove_lines_key(val)
-    end
-  else
-    obj
+  return obj unless obj.is_a?(Hash)
+
+  obj.transform_values do |val|
+    val.is_a?(Hash) && val.key?('lines') ? val['lines'] : remove_lines_key(val)
   end
 end
 

data/bin/run_ci

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -e
+
+RUBY_V=$(ruby -v)
+RUBY_3_1="ruby 3.1."
+
+rm Gemfile.lock
+
+bundle install
+
+if [[ $RUBY_V =~ $RUBY_3_1 ]]; then
+  bundle exec srb tc
+  bundle exec rubocop
+fi
+
+bundle exec rake test

data/bin/tapioca

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('tapioca', 'tapioca')

data/examples/rgb/number.rb

@@ -11,7 +11,7 @@ module RGB
     end
 
     def to_s
-      @to_s ||= '%02x' % value
+      @to_s ||= format('%02x', value)
     end
 
     def inspect

data/examples/rgb_1.rb

@@ -6,12 +6,13 @@ 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
-  Number = Kind.object(name: 'Integer(>= 0 and <= 255)') do |value|
-    value.is_a?(::Integer) && value >= 0 && value <= 255
+  Number = ->(value) do
+    return value if value.is_a?(::Integer) && value >= 0 && value <= 255
+
+    raise TypeError.new("#{value} must be an Integer(>= 0 and <= 255)")
   end
 
   def initialize(r, g, b)
@@ -19,7 +20,7 @@ RGBColor = Micro::Struct.with(:readonly, :to_ary).new(:red, :green, :blue) do
   end
 
   def to_hex
-    '#%02x%02x%02x' % self
+    format('#%<r>02x%<g>02x%<b>02x', r: red, g: green, b: blue)
   end
 end
 
@@ -48,6 +49,6 @@ puts
 
 begin
   RGBColor.new(red: 1, green: -1, blue: 255)
-rescue => exception
-  puts exception # Kind::Error (-1 expected to be a kind of Integer(>= 0 and <= 255))
+rescue TypeError => exception
+  puts exception # TypeError (-1 must be an Integer(>= 0 and <= 255))
 end

data/examples/rgb_2.rb

@@ -19,7 +19,7 @@ RGBNumber = Micro::Struct.with(:readonly).new(:value) do
   end
 
   def to_s
-    '%02x' % value
+    format('%02x', value)
   end
 
   def inspect
@@ -70,6 +70,6 @@ puts
 
 begin
   RGBColor.new(r: 1, g: -1, b: 255)
-rescue => exception
+rescue Kind::Error => exception
   puts exception # Kind::Error (-1 expected to be a kind of Integer(>= 0 and <= 255))
 end

data/examples/rgb_3.rb

@@ -37,6 +37,6 @@ puts
 
 begin
   RGB::Color.new(red: 1, green: -1, blue: 255)
-rescue => exception
+rescue Kind::Error => 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

@@ -1,88 +1,114 @@
+# typed: true
 # 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, features, struct_block)
+        struct = create_struct(members)
 
-      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)
 
-      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]
+        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)
 
-      ClassScope.evaluate(struct, block)
+        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)
 
-      struct
-    end
+        ClassScope.evaluate(struct, struct_block)
 
-    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
+        struct
       end
 
-      def self.def_to_proc(struct)
-        struct.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.to_proc
-            ->(hash) { new(**hash) }
-          end
-        RUBY
-      end
+      private
 
-      def self.def_private_writers(struct)
-        struct.send(:private, *struct.members.map { |member| "#{member}=" })
+      def create_struct(members)
+        ::Struct.new(*members.required_and_optional)
       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
+      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.members.each { |member| struct.send(:private, "#{member}=") }
+        end
+
+        def self.evaluate(struct, block)
+          struct.class_eval(&block) if block
+        end
       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
+      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
-  end
 
-  private_constant :CreateStruct
+    private_constant :CreateStruct
+  end
 end

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro::Struct

data/lib/micro/struct/factory.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro::Struct
@@ -5,14 +6,22 @@ module Micro::Struct
     require_relative 'factory/members'
     require_relative 'factory/create_struct'
 
-    def initialize(features)
-      @features = Features.require(features)
+    def initialize(feature_names)
+      @features = Features.config(feature_names)
     end
 
-    def new(*required_members, required: nil, optional: nil, &struct_block)
+    def __create__(required_members, required, optional, struct_block) # :nodoc:
       members = Members.new(required_members, required, optional)
 
-      CreateStruct.with(members, struct_block, @features)
+      CreateStruct.with(members, @features, struct_block)
+    end
+
+    def new(*required_members, required: nil, optional: nil, &struct_block)
+      __create__(required_members, required, optional, struct_block)
+    end
+
+    def instance(**members, &block)
+      __create__(members.keys, nil, nil, block).new(**members)
     end
   end
 

data/lib/micro/struct/features.rb

@@ -1,30 +1,49 @@
+# typed: true
 # 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 }
+    module Options
+      def self.from(names:)
+        options = names.each_with_object({}) { |name, memo| memo[name] = true }
+
+        {
+          to_ary: options.fetch(:to_ary, false),
+          to_hash: options.fetch(:to_hash, false),
+          to_proc: options.fetch(:to_proc, false),
+          readonly: options.fetch(:readonly, false),
+          instance_copy: options.fetch(:instance_copy, false),
+          exposed_features: options.fetch(:exposed_features, false)
+        }
+      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)
+
     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 }
+    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/normalize_names.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro::Struct
@@ -5,10 +6,10 @@ module Micro::Struct
     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
+      AsSymbol = ->(context, val) { REGEXP =~ val ? val.to_sym : Invalid[context, val] }
 
-      def self.call(values, context:)
-        Array(values).map(&AsSymbol[context])
+      def self.call(arg, context:)
+        Array(arg).map { |values| AsSymbol[context, values] }
       end
     end
   end

data/lib/micro/struct/version.rb

@@ -1,7 +1,8 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro
   module Struct
-    VERSION = '0.11.0'
+    VERSION = '1.1.0'
   end
 end

data/lib/micro/struct.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require_relative 'struct/version'
@@ -31,13 +32,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. ;)
   #
@@ -57,12 +59,42 @@ module Micro
   #
   #   Micro::Struct.with(*features).new(...) {}
   module Struct
-    def self.new(*members, required: nil, optional: nil, &block)
-      with.new(*members, required: required, optional: optional, &block)
+    extend self
+
+    def with(*feature_names)
+      factory(feature_names)
+    end
+
+    alias_method :[], :with
+
+    def new(*members, required: nil, optional: nil, &block)
+      with.__create__(members, required, optional, block)
+    end
+
+    def instance(**members, &block)
+      with.instance(**members, &block)
+    end
+
+    READONLY = [:readonly].freeze
+    IMMUTABLE = [:readonly, :instance_copy].freeze
+    EMPTY_ARRAY = [].freeze
+
+    def readonly(with: EMPTY_ARRAY)
+      factory(with, READONLY)
     end
 
-    def self.with(*features)
-      Factory.new(features)
+    def immutable(with: EMPTY_ARRAY)
+      factory(with, IMMUTABLE)
     end
+
+    private
+
+    def factory(names, defaults = EMPTY_ARRAY)
+      features = ::Kernel.Array(names)
+
+      Factory.new(defaults.empty? ? features : defaults + features)
+    end
+
+    private_constant :READONLY, :IMMUTABLE, :EMPTY_ARRAY
   end
 end

data/lib/u-struct.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'micro/struct'

data/rbi/micro/struct/factory/create_struct.rbi

@@ -0,0 +1,60 @@
+# typed: true
+
+module Micro::Struct::Factory::CreateStruct
+  extend self
+
+  STRUCT_BLOCK = T.type_alias { T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped)) }
+  STRUCT_MEMBERS = T.type_alias { Micro::Struct::Factory::Members }
+  FEATURES_EXPOSED = T.type_alias { Micro::Struct::Features::Exposed }
+  FEATURES_CONFIG = T.type_alias { T.any(Micro::Struct::Features::Config, FEATURES_EXPOSED) }
+
+  sig {
+    params(
+      members: STRUCT_MEMBERS,
+      features: FEATURES_CONFIG,
+      struct_block: STRUCT_BLOCK
+    ).returns(T.class_of(Struct))
+  }
+  def with(members, features, struct_block)
+  end
+
+  private
+
+  def create_struct(members); end
+
+  module ClassScope
+    sig { params(struct: T.class_of(Struct), members: STRUCT_MEMBERS).void }
+    def self.def_new(struct, members)
+    end
+
+    sig { params(struct: T.untyped, features: FEATURES_EXPOSED).void }
+    def self.def_features(struct, features)
+    end
+
+    sig { params(struct: T.class_of(Struct)).void }
+    def self.def_to_proc(struct)
+    end
+
+    sig { params(struct: T.class_of(Struct)).void }
+    def self.def_private_writers(struct)
+    end
+
+    sig { params(struct: T.class_of(Struct), block: STRUCT_BLOCK).void }
+    def self.evaluate(struct, block)
+    end
+  end
+
+  module InstanceScope
+    sig { params(struct: T.class_of(Struct)).void }
+    def self.def_to_ary(struct)
+    end
+
+    sig { params(struct: T.class_of(Struct)).void }
+    def self.def_to_hash(struct)
+    end
+
+    sig { params(struct: T.class_of(Struct)).void }
+    def self.def_with(struct)
+    end
+  end
+end