u-struct 1.0.0 → 1.1.0

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro::Struct
@@ -5,11 +6,11 @@ module Micro::Struct
     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_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)
@@ -18,11 +19,17 @@ module Micro::Struct
         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, struct_block)
 
         struct
       end
 
+      private
+
+      def create_struct(members)
+        ::Struct.new(*members.required_and_optional)
+      end
+
       module ClassScope
         def self.def_new(struct, members)
           # The .new() method will require all required keyword arguments.
@@ -67,7 +74,7 @@ module Micro::Struct
 
         def self.def_private_writers(struct)
           struct.send(:private, :[]=)
-          struct.send(:private, *struct.members.map { |member| "#{member}=" })
+          struct.members.each { |member| struct.send(:private, "#{member}=") }
         end
 
         def self.evaluate(struct, block)

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,18 +6,22 @@ module Micro::Struct
     require_relative 'factory/members'
     require_relative 'factory/create_struct'
 
-    def initialize(features)
-      @features = Features.config(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)
-      new(*members.keys, &block).new(**members)
+      __create__(members.keys, nil, nil, block).new(**members)
     end
   end
 

data/lib/micro/struct/features.rb

@@ -1,29 +1,20 @@
+# typed: true
 # frozen_string_literal: true
 
 module Micro::Struct
   module Features
-    Names = ->(values) do
-      NormalizeNames::AsSymbols.(values, context: 'feature')
-    end
-
     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))
+      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
 
@@ -31,7 +22,7 @@ module Micro::Struct
       def option?(name)
         options.fetch(name)
       end
-      
+
       def options?(*names)
         names.all? { |name| option?(name) }
       end
@@ -39,9 +30,13 @@ module Micro::Struct
 
     Exposed = Class.new(Config)
 
+    Names = ->(values) do
+      NormalizeNames::AsSymbols.(values, context: 'feature')
+    end
+
     def self.config(values)
       names = Names[values]
-      options = Options.from_names(names)
+      options = Options.from(names: names)
 
       return Config.new(names, options) unless options[:exposed_features]
 

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 = '1.0.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'
@@ -58,16 +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
 
-    def self.with(*features)
-      Factory.new(features)
+    alias_method :[], :with
+
+    def new(*members, required: nil, optional: nil, &block)
+      with.__create__(members, required, optional, block)
     end
 
-    def self.instance(**members, &block)
+    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 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

data/rbi/micro/struct/factory/members.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+class Micro::Struct::Factory::Members
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  MEMBER_NAMES  = T.type_alias { T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL]) }
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :required_and_optional
+
+  Names = T.let(T.unsafe, T.proc.params(arg0: T.nilable(MEMBER_NAMES)).returns(T::Array[Symbol]))
+
+  sig {
+    params(
+      required_members: T::Array[STR_OR_SYMBOL],
+      required_option: T.nilable(MEMBER_NAMES),
+      optional_option: T.nilable(MEMBER_NAMES)
+    ).void
+  }
+  def initialize(required_members, required_option, optional_option)
+  end
+
+  class ToEval < ::Struct
+    extend T::Generic
+
+    sig {
+      params(
+        required: T::Array[Symbol],
+        optional: T::Array[Symbol],
+        required_and_optional: T::Array[Symbol]
+      ).void
+    }
+    def initialize(required, optional, required_and_optional)
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def required
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def optional
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def required_and_optional
+    end
+
+    sig { params(name: Symbol).returns(T::Boolean) }
+    def option?(name)
+    end
+
+    sig { params(names: Symbol).returns(T::Boolean) }
+    def options?(*names)
+    end
+
+    sig { returns(String) }
+    def keyword_args
+    end
+
+    sig { returns(String) }
+    def positional_args
+    end
+  end
+
+  sig { returns(ToEval) }
+  def to_eval
+  end
+end

