mega-sharp-sys 0.0.1

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Messages
+      # Namespaced messages backend
+      #
+      # @api public
+      class Namespaced < ::Dry::Schema::Messages::Abstract
+        # @api private
+        attr_reader :namespace
+
+        # @api private
+        attr_reader :messages
+
+        # @api private
+        attr_reader :config
+
+        # @api private
+        attr_reader :call_opts
+
+        # @api private
+        def initialize(namespace, messages)
+          super()
+          @config = messages.config
+          @namespace = namespace
+          @messages = messages
+          @call_opts = {namespace: namespace}.freeze
+        end
+
+        # Get a message for the given key and its options
+        #
+        # @param [Symbol] key
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def get(key, options = {})
+          messages.get(key, options)
+        end
+
+        # @api public
+        def call(key, options = {})
+          super(key, options.empty? ? call_opts : options.merge(call_opts))
+        end
+        alias_method :[], :call
+
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, *args)
+          messages.key?(key, *args)
+        end
+
+        # @api private
+        def filled_lookup_paths(tokens)
+          super(tokens.merge(root: "#{tokens[:root]}.#{namespace}")) + super
+        end
+
+        # @api private
+        def rule_lookup_paths(tokens)
+          base_paths = messages.rule_lookup_paths(tokens)
+          base_paths.map { |key|
+            key.sub(config.top_namespace, "#{config.top_namespace}.#{namespace}")
+          } + base_paths
+        end
+
+        # @api private
+        def cache_key(predicate, options)
+          messages.cache_key(predicate, options)
+        end
+
+        # @api private
+        def interpolatable_data(key, options, **data)
+          messages.interpolatable_data(key, options, **data)
+        end
+
+        # @api private
+        def interpolate(key, options, **data)
+          messages.interpolate(key, options, **data)
+        end
+
+        # @api private
+        def translate(key, **args)
+          messages.translate(key, **args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/core/equalizer"
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    module Messages
+      # @api private
+      class Template
+        extend ::Dry::Initializer
+        include ::Dry::Equalizer(:messages, :key, :options)
+
+        option :messages
+        option :key
+        option :options
+
+        # @api private
+        def data(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolatable_data(key, options, **options, **data)
+        end
+
+        # @api private
+        def call(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolate(key, options, **data)
+        end
+        alias_method :[], :call
+
+        private
+
+        def ensure_message!
+          return if messages.key?(key, options)
+
+          raise KeyError, "No message found for template, template=#{inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    module Messages
+      # Plain YAML message backend
+      #
+      # @api public
+      class YAML < Abstract
+        LOCALE_TOKEN = "%<locale>s"
+        TOKEN_REGEXP = /%{(\w*)}/
+        EMPTY_CONTEXT = ::Object.new.tap { |ctx|
+          def ctx.context
+            binding
+          end
+        }.freeze.context
+
+        include ::Dry::Equalizer(:data)
+
+        # Loaded localized message templates
+        #
+        # @return [Hash]
+        attr_reader :data
+
+        # Translation function
+        #
+        # @return [Proc]
+        attr_reader :t
+
+        # @api private
+        def self.build(options = EMPTY_HASH)
+          super do |config|
+            config.default_locale = :en unless config.default_locale
+
+            config.root = -"%<locale>s.#{config.root}"
+
+            config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+              -"%<locale>s.#{path}"
+            }
+          end
+        end
+
+        # @api private
+        # rubocop: disable Metrics/PerceivedComplexity
+        def self.flat_hash(hash, path = EMPTY_ARRAY, keys = {})
+          hash.each do |key, value|
+            flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
+
+            if value.is_a?(String) && hash["text"] != value
+              keys[[*path, key].join(DOT)] = {
+                text: value,
+                meta: EMPTY_HASH
+              }
+            elsif value.is_a?(Hash) && value["text"].is_a?(String)
+              keys[[*path, key].join(DOT)] = {
+                text: value["text"],
+                meta: value.reject { _1.eql?("text") }.transform_keys(&:to_sym)
+              }
+            end
+          end
+
+          keys
+        end
+        # rubocop: enable Metrics/PerceivedComplexity
+
+        # @api private
+        def self.cache
+          @cache ||= Concurrent::Map.new do |h, k|
+            h.compute_if_absent(k) { Concurrent::Map.new }
+          end
+        end
+
+        # @api private
+        def self.source_cache
+          @source_cache ||= Concurrent::Map.new
+        end
+
+        # @api private
+        def initialize(data: EMPTY_HASH, config: nil)
+          super()
+          @data = data
+          @__config__ = config if config
+          @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
+        end
+
+        # Get an array of looked up paths
+        #
+        # @param [Symbol] predicate
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def looked_up_paths(predicate, options)
+          super.map { |path| path % {locale: options[:locale] || default_locale} }
+        end
+
+        # Get a message for the given key and its options
+        #
+        # @param [Symbol] key
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def get(key, options = EMPTY_HASH)
+          data[evaluated_key(key, options)]
+        end
+
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options = EMPTY_HASH)
+          data.key?(evaluated_key(key, options))
+        end
+
+        # Merge messages from an additional path
+        #
+        # @param [String] overrides
+        #
+        # @return [Messages::I18n]
+        #
+        # @api public
+        def merge(overrides)
+          if overrides.is_a?(Hash)
+            self.class.new(
+              data: data.merge(self.class.flat_hash(overrides)),
+              config: config
+            )
+          else
+            self.class.new(
+              data: Array(overrides).reduce(data) { |a, e| a.merge(load_translations(e)) },
+              config: config
+            )
+          end
+        end
+
+        # @api private
+        def prepare
+          @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
+          self
+        end
+
+        # @api private
+        def interpolatable_data(key, options, **data)
+          tokens = evaluation_context(key, options).fetch(:tokens)
+          data.select { |k,| tokens.include?(k) }
+        end
+
+        # @api private
+        def interpolate(key, options, **data)
+          evaluator = evaluation_context(key, options).fetch(:evaluator)
+          data.empty? ? evaluator.() : evaluator.(**data)
+        end
+
+        private
+
+        # @api private
+        def evaluation_context(key, options)
+          cache.fetch_or_store(get(key, options).fetch(:text)) do |input|
+            tokens = input.scan(TOKEN_REGEXP).flatten(1).to_set(&:to_sym)
+            text = input.gsub("%", "#")
+
+            # rubocop:disable Security/Eval
+            evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
+              -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }  # -> (a:, b:) { "Translation #\{a} #\{b}" }
+            RUBY
+            # rubocop:enable Security/Eval
+
+            {
+              tokens: tokens,
+              evaluator: evaluator
+            }
+          end
+        end
+
+        # @api private
+        def cache
+          @cache ||= self.class.cache[self]
+        end
+
+        # @api private
+        def load_translations(path)
+          data = self.class.source_cache.fetch_or_store(path) do
+            self.class.flat_hash(::YAML.load_file(path)).freeze
+          end
+
+          return data unless custom_top_namespace?(path)
+
+          data.transform_keys { _1.gsub(DEFAULT_MESSAGES_ROOT, config.top_namespace) }
+        end
+
+        # @api private
+        def evaluated_key(key, options)
+          return key unless key.include?(LOCALE_TOKEN)
+
+          key % {locale: options[:locale] || default_locale}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # An API for configuring message backends
+    #
+    # @api private
+    module Messages
+      BACKENDS = {
+        i18n: "I18n",
+        yaml: "YAML"
+      }.freeze
+
+      module_function
+
+      public def setup(config)
+        backend_class = BACKENDS.fetch(config.backend) do
+          raise "+#{config.backend}+ is not a valid messages identifier"
+        end
+
+        namespace = config.namespace
+        options = config.to_h.select { |k, _| Abstract.setting_names.include?(k) }
+
+        messages = Messages.const_get(backend_class).build(options)
+
+        return messages.namespaced(namespace) if namespace
+
+        messages
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # A special rule type that is configured under a specified namespace
+    #
+    # This is used internally to create rules that can be properly handled
+    # by the message compiler in situations where a schema reuses another schema
+    # but it is configured to use a message namespace
+    #
+    # @api private
+    class NamespacedRule
+      # @api private
+      attr_reader :rule
+
+      # @api private
+      attr_reader :namespace
+
+      # @api private
+      def initialize(namespace, rule)
+        @namespace = namespace
+        @rule = rule
+      end
+
+      # @api private
+      def call(input)
+        result = rule.call(input)
+        Logic::Result.new(result.success?) { [:namespace, [namespace, result.to_ast]] }
+      end
+
+      # @api private
+      def ast(input = Undefined)
+        [:namespace, [namespace, rule.ast(input)]]
+      end
+      alias_method :to_ast, :ast
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Params schema type
+    #
+    # @see Processor
+    # @see Schema#Params
+    #
+    # @api public
+    class Params < Processor
+      config.key_map_type = :stringified
+      config.type_registry_namespace = :params
+      config.filter_empty_string = true
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # Path represents a list of keys in a hash
+    #
+    # @api private
+    class Path
+      include ::Dry.Equalizer(:keys)
+      include ::Comparable
+      include ::Enumerable
+
+      # @return [Array<Symbol>]
+      attr_reader :keys
+
+      alias_method :root, :first
+
+      # Coerce a spec into a path object
+      #
+      # @param [Path, Symbol, String, Hash, Array<Symbol>] spec
+      #
+      # @return [Path]
+      #
+      # @api private
+      def self.call(spec)
+        case spec
+        when ::Symbol, ::Array
+          new([*spec])
+        when ::String
+          new(spec.split(DOT).map(&:to_sym))
+        when ::Hash
+          new(keys_from_hash(spec))
+        when self
+          spec
+        else
+          raise ::ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a #{name}"
+        end
+      end
+
+      # @api private
+      def self.[](spec)
+        call(spec)
+      end
+
+      # Extract a list of keys from a hash
+      #
+      # @api private
+      def self.keys_from_hash(hash)
+        hash.inject([]) { |a, (k, v)|
+          v.is_a?(::Hash) ? a.push(k, *keys_from_hash(v)) : a.push(k, v)
+        }
+      end
+
+      # @api private
+      def initialize(keys)
+        @keys = keys
+      end
+
+      # @api private
+      def to_h(value = EMPTY_ARRAY.dup)
+        value = [value] unless value.is_a?(::Array)
+
+        keys.reverse_each.reduce(value) { |result, key| {key => result} }
+      end
+
+      # @api private
+      def each(&)
+        keys.each(&)
+      end
+
+      # @api private
+      def include?(other)
+        keys[0, other.keys.length].eql?(other.keys)
+      end
+
+      # @api private
+      def <=>(other)
+        return keys.length <=> other.keys.length if include?(other) || other.include?(self)
+
+        first_uncommon_index = (self & other).keys.length
+
+        keys[first_uncommon_index] <=> other.keys[first_uncommon_index]
+      end
+
+      # @api private
+      def &(other)
+        self.class.new(
+          keys.take_while.with_index { |key, index| other.keys[index].eql?(key) }
+        )
+      end
+
+      # @api private
+      def last
+        keys.last
+      end
+
+      # @api private
+      def same_root?(other)
+        root.equal?(other.root)
+      end
+
+      EMPTY = new(EMPTY_ARRAY).freeze
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/logic/operators"
+
+module Dry
+  module Schema
+    # Predicate objects used within the DSL
+    #
+    # @api public
+    class Predicate
+      # A negated predicate
+      #
+      # @api private
+      class Negation
+        include ::Dry::Logic::Operators
+
+        # @api private
+        attr_reader :predicate
+
+        # @api private
+        def initialize(predicate)
+          @predicate = predicate
+        end
+
+        # Dump negated predicate to an AST
+        #
+        # @return [Array]
+        #
+        # @api private
+        def to_ast(...)
+          [:not, predicate.to_ast(...)]
+        end
+        alias_method :ast, :to_ast
+      end
+
+      include ::Dry::Logic::Operators
+      include ::Dry::Equalizer(:name, :args, :block)
+
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      attr_reader :name
+
+      # @api private
+      attr_reader :args
+
+      # @api private
+      attr_reader :arity
+
+      # @api private
+      attr_reader :block
+
+      # @api private
+      def initialize(compiler, name, args, block)
+        @compiler = compiler
+        @name = name
+        @args = args
+        @block = block
+        # Cater for optional second argument like in case of `eql?` or `respond_to?`
+        @arity = compiler.predicates[name].arity.abs
+      end
+
+      # Negate a predicate
+      #
+      # @example
+      #   required(:name).value(:string) { !empty? }
+      #
+      # @return [Negation]
+      #
+      # @api public
+      def !
+        Negation.new(self)
+      end
+
+      # @api private
+      def ensure_valid
+        if arity - 1 != args.size
+          raise ::ArgumentError, "#{name} predicate arity is invalid"
+        end
+      end
+
+      # Compile predicate to a rule object
+      #
+      # @api private
+      def to_rule
+        compiler.visit(to_ast)
+      end
+
+      # Dump predicate to an AST
+      #
+      # @return [Array]
+      #
+      # @api private
+      def to_ast(*)
+        [:predicate, [name, compiler.predicates.arg_list(name, *args)]]
+      end
+      alias_method :ast, :to_ast
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # A registry with predicate objects from `Dry::Logic::Predicates`
+    #
+    # @api private
+    class PredicateRegistry < ::Dry::Types::PredicateRegistry
+      # @api private
+      def arg_list(name, *values)
+        predicate = self[name]
+        # Cater for optional second argument like in case of `eql?` or `respond_to?`
+        arity = predicate.arity.abs
+
+        predicate
+          .parameters
+          .map(&:last)
+          .zip(values + ::Array.new(arity - values.size, Undefined))
+      end
+    end
+  end
+end