pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry/struct/struct_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Dry
+  class Struct
+    # @private
+    class StructBuilder < Compiler
+      attr_reader :struct
+
+      def initialize(struct)
+        super(Types)
+        @struct = struct
+      end
+
+      # @param [Symbol|String] attr_name the name of the nested type
+      # @param [Dry::Struct,Dry::Types::Type::Array,Undefined] type the superclass
+      #                                                        of the nested struct
+      # @yield the body of the nested struct
+      def call(attr_name, type, &block)
+        const_name = const_name(type, attr_name)
+        check_name(const_name)
+
+        builder = self
+        parent = parent(type)
+
+        new_type = ::Class.new(Undefined.default(parent, struct.abstract_class)) do
+          if Undefined.equal?(parent)
+            schema builder.struct.schema.clear
+          end
+
+          class_exec(&block)
+        end
+
+        struct.const_set(const_name, new_type)
+
+        if array?(type)
+          type.of(new_type)
+        elsif optional?(type)
+          new_type.optional
+        else
+          new_type
+        end
+      end
+
+      private
+
+      def type?(type) = type.is_a?(Types::Type)
+
+      def array?(type)
+        type?(type) && !type.optional? && type.primitive.equal?(::Array)
+      end
+
+      def optional?(type) = type?(type) && type.optional?
+
+      def parent(type)
+        if array?(type)
+          visit(type.to_ast)
+        elsif optional?(type)
+          type.right
+        else
+          type
+        end
+      end
+
+      def const_name(type, attr_name)
+        snake_name =
+          if array?(type)
+            Core::Inflector.singularize(attr_name)
+          else
+            attr_name
+          end
+
+        Core::Inflector.camelize(snake_name)
+      end
+
+      def check_name(name)
+        if struct.const_defined?(name, false)
+          raise(
+            Error,
+            "Can't create nested attribute - `#{struct}::#{name}` already defined"
+          )
+        end
+      end
+
+      def visit_constrained(node)
+        definition, * = node
+        visit(definition)
+      end
+
+      def visit_array(node)
+        member, * = node
+        visit(member)
+      end
+
+      def visit_nominal(*) = Undefined
+
+      def visit_constructor(node)
+        definition, * = node
+        visit(definition)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry/struct/sum.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Dry
+  class Struct
+    # A sum type of two or more structs
+    # As opposed to Dry::Types::Sum::Constrained
+    # this type tries no to coerce data first.
+    class Sum < Dry::Types::Sum::Constrained
+      def call(input)
+        left.try_struct(input) do
+          right.try_struct(input) { super }
+        end
+      end
+
+      # @param [Hash{Symbol => Object},Dry::Struct] input
+      # @yieldparam [Dry::Types::Result::Failure] failure
+      # @yieldreturn [Dry::Types::Result]
+      # @return [Dry::Types::Result]
+      def try(input)
+        if input.is_a?(Struct)
+          ::Dry::Types::Result::Success.new(try_struct(input) { return super })
+        else
+          super
+        end
+      end
+
+      # Build a new sum type
+      # @param [Dry::Types::Type] type
+      # @return [Dry::Types::Sum]
+      def |(type)
+        if (type.is_a?(::Class) && type <= Struct) || type.is_a?(Sum)
+          Sum.new(self, type)
+        else
+          super
+        end
+      end
+
+      # @return [boolean]
+      def ===(value) = left === value || right === value
+
+      protected
+
+      # @private
+      def try_struct(input, &block)
+        left.try_struct(input) do
+          right.try_struct(input, &block)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry/struct/value.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "ice_nine"
+
+module Dry
+  class Struct
+    extend Core::Deprecations[:"dry-struct"]
+
+    # {Value} objects behave like {Struct}s but *deeply frozen*
+    # using [`ice_nine`](https://github.com/dkubb/ice_nine)
+    #
+    # @example
+    #   class Location < Dry::Struct::Value
+    #     attribute :lat, Types::Float
+    #     attribute :lng, Types::Float
+    #   end
+    #
+    #   loc1 = Location.new(lat: 1.23, lng: 4.56)
+    #   loc2 = Location.new(lat: 1.23, lng: 4.56)
+    #
+    #   loc1.frozen? #=> true
+    #   loc2.frozen? #=> true
+    #   loc1 == loc2 #=> true
+    #
+    # @see https://github.com/dkubb/ice_nine
+    class Value < self
+      abstract
+
+      # @param (see ClassInterface#new)
+      # @return [Value]
+      # @see https://github.com/dkubb/ice_nine
+      def self.new(*) = ::IceNine.deep_freeze(super)
+    end
+
+    deprecate_constant :Value
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry/struct/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dry
+  class Struct
+    # @private
+    VERSION = "1.8.0"
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry/struct.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+require "dry/core"
+require "dry/types"
+
+require "dry/struct/class_interface"
+require "dry/struct/errors"
+require "dry/struct/version"
+
+module Dry
+  # Constructor method for easily creating a {Dry::Struct}.
+  # @return [Dry::Struct]
+  # @example
+  #   require 'dry-struct'
+  #
+  #   module Types
+  #     include Dry.Types()
+  #   end
+  #
+  #   Person = Dry.Struct(name: Types::String, age: Types::Integer)
+  #   matz = Person.new(name: "Matz", age: 52)
+  #   matz.name #=> "Matz"
+  #   matz.age #=> 52
+  #
+  #   Test = Dry.Struct(expected: Types::String) { schema(schema.strict) }
+  #   Test[expected: "foo", unexpected: "bar"]
+  #   #=> Dry::Struct::Error: [Test.new] unexpected keys [:unexpected] in Hash input
+  def self.Struct(attributes = Dry::Core::Constants::EMPTY_HASH, &block)
+    Class.new(Dry::Struct) do
+      attributes.each { |a, type| attribute a, type }
+      module_eval(&block) if block_given?
+    end
+  end
+
+  # Typed {Struct} with virtus-like DSL for defining schema.
+  #
+  # ### Differences between dry-struct and virtus
+  #
+  # {Struct} look somewhat similar to [Virtus][] but there are few significant differences:
+  #
+  # * {Struct}s don't provide attribute writers and are meant to be used
+  #   as "data objects" exclusively.
+  # * Handling of attribute values is provided by standalone type objects from
+  #   [`dry-types`][].
+  # * Handling of attribute hashes is provided by standalone hash schemas from
+  #   [`dry-types`][].
+  # * Struct classes quack like [`dry-types`][], which means you can use them
+  #   in hash schemas, as array members or sum them
+  #
+  # {Struct} class can specify a constructor type, which uses [hash schemas][]
+  # to handle attributes in `.new` method.
+  #
+  # [`dry-types`]: https://github.com/dry-rb/dry-types
+  # [Virtus]: https://github.com/solnic/virtus
+  # [hash schemas]: http://dry-rb.org/gems/dry-types/hash-schemas
+  #
+  # @example
+  #   require 'dry-struct'
+  #
+  #   module Types
+  #     include Dry.Types()
+  #   end
+  #
+  #   class Book < Dry::Struct
+  #     attribute :title, Types::String
+  #     attribute :subtitle, Types::String.optional
+  #   end
+  #
+  #   rom_n_roda = Book.new(
+  #     title: 'Web Development with ROM and Roda',
+  #     subtitle: nil
+  #   )
+  #   rom_n_roda.title #=> 'Web Development with ROM and Roda'
+  #   rom_n_roda.subtitle #=> nil
+  #
+  #   refactoring = Book.new(
+  #     title: 'Refactoring',
+  #     subtitle: 'Improving the Design of Existing Code'
+  #   )
+  #   refactoring.title #=> 'Refactoring'
+  #   refactoring.subtitle #=> 'Improving the Design of Existing Code'
+  class Struct
+    extend Core::Extensions
+    include Core::Constants
+    extend ClassInterface
+    extend Core::Deprecations[:"dry-struct"]
+
+    class << self
+      # override `Dry::Types::Builder#prepend`
+      define_method(:prepend, ::Module.method(:prepend))
+
+      def loader
+        @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
+          root = ::File.expand_path("..", __dir__)
+          loader.tag = "dry-struct"
+          loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-struct.rb")
+          loader.push_dir(root)
+          loader.ignore(
+            "#{root}/dry-struct.rb",
+            "#{root}/dry/struct/{class_interface,errors,extensions,printer,value,version}.rb",
+            "#{root}/dry/struct/extensions"
+          )
+        end
+      end
+    end
+
+    loader.setup
+
+    include ::Dry::Equalizer(:__attributes__, inspect: false, immutable: true)
+
+    # {Dry::Types::Hash::Schema} subclass with specific behaviour defined for
+    # @return [Dry::Types::Hash::Schema]
+    defines :schema
+    schema Types["coercible.hash"].schema(EMPTY_HASH)
+
+    defines :abstract_class
+    abstract
+
+    # @!attribute [Hash{Symbol => Object}] attributes
+    attr_reader :attributes
+    alias_method :__attributes__, :attributes
+
+    # @param [Hash, #each] attributes
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    # Retrieves value of previously defined attribute by its' `name`
+    #
+    # @param [String] name
+    # @return [Object]
+    #
+    # @example
+    #   class Book < Dry::Struct
+    #     attribute :title, Types::String
+    #     attribute :subtitle, Types::String.optional
+    #   end
+    #
+    #   rom_n_roda = Book.new(
+    #     title: 'Web Development with ROM and Roda',
+    #     subtitle: nil
+    #   )
+    #   rom_n_roda[:title] #=> 'Web Development with ROM and Roda'
+    #   rom_n_roda[:subtitle] #=> nil
+    def [](name)
+      @attributes.fetch(name) do
+        if self.class.attribute_names.include?(name)
+          nil
+        else
+          raise MissingAttributeError.new(attribute: name, klass: self.class)
+        end
+      end
+    end
+
+    # Converts the {Dry::Struct} to a hash with keys representing
+    # each attribute (as symbols) and their corresponding values
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @example
+    #   class Book < Dry::Struct
+    #     attribute :title, Types::String
+    #     attribute :subtitle, Types::String.optional
+    #   end
+    #
+    #   rom_n_roda = Book.new(
+    #     title: 'Web Development with ROM and Roda',
+    #     subtitle: nil
+    #   )
+    #   rom_n_roda.to_hash
+    #     #=> {title: 'Web Development with ROM and Roda', subtitle: nil}
+    def to_h
+      self.class.schema.each_with_object({}) do |key, result|
+        result[key.name] = Hashify[self[key.name]] if attributes.key?(key.name)
+      end
+    end
+    # TODO: remove in 2.0
+    alias_method :to_hash, :to_h
+
+    # Create a copy of {Dry::Struct} with overriden attributes
+    #
+    # @param [Hash{Symbol => Object}] changeset
+    #
+    # @return [Struct]
+    #
+    # @example
+    #   class Book < Dry::Struct
+    #     attribute :title, Types::String
+    #     attribute :subtitle, Types::String.optional
+    #   end
+    #
+    #   rom_n_roda = Book.new(
+    #     title: 'Web Development with ROM and Roda',
+    #     subtitle: '2nd edition'
+    #   )
+    #     #=> #<Book title="Web Development with ROM and Roda" subtitle="2nd edition">
+    #
+    #   rom_n_roda.new(subtitle: '3rd edition')
+    #     #=> #<Book title="Web Development with ROM and Roda" subtitle="3rd edition">
+    def new(changeset)
+      new_attributes = self.class.schema.apply(
+        changeset,
+        skip_missing: true,
+        resolve_defaults: false
+      )
+      self.class.load(__attributes__.merge(new_attributes))
+    rescue Types::SchemaError, Types::MissingKeyError, Types::UnknownKeysError => e
+      raise Error, "[#{self}.new] #{e}"
+    end
+    alias_method :__new__, :new
+
+    # @return [String]
+    def inspect
+      klass = self.class
+      attrs = klass.attribute_names.map { |key| " #{key}=#{@attributes[key].inspect}" }.join
+      "#<#{klass.name || klass.inspect}#{attrs}>"
+    end
+
+    # Pattern matching support
+    #
+    # @api private
+    def deconstruct_keys(_keys) = attributes
+  end
+end
+
+require "dry/struct/extensions"
+require "dry/struct/printer"
+require "dry/struct/value"

data/vendor/bundle/ruby/3.3.0/gems/dry-struct-1.8.0/lib/dry-struct.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "dry/struct"