data/rbi/micro/struct/factory.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+class Micro::Struct::Factory
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  MEMBER_NAMES = T.type_alias { T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL]) }
+  STRUCT_BLOCK = T.type_alias { T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped)) }
+
+  sig {
+    params(feature_names: T::Array[T.any(String, Symbol)]).void
+  }
+  def initialize(feature_names)
+  end
+
+  sig { params(members: T.untyped, block:   STRUCT_BLOCK).returns(Struct) }
+  def instance(**members, &block)
+  end
+
+  sig {
+    params(
+      required_members: STR_OR_SYMBOL,
+      required:     T.nilable(MEMBER_NAMES),
+      optional:     T.nilable(MEMBER_NAMES),
+      struct_block: STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def new(*required_members, required: nil, optional: nil, &struct_block)
+  end
+
+  sig {
+    params(
+      required_members: T::Array[STR_OR_SYMBOL],
+      required:     T.nilable(MEMBER_NAMES),
+      optional:     T.nilable(MEMBER_NAMES),
+      struct_block: STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def __create__(required_members, required, optional, struct_block)
+  end
+end

data/rbi/micro/struct/features.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Micro::Struct::Features
+  FEAT_NAMES = T.type_alias { T::Array[Symbol] }
+  FEAT_OPTIONS = T.type_alias { T::Hash[Symbol, T::Boolean] }
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+
+  module Options
+    sig { params(names: FEAT_NAMES).returns(FEAT_OPTIONS) }
+    def from(names:)
+    end
+  end
+
+  class Config < ::Struct
+    extend T::Generic
+
+    sig { params(names: FEAT_NAMES, options: FEAT_OPTIONS).void }
+    def initialize(names, options)
+    end
+
+    sig { returns(FEAT_NAMES) }
+    def names; end
+
+    sig { returns(FEAT_OPTIONS) }
+    def options; end
+
+    sig { params(name: Symbol).returns(T::Boolean) }
+    def option?(name); end
+
+    sig { params(names: Symbol).returns(T::Boolean) }
+    def options?(*names); end
+  end
+
+  Names = T.let(T.unsafe, T.proc.params(arg0: T::Array[STR_OR_SYMBOL]).returns(FEAT_NAMES))
+
+  sig {
+    params(values: T::Array[STR_OR_SYMBOL]).returns(T.any(Config, Exposed))
+  }
+  def self.config(values)
+  end
+end

data/rbi/micro/struct/normalize_names.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Micro::Struct::NormalizeNames
+  module AsSymbols
+    STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+
+    REGEXP = T.let(T.unsafe, Regexp)
+    Invalid = T.let(T.unsafe, T.proc.params(arg0: String, arg1: T.any(STR_OR_SYMBOL)).void)
+    AsSymbol = T.let(T.unsafe, T.proc.params(arg0: String, arg1: T.any(STR_OR_SYMBOL)).returns(Symbol))
+
+    sig {
+      params(
+        values:  T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+        context: String
+      ).returns(T::Array[Symbol])
+    }
+    def self.call(values, context:)
+    end
+  end
+end

data/rbi/micro/struct/version.rbi

@@ -0,0 +1,3 @@
+# typed: strong
+
+Micro::Struct::VERSION = T.let(T.unsafe(nil), String)

data/rbi/micro/struct.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Micro::Struct
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  STRUCT_BLOCK  = T.type_alias { T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped)) }
+
+  sig {
+    params(feature_names: Symbol).returns(Micro::Struct::Factory)
+  }
+  def self.with(*feature_names)
+  end
+
+  sig {
+    params(feature_names: Symbol).returns(Micro::Struct::Factory)
+  }
+  def self.[](*feature_names)
+  end
+
+  sig {
+    params(
+      members:  STR_OR_SYMBOL,
+      required: T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+      optional: T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+      block:    STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def self.new(*members, required: nil, optional: nil, &block)
+  end
+
+  sig {
+    params(
+      members: T.untyped,
+      block:   STRUCT_BLOCK
+    )
+    .returns(Struct)
+  }
+  def self.instance(**members, &block)
+  end
+
+  READONLY = T.let(T::Array[Symbol])
+  IMMUTABLE = T.let(T::Array[Symbol])
+  EMPTY_ARRAY = T.let(T::Array)
+
+  sig {
+    params(with: T::Array[Symbol]).returns(Micro::Struct::Factory)
+  }
+  def readonly(with: EMPTY_ARRAY)
+  end
+
+  sig {
+    params(with: T::Array[Symbol]).returns(Micro::Struct::Factory)
+  }
+  def immutable(with: EMPTY_ARRAY)
+  end
+
+  private
+
+  sig {
+    params(
+      names: T.nilable(T::Array[Symbol]),
+      defaults: T::Array[Symbol]
+    )
+    .returns(Micro::Struct::Factory)
+  }
+  def factory(names, defaults = EMPTY_ARRAY)
+  end
+end

data/sorbet/config

@@ -0,0 +1,8 @@
+--dir
+.
+
+--ignore
+examples
+
+--ignore
+vendor

data/sorbet/rbi/gems/ast@2.4.2.rbi

@@ -0,0 +1,54 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `bin/tapioca gem ast`.
+
+module AST; end
+
+class AST::Node
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def deconstruct; end
+  def dup; end
+  def eql?(other); end
+  def hash; end
+  def inspect(indent = T.unsafe(nil)); end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = T.unsafe(nil)); end
+  def to_sexp(indent = T.unsafe(nil)); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  protected
+
+  def assign_properties(properties); end
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
+end
+
+class AST::Processor
+  include ::AST::Processor::Mixin
+end
+
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
+
+module AST::Sexp
+  def s(type, *children); end
+end

data/sorbet/rbi/gems/coderay@1.1.3.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `coderay` gem.
+# Please instead update this file by running `bin/tapioca gem coderay`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires

data/sorbet/rbi/gems/diff-lcs@1.5.0.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `diff-lcs` gem.
+# Please instead update this file by running `bin/tapioca gem diff-lcs`.
+
+class Integer < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+end
+
+Integer::GMP_VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/docile@1.4.0.rbi

@@ -0,0 +1,54 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `docile` gem.
+# Please instead update this file by running `bin/tapioca gem docile`.
+
+module Docile
+  extend ::Docile::Execution
+
+  private
+
+  def dsl_eval(dsl, *args, &block); end
+  def dsl_eval_immutable(dsl, *args, &block); end
+  def dsl_eval_with_block_return(dsl, *args, &block); end
+
+  class << self
+    def dsl_eval(dsl, *args, &block); end
+    def dsl_eval_immutable(dsl, *args, &block); end
+    def dsl_eval_with_block_return(dsl, *args, &block); end
+  end
+end
+
+module Docile::BacktraceFilter
+  def backtrace; end
+  def backtrace_locations; end
+end
+
+Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
+  def method_missing(method, *args, &block); end
+end
+
+module Docile::Execution
+  private
+
+  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+
+  class << self
+    def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+  end
+end
+
+class Docile::FallbackContextProxy
+  def initialize(receiver, fallback); end
+
+  def instance_variables; end
+  def method_missing(method, *args, &block); end
+end
+
+Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
+Docile::VERSION = T.let(T.unsafe(nil), String)