mega-sharp-sys 0.0.1

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    # Compiles rule results AST into human-readable format
+    #
+    # @api private
+    class MessageCompiler
+      extend ::Dry::Initializer
+
+      resolve_key_predicate = proc { |node, opts|
+        *arg_vals, val = node.map(&:last)
+        [[*opts.path, arg_vals[0]], arg_vals[1..arg_vals.size - 1], val]
+      }
+
+      resolve_predicate = proc { |node, opts|
+        [Array(opts.path), *node.map(&:last)]
+      }
+
+      DEFAULT_PREDICATE_RESOLVERS = ::Hash
+        .new(resolve_predicate).update(key?: resolve_key_predicate).freeze
+
+      EMPTY_OPTS = VisitorOpts.new
+      EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).freeze
+      FULL_MESSAGE_WHITESPACE = ::Hash.new(" ").merge(
+        ja: "",
+        zh: "",
+        bn: "",
+        th: "",
+        lo: "",
+        my: ""
+      )
+
+      param :messages
+
+      option :full, default: -> { false }
+      option :locale, default: -> { :en }
+      option :predicate_resolvers, default: -> { DEFAULT_PREDICATE_RESOLVERS }
+
+      attr_reader :options
+
+      attr_reader :default_lookup_options
+
+      # @api private
+      def initialize(messages, **options)
+        super
+        @options = options
+        @default_lookup_options = options[:locale] ? {locale: locale} : EMPTY_HASH
+      end
+
+      # @api private
+      def with(new_options)
+        return self if new_options.empty?
+
+        updated_opts = options.merge(new_options)
+
+        return self if updated_opts.eql?(options)
+
+        self.class.new(messages, **updated_opts)
+      end
+
+      # @api private
+      def call(ast)
+        return EMPTY_MESSAGE_SET if ast.empty?
+
+        current_messages = EMPTY_ARRAY.dup
+        compiled_messages = ast.map { |node| visit(node, EMPTY_OPTS.dup(current_messages)) }
+
+        MessageSet[compiled_messages, failures: options.fetch(:failures, true)]
+      end
+
+      # @api private
+      def visit(node, opts = EMPTY_OPTS.dup)
+        __send__(:"visit_#{node[0]}", node[1], opts)
+      end
+
+      # @api private
+      def visit_failure(node, opts)
+        rule, other = node
+        visit(other, opts.(rule: rule))
+      end
+
+      # @api private
+      def visit_hint(*)
+        nil
+      end
+
+      # @api private
+      def visit_not(node, opts)
+        visit(node, opts.(not: true))
+      end
+
+      # @api private
+      def visit_and(node, opts)
+        left, right = node.map { |n| visit(n, opts) }
+
+        if right
+          [left, right]
+        else
+          left
+        end
+      end
+
+      # @api private
+      def visit_unexpected_key(node, opts)
+        visit_predicate([:unexpected_key, []], opts.dup.update(path: Path[node.first]))
+      end
+
+      # @api private
+      def visit_or(node, opts)
+        left, right = node.map { |n| visit(n, opts) }
+        Message::Or[left, right, or_translator]
+      end
+
+      # @api private
+      def or_translator
+        @or_translator ||= proc { |k|
+          message = messages.translate(k, **default_lookup_options)
+          message.is_a?(Hash) ? message[:text] : message
+        }
+      end
+
+      # @api private
+      def visit_namespace(node, opts)
+        ns, rest = node
+        self.class.new(messages.namespaced(ns), **options).visit(rest, opts)
+      end
+
+      # @api private
+      def visit_predicate(node, opts)
+        predicate, args = node
+
+        tokens = message_tokens(args)
+        path, *arg_vals, input = predicate_resolvers[predicate].(args, opts)
+
+        options = opts.dup.update(
+          path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
+        ).to_h
+
+        template, meta = messages[predicate, options]
+
+        unless template
+          raise MissingMessageError.new(path, messages.looked_up_paths(predicate, options))
+        end
+
+        text = message_text(template, tokens, options)
+
+        message_type(options).new(
+          text: text,
+          meta: meta,
+          path: path,
+          predicate: predicate,
+          args: arg_vals,
+          input: input
+        )
+      end
+
+      # @api private
+      def message_type(*)
+        Message
+      end
+
+      # @api private
+      def visit_key(node, opts)
+        name, other = node
+        visit(other, opts.(path: name))
+      end
+
+      # @api private
+      def visit_set(node, opts)
+        node.map { |el| visit(el, opts) }
+      end
+
+      # @api private
+      def visit_implication(node, *args)
+        _, right = node
+        visit(right, *args)
+      end
+
+      # @api private
+      def visit_xor(node, opts)
+        left, right = node
+        [visit(left, opts), visit(right, opts)].uniq
+      end
+
+      # @api private
+      def lookup_options(arg_vals:, input:)
+        default_lookup_options.merge(
+          arg_type: arg_vals.size == 1 && arg_vals[0].class,
+          val_type: input.equal?(Undefined) ? ::NilClass : input.class
+        )
+      end
+
+      # @api private
+      def message_text(template, tokens, options)
+        text = template[template.data(tokens)]
+
+        return text if !text || !full
+
+        rule = options[:path]
+        [messages.rule(rule, options) || rule,
+         text].join(FULL_MESSAGE_WHITESPACE[template.options[:locale]])
+      end
+
+      # @api private
+      def message_tokens(args)
+        tokens = args.each_with_object({}) do |arg, hash|
+          case arg[1]
+          when ::Array, ::Set
+            hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
+          when ::Range
+            hash[:"#{arg[0]}_left"] = arg[1].first
+            hash[:"#{arg[0]}_right"] = arg[1].last
+          else
+            hash[arg[0]] = arg[1]
+          end
+        end
+        args.any? { |e| e.first == :size } ? append_mapped_size_tokens(tokens) : tokens
+      end
+
+      # @api private
+      def append_mapped_size_tokens(tokens)
+        # this is a temporary fix for the inconsistency in the "size" errors arguments
+        mapped_hash = tokens.transform_keys do |k|
+          k.to_s.gsub("size", "num").to_sym
+        end
+        tokens.merge(mapped_hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Dry
+  module Schema
+    # A set of messages used to generate errors
+    #
+    # @see Result#message_set
+    #
+    # @api public
+    class MessageSet
+      include ::Enumerable
+      include ::Dry::Equalizer(:messages, :options)
+
+      # A list of compiled message objects
+      #
+      # @return [Array<Message>]
+      attr_reader :messages
+
+      # Options hash
+      #
+      # @return [Hash]
+      attr_reader :options
+
+      # @api private
+      def self.[](messages, options = EMPTY_HASH)
+        new(messages.flatten, options)
+      end
+
+      # @api private
+      def initialize(messages, options = EMPTY_HASH)
+        @messages = messages
+        @options = options
+      end
+
+      # Iterate over messages
+      #
+      # @example
+      #   result.errors.each do |message|
+      #     puts message.text
+      #   end
+      #
+      # @return [Array]
+      #
+      # @api public
+      def each(&)
+        return self if empty?
+        return to_enum unless block_given?
+
+        messages.each(&)
+      end
+
+      # Dump message set to a hash
+      #
+      # @return [Hash<Symbol=>Array<String>>]
+      #
+      # @api public
+      def to_h
+        @to_h ||= messages_map
+      end
+      alias_method :to_hash, :to_h
+
+      # Get a list of message texts for the given key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Array<String>]
+      #
+      # @api public
+      def [](key)
+        to_h[key]
+      end
+
+      # Get a list of message texts for the given key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Array<String>]
+      #
+      # @raise KeyError
+      #
+      # @api public
+      def fetch(key)
+        self[key] || raise(::KeyError, "+#{key}+ message was not found")
+      end
+
+      # Check if a message set is empty
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        @empty ||= messages.empty?
+      end
+
+      # @api private
+      def freeze
+        to_h
+        empty?
+        super
+      end
+
+      private
+
+      # @api private
+      def messages_map(messages = self.messages)
+        combine_message_hashes(messages.map(&:to_h)).freeze
+      end
+
+      # @api private
+      def combine_message_hashes(hashes)
+        hashes.reduce(EMPTY_HASH.dup) do |a, e|
+          a.merge(e) do |_, *values|
+            combine_message_values(values)
+          end
+        end
+      end
+
+      # @api private
+      def combine_message_values(values)
+        hashes, other = partition_message_values(values)
+        combined = combine_message_hashes(hashes)
+        flattened = other.flatten
+
+        if flattened.empty?
+          combined
+        elsif combined.empty?
+          flattened
+        else
+          [flattened, combined]
+        end
+      end
+
+      # @api private
+      def partition_message_values(values)
+        values
+          .map { |value| value.is_a?(::Array) ? value : [value] }
+          .reduce(EMPTY_ARRAY.dup, :+)
+          .partition { |value| value.is_a?(::Hash) && !value[:text].is_a?(::String) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+require "dry/schema/constants"
+
+module Dry
+  module Schema
+    module Messages
+      # Abstract class for message backends
+      #
+      # @api public
+      class Abstract
+        include ::Dry::Configurable
+        include ::Dry::Equalizer(:config)
+
+        setting :default_locale
+        setting :load_paths, default: ::Set[DEFAULT_MESSAGES_PATH]
+        setting :top_namespace, default: DEFAULT_MESSAGES_ROOT
+        setting :root, default: "errors"
+        setting :lookup_options, default: %i[root predicate path val_type arg_type].freeze
+
+        setting :lookup_paths, default: [
+          "%<root>s.rules.%<path>s.%<predicate>s.arg.%<arg_type>s",
+          "%<root>s.rules.%<path>s.%<predicate>s",
+          "%<root>s.%<predicate>s.%<message_type>s",
+          "%<root>s.%<predicate>s.value.%<path>s",
+          "%<root>s.%<predicate>s.value.%<val_type>s.arg.%<arg_type>s",
+          "%<root>s.%<predicate>s.value.%<val_type>s",
+          "%<root>s.%<predicate>s.arg.%<arg_type>s",
+          "%<root>s.%<predicate>s"
+        ].freeze
+
+        setting :rule_lookup_paths, default: ["rules.%<name>s"].freeze
+
+        setting :arg_types, default: ::Hash.new { |*| "default" }.update(
+          ::Range => "range"
+        )
+
+        setting :val_types, default: ::Hash.new { |*| "default" }.update(
+          ::Range => "range",
+          ::String => "string"
+        )
+
+        # @api private
+        def self.setting_names
+          @setting_names ||= settings.map { _1.name.to_sym }
+        end
+
+        # @api private
+        def self.build(options = EMPTY_HASH)
+          messages = new
+
+          messages.configure do |config|
+            options.each do |key, value|
+              config.public_send(:"#{key}=", value)
+            end
+
+            config.root = "#{config.top_namespace}.#{config.root}"
+
+            config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+              "#{config.top_namespace}.#{path}"
+            }
+
+            yield(config) if block_given?
+          end
+
+          messages.prepare
+        end
+
+        # @api private
+        def translate(key, locale: default_locale)
+          t["#{config.top_namespace}.#{key}", locale: locale]
+        end
+
+        # @api private
+        def rule(name, options = {})
+          tokens = {name: name, locale: options.fetch(:locale, default_locale)}
+          path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }
+
+          rule = get(path, options) if path
+          rule.is_a?(::Hash) ? rule[:text] : rule
+        end
+
+        # Retrieve a message template
+        #
+        # @return [Template]
+        #
+        # @api public
+        def call(predicate, options)
+          options = {locale: default_locale, **options}
+          opts = options.reject { |k,| config.lookup_options.include?(k) }
+          path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
+
+          return unless path
+
+          result = get(path, opts)
+
+          [
+            Template.new(
+              messages: self,
+              key: path,
+              options: opts
+            ),
+            result[:meta]
+          ]
+        end
+
+        alias_method :[], :call
+
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(_key, _options = EMPTY_HASH)
+          raise ::NotImplementedError
+        end
+
+        # Retrieve an array of looked up paths
+        #
+        # @param [Symbol] predicate
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def looked_up_paths(predicate, options)
+          tokens = lookup_tokens(predicate, options)
+          filled_lookup_paths(tokens)
+        end
+
+        # @api private
+        def lookup_paths(predicate, options)
+          tokens = lookup_tokens(predicate, options)
+          filled_lookup_paths(tokens)
+        end
+
+        # @api private
+        def filled_lookup_paths(tokens)
+          config.lookup_paths.map { |path| path % tokens }
+        end
+
+        # @api private
+        def rule_lookup_paths(tokens)
+          config.rule_lookup_paths.map { |key| key % tokens }
+        end
+
+        # Return a new message backend that will look for messages under provided namespace
+        #
+        # @param [Symbol,String] namespace
+        #
+        # @api public
+        def namespaced(namespace)
+          Dry::Schema::Messages::Namespaced.new(namespace, self)
+        end
+
+        # Return root path to messages file
+        #
+        # @return [Pathname]
+        #
+        # @api public
+        def root
+          config.root
+        end
+
+        # @api private
+        def default_locale
+          config.default_locale
+        end
+
+        # @api private
+        def interpolatable_data(_key, _options, **_data)
+          raise ::NotImplementedError
+        end
+
+        # @api private
+        def interpolate(_key, _options, **_data)
+          raise ::NotImplementedError
+        end
+
+        private
+
+        # @api private
+        def lookup_tokens(predicate, options)
+          options.merge(
+            predicate: predicate,
+            root: options[:not] ? "#{root}.not" : root,
+            arg_type: config.arg_types[options[:arg_type]],
+            val_type: config.val_types[options[:val_type]],
+            message_type: options[:message_type] || :failure
+          )
+        end
+
+        # @api private
+        def custom_top_namespace?(path)
+          path.to_s == DEFAULT_MESSAGES_PATH.to_s && config.top_namespace != DEFAULT_MESSAGES_ROOT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "i18n"
+
+module Dry
+  module Schema
+    module Messages
+      # I18n message backend
+      #
+      # @api public
+      class I18n < Abstract
+        # Translation function
+        #
+        # @return [Method]
+        attr_reader :t
+
+        # @api private
+        def initialize
+          super
+          @t = ::I18n.method(:t)
+        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)
+          return unless key
+
+          result = t.(key, locale: default_locale, **options)
+
+          if result.is_a?(Hash)
+            text = result[:text]
+            meta = result.dup.tap { |h| h.delete(:text) }
+          else
+            text = result
+            meta = EMPTY_HASH.dup
+          end
+
+          {
+            text: text,
+            meta: meta
+          }
+        end
+
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options)
+          ::I18n.exists?(key, options.fetch(:locale, default_locale)) ||
+            ::I18n.exists?(key, ::I18n.default_locale)
+        end
+
+        # Merge messages from an additional path
+        #
+        # @param [String, Array<String>] paths
+        #
+        # @return [Messages::I18n]
+        #
+        # @api public
+        def merge(paths)
+          prepare(paths)
+        end
+
+        # @api private
+        def default_locale
+          super || ::I18n.locale || ::I18n.default_locale
+        end
+
+        # @api private
+        def prepare(paths = config.load_paths)
+          paths.each do |path|
+            data = ::YAML.load_file(path)
+
+            if custom_top_namespace?(path)
+              top_namespace = config.top_namespace
+
+              mapped_data = data.transform_values { |v|
+                {top_namespace => v[DEFAULT_MESSAGES_ROOT]}
+              }
+
+              store_translations(mapped_data)
+            else
+              store_translations(data)
+            end
+          end
+
+          self
+        end
+
+        # @api private
+        def interpolatable_data(_key, _options, **data)
+          data
+        end
+
+        # @api private
+        def interpolate(key, options, **data)
+          text_key = "#{key}.text"
+
+          opts = {
+            locale: default_locale,
+            **options,
+            **data
+          }
+
+          resolved_key = key?(text_key, opts) ? text_key : key
+
+          result = t.(resolved_key, **opts)
+
+          if result.is_a?(::Hash)
+            result[:text]
+          else
+            result
+          end
+        end
+
+        private
+
+        # @api private
+        def store_translations(data)
+          locales = data.keys.map(&:to_sym)
+
+          ::I18n.available_locales |= locales
+
+          locales.each do |locale|
+            ::I18n.backend.store_translations(locale, data[locale.to_s])
+          end
+        end
+      end
+    end
+  end
+end