dry-struct 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b2abda38b30796edc16f515274eb6c0be35a528
-  data.tar.gz: 0114e855f8892fcfb1598410da854f52e61188ae
+  metadata.gz: 0cc9fef4b32f2b57bac889a7f5ca759795b650dd
+  data.tar.gz: be8ff9b280bcc8d0afdccf28d39453b7060e13d3
 SHA512:
-  metadata.gz: eb01e9ed8ec7a914957c385733e0ea1894621309721527e5de11c1855d36fc2f0b615d5387474947cb65da30b52b70b5cc33701170ffaa987a2a53481352731c
-  data.tar.gz: e1403ea9f6f014e7d0fb31f64019dc179f87175c9fbe0afcb42551ec6b7cb5b09a9b73df5b7d4d33702a5d8684a7213648f35903f906b0a5628d84b2553ed37f
+  metadata.gz: f8c76b9683ad51451060a3c388741598aedcac78946b0f979c8928fef1a3e6f4300c211438f3d3ca6490c23525730d051ffb7c2a808fd5e1b322474e91b20e9a
+  data.tar.gz: 0d8dc1bc47204f422ee104d60ee732e7bb276e3441ec255303f3a794f2718be0eb63bea2beda822c08a40a1a04a864d097171c4becaede57d7ffa701794a17fd

data/.travis.yml

@@ -5,16 +5,21 @@ bundler_args: --without benchmarks tools
 script:
   - bundle exec rake spec
 after_success:
-  - '[ "$TRAVIS_RUBY_VERSION" = "2.3.1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
   - 2.1.10
-  - 2.2.5
-  - 2.3.1
+  - 2.2.7
+  - 2.3.3
+  - 2.4.1
   - rbx-3
-  - jruby-9.1.5.0
+  - jruby-9.1.8.0
 env:
   global:
+    - COVERAGE=true
     - JRUBY_OPTS='--dev -J-Xmx1024M'
+matrix:
+  allow_failures:
+    - rvm: rbx-3
 notifications:
   email: false
   webhooks:

data/.yardopts

@@ -0,0 +1,4 @@
+--title 'dry-struct'
+--markup markdown
+--readme README.md
+lib/**/*.rb

data/CHANGELOG.md

@@ -1,9 +1,28 @@
+master
+
+## Added
+
+* `Dry::Struct#new` method to return new instance with applied changeset (Kukunin)
+
+## Fixed
+
+* `.[]` and `.call` does not coerce subclass to superclass anymore (Kukunin)
+* Raise ArgumentError when attribute type is a string and no value provided is for `new` (GustavoCaso)
+
+## Changed
+
+* `.new` without arguments doesn't use nil as an input for non-default types anymore (flash-gordon)
+
+[Compare v0.2.1...master](https://github.com/dry-rb/dry-struct/compare/v0.2.1...master)
+
 # v0.2.1 2017-02-27
 
 ## Fixed
 
 * Fixed `Dry::Struct::Value` which appeared to be broken in the last release (flash-gordon)
 
+[Compare v0.2.0...v0.2.1](https://github.com/dry-rb/dry-struct/compare/v0.2.0...v0.2.1)
+
 # v0.2.0 2016-02-26
 
 ## Changed

data/Rakefile

@@ -4,3 +4,7 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+require 'yard'
+require 'yard/rake/yardoc_task'
+YARD::Rake::YardocTask.new(:doc)

data/dry-struct.gemspec

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'dry/struct/version'
@@ -31,9 +29,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
   spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.3'
   spec.add_runtime_dependency 'ice_nine', '~> 0.11'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 11.0'
   spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'yard', '~> 0.9.5'
 end

data/lib/dry/struct.rb

@@ -6,25 +6,230 @@ require 'dry/struct/class_interface'
 require 'dry/struct/hashify'
 
 module Dry
+  # Typed {Struct} with virtus-like DSL for defining schema.
+  #
+  # ### Differences between dry-struct and virtus
+  #
+  # {Struct} look somewhat similar to [Virtus][] but there are few significant differences:
+  #
+  # * {Struct}s don't provide attribute writers and are meant to be used
+  #   as "data objects" exclusively.
+  # * Handling of attribute values is provided by standalone type objects from
+  #   [`dry-types`][].
+  # * Handling of attribute hashes is provided by standalone hash schemas from
+  #   [`dry-types`][], which means there are different types of constructors in
+  #   {Struct} (see {Dry::Struct::ClassInterface#constructor_type})
+  # * Struct classes quack like [`dry-types`][], which means you can use them
+  #   in hash schemas, as array members or sum them
+  #
+  # {Struct} class can specify a constructor type, which uses [hash schemas][]
+  # to handle attributes in `.new` method.
+  # See {ClassInterface#new} for constructor types descriptions and examples.
+  #
+  # [`dry-types`]: https://github.com/dry-rb/dry-types
+  # [Virtus]: https://github.com/solnic/virtus
+  # [hash schemas]: http://dry-rb.org/gems/dry-types/hash-schemas
+  #
+  # @example
+  #   require 'dry-struct'
+  #
+  #   module Types
+  #     include Dry::Types.module
+  #   end
+  #
+  #   class Book < Dry::Struct
+  #     attribute :title, Types::Strict::String
+  #     attribute :subtitle, Types::Strict::String.optional
+  #   end
+  #
+  #   rom_n_roda = Book.new(
+  #     title: 'Web Development with ROM and Roda',
+  #     subtitle: nil
+  #   )
+  #   rom_n_roda.title #=> 'Web Development with ROM and Roda'
+  #   rom_n_roda.subtitle #=> nil
+  #
+  #   refactoring = Book.new(
+  #     title: 'Refactoring',
+  #     subtitle: 'Improving the Design of Existing Code'
+  #   )
+  #   refactoring.title #=> 'Refactoring'
+  #   refactoring.subtitle #=> 'Improving the Design of Existing Code'
   class Struct
     extend ClassInterface
 
-    constructor_type(:permissive)
+    # {Dry::Types::Hash} subclass with specific behaviour defined for
+    # @return [Dry::Types::Hash]
+    # @see #constructor_type
+    defines :input
+    input Types['coercible.hash']
 
+    # Sets or retrieves {#constructor} type as a symbol
+    #
+    # @note All examples below assume that you have defined {Struct} with
+    #   following attributes and explicitly call only {#constructor_type}:
+    #
+    #   ```ruby
+    #   class User < Dry::Struct
+    #     attribute :name, Types::Strict::String.default('John Doe')
+    #     attribute :age, Types::Strict::Int
+    #   end
+    #   ```
+    #
+    # ### Common constructor types include:
+    #
+    # * `:permissive` - the default constructor type, useful for defining
+    #   {Struct}s that are instantiated using data from the database
+    #   (i.e. results of a database query), where you expect *all defined
+    #   attributes to be present* and it's OK to ignore other keys
+    #   (i.e. keys used for joining, that are not relevant from your domain
+    #   {Struct}s point of view). Default values **are not used** otherwise
+    #   you wouldn't notice missing data.
+    # * `:schema` - missing keys will result in setting them using default
+    #   values, unexpected keys will be ignored.
+    # * `:strict` - useful when you *do not expect keys other than the ones
+    #   you specified as attributes* in the input hash
+    # * `:strict_with_defaults` - same as `:strict` but you are OK that some
+    #   values may be nil and you want defaults to be set
+    #
+    # To feel the difference between constructor types, look into examples.
+    # Each of them provide the same attributes' definitions,
+    # different constructor type, and 4 cases of given input:
+    #
+    # 1. Input omits a key for a value that does not have a default
+    # 2. Input omits a key for a value that has a default
+    # 3. Input contains nil for a value that specifies a default
+    # 4. Input includes a key that was not specified in the schema
+    #
+    # @note Don’t use `:weak` and `:symbolized` as {#constructor_type},
+    #   and instead use [`dry-validation`][] to process and validate
+    #   attributes, otherwise your struct will behave as a data validator
+    #   which raises exceptions on invalid input (assuming your attributes
+    #   types are strict)
+    #   [`dry-validation`]: https://github.com/dry-rb/dry-validation
+    #
+    # @example `:permissive` constructor
+    #   class User < Dry::Struct
+    #     constructor_type :permissive
+    #   end
+    #
+    #   User.new(name: "Jane")
+    #     #=> Dry::Struct::Error: [User.new] :age is missing in Hash input
+    #   User.new(age: 31)
+    #     #=> Dry::Struct::Error: [User.new] :name is missing in Hash input
+    #   User.new(name: nil, age: 31)
+    #     #=> #<User name="John Doe" age=31>
+    #   User.new(name: "Jane", age: 31, unexpected: "attribute")
+    #     #=> #<User name="Jane" age=31>
+    #
+    # @example `:schema` constructor
+    #   class User < Dry::Struct
+    #     constructor_type :schema
+    #   end
+    #
+    #   User.new(name: "Jane")        #=> #<User name="Jane" age=nil>
+    #   User.new(age: 31)             #=> #<User name="John Doe" age=31>
+    #   User.new(name: nil, age: 31)  #=> #<User name="John Doe" age=31>
+    #   User.new(name: "Jane", age: 31, unexpected: "attribute")
+    #     #=> #<User name="Jane" age=31>
+    #
+    # @example `:strict` constructor
+    #   class User < Dry::Struct
+    #     constructor_type :strict
+    #   end
+    #
+    #   User.new(name: "Jane")
+    #     #=> Dry::Struct::Error: [User.new] :age is missing in Hash input
+    #   User.new(age: 31)
+    #     #=> Dry::Struct::Error: [User.new] :name is missing in Hash input
+    #   User.new(name: nil, age: 31)
+    #     #=> Dry::Struct::Error: [User.new] nil (NilClass) has invalid type for :name
+    #   User.new(name: "Jane", age: 31, unexpected: "attribute")
+    #     #=> Dry::Struct::Error: [User.new] unexpected keys [:unexpected] in Hash input
+    #
+    # @example `:strict_with_defaults` constructor
+    #   class User < Dry::Struct
+    #     constructor_type :strict_with_defaults
+    #   end
+    #
+    #   User.new(name: "Jane")
+    #     #=> Dry::Struct::Error: [User.new] :age is missing in Hash input
+    #   User.new(age: 31)
+    #     #=> #<User name="John Doe" age=31>
+    #   User.new(name: nil, age: 31)
+    #     #=> Dry::Struct::Error: [User.new] nil (NilClass) has invalid type for :name
+    #   User.new(name: "Jane", age: 31, unexpected: "attribute")
+    #     #=> Dry::Struct::Error: [User.new] unexpected keys [:unexpected] in Hash input
+    #
+    # @see http://dry-rb.org/gems/dry-types/hash-schemas
+    #
+    # @overload constructor_type(type)
+    #   Sets the constructor type for {Struct}
+    #   @param [Symbol] type one of constructor types, see above
+    #   @return [Symbol]
+    #
+    # @overload constructor_type
+    #   Returns the constructor type for {Struct}
+    #   @return [Symbol] (:strict)
+    defines :constructor_type
+    constructor_type :permissive
+
+    # @return [Dry::Equalizer]
+    defines :equalizer
+
+    # @param [Hash, #each] attributes
     def initialize(attributes)
       attributes.each { |key, value| instance_variable_set("@#{key}", value) }
     end
 
+    # Retrieves value of previously defined attribute by its' `name`
+    #
+    # @param [String] name
+    # @return [Object]
+    #
+    # @example
+    #   class Book < Dry::Struct
+    #     attribute :title, Types::Strict::String
+    #     attribute :subtitle, Types::Strict::String.optional
+    #   end
+    #
+    #   rom_n_roda = Book.new(
+    #     title: 'Web Development with ROM and Roda',
+    #     subtitle: nil
+    #   )
+    #   rom_n_roda[:title] #=> 'Web Development with ROM and Roda'
+    #   rom_n_roda[:subtitle] #=> nil
     def [](name)
       public_send(name)
     end
 
+    # Converts the {Dry::Struct} to a hash with keys representing
+    # each attribute (as symbols) and their corresponding values
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @example
+    #   class Book < Dry::Struct
+    #     attribute :title, Types::Strict::String
+    #     attribute :subtitle, Types::Strict::String.optional
+    #   end
+    #
+    #   rom_n_roda = Book.new(
+    #     title: 'Web Development with ROM and Roda',
+    #     subtitle: nil
+    #   )
+    #   rom_n_roda.to_hash
+    #     #=> {title: 'Web Development with ROM and Roda', subtitle: nil}
     def to_hash
       self.class.schema.keys.each_with_object({}) do |key, result|
         result[key] = Hashify[self[key]]
       end
     end
     alias_method :to_h, :to_hash
+
+    def new(changeset)
+      self.class[to_hash.merge(changeset)]
+    end
   end
 end
 

data/lib/dry/struct/class_interface.rb

@@ -1,48 +1,78 @@
+require 'dry/core/class_attributes'
+require 'dry/equalizer'
+
 require 'dry/struct/errors'
 
 module Dry
   class Struct
+    # Class-level interface of {Struct} and {Value}
     module ClassInterface
-      include Dry::Types::Builder
-
-      attr_accessor :constructor
+      include Core::ClassAttributes
 
-      attr_accessor :equalizer
-
-      attr_writer :constructor_type
-
-      protected :constructor=, :equalizer=, :constructor_type=
+      include Dry::Types::Builder
 
+      # @param [Module] base
       def self.extended(base)
-        base.instance_variable_set(:@schema, {})
+        base.instance_variable_set(:@schema, EMPTY_HASH)
       end
 
+      # @param [Class] klass
       def inherited(klass)
         super
 
-        klass.instance_variable_set(:@schema, {})
-        klass.equalizer = Equalizer.new(*schema.keys)
-        klass.constructor_type = constructor_type
+        klass.instance_variable_set(:@schema, EMPTY_HASH)
+        klass.equalizer Equalizer.new(*schema.keys)
         klass.send(:include, klass.equalizer)
 
-        unless klass == Value
-          klass.constructor = Types['coercible.hash']
-        end
-
-        klass.attributes({}) unless equal?(Struct)
-      end
-
+        klass.attributes(EMPTY_HASH) unless equal?(Struct)
+      end
+
+      # Adds an attribute for this {Struct} with given `name` and `type`
+      # and modifies {.schema} accordingly.
+      #
+      # @param [Symbol] name name of the defined attribute
+      # @param [Dry::Types::Definition] type
+      # @return [Dry::Struct]
+      # @raise [RepeatedAttributeError] when trying to define attribute with the
+      #   same name as previously defined one
+      #
+      # @example
+      #   class Language < Dry::Struct
+      #     attribute :name, Types::String
+      #   end
+      #
+      #   Language.schema
+      #     #=> {name: #<Dry::Types::Definition primitive=String options={}>}
+      #
+      #   ruby = Language.new(name: 'Ruby')
+      #   ruby.name #=> 'Ruby'
       def attribute(name, type)
         attributes(name => type)
       end
 
+      # @param [Hash{Symbol => Dry::Types::Definition}] new_schema
+      # @return [Dry::Struct]
+      # @raise [RepeatedAttributeError] when trying to define attribute with the
+      #   same name as previously defined one
+      # @see #attribute
+      # @example
+      #   class Book1 < Dry::Struct
+      #     attributes(
+      #       title: Types::String,
+      #       author: Types::String
+      #     )
+      #   end
+      #
+      #   Book.schema
+      #     #=> {title: #<Dry::Types::Definition primitive=String options={}>,
+      #     #    author: #<Dry::Types::Definition primitive=String options={}>}
       def attributes(new_schema)
         check_schema_duplication(new_schema)
 
         prev_schema = schema
 
         @schema = prev_schema.merge(new_schema)
-        @constructor = Types['coercible.hash'].public_send(constructor_type, schema)
+        input Types['coercible.hash'].public_send(constructor_type, schema)
 
         attr_reader(*new_schema.keys)
         equalizer.instance_variable_get('@keys').concat(new_schema.keys)
@@ -50,6 +80,9 @@ module Dry
         self
       end
 
+      # @param [Hash{Symbol => Dry::Types::Definition, Dry::Struct}] new_schema
+      # @raise [RepeatedAttributeError] when trying to define attribute with the
+      #   same name as previously defined one
       def check_schema_duplication(new_schema)
         shared_keys = new_schema.keys & (schema.keys - superclass.schema.keys)
 
@@ -57,37 +90,60 @@ module Dry
       end
       private :check_schema_duplication
 
-      def constructor_type(type = nil)
-        if type
-          @constructor_type = type
-        else
-          @constructor_type || :strict
-        end
-      end
-
+      # @return [Hash{Symbol => Dry::Types::Definition, Dry::Struct}]
       def schema
-        super_schema = superclass.respond_to?(:schema) ? superclass.schema : {}
+        super_schema = superclass.respond_to?(:schema) ? superclass.schema : EMPTY_HASH
         super_schema.merge(@schema)
       end
 
+      # @param [Hash{Symbol => Object},Dry::Struct] attributes
+      # @raise [Struct::Error] if the given attributes don't conform {#schema}
+      #   with given {#constructor_type}
       def new(attributes = default_attributes)
         if attributes.instance_of?(self)
           attributes
         else
-          super(constructor[attributes])
+          super(input[attributes])
         end
       rescue Types::SchemaError, Types::MissingKeyError, Types::UnknownKeysError => error
         raise Struct::Error, "[#{self}.new] #{error}"
       end
-      alias_method :call, :new
-      alias_method :[], :new
 
+      # Calls type constructor. The behavior is identical to `.new` but returns
+      # returns the input back if it's a subclass of the struct.
+      #
+      # @param [Hash{Symbol => Object},Dry::Struct] attributes
+      # @return [Dry::Struct]
+      def call(attributes = default_attributes)
+        return attributes if attributes.is_a?(self)
+        new(attributes)
+      end
+      alias_method :[], :call
+
+      # Retrieves default attributes from defined {.schema}.
+      # Used in a {Struct} constructor if no attributes provided to {.new}
+      #
+      # @return [Hash{Symbol => Object}]
       def default_attributes
+        check_invalid_schema_keys
         schema.each_with_object({}) { |(name, type), result|
-          result[name] = type.default? ? type.evaluate : type[nil]
+          result[name] = type.evaluate if type.default?
         }
       end
 
+      def check_invalid_schema_keys
+        invalid_keys = schema.select { |name, type|  type.instance_of?(String) }
+        raise ArgumentError, argument_error_msg(invalid_keys.keys) if invalid_keys.any?
+      end
+
+      def argument_error_msg(keys)
+        "Invaild argument for #{keys.join(', ')}"
+      end
+
+      # @param [Hash{Symbol => Object}] input
+      # @yieldparam [Dry::Types::Result::Failure] failure
+      # @yieldreturn [Dry::Types::ResultResult]
+      # @return [Dry::Types::Result]
       def try(input)
         Types::Result::Success.new(self[input])
       rescue Struct::Error => e
@@ -95,33 +151,49 @@ module Dry
         block_given? ? yield(failure) : failure
       end
 
+      # @param [({Symbol => Object})] args
+      # @return [Dry::Types::Result::Success]
       def success(*args)
         result(Types::Result::Success, *args)
       end
 
+      # @param [({Symbol => Object})] args
+      # @return [Dry::Types::Result::Failure]
       def failure(*args)
         result(Types::Result::Failure, *args)
       end
 
+      # @param [Class] klass
+      # @param [({Symbol => Object})] args
       def result(klass, *args)
         klass.new(*args)
       end
 
+      # @return [false]
       def default?
         false
       end
 
+      # @param [Object, Dry::Struct] value
+      # @return [Boolean]
       def valid?(value)
         self === value
       end
 
+      # @return [true]
       def constrained?
         true
       end
 
+      # @return [self]
       def primitive
         self
       end
+
+      # @return [false]
+      def optional?
+        false
+      end
     end
   end
 end

data/lib/dry/struct/errors.rb

@@ -4,9 +4,13 @@ module Dry
 
     setting :namespace, self
 
+    # Raised when given input doesn't conform schema and constructor type
     Error = Class.new(TypeError)
 
+    # Raised when defining duplicate attributes
     class RepeatedAttributeError < ArgumentError
+      # @param [Symbol] key
+      #   attribute name that is the same as previously defined one
       def initialize(key)
         super("Attribute :#{key} has already been defined")
       end

data/lib/dry/struct/hashify.rb

@@ -1,8 +1,10 @@
-# Converts value to hash recursively
-
 module Dry
   class Struct
+    # Helper for {Struct#to_hash} implementation
     module Hashify
+      # Converts value to hash recursively
+      # @param [#to_hash, #map, Object] value
+      # @return [Hash, Array]
       def self.[](value)
         if value.respond_to?(:to_hash)
           value.to_hash

data/lib/dry/struct/value.rb

@@ -2,7 +2,27 @@ require 'ice_nine'
 
 module Dry
   class Struct
+    # {Value} objects behave like {Struct}s but *deeply frozen*
+    # using [`ice_nine`](https://github.com/dkubb/ice_nine)
+    #
+    # @example
+    #   class Location < Dry::Struct::Value
+    #     attribute :lat, Types::Strict::Float
+    #     attribute :lng, Types::Strict::Float
+    #   end
+    #
+    #   loc1 = Location.new(lat: 1.23, lng: 4.56)
+    #   loc2 = Location.new(lat: 1.23, lng: 4.56)
+    #
+    #   loc1.frozen? #=> true
+    #   loc2.frozen? #=> true
+    #   loc1 == loc2 #=> true
+    #
+    # @see https://github.com/dkubb/ice_nine
     class Value < self
+      # @param (see ClassInterface#new)
+      # @return [Value]
+      # @see https://github.com/dkubb/ice_nine
       def self.new(*)
         IceNine.deep_freeze(super)
       end

data/lib/dry/struct/version.rb

@@ -1,5 +1,5 @@
 module Dry
   class Struct
-    VERSION = '0.2.1'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-struct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-27 00:00:00.000000000 Z
+date: 2017-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -58,6 +58,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: ice_nine
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +128,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
 description: Typed structs and value objects.
 email:
 - piotr.solnica@gmail.com
@@ -124,6 +152,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -162,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Typed structs and value objects.