dry-types 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56b7935633ed4d23fa17d30082254f98e3e7f642a482c17bdb6f77629f88a399
-  data.tar.gz: f9860f5500c746b10dcdd0aec29c70737d31615dc2342ee2ad7bc1f3e12c9250
+  metadata.gz: e14386ca189be49fd569c297a7d1ac385806569218fb172a63761ba0045a7fd6
+  data.tar.gz: 353f074f3cf5fe2718eb4e5eb4f3ff4273f3c565a67f2267f0b2014ba67f22dd
 SHA512:
-  metadata.gz: 363ff8a7854062a51c71ff646d5e6c3c9ae1c964be5b99267c77b4cbfc5efa9d99b0466cdc736d142859aa624be99bb9fba1cf89bf9282eeb71f234eb5e3898f
-  data.tar.gz: 6f6b1714103ea16df7a837c9e0a5b9488adf59f6eddeb8f28228c09daeb843edabacdae54ce9d4b461010c4851f75f8da5860f210b943b1a879105dd85dfd2bf
+  metadata.gz: cff40f66df4f87bee0bed14f033c49d8e6b1ffa98200f6f076def32a4bb4fdecf5906e9d3be6ee5a6cb611a21fa2f1fae6653c40ef49e3f21cfaf285ae4455b4
+  data.tar.gz: 0cdadfae930f5833efd33f8e73189b9880d4606b0ebf3f1fe0f2e948d1eec8cb4896abccd2b0e4f2d9269c92d6b5aa41c29431fb247f56337b9dc82a7d998488

data/.codeclimate.yml

@@ -0,0 +1,15 @@
+version: "2"
+
+prepare:
+  fetch:
+  - url: "https://raw.githubusercontent.com/dry-rb/devtools/master/.rubocop.yml"
+    path: ".rubocop.yml"
+
+exclude_patterns:
+  - "benchmarks/"
+  - "examples/"
+  - "spec/"
+
+plugins:
+  rubocop:
+    enabled: true

data/.rubocop.yml

@@ -0,0 +1,43 @@
+AllCops:
+  TargetRubyVersion: 2.4
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/Alias:
+  Enabled: false
+
+Style/LambdaCall:
+  Enabled: false
+
+Style/StabbyLambdaParentheses:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+Metrics/LineLength:                                                             
+  Max: 100 
+
+Metrics/MethodLength:
+  Max: 22
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/BlockLength:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*_spec.rb'
+
+Metrics/CyclomaticComplexity:
+  Enabled: true
+  Max: 10
+
+Lint/BooleanSymbol:
+  Enabled: false

data/.travis.yml

@@ -1,27 +1,28 @@
 language: ruby
-dist: trusty
-sudo: required
 cache: bundler
+sudo: false
 bundler_args: --without benchmarks tools
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - "[ -d coverage ] && ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
 script:
   - bundle exec rake
-after_success:
-  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.3.8
+  - 2.6.1
+  - 2.5.3
   - 2.4.5
-  - 2.5.5
-  - 2.6.2
   - jruby-9.2.6.0
 env:
   global:
     - COVERAGE=true
-    - JRUBY_OPTS='--dev -J-Xmx1024M'
 notifications:
   email: false
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/19098b4253a72c9796db
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false
+    on_success: change # options: [always|never|change] default: always
+    on_failure: always # options: [always|never|change] default: always
+    on_start: false # default: false

data/CHANGELOG.md

