mega-sharp-sys 0.0.1

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Captures predicates defined within the DSL
+    #
+    # @api private
+    class Trace < ::BasicObject
+      INVALID_PREDICATES = %i[key?].freeze
+      RESPOND_TO_MISSING_METHOD = ::Kernel.instance_method(:respond_to_missing?)
+
+      include ::Dry::Equalizer(:compiler, :captures)
+
+      undef eql?
+
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      attr_reader :captures
+
+      # @api private
+      def initialize(compiler = Compiler.new)
+        @compiler = compiler
+        @captures = []
+      end
+
+      # @api private
+      def evaluate(*args, **opts)
+        predicates = opts.empty? ? args : args.push(opts)
+
+        evaluate_predicates(predicates).each do |rule|
+          append(rule)
+        end
+
+        self
+      end
+
+      # @api private
+      def evaluate_predicates(predicates)
+        predicates.flat_map do |predicate|
+          if predicate.respond_to?(:call)
+            predicate
+          elsif predicate.is_a?(::Array)
+            predicate.map { |pred| evaluate_predicates(pred).reduce(:&) }.reduce(:|)
+          elsif predicate.is_a?(::Hash)
+            predicate.map { |pred, *args| __send__(pred, *args) }
+          else
+            __send__(predicate)
+          end
+        end
+      end
+
+      # @api private
+      def append(op)
+        captures << op
+        self
+      end
+      alias_method :<<, :append
+
+      # @api private
+      def to_rule(name = nil)
+        return if captures.empty?
+
+        if name
+          compiler.visit([:key, [name, to_ast]])
+        else
+          reduced_rule
+        end
+      end
+
+      # @api private
+      def to_ast
+        reduced_rule.to_ast
+      end
+
+      # @api private
+      def class
+        ::Dry::Schema::Trace
+      end
+
+      private
+
+      # @api private
+      def reduced_rule
+        captures.map(&:to_ast).map(&compiler.method(:visit)).reduce(:and)
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        RESPOND_TO_MISSING_METHOD.bind_call(self, meth, include_private) ||
+          (meth.to_s.end_with?(QUESTION_MARK) && compiler.support?(meth))
+      end
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if !meth.equal?(:respond_to_missing?) && meth.to_s.end_with?(QUESTION_MARK)
+          if ::Dry::Schema::Trace::INVALID_PREDICATES.include?(meth)
+            ::Kernel.raise InvalidSchemaError, "#{meth} predicate cannot be used in this context"
+          end
+
+          unless compiler.support?(meth)
+            ::Kernel.raise ::ArgumentError, "#{meth} predicate is not defined"
+          end
+
+          predicate = Predicate.new(compiler, meth, args, block)
+          predicate.ensure_valid
+          predicate
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "dry/core/container"
+require "dry/types"
+
+module Dry
+  module Schema
+    # A class to build containers for custom types, which can be used in schemas
+    #
+    # @example
+    #   MyTypeContainer = Dry::Schema::TypeContainer.new
+    #   MyTypeContainer.register('params.fancy_string', Types::FancyString)
+    #
+    # @api public
+    class TypeContainer
+      include ::Dry::Core::Container::Mixin
+
+      def initialize(types_container = ::Dry::Types.container)
+        super()
+
+        merge(types_container)
+      end
+
+      alias_method :registered?, :key?
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+require "dry/schema/types"
+
+module Dry
+  module Schema
+    # A simple wrapper around Dry::Types registry
+    #
+    # This is used internally by specialized processor sub-classes
+    #
+    # @api private
+    class TypeRegistry
+      # @api private
+      attr_reader :types
+
+      # @api private
+      attr_reader :namespace
+
+      # @api private
+      def self.new(types = ::Dry::Types, namespace = :strict)
+        super
+      end
+
+      # @api private
+      def initialize(types, namespace = :strict)
+        @types = types
+        @namespace = namespace
+      end
+
+      # @api private
+      def namespaced(ns)
+        self.class.new(types, ns)
+      end
+
+      # @api private
+      def [](name)
+        key = [namespace, name].compact.join(DOT)
+
+        types.registered?(key) ? types[key] : types[name.to_s]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "dry/types"
+
+module Dry
+  module Schema
+    # Schema's own type registry
+    #
+    # @api public
+    module Types
+      include ::Dry.Types
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Combines multiple logical operations into a single type, taking into
+    # account the type of logical operation (or, and, implication) and the
+    # underlying types (schemas, nominals, etc.)
+    #
+    # @api private
+    class TypesMerger
+      attr_reader :type_registry
+
+      # @api private
+      class ValueMerger
+        attr_reader :types_merger
+        attr_reader :op_class
+        attr_reader :old
+        attr_reader :new
+
+        # @api private
+        def initialize(types_merger, op_class, old, new)
+          @types_merger = types_merger
+          @op_class = op_class
+          @old = old
+          @new = new
+        end
+
+        # @api private
+        def call
+          if op_class <= ::Dry::Logic::Operations::Or
+            merge_or
+          elsif op_class <= ::Dry::Logic::Operations::And
+            merge_and
+          elsif op_class <= ::Dry::Logic::Operations::Implication
+            merge_implication
+          else
+            raise ::ArgumentError, <<~MESSAGE
+              Can't merge operations, op_class=#{op_class}
+            MESSAGE
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_or
+          old | new
+        end
+
+        # @api private
+        def merge_ordered
+          return old if old == new
+
+          unwrapped_old, old_rule = unwrap_type(old)
+          unwrapped_new, new_rule = unwrap_type(new)
+
+          type = merge_unwrapped_types(unwrapped_old, unwrapped_new)
+
+          rule = [old_rule, new_rule].compact.reduce { op_class.new(_1, _2) }
+
+          type = ::Dry::Types::Constrained.new(type, rule: rule) if rule
+
+          type
+        end
+
+        alias_method :merge_and, :merge_ordered
+        alias_method :merge_implication, :merge_ordered
+
+        # @api private
+        def merge_unwrapped_types(unwrapped_old, unwrapped_new)
+          case [unwrapped_old, unwrapped_new]
+          in ::Dry::Types::Schema, ::Dry::Types::Schema
+            merge_schemas(unwrapped_old, unwrapped_new)
+          in [::Dry::Types::AnyClass, _] | [::Dry::Types::Hash, ::Dry::Types::Schema]
+            unwrapped_new
+          in [::Dry::Types::Schema, ::Dry::Types::Hash] | [_, ::Dry::Types::AnyClass]
+            unwrapped_old
+          else
+            merge_equivalent_types(unwrapped_old, unwrapped_new)
+          end
+        end
+
+        # @api private
+        def merge_schemas(unwrapped_old, unwrapped_new)
+          types_merger.type_registry["hash"].schema(
+            types_merger.call(
+              op_class,
+              unwrapped_old.name_key_map,
+              unwrapped_new.name_key_map
+            )
+          )
+        end
+
+        # @api private
+        def merge_equivalent_types(unwrapped_old, unwrapped_new)
+          if unwrapped_old.primitive <= unwrapped_new.primitive
+            unwrapped_new
+          elsif unwrapped_new.primitive <= unwrapped_old.primitive
+            unwrapped_old
+          else
+            raise ::ArgumentError, <<~MESSAGE
+              Can't merge types, unwrapped_old=#{unwrapped_old.inspect}, unwrapped_new=#{unwrapped_new.inspect}
+            MESSAGE
+          end
+        end
+
+        # @api private
+        def unwrap_type(type)
+          rules = []
+
+          loop do
+            rules << type.rule if type.respond_to?(:rule)
+
+            if type.optional?
+              type = type.left.primitive?(nil) ? type.right : type.left
+            elsif type.is_a?(::Dry::Types::Decorator)
+              type = type.type
+            else
+              break
+            end
+          end
+
+          [type, rules.reduce(:&)]
+        end
+      end
+
+      def initialize(type_registry = TypeRegistry.new)
+        @type_registry = type_registry
+      end
+
+      # @api private
+      def call(op_class, lhs, rhs)
+        lhs.merge(rhs) do |_k, old, new|
+          ValueMerger.new(self, op_class, old, new).call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/initializer"
+
+module Dry
+  module Schema
+    # Used by the processors to coerce values in the input hash
+    #
+    # @api private
+    class ValueCoercer
+      extend ::Dry::Initializer
+      include ::Dry::Equalizer(:type_schema)
+
+      # @api private
+      param :type_schema
+
+      # @api private
+      def call(input)
+        if input.success?
+          type_schema[input.to_h]
+        else
+          type_schema.each_with_object(EMPTY_HASH.dup) do |key, hash|
+            name = key.name
+
+            next unless input.key?(name)
+
+            value = input[name]
+
+            hash[name] = input.error?(name) ? value : key[value]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    VERSION = "1.16.0"
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+require "dry/core"
+require "dry/configurable"
+require "dry/logic"
+require "dry/types"
+
+module Dry
+  # Main interface
+  #
+  # @api public
+  module Schema
+    extend ::Dry::Core::Extensions
+
+    # @api private
+    def self.loader
+      @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
+        root = ::File.expand_path("..", __dir__)
+        loader.tag = "dry-schema"
+        loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-schema.rb")
+        loader.inflector.inflect(
+          "dsl" => "DSL",
+          "yaml" => "YAML",
+          "json" => "JSON",
+          "i18n" => "I18n"
+        )
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/dry-schema.rb",
+          "#{root}/dry/schema/{constants,errors,version,extensions}.rb",
+          "#{root}/dry/schema/extensions"
+        )
+        loader.do_not_eager_load("#{root}/dry/schema/messages/i18n.rb")
+        loader.inflector.inflect("dsl" => "DSL")
+      end
+    end
+
+    # Configuration
+    #
+    # @example
+    #   Dry::Schema.config.messages.backend = :i18n
+    #
+    # @return [Config]
+    #
+    # @api public
+    def self.config
+      @config ||= Config.new
+    end
+
+    # Define a schema
+    #
+    # @example
+    #   Dry::Schema.define do
+    #     required(:name).filled(:string)
+    #     required(:age).value(:integer, gt?: 0)
+    #   end
+    #
+    # @param [Hash] options
+    #
+    # @return [Processor]
+    #
+    # @see DSL.new
+    #
+    # @api public
+    def self.define(...)
+      DSL.new(...).call
+    end
+
+    # Define a schema suitable for HTTP params
+    #
+    # This schema type uses `Types::Params` for coercion by default
+    #
+    # @example
+    #   Dry::Schema.Params do
+    #     required(:name).filled(:string)
+    #     required(:age).value(:integer, gt?: 0)
+    #   end
+    #
+    # @return [Params]
+    #
+    # @see Schema#define
+    #
+    # @api public
+    def self.Params(**options, &)
+      define(**options, processor_type: Params, &)
+    end
+    singleton_class.alias_method(:Form, :Params)
+
+    # Define a schema suitable for JSON data
+    #
+    # This schema type uses `Types::JSON` for coercion by default
+    #
+    # @example
+    #   Dry::Schema.JSON do
+    #     required(:name).filled(:string)
+    #     required(:age).value(:integer, gt?: 0)
+    #   end
+    #
+    # @return [Params]
+    #
+    # @see Schema#define
+    #
+    # @api public
+    def self.JSON(**options, &)
+      define(**options, processor_type: JSON, &)
+    end
+
+    loader.setup
+  end
+end
+
+require "dry/schema/extensions"

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

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

