dry-schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b804e7069cd7d8764f82ce208e38768fa9975e6d1460e1e44917d5c0eaeee911
+  data.tar.gz: 6814f96c49db2634895c20faf7b331feccbdcdcbc83ff89292f655acd6c0adfc
+SHA512:
+  metadata.gz: 80d4cc2626025ef517e48bba83026c1bba7ef5797fa25e2543589ed503ec9d7142e799ed9713d4452b7a1f1b2d2988b4c6aeb3172230ec6fd4987d58c8621775
+  data.tar.gz: f35d2b94570ec416b6fcb0457a4e685f37ff3a265a011a4016af611307e2d8d1b8b03dc9e4b59a63b5f2cf55aacf8ceabac0a5d689e73f14e4aaa5cef96e1fa4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 2019-01-30
+
+Initial release.

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dryrb Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+[gem]: https://rubygems.org/gems/dry-schema
+[travis]: https://travis-ci.org/dry-rb/dry-schema
+[codeclimate]: https://codeclimate.com/github/dry-rb/dry-schema
+[coveralls]: https://coveralls.io/r/dry-rb/dry-schema
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-schema
+
+# dry-schema [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
+
+[![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][gem]
+[![Build Status](https://travis-ci.org/dry-rb/dry-schema.svg?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/dry-rb/dry-schema/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/dry-rb/dry-schema/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-schema.svg?branch=master)][inchpages]
+
+<!-- ## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-schema) -->
+
+## License
+
+See `LICENSE` file.

data/config/errors.yml

@@ -0,0 +1,91 @@
+en:
+  errors:
+    or: "or"
+    array?: "must be an array"
+
+    empty?: "must be empty"
+
+    excludes?: "must not include %{value}"
+
+    excluded_from?:
+      arg:
+        default: "must not be one of: %{list}"
+        range: "must not be one of: %{list_left} - %{list_right}"
+    exclusion?: "must not be one of: %{list}"
+
+    eql?: "must be equal to %{left}"
+
+    not_eql?: "must not be equal to %{left}"
+
+    filled?: "must be filled"
+
+    format?: "is in invalid format"
+
+    number?: "must be a number"
+
+    odd?: "must be odd"
+
+    even?: "must be even"
+
+    gt?: "must be greater than %{num}"
+
+    gteq?: "must be greater than or equal to %{num}"
+
+    hash?: "must be a hash"
+
+    included_in?:
+      arg:
+        default: "must be one of: %{list}"
+        range: "must be one of: %{list_left} - %{list_right}"
+    inclusion?: "must be one of: %{list}"
+
+    includes?: "must include %{value}"
+
+    bool?: "must be boolean"
+
+    true?: "must be true"
+
+    false?: "must be false"
+
+    int?: "must be an integer"
+
+    float?: "must be a float"
+
+    decimal?: "must be a decimal"
+
+    date?: "must be a date"
+
+    date_time?: "must be a date time"
+
+    time?: "must be a time"
+
+    key?: "is missing"
+
+    attr?: "is missing"
+
+    lt?: "must be less than %{num}"
+
+    lteq?: "must be less than or equal to %{num}"
+
+    max_size?: "size cannot be greater than %{num}"
+
+    min_size?: "size cannot be less than %{num}"
+
+    nil?: "cannot be defined"
+
+    str?: "must be a string"
+
+    type?: "must be %{type}"
+
+    size?:
+      arg:
+        default: "size must be %{size}"
+        range: "size must be within %{size_left} - %{size_right}"
+
+      value:
+        string:
+          arg:
+            default: "length must be %{size}"
+            range: "length must be within %{size_left} - %{size_right}"
+    not:
+      empty?: "cannot be empty"

data/lib/dry-schema.rb

@@ -0,0 +1 @@
+require 'dry/schema'

data/lib/dry/schema.rb

@@ -0,0 +1,51 @@
+require 'dry/core/extensions'
+
+require 'dry/schema/constants'
+require 'dry/schema/dsl'
+require 'dry/schema/params'
+require 'dry/schema/json'
+
+module Dry
+  module Schema
+    extend Dry::Core::Extensions
+
+    # Define a schema
+    #
+    # @return [Processor]
+    #
+    # @api public
+    def self.define(options = EMPTY_HASH, &block)
+      DSL.new(options, &block).call
+    end
+
+    # Define a param schema
+    #
+    # @return [Params]
+    #
+    # @api public
+    def self.Params(**options, &block)
+      define(**options, processor_type: Params, &block)
+    end
+    singleton_class.send(:alias_method, :Form, :Params)
+
+    # Define a JSON schema
+    #
+    # @return [JSON]
+    #
+    # @api public
+    def self.JSON(**options, &block)
+      define(**options, processor_type: JSON, &block)
+    end
+
+    # Return configured paths to message files
+    #
+    # @return [Array<String>]
+    #
+    # @api public
+    def self.messages_paths
+      Messages::Abstract.config.paths
+    end
+  end
+end
+
+require 'dry/schema/extensions'

data/lib/dry/schema/compiler.rb

@@ -0,0 +1,31 @@
+require 'dry/logic/rule_compiler'
+require 'dry/schema/predicate_registry'
+
+module Dry
+  module Schema
+    # Extended rule compiler used internally by the DSL
+    #
+    # @api private
+    class Compiler < Logic::RuleCompiler
+      # Builds a default compiler instance with custom predicate registry
+      #
+      # @return [Compiler]
+      #
+      # @api private
+      def self.new(predicates = PredicateRegistry.new)
+        super
+      end
+
+      # Return true if a given predicate is supported by this compiler
+      #
+      # @param [Symbol] predicate
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def supports?(predicate)
+        predicates.key?(predicate)
+      end
+    end
+  end
+end

data/lib/dry/schema/config.rb

@@ -0,0 +1,52 @@
+require 'delegate'
+require 'dry/configurable'
+
+require 'dry/schema/predicate_registry'
+
+module Dry
+  module Schema
+    # Schema definition configuration class
+    #
+    # @see DSL#configure
+    #
+    # @api public
+    class Config < SimpleDelegator
+      extend Dry::Configurable
+
+      setting :predicates, Schema::PredicateRegistry.new
+      setting :messages, :yaml
+      setting :messages_file
+      setting :namespace
+      setting :rules, {}
+
+      # Build a new config object with defaults filled in
+      #
+      # @api private
+      def self.new
+        super(struct.new(*settings.map { |key| config.public_send(key) }))
+      end
+
+      # Build a struct with defined settings
+      #
+      # @return [Struct]
+      #
+      # @api private
+      def self.struct
+        ::Struct.new(*settings)
+      end
+
+      # Expose configurable object to the provided block
+      #
+      # This method is used by `DSL#configure`
+      #
+      # @return [Config]
+      #
+      # @api private
+      def configure(&block)
+        yield(__getobj__)
+        values.freeze
+        freeze
+      end
+    end
+  end
+end

data/lib/dry/schema/constants.rb

@@ -0,0 +1,13 @@
+require 'dry/core/constants'
+
+module Dry
+  module Schema
+    include Core::Constants
+
+    InvalidSchemaError = Class.new(StandardError)
+    MissingMessageError = Class.new(StandardError)
+
+    QUESTION_MARK = '?'.freeze
+    DOT = '.'.freeze
+  end
+end

data/lib/dry/schema/dsl.rb

@@ -0,0 +1,382 @@
+require 'dry/initializer'
+
+require 'dry/schema/constants'
+require 'dry/schema/config'
+require 'dry/schema/compiler'
+require 'dry/schema/types'
+require 'dry/schema/macros'
+
+require 'dry/schema/processor'
+require 'dry/schema/key_map'
+require 'dry/schema/key_coercer'
+require 'dry/schema/value_coercer'
+require 'dry/schema/rule_applier'
+
+module Dry
+  module Schema
+    # The schema definition DSL class
+    #
+    # The DSL is exposed by:
+    #   - `Schema.define`
+    #   - `Schema.Params`
+    #   - `Schema.JSON`
+    #   - `Schema::Params.define` - use with sub-classes
+    #   - `Schema::JSON.define` - use with sub-classes
+    #
+    # @example class-based definition
+    #   class UserSchema < Dry::Schema::Params
+    #     define do
+    #       required(:name).filled
+    #       required(:age).filled(:integer, gt: 18)
+    #     end
+    #   end
+    #
+    #   user_schema = UserSchema.new
+    #   user_schema.(name: 'Jame', age: 21)
+    #
+    # @example instance-based definition shortcut
+    #   UserSchema = Dry::Schema.Params do
+    #     required(:name).filled
+    #     required(:age).filled(:integer, gt: 18)
+    #   end
+    #
+    #   UserSchema.(name: 'Jame', age: 21)
+    #
+    # @api public
+    class DSL
+      Types = Schema::Types
+
+      extend Dry::Initializer
+
+      include ::Dry::Equalizer(:options)
+
+      # @!attribute [r] compiler
+      #   @return [Compiler] The rule compiler object
+      option :compiler, default: -> { Compiler.new }
+
+      # @!attribute [r] processor_type
+      #   @return [Compiler] The type of the processor (Params, JSON, or a custom sub-class)
+      option :processor_type, default: -> { Processor }
+
+      # @!attribute [r] macros
+      #   @return [Array] An array with macros defined within the DSL
+      option :macros, default: -> { EMPTY_ARRAY.dup }
+
+      # @!attribute [r] types
+      #   @return [Compiler] A key=>type map defined within the DSL
+      option :types, default: -> { EMPTY_HASH.dup }
+
+      # @!attribute [r] parent
+      #   @return [DSL] An optional parent DSL object that will be used to merge keys and rules
+      option :parent, optional: true
+
+      # @!attribute [r] config
+      #   @return [Config] Configuration object exposed via `#configure` method
+      option :config, optional: true, default: -> { Config.new }
+
+      # Build a new DSL object and evaluate provided block
+      #
+      # @param [Hash] options
+      # @option options [Class] :processor The processor type (`Params`, `JSON` or a custom sub-class)
+      # @option options [Compiler] :compiler An instance of a rule compiler (must be compatible with `Schema::Compiler`) (optional)
+      # @option options [DSL] :parent An instance of the parent DSL (optional)
+      # @option options [Config] :config A configuration object (optional)
+      #
+      # @see Schema.define
+      # @see Schema.Params
+      # @see Schema.JSON
+      # @see Processor.define
+      #
+      # @return [DSL]
+      #
+      # @api public
+      def self.new(options = EMPTY_HASH, &block)
+        dsl = super
+        dsl.instance_eval(&block) if block
+        dsl
+      end
+
+      # Provide customized configuration for your schema
+      #
+      # @example
+      #   Dry::Schema.define do
+      #     configure do |config|
+      #       config.messages = :i18n
+      #     end
+      #   end
+      #
+      # @see Config
+      #
+      # @return [DSL]
+      #
+      # @api public
+      def configure(&block)
+        config.configure(&block)
+        self
+      end
+
+      # Define a required key
+      #
+      # @example
+      #   required(:name).filled
+      #
+      #   required(:age).value(:integer)
+      #
+      #   required(:user_limit).value(:integer, gt?: 0)
+      #
+      #   required(:tags).filled { array? | str? }
+      #
+      # @param [Symbol] name The key name
+      #
+      # @return [Macros::Required]
+      #
+      # @api public
+      def required(name, &block)
+        key(name, macro: Macros::Required, &block)
+      end
+
+      # Define an optional key
+      #
+      # This works exactly the same as `required` except that if a key is not present
+      # rules will not be applied
+      #
+      # @see DSL#required
+      #
+      # @param [Symbol] name The key name
+      #
+      # @return [Macros::Optional]
+      #
+      # @api public
+      def optional(name, &block)
+        key(name, macro: Macros::Optional, &block)
+      end
+
+      # A generic method for defining keys
+      #
+      # @param [Symbol] name The key name
+      # @param [Class] macro The macro sub-class (ie `Macros::Required` or any other `Macros::Key` subclass)
+      #
+      # @return [Macros::Key]
+      #
+      # @api public
+      def key(name, macro:, &block)
+        set_type(name, Types::Any)
+
+        macro = macro.new(
+          name: name,
+          compiler: compiler,
+          schema_dsl: self,
+          filter_schema: filter_schema
+        )
+
+        macro.value(&block) if block
+        macros << macro
+        macro
+      end
+
+      # Build a processor based on DSL's definitions
+      #
+      # @return [Processor]
+      #
+      # @api private
+      def call
+        steps = [key_coercer]
+        steps << filter_schema.rule_applier if filter_rules?
+        steps << value_coercer << rule_applier
+
+        processor_type.new { |processor| steps.each { |step| processor << step } }
+      end
+
+      # Cast this DSL into a rule object
+      #
+      # @return [RuleApplier]
+      def to_rule
+        call.to_rule
+      end
+
+      # A shortcut for defining an array type with a member
+      #
+      # @example
+      #   required(:tags).filled(array[:string])
+      #
+      # @return [Dry::Types::Array::Member]
+      #
+      # @api public
+      def array
+        -> member_type { type_registry["array"].of(resolve_type(member_type)) }
+      end
+
+      # Return type schema used by the value coercer
+      #
+      # @return [Dry::Types::Safe]
+      #
+      # @api private
+      def type_schema
+        type_registry["hash"].schema(types.merge(parent_types)).safe
+      end
+
+      # Return a new DSL instance using the same processor type
+      #
+      # @return [Dry::Types::Safe]
+      #
+      # @api private
+      def new(&block)
+        self.class.new(processor_type: processor_type, &block)
+      end
+
+      # Set a type for the given key name
+      #
+      # @param [Symbol] name The key name
+      # @param [Symbol, Array<Symbol>, Dry::Types::Type] spec The type spec or a type object
+      #
+      # @return [Dry::Types::Safe]
+      #
+      # @api private
+      def set_type(name, spec)
+        type = resolve_type(spec)
+        meta = { omittable: true, maybe: maybe?(type) }
+
+        types[name] = type.meta(meta)
+      end
+
+      # Check if the given type is a maybe sum
+      #
+      # @api private
+      def maybe?(type)
+        type.is_a?(Dry::Types::Sum) && type.left.primitive.equal?(NilClass)
+      end
+
+      protected
+
+      # Build a rule applier
+      #
+      # @return [RuleApplier]
+      #
+      # @api protected
+      def rule_applier
+        RuleApplier.new(rules, config: config)
+      end
+
+      # Build rules from defined macros
+      #
+      # @see #rule_applier
+      #
+      # @api protected
+      def rules
+        macros.map { |m| [m.name, m.to_rule] }.to_h.merge(parent_rules)
+      end
+
+      # Build a key map from defined types
+      #
+      # @api protected
+      def key_map(types = self.types)
+        keys = types.keys.each_with_object([]) { |key_name, arr|
+          arr << key_spec(key_name, types[key_name])
+        }
+        km = KeyMap.new(keys)
+
+        if key_map_type
+          km.public_send(key_map_type)
+        else
+          km
+        end
+      end
+
+      private
+
+      # Check if any filter rules were defined
+      #
+      # @api private
+      def filter_rules?
+        instance_variable_defined?('@__filter_schema__') && !filter_schema.macros.empty?
+      end
+
+      # Build an input schema DSL used by `filter` API
+      #
+      # @see Macros::Value#filter
+      #
+      # @api private
+      def filter_schema
+        @__filter_schema__ ||= new
+      end
+
+      # Build a key coercer
+      #
+      # @return [KeyCoercer]
+      #
+      # @api private
+      def key_coercer
+        KeyCoercer.symbolized(key_map + parent_key_map)
+      end
+
+      # Build a value coercer
+      #
+      # @return [ValueCoercer]
+      #
+      # @api private
+      def value_coercer
+        ValueCoercer.new(type_schema)
+      end
+
+      # Return type registry configured by the processor type
+      #
+      # @api private
+      def type_registry
+        processor_type.config.type_registry
+      end
+
+      # Return key map type configured by the processor type
+      #
+      # @api private
+      def key_map_type
+        processor_type.config.key_map_type
+      end
+
+      # Build a key spec needed by the key map
+      #
+      # @api private
+      def key_spec(name, type)
+        if type.respond_to?(:member_types)
+          { name => key_map(type.member_types) }
+        elsif type.respond_to?(:member)
+          kv = key_spec(name, type.member)
+          kv.equal?(name) ? name : kv.flatten(1)
+        else
+          name
+        end
+      end
+
+      # Resolve type object from the provided spec
+      #
+      # @param [Symbol, Array<Symbol>, Dry::Types::Type]
+      #
+      # @return [Dry::Types::Type]
+      #
+      # @api private
+      def resolve_type(spec)
+        case spec
+        when ::Dry::Types::Type then spec
+        when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
+        else
+          type_registry[spec]
+        end
+      end
+
+      # @api private
+      def parent_rules
+        parent&.rules || EMPTY_HASH
+      end
+
+      # @api private
+      def parent_types
+        # TODO: this is awful, it'd be nice if we had `Dry::Types::Hash::Schema#merge`
+        parent&.type_schema&.member_types || EMPTY_HASH
+      end
+
+      # @api private
+      def parent_key_map
+        parent&.key_map || EMPTY_ARRAY
+      end
+    end
+  end
+end