mega-sharp-sys 0.0.1

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # @api private
+    class PrimitiveInferrer < ::Dry::Types::PrimitiveInferrer
+      Compiler = ::Class.new(superclass::Compiler) do
+        # @api private
+        def visit_intersection(node)
+          left, right = node
+          [visit(left), visit(right)].flatten(1)
+        end
+      end
+
+      def initialize
+        super
+
+        @compiler = Compiler.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+
+module Dry
+  module Schema
+    # Processes input data using objects configured within the DSL
+    # Processing is split into steps represented by `ProcessorSteps`.
+    #
+    # @see ProcessorSteps
+    # @see Params
+    # @see JSON
+    #
+    # @api public
+    class Processor
+      extend ::Dry::Initializer
+      extend ::Dry::Configurable
+
+      include ::Dry::Logic::Operators
+
+      setting :key_map_type
+      setting :type_registry_namespace, default: :strict
+      setting :filter_empty_string, default: false
+
+      option :steps, default: -> { ProcessorSteps.new }
+
+      option :schema_dsl
+
+      class << self
+        # Return DSL configured via #define
+        #
+        # @return [DSL]
+        # @api private
+        attr_reader :definition
+
+        # Define a schema for your processor class
+        #
+        # @see Schema#define
+        # @see Schema#Params
+        # @see Schema#JSON
+        #
+        # @return [Class]
+        #
+        # @api public
+        def define(&)
+          @definition ||= DSL.new(
+            processor_type: self, parent: superclass.definition, **config.to_h, &
+          )
+          self
+        end
+
+        # Build a new processor object
+        #
+        # @return [Processor]
+        #
+        # @api public
+        def new(options = nil)
+          if options || block_given?
+            processor = super(**(options || EMPTY_HASH))
+            yield(processor) if block_given?
+            processor
+          elsif definition
+            definition.call
+          else
+            raise ::ArgumentError, "Cannot create a schema without a definition"
+          end
+        end
+      end
+
+      # Apply processing steps to the provided input
+      #
+      # @param [Hash] input
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(input)
+        Result.new(input.dup, message_compiler: message_compiler) do |result|
+          steps.call(result)
+        end
+      end
+      alias_method :[], :call
+
+      # @api public
+      def xor(_other)
+        raise ::NotImplementedError, "composing schemas using `xor` operator is not supported yet"
+      end
+      alias_method :^, :xor
+
+      # Merge with another schema
+      #
+      # @param [Processor] other
+      #
+      # @return [Processor, Params, JSON]
+      #
+      # @api public
+      def merge(other)
+        schema_dsl.merge(other.schema_dsl).()
+      end
+
+      # Return a proc that acts like a schema object
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        ->(input) { call(input) }
+      end
+
+      # Return string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        <<~STR.strip
+          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.transform_values(&:to_s)}>
+        STR
+      end
+
+      # Return the key map
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def key_map
+        steps.key_map
+      end
+
+      # Return the type schema
+      #
+      # @return [Dry::Types::Lax]
+      #
+      # @api private
+      def type_schema
+        steps.type_schema
+      end
+
+      # Return type schema used when composing subschemas
+      #
+      # @return [Dry::Types::Schema]
+      #
+      # @api private
+      def strict_type_schema
+        schema_dsl.strict_type_schema
+      end
+
+      # Return the rule applier
+      #
+      # @api private
+      def rule_applier
+        steps.rule_applier
+      end
+      alias_method :to_rule, :rule_applier
+
+      # Return the rules config
+      #
+      # @return [Dry::Types::Config]
+      #
+      # @api private
+      def config
+        @config ||= rule_applier.config
+      end
+
+      # Return AST representation of the rules
+      #
+      # @api private
+      def to_ast(*)
+        rule_applier.to_ast
+      end
+      alias_method :ast, :to_ast
+
+      # Return the message compiler
+      #
+      # @return [MessageCompiler]
+      #
+      # @api private
+      def message_compiler
+        rule_applier.message_compiler
+      end
+
+      # Return the rules from rule applier
+      #
+      # @return [MessageCompiler]
+      #
+      # @api private
+      def rules
+        rule_applier.rules
+      end
+
+      # Return the types from the schema DSL
+      #
+      # @api private
+      def types
+        schema_dsl.types
+      end
+
+      # Check if there are filter rules
+      #
+      # @api private
+      def filter_rules?
+        @filter_rules_predicate ||= schema_dsl.filter_rules?
+      end
+
+      # Return filter schema
+      #
+      # @api private
+      def filter_schema
+        @filter_schema ||= schema_dsl.filter_schema
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # Steps for the Dry::Schema::Processor
+    #
+    # There are 4 main steps:
+    #
+    #   1. `key_coercer` - Prepare input hash using a key map
+    #   2. `filter_schema` - Apply pre-coercion filtering rules
+    #      (optional step, used only when `filter` was used)
+    #   3. `value_coercer` - Apply value coercions based on type specifications
+    #   4. `rule_applier` - Apply rules
+    #
+    # @see Processor
+    #
+    # @api public
+    class ProcessorSteps
+      extend ::Dry::Initializer
+
+      option :steps, default: -> { EMPTY_HASH.dup }
+      option :before_steps, default: -> { EMPTY_HASH.dup }
+      option :after_steps, default: -> { EMPTY_HASH.dup }
+
+      # Executes steps and callbacks in order
+      #
+      # @param [Result] result
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(result)
+        STEPS_IN_ORDER.each do |name|
+          before_steps[name]&.each { |step| step&.(result) }
+          steps[name]&.(result)
+          after_steps[name]&.each { |step| step&.(result) }
+        end
+
+        result
+      end
+
+      # @api private
+      def rule_applier
+        @rule_applier ||= steps[:rule_applier].executor
+      end
+
+      # @api private
+      def key_map
+        @key_map ||= self[:key_coercer].executor.key_map
+      end
+
+      # @api private
+      def type_schema
+        @type_schema ||= steps[:value_coercer].executor.type_schema
+      end
+
+      # Returns step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def [](name)
+        steps[name]
+      end
+
+      # Sets step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def []=(name, value)
+        steps[name] = Step.new(type: :core, name: name, executor: value)
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def after(name, &block)
+        after_steps[name] ||= EMPTY_ARRAY.dup
+        after_steps[name] << Step.new(type: :after, name: name, executor: block)
+        after_steps[name].sort_by!(&:path)
+        self
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def before(name, &block)
+        before_steps[name] ||= EMPTY_ARRAY.dup
+        before_steps[name] << Step.new(type: :before, name: name, executor: block)
+        before_steps[name].sort_by!(&:path)
+        self
+      end
+
+      # Stacks callback steps and returns new ProcessorSteps instance
+      #
+      # @param [ProcessorSteps] other
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def merge(other)
+        ProcessorSteps.new(
+          before_steps: merge_callbacks(before_steps, other.before_steps),
+          after_steps: merge_callbacks(after_steps, other.after_steps)
+        )
+      end
+
+      # @api private
+      def merge_callbacks(left, right)
+        left.merge(right) do |_key, oldval, newval|
+          (oldval + newval).sort_by(&:path)
+        end
+      end
+
+      # @api private
+      def import_callbacks(path, other)
+        other.before_steps.each do |name, steps|
+          before_steps[name] ||= []
+          before_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
+        end
+
+        other.after_steps.each do |name, steps|
+          after_steps[name] ||= []
+          after_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/core/equalizer"
+
+module Dry
+  module Schema
+    # Processing result
+    #
+    # @see Processor#call
+    #
+    # @api public
+    class Result
+      include ::Dry::Equalizer(:output, :errors)
+
+      extend ::Dry::Initializer[undefined: false]
+
+      # @api private
+      param :output, reader: false
+
+      # A list of failure ASTs produced by rule result objects
+      #
+      # @api private
+      option :result_ast, default: -> { EMPTY_ARRAY.dup }
+
+      # @api private
+      option :message_compiler
+
+      # @api private
+      option :path, optional: true, reader: false
+
+      # @api private
+      def self.new(*, **)
+        result = super
+        yield(result) if block_given?
+        result.freeze
+      end
+
+      # Return a new result scoped to a specific path
+      #
+      # @param path [Symbol, Array, Path]
+      #
+      # @return [Result]
+      #
+      # @api private
+      def at(at_path, &)
+        new(@output, path: Path.new([*path, *Path[at_path]]), &)
+      end
+
+      # @api private
+      def new(output, **opts, &)
+        self.class.new(
+          output,
+          message_compiler: message_compiler,
+          result_ast: result_ast,
+          **opts,
+          &
+        )
+      end
+
+      # @api private
+      def update(hash)
+        output.update(hash)
+        self
+      end
+
+      # @api private
+      def path
+        @path || Path::EMPTY
+      end
+
+      # Dump result to a hash returning processed and validated data
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def output
+        path.equal?(Path::EMPTY) ? @output : @output.dig(*path)
+      end
+      alias_method :to_h, :output
+
+      # @api private
+      def replace(value)
+        if value.is_a?(output.class)
+          output.replace(value)
+        elsif path.equal?(Path::EMPTY)
+          @output = value
+        else
+          value_holder = path.keys.length > 1 ? @output.dig(*path.to_a[0..-2]) : @output
+
+          value_holder[path.last] = value
+        end
+
+        self
+      end
+
+      # @api private
+      def concat(other)
+        result_ast.concat(other.map(&:to_ast))
+        self
+      end
+
+      # Read value from the output hash
+      #
+      # @param [Symbol] name
+      #
+      # @return [Object]
+      #
+      # @api public
+      def [](name)
+        output[name]
+      end
+
+      # Check if a given key is present in the output
+      #
+      # @param [Symbol] name
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def key?(name)
+        output.key?(name)
+      end
+
+      # Check if there's an error for the provided spec
+      #
+      # @param [Symbol, Hash<Symbol=>Symbol>] spec
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def error?(spec)
+        message_set.any? { |msg| Path[msg.path].include?(Path[spec]) }
+      end
+
+      # Check if the result is successful
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def success?
+        result_ast.empty?
+      end
+
+      # Check if the result is not successful
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def failure?
+        !success?
+      end
+
+      # Get human-readable error representation
+      #
+      # @see #message_set
+      #
+      # @return [MessageSet]
+      #
+      # @api public
+      def errors(options = EMPTY_HASH)
+        message_set(options)
+      end
+
+      # Return the message set
+      #
+      # @param [Hash] options
+      # @option options [Symbol] :locale Alternative locale (default is :en)
+      # @option options [Boolean] :hints Whether to include hint messages or not
+      # @option options [Boolean] :full Whether to generate messages that include key names
+      #
+      # @return [MessageSet]
+      #
+      # @api public
+      def message_set(options = EMPTY_HASH)
+        message_compiler.with(options).(result_ast)
+      end
+
+      # Return a string representation of the result
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect} path=#{path.keys.inspect}>"
+      end
+
+      # Pattern matching support
+      #
+      # @api private
+      def deconstruct_keys(_)
+        output
+      end
+
+      # Add a new error AST node
+      #
+      # @api private
+      def add_error(node)
+        result_ast << node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # Applies rules defined within the DSL
+    #
+    # @api private
+    class RuleApplier
+      extend ::Dry::Initializer
+
+      # @api private
+      param :rules
+
+      # @api private
+      option :config, default: -> { Schema.config.dup }
+
+      # @api private
+      option :message_compiler, default: -> { MessageCompiler.new(Messages.setup(config.messages)) }
+
+      # @api private
+      def call(input)
+        results = EMPTY_ARRAY.dup
+
+        rules.each do |name, rule|
+          next if input.error?(name)
+
+          result = rule.(input.to_h)
+          results << result if result.failure?
+        end
+
+        input.concat(results)
+      end
+
+      # @api private
+      def to_ast
+        if config.messages.namespace
+          [:namespace, [config.messages.namespace, [:set, rules.values.map(&:to_ast)]]]
+        else
+          [:set, rules.values.map(&:to_ast)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    class Step
+      # @api private
+      attr_reader :name
+
+      # @api private
+      attr_reader :type
+
+      # @api private
+      attr_reader :executor
+
+      # @api private
+      attr_reader :path
+
+      # @api private
+      def initialize(type:, name:, executor:, path: Path::EMPTY)
+        @type = type
+        @name = name
+        @executor = executor
+        @path = path
+        validate_name(name)
+      end
+
+      # @api private
+      def call(result)
+        scoped_result = path.equal?(Path::EMPTY) ? result : result.at(path)
+
+        output = executor.(scoped_result)
+        scoped_result.replace(output) if output.is_a?(Hash)
+        output
+      end
+
+      # @api private
+      def scoped(parent_path)
+        self.class.new(
+          type: type,
+          name: name,
+          executor: executor,
+          path: Path.new([*parent_path, *path])
+        )
+      end
+
+      private
+
+      # @api private
+      def validate_name(name)
+        return if STEPS_IN_ORDER.include?(name)
+
+        raise ArgumentError, "Undefined step name #{name}. Available names: #{STEPS_IN_ORDER}"
+      end
+    end
+  end
+end