dry-schema 0.1.0

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

@@ -0,0 +1,60 @@
+require 'i18n'
+require 'dry/schema/messages/abstract'
+
+module Dry
+  module Schema
+    # I18n message backend
+    #
+    # @api public
+    class Messages::I18n < Messages::Abstract
+      attr_reader :t
+
+      ::I18n.load_path.concat(config.paths)
+
+      # @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 = {})
+        t.(key, options) if key
+      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] path
+      #
+      # @return [Messages::I18n]
+      #
+      # @api public
+      def merge(path)
+        ::I18n.load_path << path
+        self
+      end
+
+      # @api private
+      def default_locale
+        I18n.locale || I18n.default_locale || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+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 :root
+
+        # @api private
+        def initialize(namespace, messages)
+          super()
+          @namespace = namespace
+          @messages = messages
+          @root = messages.root
+        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
+
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, *args)
+          messages.key?(key, *args)
+        end
+
+        # @api private
+        def lookup_paths(tokens)
+          super(tokens.merge(root: "#{root}.rules.#{namespace}")) + super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'yaml'
+require 'pathname'
+
+require 'dry/equalizer'
+require 'dry/schema/messages/abstract'
+
+module Dry
+  module Schema
+    # Plain YAML message backend
+    #
+    # @api public
+    class Messages::YAML < Messages::Abstract
+      include Dry::Equalizer(:data)
+
+      attr_reader :data
+
+      # @api private
+      configure do |config|
+        config.root = '%{locale}.errors'.freeze
+      end
+
+      # @api private
+      def self.load(paths = config.paths)
+        new(paths.map { |path| load_file(path) }.reduce(:merge))
+      end
+
+      # @api private
+      def self.load_file(path)
+        flat_hash(YAML.load_file(path))
+      end
+
+      # @api private
+      def self.flat_hash(h, f = [], g = {})
+        return g.update(f.join('.'.freeze) => h) unless h.is_a? Hash
+        h.each { |k, r| flat_hash(r, f + [k], g) }
+        g
+      end
+
+      # @api private
+      def initialize(data)
+        super()
+        @data = data
+      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 = {})
+        data[key % { locale: options.fetch(:locale, default_locale) }]
+      end
+
+      # Check if given key is defined
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def key?(key, options = {})
+        data.key?(key % { locale: options.fetch(:locale, default_locale) })
+      end
+
+      # Merge messages from an additional path
+      #
+      # @param [String] path
+      #
+      # @return [Messages::I18n]
+      #
+      # @api public
+      def merge(overrides)
+        if overrides.is_a?(Hash)
+          self.class.new(data.merge(self.class.flat_hash(overrides)))
+        else
+          self.class.new(data.merge(Messages::YAML.load_file(overrides)))
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/params.rb

@@ -0,0 +1,16 @@
+require 'dry/schema/processor'
+
+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 = config.type_registry.namespaced(:params)
+    end
+  end
+end

data/lib/dry/schema/predicate.rb

@@ -0,0 +1,80 @@
+require 'dry/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
+        # @api private
+        attr_reader :predicate
+
+        # @api private
+        def initialize(predicate)
+          @predicate = predicate
+        end
+
+        # @api private
+        def to_ast(*args)
+          [:not, predicate.to_ast(*args)]
+        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 :block
+
+      # @api private
+      def initialize(compiler, name, args, block)
+        @compiler = compiler
+        @name = name
+        @args = args
+        @block = block
+      end
+
+      # Negate a predicate
+      #
+      # @return [Negation]
+      #
+      # @api public
+      def !
+        Negation.new(self)
+      end
+
+      # @api private
+      def ensure_valid
+        if compiler.predicates[name].arity - 1 != args.size
+          raise ArgumentError, "#{name} predicate arity is invalid"
+        end
+      end
+
+      # @api private
+      def to_rule
+        compiler.visit(to_ast)
+      end
+
+      # @api private
+      def to_ast(*)
+        [:predicate, [name, compiler.predicates.arg_list(name, *args)]]
+      end
+      alias_method :ast, :to_ast
+    end
+  end
+end

data/lib/dry/schema/predicate_inferrer.rb

