dry-schema 1.8.0 → 1.9.2

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

@@ -9,195 +9,202 @@ require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
-    # Plain YAML message backend
-    #
-    # @api public
-    class Messages::YAML < Messages::Abstract
-      LOCALE_TOKEN = "%<locale>s"
-      TOKEN_REGEXP = /%{(\w*)}/.freeze
-      EMPTY_CONTEXT = Object.new.tap { |ctx|
-        def ctx.context
-          binding
-        end
-      }.freeze.context
-
-      include Dry::Equalizer(:data)
-
-      # Loaded localized message templates
+    module Messages
+      # Plain YAML message backend
       #
-      # @return [Hash]
-      attr_reader :data
+      # @api public
+      class YAML < Abstract
+        LOCALE_TOKEN = "%<locale>s"
+        TOKEN_REGEXP = /%{(\w*)}/.freeze
+        EMPTY_CONTEXT = Object.new.tap { |ctx|
+          def ctx.context
+            binding
+          end
+        }.freeze.context
 
-      # Translation function
-      #
-      # @return [Proc]
-      attr_reader :t
+        include ::Dry::Equalizer(:data)
 
-      # @api private
-      def self.build(options = EMPTY_HASH)
-        super do |config|
-          config.default_locale = :en unless config.default_locale
+        # Loaded localized message templates
+        #
+        # @return [Hash]
+        attr_reader :data
 
-          config.root = "%<locale>s.#{config.root}"
+        # Translation function
+        #
+        # @return [Proc]
+        attr_reader :t
 
-          config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
-            "%<locale>s.#{path}"
-          }
-        end
-      end
+        # @api private
+        def self.build(options = EMPTY_HASH)
+          super do |config|
+            config.default_locale = :en unless config.default_locale
 
-      # @api private
-      def self.flat_hash(hash, path = [], keys = {})
-        hash.each do |key, value|
-          flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
+            config.root = -"%<locale>s.#{config.root}"
 
-          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.dup.delete_if { |k| k == "text" }.map { |k, v| [k.to_sym, v] }.to_h
+            config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+              -"%<locale>s.#{path}"
             }
           end
         end
-        keys
-      end
-
-      # @api private
-      def self.cache
-        @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
-      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
+        # @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
 
-      # 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
+          keys
+        end
+        # rubocop: enable Metrics/PerceivedComplexity
 
-      # 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
+        # @api private
+        def self.cache
+          @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+        end
 
-      # Check if given key is defined
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def key?(key, options = EMPTY_HASH)
-        data.key?(evaluated_key(key, options))
-      end
+        # @api private
+        def self.source_cache
+          @source_cache ||= Concurrent::Map.new
+        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
-          )
+        # @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
-      end
 
-      # @api private
-      def prepare
-        @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
-        self
-      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
 
-      # @api private
-      def interpolatable_data(key, options, **data)
-        tokens = evaluation_context(key, options).fetch(:tokens)
-        data.select { |k,| tokens.include?(k) }
-      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
 
-      # @api private
-      def interpolate(key, options, **data)
-        evaluator = evaluation_context(key, options).fetch(:evaluator)
-        data.empty? ? evaluator.() : evaluator.(**data)
-      end
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options = EMPTY_HASH)
+          data.key?(evaluated_key(key, options))
+        end
 
-      private
+        # 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 evaluation_context(key, options)
-        cache.fetch_or_store(get(key, options).fetch(:text)) do |input|
-          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym).to_set
-          text = input.gsub("%", "#")
+        # @api private
+        def prepare
+          @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
+          self
+        end
 
-          # rubocop:disable Security/Eval
-          evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-          # rubocop:enable Security/Eval
+        # @api private
+        def interpolatable_data(key, options, **data)
+          tokens = evaluation_context(key, options).fetch(:tokens)
+          data.select { |k,| tokens.include?(k) }
+        end
 
-          {
-            tokens: tokens,
-            evaluator: evaluator
-          }
+        # @api private
+        def interpolate(key, options, **data)
+          evaluator = evaluation_context(key, options).fetch(:evaluator)
+          data.empty? ? evaluator.() : evaluator.(**data)
         end
-      end
 
-      # @api private
-      def cache
-        @cache ||= self.class.cache[self]
-      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).map(&:to_sym).to_set
+            text = input.gsub("%", "#")
+
+            # rubocop:disable Security/Eval
+            # rubocop:disable Style/DocumentDynamicEvalDefinition
+            evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
+              -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+            RUBY
+            # rubocop:enable Style/DocumentDynamicEvalDefinition
+            # rubocop:enable Security/Eval
+
+            {
+              tokens: tokens,
+              evaluator: evaluator
+            }
+          end
+        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
+        # @api private
+        def cache
+          @cache ||= self.class.cache[self]
         end
 
