mega-sharp-sys 0.0.1

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # A macro used for specifying predicates to be applied to values from a hash
+      #
+      # @api private
+      class Value < DSL
+        # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def call(*args, **opts, &)
+          types, predicates = args.partition { _1.is_a?(::Dry::Types::Type) }
+
+          constructor = types.select { _1.is_a?(::Dry::Types::Constructor) }.reduce(:>>)
+          schema = predicates.detect { _1.is_a?(Processor) }
+
+          schema_dsl.set_type(name, constructor) if constructor
+
+          type_spec = opts[:type_spec]
+
+          if schema
+            current_type = schema_dsl.types[name]
+
+            updated_type =
+              if array_type?(current_type)
+                build_array_type(current_type, schema.strict_type_schema)
+              else
+                schema.strict_type_schema
+              end
+
+            import_steps(schema)
+
+            if !custom_type? || array_type?(current_type) || hash_type?(current_type)
+              type(updated_type)
+            elsif maybe_type?(current_type)
+              type(updated_type.optional)
+            end
+          end
+
+          trace_opts = opts.except(:type_spec, :type_rule)
+
+          if (type_rule = opts[:type_rule])
+            trace.append(type_rule).evaluate(*predicates, **trace_opts)
+            trace.append(new(chain: false).instance_exec(&)) if block_given?
+          else
+            trace.evaluate(*predicates, **trace_opts)
+
+            if block_given? && type_spec.equal?(:hash)
+              hash(&)
+            elsif type_spec.is_a?(::Dry::Types::Type) && hash_type?(type_spec)
+              hash(type_spec)
+            elsif block_given?
+              trace.append(new(chain: false).instance_exec(&))
+            end
+          end
+
+          if trace.captures.empty?
+            raise ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
+          end
+
+          each(type_spec.type.member) if type_spec.respond_to?(:member)
+
+          self
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        # @api private
+        def array_type?(type)
+          primitive_inferrer[type].eql?([::Array])
+        end
+
+        # @api private
+        def hash_type?(type)
+          primitive_inferrer[type].eql?([::Hash])
+        end
+
+        # @api private
+        def maybe_type?(type)
+          type.meta[:maybe].equal?(true)
+        end
+
+        # @api private
+        def build_array_type(array_type, member)
+          if array_type.respond_to?(:of)
+            array_type.of(member)
+          else
+            raise ArgumentError, <<~ERROR.split("\n").join(" ")
+              Cannot define schema for a nominal array type.
+              Array types must be instances of Dry::Types::Array,
+              usually constructed with Types::Constructor(Array) { ... } or
+              Dry::Types['array'].constructor { ... }
+            ERROR
+          end
+        end
+
+        # @api private
+        def import_steps(schema)
+          schema_dsl.steps.import_callbacks(Path[[*path, name]], schema.steps)
+        end
+
+        # @api private
+        def respond_to_missing?(meth, include_private = false)
+          super || meth.to_s.end_with?(QUESTION_MARK)
+        end
+
+        private
+
+        # @api private
+        def method_missing(meth, ...)
+          if meth.to_s.end_with?(QUESTION_MARK)
+            trace.__send__(meth, ...)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/message/or/abstract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations
+        #
+        # @abstract
+        #
+        # @api private
+        class Abstract
+          # @api private
+          attr_reader :left
+
+          # @api private
+          attr_reader :right
+
+          # @api private
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/message/or/multi_path.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with different paths
+        #
+        # @api public
+        class MultiPath < Abstract
+          # @api private
+          class MessageArray
+            # @api private
+            def initialize(messages)
+              @messages = messages.flatten
+            end
+
+            # @api private
+            def _paths
+              @messages.map(&:_path)
+            end
+
+            # @api private
+            def to_or(root)
+              self.class.new(@messages.map { _1.to_or(root) })
+            end
+
+            # @api private
+            def to_h
+              MessageSet.new(@messages).to_h
+            end
+          end
+
+          MESSAGE_ARRAY_HANDLER = -> { MessageArray.new(_1) }
+
+          # @api private
+          def self.handler(message)
+            case message
+            when self
+              IDENTITY
+            when Array
+              MESSAGE_ARRAY_HANDLER
+            end
+          end
+
+          # @api public
+          def to_h
+            @to_h ||= Path[[*root, :or]].to_h(messages.map(&:to_h))
+          end
+
+          # @api private
+          def messages
+            @messages ||= _messages.flat_map { _1.to_or(root) }
+          end
+
+          # @api private
+          def root
+            @root ||= _paths.reduce(:&)
+          end
+
+          # @api private
+          def path
+            root
+          end
+
+          # @api private
+          def _path
+            @_path ||= Path[root]
+          end
+
+          # @api private
+          def _paths
+            @paths ||= _messages.flat_map(&:_paths)
+          end
+
+          # @api private
+          def to_or(root)
+            self.root == root ? messages : [self]
+          end
+
+          private
+
+          # @api private
+          def _messages
+            @_messages ||= [left, right].map do |message|
+              handler = self.class.handler(message)
+
+              unless handler
+                raise ArgumentError,
+                      "#{message.inspect} is of unknown type #{message.class.inspect}"
+              end
+
+              handler.(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/message/or/single_path.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with the same path
+        #
+        # @api public
+        class SinglePath < Abstract
+          # @api private
+          attr_reader :path
+
+          # @api private
+          attr_reader :_path
+
+          # @api private
+          attr_reader :messages
+
+          # @api private
+          def initialize(*args, messages)
+            super(*args.map { [_1].flatten })
+            @messages = messages
+            message = left.first
+            @path = message.path
+            @_path = message._path
+          end
+
+          # Dump a message into a string
+          #
+          # Both sides of the message will be joined using translated
+          # value under `dry_schema.or` message key
+          #
+          # @see Message#dump
+          #
+          # @return [String]
+          #
+          # @api public
+          def dump
+            @dump ||= [*left, *right].map(&:dump).join(" #{messages[:or]} ")
+          end
+          alias_method :to_s, :dump
+
+          # Dump an `or` message into a hash
+          #
+          # @see Message#to_h
+          #
+          # @return [String]
+          #
+          # @api public
+          def to_h
+            @to_h ||= _path.to_h(dump)
+          end
+
+          # @api private
+          def to_a
+            @to_a ||= [*left, *right]
+          end
+
+          # @api private
+          def to_or(root)
+            to_ored = [left, right].map do |msgs|
+              msgs.map { _1.to_or(root) }
+            end
+
+            self.class.new(*to_ored, messages)
+          end
+        end
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/message/or.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Message objects used by message sets
+    #
+    # @api public
+    class Message
+      module Or
+        # @api private
+        def self.[](left, right, messages)
+          msgs = [left, right].flatten
+          paths = msgs.map(&:path)
+
+          if paths.uniq.size == 1
+            SinglePath.new(left, right, messages)
+          elsif MultiPath.handler(right)
+            if MultiPath.handler(left) && paths.uniq.size > 1
+              MultiPath.new(left, right)
+            else
+              right
+            end
+          else
+            msgs.max
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+
+module Dry
+  module Schema
+    # Message objects used by message sets
+    #
+    # @api public
+    class Message
+      include ::Dry::Equalizer(:text, :path, :predicate, :input)
+
+      extend ::Dry::Initializer
+
+      # @!attribute [r] text
+      #   Message text representation created from a localized template
+      #   @return [String]
+      option :text
+
+      # @!attribute [r] path
+      #   Path to the value
+      #   @return [String]
+      option :path
+
+      # @!attribute [r] predicate
+      #   Predicate identifier that was used to produce a message
+      #   @return [Symbol]
+      option :predicate
+
+      # @!attribute [r] args
+      #   Optional list of arguments used by the predicate
+      #   @return [Array]
+      option :args, default: proc { EMPTY_ARRAY }
+
+      # @!attribute [r] input
+      #   The input value
+      #   @return [Object]
+      option :input
+
+      # @!attribute [r] meta
+      #   Arbitrary meta data
+      #   @return [Hash]
+      option :meta, optional: true, default: proc { EMPTY_HASH }
+
+      # Dump the message to a representation suitable for the message set hash
+      #
+      # @return [String,Hash]
+      #
+      # @api public
+      def dump
+        @dump ||= meta.empty? ? text : {text: text, **meta}
+      end
+      alias_method :to_s, :dump
+
+      # Dump the message into a hash
+      #
+      # The hash will be deeply nested if the path's size is greater than 1
+      #
+      # @see Message#to_h
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @to_h ||= _path.to_h(dump)
+      end
+
+      # See if another message is the same
+      #
+      # If a string is passed, it will be compared with the text
+      #
+      # @param other [Message,String]
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def eql?(other)
+        other.is_a?(::String) ? text == other : super
+      end
+
+      # @api private
+      def to_or(root)
+        clone = dup
+        clone.instance_variable_set("@path", remove_prefix(path, prefix: root.to_a))
+        clone.instance_variable_set("@_path", nil)
+        clone
+      end
+
+      # See which message is higher in the hierarchy
+      #
+      # @api private
+      def <=>(other)
+        l_path = _path
+        r_path = other._path
+
+        unless l_path.same_root?(r_path)
+          raise ::ArgumentError, "Cannot compare messages from different root paths"
+        end
+
+        l_path <=> r_path
+      end
+
+      # @api private
+      def _path
+        @_path ||= Path[path]
+      end
+
+      private
+
+      def remove_prefix(array, prefix:)
+        has_prefix = array[0, prefix.length] == prefix
+        has_prefix ? array[prefix.length..] : array.dup
+      end
+    end
+  end
+end

data/dry-schema-1.16.0/lib/dry/schema/message_compiler/visitor_opts.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # @api private
+    class MessageCompiler
+      # Optimized option hash used by visitor methods in message compiler
+      #
+      # @api private
+      class VisitorOpts < Hash
+        # @api private
+        def self.new
+          opts = super
+          opts[:path] = EMPTY_ARRAY
+          opts[:message_type] = :failure
+          opts[:current_messages] = EMPTY_ARRAY.dup
+          opts
+        end
+
+        # @api private
+        def path
+          self[:path]
+        end
+
+        # @api private
+        def call(other)
+          merge(other.update(path: [*path, *other[:path]]))
+        end
+
+        def dup(current_messages = EMPTY_ARRAY.dup)
+          opts = super()
+          opts[:current_messages] = current_messages
+          opts
+        end
+
+        def key_failure?(path)
+          failures.any? { |f| f.path == path && f.predicate.equal?(:key?) }
+        end
+
+        def failures
+          current_messages.reject(&:hint?)
+        end
+
+        def hints
+          current_messages.select(&:hint?)
+        end
+
+        def current_messages
+          self[:current_messages]
+        end
+      end
+    end
+  end
+end