@@ -0,0 +1,49 @@
+require 'dry/core/cache'
+
+module Dry
+  module Schema
+    # PredicateInferrer is used internally by `Macros::Value`
+    # for inferring type-check predicates from type specs.
+    #
+    # @api private
+    class PredicateInferrer
+      extend Dry::Core::Cache
+
+      TYPE_TO_PREDICATE = Hash.new do |hash, type|
+        primitive = type.meta[:maybe] ? type.right.primitive : type.primitive
+
+        if hash.key?(primitive)
+          hash[primitive]
+        else
+          :"#{primitive.name.split('::').last.downcase}?"
+        end
+      end
+
+      TYPE_TO_PREDICATE.update(
+        FalseClass => :false?,
+        Integer => :int?,
+        NilClass => :nil?,
+        String => :str?,
+        TrueClass => :true?
+      ).freeze
+
+      # Infer predicate identifier from the provided type
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def self.[](type)
+        fetch_or_store(type.hash) {
+          predicates =
+            if type.is_a?(Dry::Types::Sum) && !type.meta[:maybe]
+              [self[type.left], self[type.right]]
+            else
+              TYPE_TO_PREDICATE[type]
+            end
+
+          Array(predicates).flatten
+        }
+      end
+    end
+  end
+end

data/lib/dry/schema/predicate_registry.rb

@@ -0,0 +1,38 @@
+require 'dry/logic/predicates'
+
+module Dry
+  module Schema
+    # A registry with predicate objects from `Dry::Logic::Predicates`
+    #
+    # @api private
+    class PredicateRegistry
+      # @api private
+      attr_reader :predicates
+
+      # @api private
+      def initialize(predicates = Dry::Logic::Predicates)
+        @predicates = predicates
+      end
+
+      # @api private
+      def [](name)
+        predicates[name]
+      end
+
+      # @api private
+      def key?(name)
+        predicates.respond_to?(name)
+      end
+
+      # @api private
+      def arg_list(name, *values)
+        predicate = self[name]
+
+        predicate
+          .parameters
+          .map(&:last)
+          .zip(values + Array.new(predicate.arity - values.size, Undefined))
+      end
+    end
+  end
+end

data/lib/dry/schema/processor.rb

@@ -0,0 +1,151 @@
+require 'dry/configurable'
+require 'dry/initializer'
+
+require 'dry/schema/type_registry'
+require 'dry/schema/rule_applier'
+require 'dry/schema/key_coercer'
+require 'dry/schema/value_coercer'
+
+module Dry
+  module Schema
+    # Processes input data using objects configured within the DSL
+    #
+    # Processing is split into 4 main steps:
+    #
+    #   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 
+    #
+    # @see Params
+    # @see JSON
+    #
+    # @api public
+    class Processor
+      extend Dry::Initializer
+      extend Dry::Configurable
+
+      setting :key_map_type
+      setting :type_registry, TypeRegistry.new
+
+      param :steps, default: -> { EMPTY_ARRAY.dup }
+
+      # Define a schema for your processor class
+      #
+      # @see Params
+      # @see JSON
+      #
+      # @return [Class]
+      #
+      # @api public
+      def self.define(&block)
+        @__definition__ ||= DSL.new(
+          processor_type: self, parent: superclass.definition, **config, &block
+        )
+        self
+      end
+
+      # Return DSL configured via #define
+      #
+      # @return [DSL]
+      #
+      # @api private
+      def self.definition
+        @__definition__
+      end
+
+      # Build a new processor object
+      #
+      # @return [Processor]
+      #
+      # @api public
+      def self.new(&block)
+        if block
+          super.tap(&block)
+        elsif definition
+          definition.call
+        else
+          raise ArgumentError, 'Cannot create a schema without a definition'
+        end
+      end
+
+      # Append a step
+      #
+      # @return [Processor]
+      #
+      # @api private
+      def <<(step)
+        steps << step
+        self
+      end
+
+      # Apply processing steps to the provided input
+      #
+      # @param [Hash] input
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(input)
+        Result.new(input, message_compiler: message_compiler) do |result|
+          steps.each do |step|
+            output = step.(result)
+            result.replace(output) if output.is_a?(::Hash)
+          end
+        end
+      end
+
+      # Return the key map
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def key_map
+        @__key_map__ ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+      end
+
+      # Return the type schema
+      #
+      # @return [Dry::Types::Safe]
+      #
+      # @api private
+      def type_schema
+        @__type_schema__ ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+      end
+
+      # Return AST representation of the rules
+      #
+      # @api private
+      def to_ast
+        rule_applier.to_ast
+      end
+
+      # Return the message compiler
+      #
+      # @return [MessageCompiler]
+      #
+      # @api private
+      def message_compiler
+        rule_applier.message_compiler
+      end
+
+      # Return the rules from rule applier
+      #
+      # @return [MessageCompiler]
+      #
+      # @api private
+      def rules
+        rule_applier.rules
+      end
+
+      # Return the rule applier
+      #
+      # @api private
+      def rule_applier
+        # TODO: make this more explicit through class types
+        @__rule_applier__ ||= steps.last
+      end
+      alias_method :to_rule, :rule_applier
+    end
+  end
+end