mega-sharp-sys 0.0.1

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

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro specialization used within the DSL
+      #
+      # @api public
+      class DSL < Core
+        include ::Dry::Logic::Operators
+
+        undef :eql?
+        undef :nil?
+        undef :respond_to?
+
+        # @!attribute [r] chain
+        #   Indicate if the macro should append its rules to the provided trace
+        #   @return [Boolean]
+        #   @api private
+        option :chain, default: -> { true }
+
+        # @!attribute [r] predicate_inferrer
+        #   PredicateInferrer is used to infer predicate type-check from a type spec
+        #   @return [PredicateInferrer]
+        #   @api private
+        option :predicate_inferrer, default: proc { PredicateInferrer.new(compiler.predicates) }
+
+        # @!attribute [r] primitive_inferrer
+        #   PrimitiveInferrer used to get a list of primitive classes from configured type
+        #   @return [PrimitiveInferrer]
+        #   @api private
+        option :primitive_inferrer, default: proc { PrimitiveInferrer.new }
+
+        # @overload value(*predicates, **predicate_opts)
+        #   Set predicates without and with arguments
+        #
+        #   @param [Array<Symbol>] predicates
+        #   @param [Hash] predicate_opts
+        #
+        #   @example with a predicate
+        #     required(:name).value(:filled?)
+        #
+        #   @example with a predicate with arguments
+        #     required(:name).value(min_size?: 2)
+        #
+        #   @example with a predicate with and without arguments
+        #     required(:name).value(:filled?, min_size?: 2)
+        #
+        #   @example with a block
+        #     required(:name).value { filled? & min_size?(2) }
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def value(*args, **opts, &block)
+          if (type_spec_from_opts = opts[:type_spec])
+            append_macro(Macros::Value) do |macro|
+              macro.call(*args, type_spec: type_spec_from_opts, **opts, &block)
+            end
+          else
+            extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+              append_macro(Macros::Value) do |macro|
+                macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+              end
+            end
+          end
+        end
+
+        # Prepends `:filled?` predicate
+        #
+        # @example with a type spec
+        #   required(:name).filled(:string)
+        #
+        # @example with a type spec and a predicate
+        #   required(:name).filled(:string, format?: /\w+/)
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def filled(*args, **opts, &block)
+          extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Filled) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
+          end
+        end
+
+        # Set type specification and predicates for a maybe value
+        #
+        # @example
+        #   required(:name).maybe(:string)
+        #
+        # @see Macros::Key#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def maybe(*args, **opts, &block)
+          extract_type_spec(args, nullable: true) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Maybe) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
+          end
+        end
+
+        # Specify a nested hash without enforced `hash?` type-check
+        #
+        # This is a simpler building block than `hash` macro, use it
+        # when you want to provide `hash?` type-check with other rules
+        # manually.
+        #
+        # @example
+        #   required(:tags).value(:hash, min_size?: 1).schema do
+        #     required(:name).value(:string)
+        #   end
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def schema(...)
+          append_macro(Macros::Schema) do |macro|
+            macro.call(...)
+          end
+        end
+
+        # Specify a nested hash with enforced `hash?` type-check
+        #
+        # @example
+        #   required(:tags).hash do
+        #     required(:name).value(:string)
+        #   end
+        #
+        # @api public
+        def hash(...)
+          append_macro(Macros::Hash) do |macro|
+            macro.call(...)
+          end
+        end
+
+        # Specify predicates that should be applied to each element of an array
+        #
+        # This is a simpler building block than `array` macro, use it
+        # when you want to provide `array?` type-check with other rules
+        # manually.
+        #
+        # @example a list of strings
+        #   required(:tags).value(:array, min_size?: 2).each(:str?)
+        #
+        # @example a list of hashes
+        #   required(:tags).value(:array, min_size?: 2).each(:hash) do
+        #     required(:name).filled(:string)
+        #   end
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def each(...)
+          append_macro(Macros::Each) do |macro|
+            macro.value(...)
+          end
+        end
+
+        # Like `each` but sets `array?` type-check
+        #
+        # @example a list of strings
+        #   required(:tags).array(:str?)
+        #
+        # @example a list of hashes
+        #   required(:tags).array(:hash) do
+        #     required(:name).filled(:string)
+        #   end
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def array(...)
+          append_macro(Macros::Array) do |macro|
+            macro.value(...)
+          end
+        end
+
+        # Set type spec
+        #
+        # @example
+        #   required(:name).type(:string).value(min_size?: 2)
+        #
+        # @param [Symbol, Array, Dry::Types::Type] spec
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def type(spec)
+          schema_dsl.set_type(name, spec)
+          self
+        end
+
+        # @api private
+        def custom_type?
+          schema_dsl.custom_type?(name)
+        end
+
+        private
+
+        # @api private
+        def append_macro(macro_type)
+          macro = macro_type.new(schema_dsl: schema_dsl, name: name)
+
+          yield(macro)
+
+          if chain
+            trace << macro
+            self
+          else
+            macro
+          end
+        end
+
+        # @api private
+        # rubocop: disable Metrics/AbcSize
+        # rubocop: disable Metrics/CyclomaticComplexity
+        # rubocop: disable Metrics/PerceivedComplexity
+        def extract_type_spec(args, nullable: false, set_type: true)
+          type_spec = args[0] unless schema_or_predicate?(args[0])
+
+          predicates = Array(type_spec ? args[1..] : args)
+          type_rule = nil
+
+          if type_spec
+            resolved_type = resolve_type(type_spec, nullable)
+
+            if type_spec.is_a?(::Array)
+              type_rule = type_spec.map { |ts| new(chain: false).value(ts) }.reduce(:|)
+            elsif type_spec.is_a?(Dry::Types::Sum) && set_type
+              type_rule = [type_spec.left, type_spec.right].map { |ts|
+                new(klass: Core, chain: false).value(ts)
+              }.reduce(:|)
+            elsif type_spec.is_a?(Dry::Types::Intersection) && set_type
+              type_rule = [type_spec.left, type_spec.right].map { |ts|
+                new(klass: Core, chain: false).value(ts)
+              }.reduce(:&)
+            else
+              type_predicates = predicate_inferrer[resolved_type]
+
+              predicates.replace(type_predicates + predicates) unless type_predicates.empty?
+
+              return self if predicates.empty?
+            end
+          end
+
+          type(resolved_type) if set_type && resolved_type
+
+          if type_rule
+            yield(*predicates, type_spec: nil, type_rule: type_rule)
+          else
+            yield(*predicates, type_spec: type_spec, type_rule: nil)
+          end
+        end
+        # rubocop: enable Metrics/AbcSize
+        # rubocop: enable Metrics/CyclomaticComplexity
+        # rubocop: enable Metrics/PerceivedComplexity
+
+        # @api private
+        def resolve_type(type_spec, nullable)
+          resolved = schema_dsl.resolve_type(type_spec)
+
+          if type_spec.is_a?(::Array) || !nullable || resolved.optional?
+            resolved
+          else
+            schema_dsl.resolve_type([:nil, resolved])
+          end
+        end
+
+        # @api private
+        def schema_or_predicate?(arg)
+          arg.is_a?(Dry::Schema::Processor) ||
+            (arg.is_a?(Symbol) &&
+              arg.to_s.end_with?(QUESTION_MARK))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for each element of an array
+      #
+      # @api private
+      class Each < DSL
+        # @api private
+        def value(*args, **opts, &block)
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
+            if type_spec && !type_spec.is_a?(Dry::Types::Type)
+              type(schema_dsl.array[type_spec])
+            end
+
+            append_macro(Macros::Value) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
+          end
+        end
+
+        # @api private
+        def 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/filled.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to prepend `:filled?` predicate
+      #
+      # @api private
+      class Filled < Value
+        # @api private
+        def call(*predicates, **opts, &block)
+          ensure_valid_predicates(predicates)
+
+          append_macro(Macros::Value) do |macro|
+            if opts[:type_spec] && !filter_empty_string?
+              macro.call(predicates[0], :filled?, *predicates.drop(1), **opts, &block)
+            elsif opts[:type_rule]
+              macro.call(:filled?).value(*predicates, **opts, &block)
+            else
+              macro.call(:filled?, *predicates, **opts, &block)
+            end
+          end
+        end
+
+        # @api private
+        def ensure_valid_predicates(predicates)
+          if predicates.include?(:empty?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with empty? predicate is invalid"
+          end
+
+          if predicates.include?(:filled?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with filled? is redundant"
+          end
+        end
+
+        # @api private
+        def filter_empty_string?
+          !expected_primitives.include?(NilClass) && processor_config.filter_empty_string
+        end
+
+        # @api private
+        def processor_config
+          schema_dsl.processor_type.config
+        end
+
+        # @api private
+        def expected_primitives
+          primitive_inferrer[schema_type]
+        end
+
+        # @api private
+        def schema_type
+          schema_dsl.types[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify a nested schema
+      #
+      # @api private
+      class Hash < Schema
+        # @api private
+        def call(*args, &block)
+          if args.size >= 1 && args[0].respond_to?(:keys)
+            hash_type = args[0]
+            type_predicates = predicate_inferrer[hash_type]
+            all_predicats = type_predicates + args.drop(1)
+
+            super(*all_predicats) do
+              hash_type.each do |key|
+                if key.required?
+                  required(key.name).value(key.type)
+                else
+                  optional(key.name).value(key.type)
+                end
+                instance_exec(&block) if block_given?
+              end
+            end
+          else
+            trace << hash?
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Base macro for specifying rules applied to a value found under a key
+      #
+      # @api public
+      class Key < DSL
+        # @!attribute [r] filter_schema_dsl
+        #   @return [Schema::DSL]
+        #   @api private
+        option :filter_schema_dsl, default: proc { schema_dsl&.filter_schema_dsl }
+
+        # Specify predicates that should be applied before coercion
+        #
+        # @example check format before coercing to a date
+        #   required(:publish_date).filter(format?: /\d{4}-\d{2}-\d{2}).value(:date)
+        #
+        # @see Macros::Key#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def filter(...)
+          (filter_schema_dsl[name] || filter_schema_dsl.optional(name)).value(...)
+          self
+        end
+
+        # Coerce macro to a rule
+        #
+        # @return [Dry::Logic::Rule]
+        #
+        # @api private
+        def to_rule
+          if trace.captures.empty?
+            super
+          else
+            [super, trace.to_rule(name)].reduce(operation)
+          end
+        end
+
+        # @api private
+        def to_ast
+          [:predicate, [:key?, [[:name, name], [:input, Undefined]]]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify predicates for a value that can be `nil`
+      #
+      # @api private
+      class Maybe < DSL
+        # @api private
+        def call(*args, **opts, &block)
+          if args.include?(:empty?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with empty? predicate is invalid"
+          end
+
+          if args.include?(:nil?)
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with nil? predicate is redundant"
+          end
+
+          append_macro(Macros::Value) do |macro|
+            macro.call(*args, **opts, &block)
+          end
+
+          self
+        end
+
+        # @api private
+        def to_ast
+          [:implication,
+           [
+             [:not, [:predicate, [:nil?, [[:input, Undefined]]]]],
+             trace.to_rule.to_ast
+           ]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # A Key specialization used for keys that can be skipped
+      #
+      # @api private
+      class Optional < Key
+        # @api private
+        def operation
+          :then
+        end
+
+        # @api private
+        def to_rule
+          super unless trace.captures.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # A Key specialization used for keys that must be present
+      #
+      # @api private
+      class Required < Key
+        # @api private
+        def operation
+          :and
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify a nested schema
+      #
+      # @api private
+      class Schema < Value
+        # @api private
+        def call(*args, &block)
+          super(*args, &nil) unless args.empty?
+
+          if args.size.equal?(1) && (op = args.first).is_a?(::Dry::Logic::Operations::Abstract)
+            process_operation(op)
+          end
+
+          if block
+            schema = define(*args, &block)
+            import_steps(schema)
+            trace << schema.to_rule
+          end
+
+          self
+        end
+
+        private
+
+        # @api private
+        def process_operation(op)
+          type(hash_type.schema(merge_operation_types(op)))
+        end
+
+        # @api private
+        def hash_type
+          schema_dsl.resolve_type(:hash)
+        end
+
+        # @api private
+        def merge_operation_types(op)
+          op.rules.reduce({}) do |acc, rule|
+            types =
+              case rule
+              when Dry::Logic::Operations::Abstract
+                merge_operation_types(rule)
+              when Processor
+                rule.types
+              else
+                EMPTY_HASH.dup
+              end
+
+            schema_dsl.merge_types(op.class, acc, types)
+          end
+        end
+
+        # @api private
+        # rubocop: disable Metrics/AbcSize
+        def define(*args, &)
+          definition = schema_dsl.new(path: schema_dsl.path, &)
+          schema = definition.call
+          type_schema =
+            if array_type?(parent_type)
+              build_array_type(parent_type, definition.strict_type_schema)
+            elsif redefined_schema?(args)
+              parent_type.schema(definition.types)
+            else
+              definition.strict_type_schema
+            end
+          final_type = optional? ? type_schema.optional : type_schema
+
+          type(final_type)
+
+          if schema.filter_rules?
+            schema_dsl[name].filter { hash?.then(schema(schema.filter_schema)) }
+          end
+
+          schema
+        end
+        # rubocop: enable Metrics/AbcSize
+
+        # @api private
+        def parent_type
+          schema_dsl.types[name]
+        end
+
+        # @api private
+        def optional?
+          parent_type.optional?
+        end
+
+        # @api private
+        def schema?
+          parent_type.respond_to?(:schema)
+        end
+
+        # @api private
+        def redefined_schema?(args)
+          schema? && args.first.is_a?(Processor)
+        end
+      end
+    end
+  end
+end