-        return data unless custom_top_namespace?(path)
+        # @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
 
-        data.map { |k, v| [k.gsub(DEFAULT_MESSAGES_ROOT, config.top_namespace), v] }.to_h
-      end
+          return data unless custom_top_namespace?(path)
 
-      # @api private
-      def evaluated_key(key, options)
-        return key unless key.include?(LOCALE_TOKEN)
+          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}
+          key % {locale: options[:locale] || default_locale}
+        end
       end
     end
   end

data/lib/dry/schema/predicate.rb

@@ -28,8 +28,8 @@ module Dry
         # @return [Array]
         #
         # @api private
-        def to_ast(*args)
-          [:not, predicate.to_ast(*args)]
+        def to_ast(...)
+          [:not, predicate.to_ast(...)]
         end
         alias_method :ast, :to_ast
       end

data/lib/dry/schema/predicate_inferrer.rb

@@ -9,6 +9,8 @@ module Dry
       Compiler = ::Class.new(superclass::Compiler)
 
       def initialize(registry = PredicateRegistry.new)
+        super
+
         @compiler = Compiler.new(registry)
       end
     end

data/lib/dry/schema/primitive_inferrer.rb

@@ -9,6 +9,8 @@ module Dry
       Compiler = ::Class.new(superclass::Compiler)
 
       def initialize
+        super
+
         @compiler = Compiler.new
       end
     end

data/lib/dry/schema/processor.rb

@@ -116,14 +116,14 @@ module Dry
         ->(input) { call(input) }
       end
 
-      # Return string represntation
+      # Return string representation
       #
       # @return [String]
       #
       # @api public
       def inspect
         <<~STR.strip
-          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.map { |k, v| [k, v.to_s] }.to_h}>
+          #<#{self.class.name} keys=#{key_map.map(&:dump)} rules=#{rules.transform_values(&:to_s)}>
         STR
       end
 

data/lib/dry/schema/result.rb

@@ -185,13 +185,11 @@ module Dry
         "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect} path=#{path.keys.inspect}>"
       end
 
-      if RUBY_VERSION >= "2.7"
-        # Pattern matching support
-        #
-        # @api private
-        def deconstruct_keys(_)
-          output
-        end
+      # Pattern matching support
+      #
+      # @api private
+      def deconstruct_keys(_)
+        output
       end
 
       # Add a new error AST node

data/lib/dry/schema/trace.rb

@@ -89,6 +89,10 @@ module Dry
         captures.map(&:to_ast).map(&compiler.method(:visit)).reduce(:and)
       end
 
+      def respond_to_missing?(meth, include_private = false)
+        super || (meth.to_s.end_with?(QUESTION_MARK) && compuiler.support?(meth))
+      end
+
       # @api private
       def method_missing(meth, *args, &block)
         if meth.to_s.end_with?(QUESTION_MARK)
@@ -96,7 +100,7 @@ module Dry
             ::Kernel.raise InvalidSchemaError, "#{meth} predicate cannot be used in this context"
           end
 
-          unless compiler.supports?(meth)
+          unless compiler.support?(meth)
             ::Kernel.raise ::ArgumentError, "#{meth} predicate is not defined"
           end
 

data/lib/dry/schema/type_registry.rb

@@ -37,8 +37,7 @@ module Dry
       def [](name)
         key = [namespace, name].compact.join(DOT)
 
-        type = types.registered?(key) ? types[key] : types[name.to_s]
-        type
+        types.registered?(key) ? types[key] : types[name.to_s]
       end
     end
   end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.8.0"
+    VERSION = "1.9.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.2
 platform: ruby
 authors:
 - Piotr Solnica
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-12 00:00:00.000000000 Z
+date: 2022-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -178,6 +178,8 @@ files:
 - lib/dry/schema/extensions/hints/result_methods.rb
 - lib/dry/schema/extensions/info.rb
 - lib/dry/schema/extensions/info/schema_compiler.rb
+- lib/dry/schema/extensions/json_schema.rb
+- lib/dry/schema/extensions/json_schema/schema_compiler.rb
 - lib/dry/schema/extensions/monads.rb
 - lib/dry/schema/extensions/struct.rb
 - lib/dry/schema/json.rb
@@ -235,10 +237,10 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/dry-rb/dry-schema/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/dry-rb/dry-schema/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/dry-rb/dry-schema
   bug_tracker_uri: https://github.com/dry-rb/dry-schema/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -246,15 +248,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: Coercion and validation for data structures
 test_files: []
+...