mega-sharp-sys 0.0.1

data/dry-schema-1.16.0/lib/dry/schema/key.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Key objects used by key maps
+    #
+    # @api public
+    class Key
+      extend ::Dry::Core::Cache
+
+      DEFAULT_COERCER = :itself.to_proc.freeze
+
+      include ::Dry.Equalizer(:name, :coercer)
+
+      # @return [Symbol] The key identifier
+      attr_reader :id
+
+      # @return [Symbol, String, Object] The actual key name expected in an input hash
+      attr_reader :name
+
+      # @return [Proc, #call] A key name coercer function
+      attr_reader :coercer
+
+      # @api private
+      def self.[](name, **opts)
+        new(name, **opts)
+      end
+
+      # @api private
+      def self.new(*args, **kwargs)
+        fetch_or_store(args, kwargs) { super }
+      end
+
+      # @api private
+      def initialize(id, name: id, coercer: DEFAULT_COERCER)
+        @id = id
+        @name = name
+        @coercer = coercer
+      end
+
+      # @api private
+      def read(source)
+        return unless source.is_a?(::Hash)
+
+        if source.key?(name)
+          yield(source[name])
+        elsif source.key?(coerced_name)
+          yield(source[coerced_name])
+        end
+      end
+
+      # @api private
+      def write(source, target)
+        read(source) { |value| target[coerced_name] = value }
+      end
+
+      # @api private
+      def coercible(&coercer)
+        new(coercer: coercer)
+      end
+
+      # @api private
+      def stringified
+        new(name: name.to_s)
+      end
+
+      # @api private
+      def to_dot_notation
+        [name.to_s]
+      end
+
+      # @api private
+      def new(**new_opts)
+        self.class.new(id, name: name, coercer: coercer, **new_opts)
+      end
+
+      # @api private
+      def dump
+        name
+      end
+
+      private
+
+      # @api private
+      def coerced_name
+        @__coerced_name__ ||= coercer[name]
+      end
+
+      # A specialized key type which handles nested hashes
+      #
+      # @api private
+      class Hash < self
+        include ::Dry.Equalizer(:name, :members, :coercer)
+
+        # @api private
+        attr_reader :members
+
+        # @api private
+        def initialize(id, members:, **opts)
+          super(id, **opts)
+          @members = members
+        end
+
+        # @api private
+        def read(source)
+          super if source.is_a?(::Hash)
+        end
+
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
+          }
+        end
+
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, members: members.coercible(&coercer))
+        end
+
+        # @api private
+        def stringified
+          new(name: name.to_s, members: members.stringified)
+        end
+
+        # @api private
+        def to_dot_notation
+          [name].product(members.flat_map(&:to_dot_notation)).map { |e| e.join(DOT) }
+        end
+
+        # @api private
+        def dump
+          {name => members.map(&:dump)}
+        end
+      end
+
+      # A specialized key type which handles nested arrays
+      #
+      # @api private
+      class Array < self
+        include ::Dry.Equalizer(:name, :member, :coercer)
+
+        attr_reader :member
+
+        # @api private
+        def initialize(id, member:, **opts)
+          super(id, **opts)
+          @member = member
+        end
+
+        # @api private
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] =
+              if value.is_a?(::Array)
+                value.map { |el| el.is_a?(::Hash) ? member.write(el) : el }
+              else
+                value
+              end
+          }
+        end
+
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, member: member.coercible(&coercer))
+        end
+
+        # @api private
+        def stringified
+          new(name: name.to_s, member: member.stringified)
+        end
+
+        # @api private
+        def to_dot_notation
+          [:"#{name}[]"].product(member.to_dot_notation).map { |el| el.join(DOT) }
+        end
+
+        # @api private
+        def dump
+          [name, member.dump]
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/key_coercer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+
+module Dry
+  module Schema
+    # Coerces keys in a hash using provided coercer function
+    #
+    # @api private
+    class KeyCoercer
+      extend ::Dry::Core::Cache
+      include ::Dry::Equalizer(:key_map, :coercer)
+
+      TO_SYM = :to_sym.to_proc.freeze
+
+      attr_reader :key_map, :coercer
+
+      # @api private
+      def self.new(*args)
+        fetch_or_store(*args) { super }
+      end
+
+      # @api private
+      def self.symbolized(*args)
+        new(*args, &TO_SYM)
+      end
+
+      # @api private
+      def initialize(key_map, &)
+        @key_map = key_map.coercible(&)
+      end
+
+      # @api private
+      def call(result)
+        key_map.write(result.to_h)
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/key_map.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # Represents a list of keys defined by the DSL
+    #
+    # KeyMap objects expose an API for introspecting schema keys and the ability
+    # to rebuild an input hash using configured coercer function.
+    #
+    # Instances of this class are used as the very first step by the schema processors.
+    #
+    # @api public
+    class KeyMap
+      extend ::Dry::Core::Cache
+
+      include ::Dry.Equalizer(:keys)
+      include ::Enumerable
+
+      # @return [Array<Key>] A list of defined key objects
+      attr_reader :keys
+
+      # Coerce a list of key specs into a key map
+      #
+      # @example
+      #   KeyMap[:id, :name]
+      #   KeyMap[:title, :artist, tags: [:name]]
+      #   KeyMap[:title, :artist, [:tags]]
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def self.[](*keys)
+        new(keys)
+      end
+
+      # Build new, or returned a cached instance of a key map
+      #
+      # @param [Array<Symbol>, Array, Hash<Symbol=>Array>] args
+      #
+      # @return [KeyMap]
+      def self.new(*args)
+        fetch_or_store(*args) { super }
+      end
+
+      # Set key objects
+      #
+      # @api private
+      def initialize(keys)
+        @keys = keys.map { |key|
+          case key
+          when Hash
+            root, rest = key.flatten
+            Key::Hash[root, members: KeyMap[*rest]]
+          when Array
+            root, rest = key
+            Key::Array[root, member: KeyMap[*rest]]
+          when Key
+            key
+          else
+            Key[key]
+          end
+        }
+      end
+
+      # Write a new hash based on the source hash
+      #
+      # @param [Hash] source The source hash
+      # @param [Hash] target The target hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def write(source, target = EMPTY_HASH.dup)
+        each { |key| key.write(source, target) }
+        target
+      end
+
+      # Return a new key map that is configured to coerce keys using provided coercer function
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def coercible(&coercer)
+        self.class.new(map { |key| key.coercible(&coercer) })
+      end
+
+      # Return a new key map with stringified keys
+      #
+      # A stringified key map is suitable for reading hashes with string keys
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def stringified
+        self.class.new(map(&:stringified))
+      end
+
+      # @api private
+      def to_dot_notation
+        @to_dot_notation ||= map(&:to_dot_notation).flatten
+      end
+
+      # Iterate over keys
+      #
+      # @api public
+      def each(&)
+        keys.each(&)
+      end
+
+      # Return a new key map merged with the provided one
+      #
+      # @param [KeyMap, Array] other Either a key map or an array with key specs
+      #
+      # @return [KeyMap]
+      def +(other)
+        self.class.new(keys + other.to_a)
+      end
+
+      # Return a string representation of a key map
+      #
+      # @return [String]
+      def inspect
+        "#<#{self.class}[#{keys.map(&:dump).map(&:inspect).join(", ")}]>"
+      end
+
+      # Dump keys to their spec format
+      #
+      # @return [Array]
+      def dump
+        keys.map(&:dump)
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/key_validator.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    class KeyValidator
+      extend ::Dry::Initializer
+
+      MULTI_INDEX_REGEX = /(\[\d+\])+/
+      INDEX_REGEX = /\[\d+\]/
+      DIGIT_REGEX = /\A\d+\z/
+      BRACKETS = "[]"
+
+      # @api private
+      option :key_map
+
+      # @api private
+      def call(result)
+        input = result.to_h
+
+        input_paths = key_paths(input)
+        key_paths = key_map.to_dot_notation.sort
+
+        input_paths.each do |path|
+          error_path = validate_path(key_paths, path)
+
+          next unless error_path
+
+          result.add_error([:unexpected_key, [error_path, input]])
+        end
+
+        result
+      end
+
+      private
+
+      # @api private
+      def validate_path(key_paths, path)
+        if path[MULTI_INDEX_REGEX]
+          key = path.gsub(MULTI_INDEX_REGEX, BRACKETS)
+          if none_key_paths_match?(key_paths, key)
+            arr = path.gsub(INDEX_REGEX) { ".#{_1[1...-1]}" }
+            arr.split(DOT).map { DIGIT_REGEX.match?(_1) ? Integer(_1, 10) : _1.to_sym }
+          end
+        elsif none_key_paths_match?(key_paths, path)
+          path
+        end
+      end
+
+      # @api private
+      def none_key_paths_match?(key_paths, path)
+        !any_key_paths_match?(key_paths, path)
+      end
+
+      # @api private
+      def any_key_paths_match?(key_paths, path)
+        find_path(key_paths, path, false) ||
+          find_path(key_paths, path + DOT, true) ||
+          find_path(key_paths, path + BRACKETS, true)
+      end
+
+      # @api private
+      def find_path(key_paths, path, prefix_match)
+        key = key_paths.bsearch { |key_path| key_path >= path }
+        prefix_match ? key&.start_with?(path) : key == path
+      end
+
+      # @api private
+      def key_paths(hash)
+        hash.flat_map { |key, value|
+          case value
+          when ::Hash
+            if value.empty?
+              [key.to_s]
+            else
+              [key].product(key_paths(hash[key])).map { _1.join(DOT) }
+            end
+          when ::Array
+            hashes_or_arrays = hashes_or_arrays(value)
+
+            if hashes_or_arrays.empty?
+              [key.to_s]
+            else
+              traverse_array(value).map { |sub_path| [key, sub_path].join("") }
+            end
+          else
+            key.to_s
+          end
+        }
+      end
+
+      # @api private
+      def hashes_or_arrays(xs)
+        xs.select { |x|
+          (x.is_a?(::Array) || x.is_a?(::Hash)) && !x.empty?
+        }
+      end
+
+      # @api private
+      def traverse_array(arr)
+        arr.each_with_index.flat_map do |el, idx|
+          case el
+          when ::Hash
+            key_paths(el).map { ["[#{idx}]", *_1].join(DOT) }
+          when ::Array
+            traverse_array(el).map { ["[#{idx}]", *_1].join("") }
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/macros/array.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for each element of an array
+      #
+      # @api private
+      class Array < DSL
+        # @api private
+        # rubocop: disable Metrics/PerceivedComplexity
+        # rubocop: disable Metrics/AbcSize
+        def value(*args, **opts, &block)
+          type(:array)
+
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
+            type(schema_dsl.array[type_spec]) if type_spec
+
+            is_hash_block = type_spec.equal?(:hash)
+
+            if predicates.any? || opts.any? || !is_hash_block
+              super(
+                *predicates, type_spec: type_spec, type_rule: type_rule, **opts,
+                &(is_hash_block ? nil : block)
+              )
+            end
+
+            is_op = args.size.equal?(2) && args[1].is_a?(Logic::Operations::Abstract)
+
+            if is_hash_block && !is_op
+              hash(&block)
+            elsif is_op
+              hash = Value.new(schema_dsl: schema_dsl.new, name: name).hash(args[1])
+
+              trace.captures.concat(hash.trace.captures)
+
+              type(schema_dsl.types[name].of(hash.schema_dsl.types[name]))
+            end
+          end
+
+          self
+        end
+        # rubocop: enable Metrics/AbcSize
+        # rubocop: enable Metrics/PerceivedComplexity
+
+        # @api private
+        def to_ast(*)
+          [:and, [trace.array?.to_ast, [:each, trace.to_ast]]]
+        end
+        alias_method :ast, :to_ast
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/macros/core.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    module Macros
+      # Abstract macro class
+      #
+      # @api private
+      class Core
+        extend Dry::Initializer
+
+        # @api private
+        option :name, default: proc {}, optional: true
+
+        # @api private
+        option :compiler, default: proc { Compiler.new }
+
+        # @api private
+        option :schema_dsl, optional: true
+
+        # @api private
+        option :trace, default: proc { Trace.new(schema_dsl&.compiler || Compiler.new) }
+
+        # @api private
+        def new(**options)
+          self.class.new(name: name, compiler: compiler, schema_dsl: schema_dsl, **options)
+        end
+
+        # @api private
+        def path
+          schema_dsl.path
+        end
+
+        # @api private
+        def to_rule
+          compiler.visit(to_ast)
+        end
+
+        # @api private
+        def to_ast(*)
+          trace.to_ast
+        end
+        alias_method :ast, :to_ast
+
+        # @api private
+        def operation
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end