@@ -1,11 +1,122 @@
-# v0.14.1 2019-03-25
+# 0.15.0 2019-03-22
+
+## Changed
+
+- [BREAKING] Internal representation of hash schemas was changed to be a simple list of key types (flash-gordon)
+  `Dry::Types::Hash#with_type_transform` now yields a key type instead of type + name:
+  ```ruby
+  Dry::Types['strict.hash'].with_type_transform { |key| key.name == :age ? key.required(false) : key }
+  ```
+- [BREAKING] Definition types were renamed to nominal (flash-gordon)
+- [BREAKING] Top-level types returned by `Dry::Types.[]` are now strict (flash-gordon)
+  ```ruby
+  # before
+  Dry::Types['integer']
+  # => #<Dry::Types[Nominal<Integer>]>
+  # now
+  Dry::Types['integer']
+  # => <Dry::Types[Constrained<Nominal<Integer> rule=[type?(Integer)]>]>
+  # you can still access nominal types using namespace
+  Dry::Types['nominal.integer']
+  # => #<Dry::Types[Nominal<Integer>]>
+  ```
+- [BREAKING] Default values are not evaluated if the decorated type returns `nil`. They are triggered on `Undefined` instead (GustavoCaso + flash-gordon)
+- [BREAKING] Support for old hash schemas was fully removed. This makes dry-types not compatible with dry-validation < 1.0 (flash-gordon)
+- `Dry::Types.module` is deprecated in favor of `Dry.Types` (flash-gordon)
+  Keep in mind `Dry.Types` uses strict types for top-level names, that is after
+  ```ruby
+  module Types
+    include Dry.Types
+  end
+  ```
+  `Types::Integer` is a strict type. If you want it to be nominal, use `include Dry.Types(default: :nominal)`. See other options below.
+- `params.integer` now always converts strings to decimal numbers, this means `09` will be coerced to `9` (threw an error before) (skryukov)
+- Ruby 2.3 is EOL and not officially supported. It may work but we don't test it.
+
+## Added
+
+- Improved string representation of types (flash-gordon)
+  ```ruby
+  Dry::Types['nominal.integer']
+  # => #<Dry::Types[Nominal<Integer>]>
+  Dry::Types['params.integer']
+  # => #<Dry::Types[Constructor<Nominal<Integer> fn=Dry::Types::Coercions::Params.to_int>]>
+  Dry::Types['hash'].schema(age?: 'integer')
+  # => #<Dry::Types[Constrained<Schema<keys={age?: Constrained<Nominal<Integer> rule=[type?(Integer)]>}> rule=[type?(Hash)]>]>
+  Dry::Types['array<integer>']
+  # => #<Dry::Types[Constrained<Array<Constrained<Nominal<Integer> rule=[type?(Integer)]>> rule=[type?(Array)]>]>
+  ```
+- Options for the list of types you want to import with `Dry.Types` (flash-gordon)
+  Cherry-pick only certain types:
+  ```ruby
+  module Types
+    include Dry.Types(:strict, :nominal, :coercible)
+  end
+  Types.constants
+  # => [:Strict, :Nominal, :Coercible]
+  ```
+  Change default top-level types:
+  ```ruby
+  module Types
+    include Dry.Types(default: :coercible)
+  end
+  # => #<Dry::Types[Constructor<Nominal<Integer> fn=Kernel.Integer>]>
+  ```
+  Rename type namespaces:
+  ```ruby
+  module Types
+    include Dry.Types(strict: :Strong, coercible: :Kernel)
+  end
+  ```
+- Optional keys for schemas can be provided with ?-ending symbols (flash-gordon)
+  ```ruby
+  Dry::Types['hash'].schema(name: 'string', age?: 'integer')
+  ```
+- Another way of making keys optional is setting `required: false` to meta. In fact, it is the preferable
+  way if you have to store this information in `meta`, otherwise use the Key's API (see below) (flash-gordon)
+  ```ruby
+  Dry::Types['hash'].schema(
+    name: Dry::Types['string'],
+    age: Dry::Types['integer'].meta(required: false)
+  )
+  ```
+- Key types have API for making keys omittable and back (flash-gordon)
+  ```ruby
+  # defining a base schema with optional keys
+  lax_hash = Dry::Types['hash'].with_type_transform { |key| key.required(false) }
+  # same as
+  lax_hash = Dry::Types['hash'].with_type_transform(&:omittable)
+
+  # keys in user_schema are not required
+  user_schema = lax_hash.schema(name: 'string', age: 'integer')
+  ```
+- `Type#optional?` now recognizes more cases where `nil` is an allowed value (flash-gordon)
+- `Constructor#{prepend,append}` with `<<` and `>>` as aliases. `Constructor#append` works the same way `Constructor#constrcutor` does. `Constuctor#prepend` chains functions in the reverse order, see examples (flash-gordon)
+  ```ruby
+  to_int = Types::Coercible::Integer
+  inc = to_int.append { |x| x + 2 }
+  inc.("1") # => "1" -> 1 -> 3
+
+  inc = to_int.prepend { |x| x + "2" }
+  inc.("1") # => "1" -> "12" -> 12
+  ```
+- Partial schema application for cases when you want to validate only a subset of keys (flash-gordon)
+  This is useful when you want to update a key or two in an already-validated hash. A perfect example is `Dry::Struct#new` where this feature is now used.
+  ```ruby
+  schema = Dry::Types['hash'].schema(name: 'string', age: 'integer')
+  value = schema.(name: 'John', age: 20)
+  update = schema.apply({ age: 21 }, skip_missing: true)
+  value.merge(update)
+  ```
 
 ## Fixed