data/mega-sharp-sys.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = "mega-sharp-sys"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on dry-schema"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: mega-sharp-sys
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on dry-schema
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dry-schema-1.16.0/CHANGELOG.md
+- dry-schema-1.16.0/LICENSE
+- dry-schema-1.16.0/README.md
+- dry-schema-1.16.0/config/errors.yml
+- dry-schema-1.16.0/dry-schema.gemspec
+- dry-schema-1.16.0/lib/dry-schema.rb
+- dry-schema-1.16.0/lib/dry/schema.rb
+- dry-schema-1.16.0/lib/dry/schema/compiler.rb
+- dry-schema-1.16.0/lib/dry/schema/config.rb
+- dry-schema-1.16.0/lib/dry/schema/constants.rb
+- dry-schema-1.16.0/lib/dry/schema/dsl.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/hints.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/hints/compiler_methods.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/hints/message_compiler_methods.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/hints/message_set_methods.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/hints/result_methods.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/info.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/info/schema_compiler.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/json_schema.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/json_schema/schema_compiler.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/monads.rb
+- dry-schema-1.16.0/lib/dry/schema/extensions/struct.rb
+- dry-schema-1.16.0/lib/dry/schema/json.rb
+- dry-schema-1.16.0/lib/dry/schema/key.rb
+- dry-schema-1.16.0/lib/dry/schema/key_coercer.rb
+- dry-schema-1.16.0/lib/dry/schema/key_map.rb
+- dry-schema-1.16.0/lib/dry/schema/key_validator.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/array.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/core.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/dsl.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/each.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/filled.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/hash.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/key.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/maybe.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/optional.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/required.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/schema.rb
+- dry-schema-1.16.0/lib/dry/schema/macros/value.rb
+- dry-schema-1.16.0/lib/dry/schema/message.rb
+- dry-schema-1.16.0/lib/dry/schema/message/or.rb
+- dry-schema-1.16.0/lib/dry/schema/message/or/abstract.rb
+- dry-schema-1.16.0/lib/dry/schema/message/or/multi_path.rb
+- dry-schema-1.16.0/lib/dry/schema/message/or/single_path.rb
+- dry-schema-1.16.0/lib/dry/schema/message_compiler.rb
+- dry-schema-1.16.0/lib/dry/schema/message_compiler/visitor_opts.rb
+- dry-schema-1.16.0/lib/dry/schema/message_set.rb
+- dry-schema-1.16.0/lib/dry/schema/messages.rb
+- dry-schema-1.16.0/lib/dry/schema/messages/abstract.rb
+- dry-schema-1.16.0/lib/dry/schema/messages/i18n.rb
+- dry-schema-1.16.0/lib/dry/schema/messages/namespaced.rb
+- dry-schema-1.16.0/lib/dry/schema/messages/template.rb
+- dry-schema-1.16.0/lib/dry/schema/messages/yaml.rb
+- dry-schema-1.16.0/lib/dry/schema/namespaced_rule.rb
+- dry-schema-1.16.0/lib/dry/schema/params.rb
+- dry-schema-1.16.0/lib/dry/schema/path.rb
+- dry-schema-1.16.0/lib/dry/schema/predicate.rb
+- dry-schema-1.16.0/lib/dry/schema/predicate_inferrer.rb
+- dry-schema-1.16.0/lib/dry/schema/predicate_registry.rb
+- dry-schema-1.16.0/lib/dry/schema/primitive_inferrer.rb
+- dry-schema-1.16.0/lib/dry/schema/processor.rb
+- dry-schema-1.16.0/lib/dry/schema/processor_steps.rb
+- dry-schema-1.16.0/lib/dry/schema/result.rb
+- dry-schema-1.16.0/lib/dry/schema/rule_applier.rb
+- dry-schema-1.16.0/lib/dry/schema/step.rb
+- dry-schema-1.16.0/lib/dry/schema/trace.rb
+- dry-schema-1.16.0/lib/dry/schema/type_container.rb
+- dry-schema-1.16.0/lib/dry/schema/type_registry.rb
+- dry-schema-1.16.0/lib/dry/schema/types.rb
+- dry-schema-1.16.0/lib/dry/schema/types_merger.rb
+- dry-schema-1.16.0/lib/dry/schema/value_coercer.rb
+- dry-schema-1.16.0/lib/dry/schema/version.rb
+- mega-sharp-sys.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []