dry-types 0.9.0 → 0.15.0

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Issue Guidelines
+
+## Reporting bugs
+
+If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
+
+## Reporting feature requests
+
+Report a feature request **only after discussing it first on [discourse.dry-rb.org](https://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
+
+## Reporting questions, support requests, ideas, concerns etc.
+
+**PLEASE DON'T** - use [discourse.dry-rb.org](https://discourse.dry-rb.org) instead.
+
+# Pull Request Guidelines
+
+A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
+
+Other requirements:
+
+1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
+2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
+3) Add API documentation if it's a new feature
+4) Update API documentation if it changes an existing feature
+5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
+
+# Asking for help
+
+If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org).

data/Gemfile

@@ -1,22 +1,23 @@
 source 'https://rubygems.org'
 
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
 gemspec
 
 group :test do
-  gem "codeclimate-test-reporter", platform: :rbx, require: false
+  platform :mri do
+    gem 'simplecov', require: false
+  end
 end
 
 group :tools do
-  gem 'byebug', platform: :mri
-  gem 'mutant'
-  gem 'mutant-rspec'
+  gem 'pry-byebug', platform: :mri
 end
 
 group :benchmarks do
-  gem 'sqlite3'
-  gem 'activerecord', platform: %i(jruby mri)
   gem 'benchmark-ips'
   gem 'virtus'
   gem 'fast_attributes'
   gem 'attrio'
+  gem 'dry-struct'
 end

data/README.md

@@ -1,6 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-types
 [travis]: https://travis-ci.org/dry-rb/dry-types
-[gemnasium]: https://gemnasium.com/dry-rb/dry-types
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-types
 [coveralls]: https://coveralls.io/r/dry-rb/dry-types
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-types
@@ -9,7 +8,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/dry-types.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-types.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/dry-rb/dry-types.svg)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/dry-rb/dry-types/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/dry-rb/dry-types/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-types.svg?branch=master)][inchpages]
@@ -20,7 +18,7 @@
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake run_specs` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/Rakefile

@@ -4,12 +4,17 @@ require "rspec/core/rake_task"
 task :run_specs do
   require 'rspec/core'
 
-  RSpec::Core::Runner.run(['spec/dry'])
+  types_result = RSpec::Core::Runner.run(['spec/dry'])
   RSpec.clear_examples
 
-  load 'spec/dry/types.rb'
   Dry::Types.load_extensions(:maybe)
-  RSpec::Core::Runner.run(['spec'])
+  ext_result = RSpec::Core::Runner.run(['spec'])
+
+  exit [types_result, ext_result].max
 end
 
 task default: :run_specs
+
+require 'yard'
+require 'yard/rake/yardoc_task'
+YARD::Rake::YardocTask.new(:doc)

data/benchmarks/hash_schemas.rb

@@ -5,13 +5,13 @@ require 'dry-types'
 
 module SchemaBench
   def self.hash_schema(type)
-    Dry::Types['hash'].public_send(type,
-      email:   Dry::Types['string'],
-      age:     Dry::Types['form.int'],
-      admin:   Dry::Types['form.bool'],
-      address: Dry::Types['hash'].public_send(type,
-        city: Dry::Types['string'],
-        street: Dry::Types['string']
+    Dry::Types['nominal.hash'].public_send(type,
+      email:   Dry::Types['nominal.string'],
+      age:     Dry::Types['params.integer'],
+      admin:   Dry::Types['params.bool'],
+      address: Dry::Types['nominal.hash'].public_send(type,
+        city: Dry::Types['nominal.string'],
+        street: Dry::Types['nominal.string']
       )
     )
   end

data/dry-types.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'dry/types/version'
@@ -12,12 +11,15 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'Type system for Ruby supporting coercions, constraints and complex types like structs, value objects, enums etc.'
   spec.description   = spec.summary
-  spec.homepage      = "https://github.com/dryrb/dry-types"
+  spec.homepage      = "https://github.com/dry-rb/dry-types"
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
   # delete this section to allow pushing this gem to any host.
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['changelog_uri'] = "https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
+    spec.metadata['source_code_uri'] = "https://github.com/dry-rb/dry-types"
+    spec.metadata['bug_tracker_uri'] = "https://github.com/dry-rb/dry-types/issues"
   else
     raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
@@ -26,18 +28,18 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.1.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_runtime_dependency 'dry-core', '~> 0.1'
+  spec.add_runtime_dependency 'dry-core', '~> 0.4', '>= 0.4.4'
+  spec.add_runtime_dependency 'dry-inflector', '~> 0.1', '>= 0.1.2'
   spec.add_runtime_dependency 'dry-container', '~> 0.3'
-  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
-  spec.add_runtime_dependency 'dry-logic', '~> 0.4', '>= 0.4.0'
-  spec.add_runtime_dependency 'inflecto', '~> 0.0.0', '>= 0.0.2'
+  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2', '>= 0.2.2'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.5', '>= 0.5'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 11.0"
   spec.add_development_dependency "rspec", "~> 3.3"
   spec.add_development_dependency 'dry-monads', '~> 0.2'
+  spec.add_development_dependency 'yard', '~> 0.9.5'
 end

data/lib/dry/types/any.rb

@@ -0,0 +1,36 @@
+module Dry
+  module Types
+    Any = Class.new(Nominal) do
+      def self.name
+        'Any'
+      end
+
+      def initialize(**options)
+        super(::Object, options)
+      end
+
+      # @return [String]
+      def name
+        'Any'
+      end
+
+      # @param [Object] any input is valid
+      # @return [true]
+      def valid?(_)
+        true
+      end
+      alias_method :===, :valid?
+
+      # @param [Hash] new_options
+      # @return [Type]
+      def with(**new_options)
+        self.class.new(**options, meta: @meta, **new_options)
+      end
+
+      # @return [Array]
+      def to_ast(meta: true)
+        [:any, meta ? self.meta : EMPTY_HASH]
+      end
+    end.new
+  end
+end

data/lib/dry/types/array/member.rb

@@ -1,26 +1,40 @@
 module Dry
   module Types
-    class Array < Definition
+    class Array < Nominal
       class Member < Array
+        # @return [Type]
         attr_reader :member
 
+        # @param [Class] primitive
+        # @param [Hash] options
+        # @option options [Type] :member
         def initialize(primitive, options = {})
           @member = options.fetch(:member)
           super
         end
 
+        # @param [Object] input
+        # @param [Symbol] meth
+        # @return [Array]
         def call(input, meth = :call)
           input.map { |el| member.__send__(meth, el) }
         end
         alias_method :[], :call
 
-        def valid?(type)
-          super && type.all? { |el| member.valid?(el) }
+        # @param [Array, #all?, Object] value
+        # @return [Boolean]
+        def valid?(value)
+          super && value.all? { |el| member.valid?(el) }
         end
 
+        # @param [Array, Object] input
+        # @param [#call,nil] block
+        # @yieldparam [Failure] failure
+        # @yieldreturn [Result]
+        # @return [Result,Logic::Result]
         def try(input, &block)
           if input.is_a?(::Array)
-            result = call(input, :try)
+            result = call(input, :try).reject { |r| r.input.equal?(Undefined) }
             output = result.map(&:input)
 
             if result.all?(&:success?)
@@ -34,6 +48,17 @@ module Dry
             block ? yield(failure) : failure
           end
         end
+
+        # @api public
+        #
+        # @see Nominal#to_ast
+        def to_ast(meta: true)
+          if member.respond_to?(:to_ast)
+            [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+          else
+            [:array, [member, meta ? self.meta : EMPTY_HASH]]
+          end
+        end
       end
     end
   end

data/lib/dry/types/array.rb

@@ -2,15 +2,17 @@ require 'dry/types/array/member'
 
 module Dry
   module Types
-    class Array < Definition
-      def member(type)
+    class Array < Nominal
+      # @param [Type] type
+      # @return [Array::Member]
+      def of(type)
         member =
           case type
-          when String, Class then Types[type]
+          when String then Types[type]
           else type
           end
 
-        Array::Member.new(primitive, options.merge(member: member))
+        Array::Member.new(primitive, **options, member: member)
       end
     end
   end

data/lib/dry/types/builder.rb

@@ -1,47 +1,89 @@
-require 'dry/core/constants'
+require 'dry/core/deprecations'
 
 module Dry
   module Types
     module Builder
       include Dry::Core::Constants
 
+      # @return [Class]
       def constrained_type
         Constrained
       end
 
+      # @return [Class]
+      def constructor_type
+        Constructor
+      end
+
+      # @param [Type] other
+      # @return [Sum, Sum::Constrained]
       def |(other)
         klass = constrained? && other.constrained? ? Sum::Constrained : Sum
         klass.new(self, other)
       end
 
+      # @return [Sum]
       def optional
         Types['strict.nil'] | self
       end
 
+      # @param [Hash] options constraining rule (see {Types.Rule})
+      # @return [Constrained]
       def constrained(options)
         constrained_type.new(self, rule: Types.Rule(options))
       end
 
-      def default(input = Undefined, &block)
-        value = input == Undefined ? block : input
+      # @param [Object] input
+      # @param [Hash] options
+      # @param [#call,nil] block
+      # @raise [ConstraintError]
+      # @return [Default]
+      def default(input = Undefined, options = EMPTY_HASH, &block)
+        unless input.frozen? || options[:shared]
+          where = Dry::Core::Deprecations::STACK.()
+          Dry::Core::Deprecations.warn(
+            "#{input.inspect} is mutable."\
+            ' Be careful: types will return the same instance of the default'\
+            ' value every time. Call `.freeze` when setting the default'\
+            ' or pass `shared: true` to discard this warning.'\
+            "\n#{ where }",
+            tag: :'dry-types'
+          )
+        end
 
-        if value.is_a?(Proc) || valid?(value)
+        value = input.equal?(Undefined) ? block : input
+
+        if value.respond_to?(:call) || valid?(value)
           Default[value].new(self, value)
         else
           raise ConstraintError.new("default value #{value.inspect} violates constraints", value)
         end
       end
 
+      # @param [Array] values
+      # @return [Enum]
       def enum(*values)
-        Enum.new(constrained(included_in: values), values: values)
+        mapping =
+          if values.length == 1 && values[0].is_a?(::Hash)
+            values[0]
+          else
+            ::Hash[values.zip(values)]
+          end
+
+        Enum.new(constrained(included_in: mapping.keys), mapping: mapping)
       end
 
+      # @return [Safe]
       def safe
         Safe.new(self)
       end
 
+      # @param [#call,nil] constructor
+      # @param [Hash] options
+      # @param [#call,nil] block
+      # @return [Constructor]
       def constructor(constructor = nil, **options, &block)
-        Constructor.new(with(options), fn: constructor || block)
+        constructor_type.new(with(options), fn: constructor || block)
       end
     end
   end

data/lib/dry/types/builder_methods.rb

@@ -0,0 +1,111 @@
+module Dry
+  module Types
+    module BuilderMethods
+      # @api private
+      def included(base)
+        super
+        base.extend(BuilderMethods)
+      end
+
+      # Build an array type.
+      # It is a shortcut for Array.of
+      #
+      # @example
+      #   Types::Strings = Types.Array(Types::String)
+      #
+      # @param [Dry::Types::Type] type
+      #
+      # @return [Dry::Types::Array]
+      def Array(type)
+        self::Array.of(type)
+      end
+
+      # Build a hash schema
+      #
+      # @param [Hash{Symbol => Dry::Types::Type}] type_map
+      #
+      # @return [Dry::Types::Array]
+      # @api public
+      def Hash(type_map)
+        self::Hash.schema(type_map)
+      end
+
+      # Build a type which values are instances of a given class
+      # Values are checked using `is_a?` call
+      #
+      # @example
+      #   Types::Error = Types.Instance(StandardError)
+      #   Types::Error = Types.Strict(StandardError)
+      #   Types.Strict(Integer) == Types::Strict::Int # => true
+      #
+      # @param [Class,Module] klass Class or module
+      #
+      # @return [Dry::Types::Type]
+      # @api public
+      def Instance(klass)
+        Nominal.new(klass).constrained(type: klass)
+      end
+      alias_method :Strict, :Instance
+
+      # Build a type with a single value
+      # The equality check done with `eql?`
+      #
+      # @param [Object] value
+      #
+      # @return [Dry::Types::Type]
+      # @api public
+      def Value(value)
+        Nominal.new(value.class).constrained(eql: value)
+      end
+
+      # Build a type with a single value
+      # The equality check done with `equal?`
+      #
+      # @param [Object] object
+      #
+      # @return [Dry::Types::Type]
+      # @api public
+      def Constant(object)
+        Nominal.new(object.class).constrained(is: object)
+      end
+
+      # Build a constructor type
+      # If no constructor block given it uses .new method
+      #
+      # @param [Class] klass
+      # @param [#call,nil] cons Value constructor
+      # @param [#call,nil] block Value constructor
+      #
+      # @return [Dry::Types::Type]
+      # @api public
+      def Constructor(klass, cons = nil, &block)
+        Nominal.new(klass).constructor(cons || block || klass.method(:new))
+      end
+
+      # Build a nominal type
+      #
+      # @param [Class] klass
+      #
+      # @return [Dry::Types::Type]
+      # @api public
+      def Nominal(klass)
+        Nominal.new(klass)
+      end
+
+      # Build a map type
+      #
+      # @example
+      #   Types::IntMap = Types.Map(Types::Strict::Integer, 'any')
+      #   Types::IntStringMap = Types.Map(Types::Strict::Integer, Types::Strict::String)
+      #
+      # @param [Type] key_type Key type
+      # @param [Type] value_type Value type
+      #
+      # @return [Dry::Types::Map]
+      # @api public
+      def Map(key_type, value_type)
+        Types['nominal.hash'].map(key_type, value_type)
+      end
+    end
+  end
+end

data/lib/dry/types/coercions/json.rb

@@ -9,7 +9,10 @@ module Dry
       module JSON
         extend Coercions
 
+        # @param [#to_d, Object] input
+        # @return [BigDecimal,nil]
         def self.to_decimal(input)
+          return if input.nil?
           input.to_d unless empty_str?(input)
         end
       end

data/lib/dry/types/coercions/{form.rb → params.rb}

@@ -4,24 +4,36 @@ require 'bigdecimal/util'
 module Dry
   module Types
     module Coercions
-      module Form
-        TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES].freeze
-        FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO].freeze
+      module Params
+        TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
+        FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
         BOOLEAN_MAP = ::Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
 
         extend Coercions
 
+        # @param [String, Object] input
+        # @return [Boolean,Object]
+        # @see TRUE_VALUES
+        # @see FALSE_VALUES
         def self.to_true(input)
           BOOLEAN_MAP.fetch(input.to_s, input)
         end
 
+        # @param [String, Object] input
+        # @return [Boolean,Object]
+        # @see TRUE_VALUES
+        # @see FALSE_VALUES
         def self.to_false(input)
           BOOLEAN_MAP.fetch(input.to_s, input)
         end
 
+        # @param [#to_int, #to_i, Object] input
+        # @return [Integer, nil, Object]
         def self.to_int(input)
           if empty_str?(input)
             nil
+          elsif input.is_a? String
+            Integer(input, 10)
           else
             Integer(input)
           end
@@ -29,6 +41,8 @@ module Dry
           input
         end
 
+        # @param [#to_f, Object] input
+        # @return [Float, nil, Object]
         def self.to_float(input)
           if empty_str?(input)
             nil
@@ -39,6 +53,8 @@ module Dry
           input
         end
 
+        # @param [#to_d, Object] input
+        # @return [BigDecimal, nil, Object]
         def self.to_decimal(input)
           result = to_float(input)
 
@@ -49,10 +65,14 @@ module Dry
           end
         end
 
+        # @param [Array, String, Object] input
+        # @return [Array, Object]
         def self.to_ary(input)
           empty_str?(input) ? [] : input
         end
 
+        # @param [Hash, String, Object] input
+        # @return [Hash, Object]
         def self.to_hash(input)
           empty_str?(input) ? {} : input
         end

data/lib/dry/types/coercions.rb

@@ -1,21 +1,28 @@
-require 'dry/core/constants'
-
 module Dry
   module Types
     module Coercions
       include Dry::Core::Constants
 
+      # @param [String, Object] input
+      # @return [nil] if the input is an empty string
+      # @return [Object] otherwise the input object is returned
       def to_nil(input)
         input unless empty_str?(input)
       end
 
+      # @param [#to_str, Object] input
+      # @return [Date, Object]
+      # @see Date.parse
       def to_date(input)
         return input unless input.respond_to?(:to_str)
         Date.parse(input)
-      rescue ArgumentError
+      rescue ArgumentError, RangeError
         input
       end
 
+      # @param [#to_str, Object] input
+      # @return [DateTime, Object]
+      # @see DateTime.parse
       def to_date_time(input)
         return input unless input.respond_to?(:to_str)
         DateTime.parse(input)
@@ -23,6 +30,9 @@ module Dry
         input
       end
 
+      # @param [#to_str, Object] input
+      # @return [Time, Object]
+      # @see Time.parse
       def to_time(input)
         return input unless input.respond_to?(:to_str)
         Time.parse(input)
@@ -32,6 +42,9 @@ module Dry
 
       private
 
+      # Checks whether String is empty
+      # @param [String, Object] value
+      # @return [Boolean]
       def empty_str?(value)
         EMPTY_STRING.eql?(value)
       end