-- `coercible.integer` now doesn't blow up on invalid strings (exterm)
 
-[Compare v0.14.0...v0.14.1](https://github.com/dry-rb/dry-types/compare/v0.14.0...v0.14.1)
+* `Hash::Map` now behaves as a constrained type if its values are constrained (flash-gordon)
+* `coercible.integer` now doesn't blow up on invalid strings (exterm)
+
+[Compare v0.14.0...v0.15.0](https://github.com/dry-rb/dry-types/compare/v0.14.0...v0.15.0)
 
-# v0.14.0 2019-01-29
+# 0.14.0 2019-01-29
 
 ## Changed
 

data/Gemfile

@@ -1,18 +1,17 @@
 source 'https://rubygems.org'
 
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
 gemspec
 
 group :test do
   platform :mri do
-    gem "codeclimate-test-reporter", require: false
     gem 'simplecov', require: false
   end
 end
 
 group :tools do
   gem 'pry-byebug', platform: :mri
-  gem 'mutant'
-  gem 'mutant-rspec'
 end
 
 group :benchmarks do

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'],
+    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['hash'].public_send(type,
-        city: Dry::Types['string'],
-        street: Dry::Types['string']
+      address: Dry::Types['nominal.hash'].public_send(type,
+        city: Dry::Types['nominal.string'],
+        street: Dry::Types['nominal.string']
       )
     )
   end

data/dry-types.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   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-equalizer', '~> 0.2', '>= 0.2.2'
   spec.add_runtime_dependency 'dry-logic', '~> 0.5', '>= 0.5'
 
   spec.add_development_dependency "bundler"

data/lib/dry/types.rb

@@ -14,9 +14,10 @@ require 'dry/types/version'
 require 'dry/types/container'
 require 'dry/types/inflector'
 require 'dry/types/type'
-require 'dry/types/definition'
+require 'dry/types/printable'
+require 'dry/types/nominal'
 require 'dry/types/constructor'
-require 'dry/types/builder_methods'
+require 'dry/types/module'
 
 require 'dry/types/errors'
 
@@ -24,34 +25,25 @@ module Dry
   module Types
     extend Dry::Core::Extensions
     extend Dry::Core::ClassAttributes
+    extend Dry::Core::Deprecations[:'dry-types']
     include Dry::Core::Constants
 
-    # @!attribute [r] namespace
-    #   @return [Container{String => Definition}]
-    defines :namespace
-
-    namespace self
-
     TYPE_SPEC_REGEX = %r[(.+)<(.+)>].freeze
 
-    # @return [Module]
-    def self.module
-      namespace = Module.new
-      define_constants(namespace, type_keys)
-      namespace.extend(BuilderMethods)
-      namespace
+    # @see Dry.Types
+    def self.module(*namespaces, default: :nominal, **aliases)
+      Module.new(container, *namespaces, default: default, **aliases)
     end
+    deprecate_class_method :module, message: <<~DEPRECATION
+      Use Dry.Types() instead. Beware, it exports strict types by default, for old behavior use Dry.Types(default: :nominal). See more options in the changelog
+    DEPRECATION
 
-    # @deprecated Include {Dry::Types.module} instead
-    def self.finalize
-      warn 'Dry::Types.finalize and configuring namespace is deprecated. Just'\
-       ' do `include Dry::Types.module` in places where you want to have access'\
-       ' to built-in types'
-
-      define_constants(self.namespace, type_keys)
+    # @api private
+    def self.included(*)
+      raise RuntimeError, "Import Dry.Types, not Dry::Types"
     end
 
-    # @return [Container{String => Definition}]
+    # @return [Container{String => Nominal}]
     def self.container
       @container ||= Container.new
     end
@@ -64,7 +56,7 @@ module Dry
     # @param [String] name
     # @param [Type] type
     # @param [#call,nil] block
-    # @return [Container{String => Definition}]
+    # @return [Container{String => Nominal}]
     # @api private
     def self.register(name, type = nil, &block)
       container.register(name, type || block.call)
@@ -96,24 +88,6 @@ module Dry
       end
     end
 
-    # @param [Module] namespace
-    # @param [<String>] identifiers
-    # @return [<Definition>]
-    def self.define_constants(namespace, identifiers)
-      names = identifiers.map do |id|
-        parts = id.split('.')
-        [Inflector.camelize(parts.pop), parts.map(&Inflector.method(:camelize))]
-      end
-
-      names.map do |(klass, parts)|
-        mod = parts.reduce(namespace) do |a, e|
-          a.constants.include?(e.to_sym) ? a.const_get(e) : a.const_set(e, Module.new)
-        end
-
-        mod.const_set(klass, self[identifier((parts + [klass]).join('::'))])
-      end
-    end
-
     # @param [#to_s] klass
     # @return [String]
     def self.identifier(klass)
@@ -125,19 +99,17 @@ module Dry
       @type_map ||= Concurrent::Map.new
     end
 
-    # List of type keys defined in {Dry::Types.container}
+   # List of type keys defined in {Dry::Types.container}
     # @return [<String>]
     def self.type_keys
       container.keys
     end
 
-    private
-
     # @api private
     def self.const_missing(const)
       underscored = Inflector.underscore(const)
 
-      if type_keys.any? { |key| key.split('.')[0] == underscored }
+      if container.keys.any? { |key| key.split('.')[0] == underscored }
         raise NameError,
               'dry-types does not define constants for default types. '\
               'You can access the predefined types with [], e.g. Dry::Types["strict.integer"] '\
@@ -147,7 +119,57 @@ module Dry
       end
     end
   end
+
+  # Export registered types as a module with constants
+  #
+  # @example no options
+  #
+  #   module Types
+  #     # imports all types as constants, uses modules for namespaces
+  #     include Dry::Types.module
+  #   end
+  #   # nominal types are exported by default
+  #   Types::Integer
+  #   # => #<Dry::Types[Nominal<Integer>]>
+  #   Types::Strict::Integer
+  #   # => #<Dry::Types[Constrained<Nominal<Integer> rule=[type?(Integer)]>]>
+  #
+  # @example changing default types
+  #
+  #   module Types
+  #     include Dry::Types(default: :strict)
+  #   end
+  #   Types::Integer
+  #   # => #<Dry::Types[Constrained<Nominal<Integer> rule=[type?(Integer)]>]>
+  #
+  # @example cherry-picking namespaces
+  #
+  #   module Types
+  #     include Dry::Types.module(:strict, :coercible)
+  #   end
+  #   # cherry-picking discards default types,
+  #   # provide the :default option along with the list of
+  #   # namespaces if you want the to be exported
+  #   Types.constants # => [:Coercible, :Strict]
+  #
+  # @example custom names
+  #   module Types
+  #     include Dry::Types.module(coercible: :Kernel)
+  #   end
+  #   Types::Kernel::Integer
+  #   # => #<Dry::Types[Constructor<Nominal<Integer> fn=Kernel.Integer>]>
+  #
+  # @param [Array<Symbol>] namespaces List of type namespaces to export
+  # @param [Symbol] default Default namespace to export
+  # @param [Hash{Symbol => Symbol}] aliases Optional renamings, like strict: :Draconian
+  # @return [Dry::Types::Module]
+  #
+  # @see Dry::types::Module
+  def self.Types(*namespaces, default: Types::Undefined, **aliases)
+    Types::Module.new(Types.container, *namespaces, default: default, **aliases)
+  end
 end
 
 require 'dry/types/core' # load built-in types
 require 'dry/types/extensions'
+require 'dry/types/printer'