dry-schema 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b804e7069cd7d8764f82ce208e38768fa9975e6d1460e1e44917d5c0eaeee911
-  data.tar.gz: 6814f96c49db2634895c20faf7b331feccbdcdcbc83ff89292f655acd6c0adfc
+  metadata.gz: ebc7203aa64419493d5557a5228e8ae17da67a89b7dab86556897aad7856138e
+  data.tar.gz: '083cad2ab1b35ecfac75a5d37a868f36145cce8ea31bf03dc10b3ad84233b498'
 SHA512:
-  metadata.gz: 80d4cc2626025ef517e48bba83026c1bba7ef5797fa25e2543589ed503ec9d7142e799ed9713d4452b7a1f1b2d2988b4c6aeb3172230ec6fd4987d58c8621775
-  data.tar.gz: f35d2b94570ec416b6fcb0457a4e685f37ff3a265a011a4016af611307e2d8d1b8b03dc9e4b59a63b5f2cf55aacf8ceabac0a5d689e73f14e4aaa5cef96e1fa4
+  metadata.gz: 0db3366b58c3fd06ad10958de4215ae5b2ff67f244873ff8b48b96da9bfcf08678a06ef3302099862891630b825596c6a4adfecac9140e8e5045ca7acc200b34
+  data.tar.gz: 04e3fa2ee8d50aaac7c6bcdaacb1611252ce06af397499cf0fbc0ed21fb33e62c55b9ab0179b4df9160bbd0efe1c6bed1c60ac628c06f23f992879df8c6326ed

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# 0.1.1 2019-02-17
+
+### Added
+
+- `Result#error?` supports checking nested errors too ie`result.error?('user.address')` (solnic)
+
+### Fixed
+
+- Fix issues with templates and invalid tokens (issue #27) (solnic)
+- Fix Ruby warnings (flash-gordon)
+
+### Internal
+
+- Key and value coercers are now equalizable (flash-gordon)
+
+[Compare v0.1.0...v0.1.1](https://github.com/dry-rb/dry-schema/compare/v0.1.0...v0.1.1)
+
 # 0.1.0 2019-01-30
 
 Initial release.

data/lib/dry/schema.rb

@@ -14,7 +14,7 @@ module Dry
     # @return [Processor]
     #
     # @api public
-    def self.define(options = EMPTY_HASH, &block)
+    def self.define(**options, &block)
       DSL.new(options, &block).call
     end
 

data/lib/dry/schema/dsl.rb

@@ -90,7 +90,7 @@ module Dry
       # @return [DSL]
       #
       # @api public
-      def self.new(options = EMPTY_HASH, &block)
+      def self.new(**options, &block)
         dsl = super
         dsl.instance_eval(&block) if block
         dsl

data/lib/dry/schema/key_coercer.rb

@@ -1,4 +1,5 @@
 require 'dry/core/cache'
+require 'dry/equalizer'
 
 module Dry
   module Schema
@@ -7,6 +8,7 @@ module Dry
     # @api private
     class KeyCoercer
       extend Dry::Core::Cache
+      include ::Dry::Equalizer(:key_map, :coercer)
 
       TO_SYM = :to_sym.to_proc.freeze
 
@@ -26,7 +28,7 @@ module Dry
       def initialize(key_map, &coercer)
         @key_map = key_map.coercible(&coercer)
       end
-      
+
       # @api private
       def call(source)
         key_map.write(Hash(source))

data/lib/dry/schema/message.rb

@@ -43,7 +43,7 @@ module Dry
         #
         # @api public
         def to_s
-          [left, right].uniq.join(" #{messages[:or]} ")
+          [left, right].uniq.join(" #{messages[:or].()} ")
         end
       end
 

data/lib/dry/schema/message_compiler.rb

@@ -164,7 +164,7 @@ module Dry
 
       # @api private
       def message_text(rule, template, tokens, opts)
-        text = template % tokens
+        text = template[template.data(tokens)]
 
         if full?
           rule_name = rule ? (messages.rule(rule, opts) || rule) : (opts[:name] || opts[:path].last)

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

@@ -4,6 +4,7 @@ require 'dry/equalizer'
 require 'dry/configurable'
 
 require 'dry/schema/constants'
+require 'dry/schema/messages/template'
 
 module Dry
   module Schema
@@ -69,15 +70,15 @@ module Dry
           get(path, options) if key?(path, options)
         end
 
-        # Retrieve a message
+        # Retrieve a message template
         #
-        # @return [String]
+        # @return [Template]
         #
         # @api public
         def call(*args)
           cache.fetch_or_store(args.hash) do
             path, opts = lookup(*args)
-            get(path, opts) if path
+            Template[get(path, opts)] if path
           end
         end
         alias_method :[], :call
@@ -96,7 +97,7 @@ module Dry
 
           tokens[:path] = options[:rule] || Array(options[:path]).join(DOT)
 
-          opts = options.reject { |k, _| config.lookup_options.include?(k) }
+          opts = options.select { |k, _| !config.lookup_options.include?(k) }
 
           path = lookup_paths(tokens).detect do |key|
             key?(key, opts) && get(key, opts).is_a?(String)

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

@@ -0,0 +1,66 @@
+require 'dry/equalizer'
+
+require 'dry/schema/constants'
+
+module Dry
+  module Schema
+    module Messages
+      # Template wraps a string with interpolation tokens and defines evaluator function
+      # dynamically
+      #
+      # @api private
+      class Template
+        include Dry::Equalizer(:text)
+
+        TOKEN_REGEXP = /%{([\w\d]*)}/
+
+        # !@attribute [r] text
+        #   @return [String]
+        attr_reader :text
+
+        # !@attribute [r] tokens
+        #   @return [Hash]
+        attr_reader :tokens
+
+        # !@attribute [r] evaluator
+        #   @return [Proc]
+        attr_reader :evaluator
+
+        # @api private
+        def self.[](input)
+          new(*parse(input))
+        end
+
+        # @api private
+        def self.parse(input)
+          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym)
+          text = input.gsub('%', '#')
+
+          evaluator = <<-RUBY.strip
+            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+          RUBY
+
+          [text, tokens, eval(evaluator, binding, __FILE__, __LINE__ - 3)]
+        end
+
+        # @api private
+        def initialize(text, tokens, evaluator)
+          @text = text
+          @tokens = tokens
+          @evaluator = evaluator
+        end
+
+        # @api private
+        def data(input)
+          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
+        end
+
+        # @api private
+        def call(data = EMPTY_HASH)
+          data.empty? ? evaluator.() : evaluator.(data)
+        end
+        alias_method :[], :call
+      end
+    end
+  end
+end

data/lib/dry/schema/path.rb

@@ -0,0 +1,55 @@
+require 'dry/schema/constants'
+
+module Dry
+  module Schema
+    # Path represents a list of keys in a hash
+    #
+    # @api private
+    class Path
+      # !@attribute [r] keys
+      #   @return [Array<Symbol>]
+      attr_reader :keys
+
+      # Coerce a spec into a path object
+      #
+      # @param [Symbol, String, Hash, Array<Symbol>] spec
+      #
+      # @return [Path]
+      #
+      # @api private
+      def self.[](spec)
+        case spec
+        when Symbol, Array
+          new(Array[*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 or Hash'
+        end
+      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.concat([k, *keys_from_hash(v)]) : a.concat([k, v])
+        }
+      end
+
+      # @api private
+      def initialize(keys)
+        @keys = keys
+      end
+
+      # @api private
+      def ==(other)
+        keys == Path[other].keys
+      end
+    end
+  end
+end

data/lib/dry/schema/processor.rb

@@ -15,7 +15,7 @@ module Dry
     #   1. Prepare input hash using a key map
     #   2. Apply pre-coercion filtering rules (optional step, used only when `filter` was used)
     #   3. Apply value coercions based on type specifications
-    #   4. Apply rules 
+    #   4. Apply rules
     #
     # @see Params
     # @see JSON
@@ -51,7 +51,7 @@ module Dry
       #
       # @api private
       def self.definition
-        @__definition__
+        @__definition__ ||= nil
       end
 
       # Build a new processor object

data/lib/dry/schema/result.rb

@@ -1,6 +1,8 @@
 require 'dry/initializer'
 require 'dry/equalizer'
 
+require 'dry/schema/path'
+
 module Dry
   module Schema
     # Processing result
@@ -66,15 +68,15 @@ module Dry
         output.key?(name)
       end
 
-      # Check if a given key resulted in an error
+      # Check if there's an error for the provided spec
       #
-      # @param [Symbol] name
+      # @param [Symbol, Hash<Symbol=>Symbol>] name
       #
       # @return [Boolean]
       #
       # @api public
-      def error?(name)
-        errors.key?(name)
+      def error?(spec)
+        message_set.any? { |msg| Path[spec] == msg.path }
       end
 
       # Check if the result is successful

data/lib/dry/schema/value_coercer.rb

@@ -1,3 +1,4 @@
+require 'dry/equalizer'
 require 'dry/initializer'
 
 module Dry
@@ -7,6 +8,7 @@ module Dry
     # @api private
     class ValueCoercer
       extend Dry::Initializer
+      include ::Dry::Equalizer(:type_schema)
 
       # @api private
       param :type_schema

data/lib/dry/schema/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Schema
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.1.1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-30 00:00:00.000000000 Z
+date: 2019-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -216,8 +216,10 @@ files:
 - lib/dry/schema/messages/abstract.rb
 - lib/dry/schema/messages/i18n.rb
 - lib/dry/schema/messages/namespaced.rb
+- lib/dry/schema/messages/template.rb
 - lib/dry/schema/messages/yaml.rb
 - lib/dry/schema/params.rb
+- lib/dry/schema/path.rb
 - lib/dry/schema/predicate.rb
 - lib/dry/schema/predicate_inferrer.rb
 - lib/dry/schema/predicate_registry.rb
@@ -248,7 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Schema coercion and validation