evil-struct 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76c9257157a79cbad182f58d41631bfd789e976c
-  data.tar.gz: 2dd06f599e56d8fd601118b142328e698862389d
+  metadata.gz: 78cb8976656ba1e9c186cfc690abd2136120dee3
+  data.tar.gz: 33cbb7dcf766ddc4c5f12cf2914b2c8b06b5af68
 SHA512:
-  metadata.gz: d6b59bf33f32dc0714cff1568ae715c514798b06328dc04a34cce10b3c875379ec6b1085e4ae05cdf4bc2993fc85ffad652c07937a481f652d690947036e318b
-  data.tar.gz: 2d434f1a059afabf5b8ecf56ea8959c66614d83e52967b6c4b2de94f59391771fe9f6a910406550447c83d837698be236fadf638fbb239f38daca68c75af5e54
+  metadata.gz: dc7be8a84e68d11f3c4fe88ec211552517c608dadf01027a4390854d3889b58491796adb2d4a81e247bd1d49e2687281d2163309ee6b5c304f2248cf334beb3d
+  data.tar.gz: 472bbdc4b9e8dbffe740e1229ee255977994ec26b8b56fb3def52f056e36bd43d6c1560ec2341f845697317b681781fe0c922639af7ae669a90113d8356cbbad

data/.rubocop.yml

@@ -17,22 +17,11 @@ Style/FileName:
 Style/FrozenStringLiteralComment:
   Enabled: false
 
+Style/ModuleFunction:
+  Enabled: false
+
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
-
-# Settings for Struct#hashify
-
-Metrics/CyclomaticComplexity:
-  Max: 7
-
-Metrics/AbcSize:
-  Max: 17.12
-
-Metrics/MethodLength:
-  Max: 15
-
-Metrics/PerceivedComplexity:
-  Max: 8

data/README.md

@@ -74,6 +74,36 @@ product == { title: "apple", price: 10.9, description: "a fruit", quantity: 0 }
 # => true
 ```
 
+The structure is designed for immutability. That's why it doesn't contain writers (but you can define them by yourself via `attr_writer`).
+
+Instead of mutating current instance, you can merge another hash to the object via `merge` or `deep_merge`.
+
+```ruby
+new_product = product.merge(title: "orange")
+new_product.class # => Product
+new_product.to_h
+# => { title: "orange", price: 10.9, description: "a fruit", quantity: 0 }
+
+# you can merge any object that responds to `to_h` or `to_hash`
+other = Product[title: "orange", price: 12]
+new_product = product.merge(other)
+new_product.to_h
+# => { title: "orange", price: 12, description: "a fruit", quantity: 0 }
+
+# merge_deeply (deep_merge) gracefully merge nested hashes or hashified objects
+grape = Product.new title: "grape",
+                    price: 30,
+                    description: { country: "FR", year: 2016, sort: "Merlot" }
+
+new_grape = grape.merge_deeply description: { year: 2017 }
+new_grape.to_h
+# => {
+#      title: "grape",
+#      price: 30,
+#      description: { country: "FR", year: 2017, sort: "Merlot" }
+#     }
+```
+
 ## Compatibility
 
 Tested under rubies [compatible to MRI 2.2+](.travis.yml).

data/evil-struct.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name     = "evil-struct"
-  gem.version  = "0.0.2"
+  gem.version  = "0.0.3"
   gem.author   = "Andrew Kozin (nepalez)"
   gem.email    = "andrew.kozin@gmail.com"
   gem.homepage = "https://github.com/evilmartians/evil-struct"
@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency "dry-initializer", "~> 0.10"
 
-  gem.add_development_dependency "dry-types", "~> 0.9"
+  gem.add_development_dependency "dry-types", "> 0.9"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "rake", "~> 11"
-  gem.add_development_dependency "rubocop", "~> 0.44"
+  gem.add_development_dependency "rake", "> 11"
+  gem.add_development_dependency "rubocop", ">= 0.44"
 end

data/lib/evil/struct.rb

@@ -5,6 +5,7 @@ class Evil::Struct
   extend Dry::Initializer::Mixin
 
   require_relative "struct/attributes"
+  require_relative "struct/utils"
 
   class << self
     # Builds a struct from value that respond to `to_h` or `to_hash`
@@ -32,14 +33,20 @@ class Evil::Struct
     alias_method :[],   :new
     alias_method :load, :new
 
+    # @!method attributes(options)
     # Shares options between definitions made inside the block
     #
-    # @param  [Hash<Symbol, Object>] options Shared options
-    # @param  [Proc] block Block with definitions of attributes
+    # @example
+    #   attributes optional: true do
+    #     attribute :foo
+    #     attribute :bar
+    #   end
+    #
+    # @option options (see #attribute)
     # @return [self] itself
     #
     def attributes(**options, &block)
-      Attributes.call(self, **options, &block)
+      Attributes.call(self, options, &block)
       self
     end
 
@@ -51,16 +58,18 @@ class Evil::Struct
       @list_of_attributes ||= []
     end
 
+    # @!method attribute(name, type = nil, options)
     # Declares the attribute
     #
     # @param  [#to_sym] name       The name of the key
-    # @param  [#call]   type (nil) The constraint
+    # @param  [#call]   type (nil) The type constraint
+    # @option options [#call]   :type     Type constraint (alternative syntax)
     # @option options [#to_sym] :as       The name of the attribute
     # @option options [Proc]    :default  Block returning a default value
     # @option options [Boolean] :optional (nil) Whether key is optional
     # @return [self]
     #
-    # @alias :attribute
+    # @alias :option
     # @alias :param
     #
     def option(name, type = nil, as: nil, **opts)
@@ -107,37 +116,76 @@ class Evil::Struct
   def to_h
     self.class.list_of_attributes.each_with_object({}) do |key, hash|
       val = send(key)
-      hash[key] = hashify(val) unless val == Dry::Initializer::UNDEFINED
+      hash[key] = Utils.hashify(val) unless val == Dry::Initializer::UNDEFINED
     end
   end
   alias_method :to_hash, :to_h
   alias_method :dump,    :to_h
 
   # @!method [](key)
-  #   Gets the attribute value by name
+  # Gets the attribute value by name
+  #
+  # @example
+  #   class User < Evil::Struct
+  #     attribute :name
+  #   end
+  #
+  #   joe = User.new(name: "Joe")
+  #   joe.name    # => "Joe"
+  #   joe[:name]  # => "Joe"
+  #   joe["name"] # => "Joe"
   #
   # @param  [Symbol, String] key The name of the attribute
   # @return [Object] A value of the attribute
   #
   alias_method :[], :send
 
-  private
+  # Shallowly merges other object to the current struct
+  #
+  # @example
+  #   class User < Evil::Struct
+  #     attribute :name
+  #     attribute :age
+  #   end
+  #   joe_at_3 = User.new(name: "Joe", age: 3)
+  #
+  #   joe_at_4 = joe_at_3.merge(age: 4)
+  #   joe_at_4.name # => "Joe"
+  #   joe_at_4.age  # => 4
+  #
+  # @param  [Hash, #to_h, #to_hash] other
+  # @return [self.class] new instance of the current class
+  #
+  def merge(other)
+    self.class[Utils.merge(to_h, other)]
+  end
 
-  def hashify(value)
-    if value.is_a? Hash
-      value.each_with_object({}) { |(key, val), obj| obj[key] = hashify(val) }
-    elsif value.is_a? Array
-      value.map { |item| hashify(item) }
-    elsif value&.respond_to? :to_a
-      hashify(value.to_a)
-    elsif value&.respond_to? :to_h
-      hashify(value.to_h)
-    elsif value.respond_to? :to_hash
-      hashify(value.to_hash)
-    elsif value.is_a? Enumerable
-      value.map { |item| hashify(item) }
-    else
-      value
-    end
+  # Deeply merges other object to the current struct
+  #
+  # It iterates through hashes and objects responding to `to_h` and `to_hash`.
+  # The iteration stops when any non-hash value reached.
+  #
+  # @example
+  #   class User < Evil::Struct
+  #     attribute :info
+  #     attribute :meta
+  #   end
+  #   user = User.new info: { names: [{ first: "Joe", last: "Doe" }], age: 33 },
+  #                   meta: { type:  :admin }
+  #
+  #   user.merge info: { names: [{ first: "John" }] }, meta: { "role" => :cto }
+  #   user.to_h # => {
+  #             #      info: { names: [{ first: "John" }], age: 33 },
+  #             #      meta: { type: :admin, role: :cto }
+  #             #    }
+  #
+  # @param  [Hash, #to_h, #to_hash] other
+  # @return [self.class] new instance of the current class
+  #
+  # @alias :deep_merge
+  #
+  def merge_deeply(other)
+    self.class[Utils.merge_deeply(self, other)]
   end
+  alias_method :deep_merge, :merge_deeply
 end

data/lib/evil/struct/utils.rb

@@ -0,0 +1,85 @@
+# Collection of utility methods to hashify and merge structures
+module Evil::Struct::Utils
+  extend self
+
+  # Converts value to nested hash
+  #
+  # Makes conversion through nested hashes, arrays, enumerables,
+  # and other objects that respond to `to_a`, `to_h`, `to_hash`, or `each`.
+  # Doesn't convert `nil` (even though it responds to `to_h` and `to_a`).
+  #
+  # @param  [Object] value
+  # @return [Hash]
+  #
+  def hashify(value)
+    hash = to_h(value)
+    list = to_a(value)
+
+    if hash
+      hash.each_with_object({}) { |(key, val), obj| obj[key] = hashify(val) }
+    elsif list
+      list.map { |item| hashify(item) }
+    else
+      value
+    end
+  end
+
+  # Shallowly merges target object to the source hash
+  #
+  # The target object can be hash, or respond to either `to_h`, or `to_hash`.
+  # Before a merge, the keys of the target object are symbolized.
+  #
+  # @param  [Hash<Symbol, Object>]  source
+  # @param  [Hash, #to_h, #to_hash] target
+  # @return [Hash<Symbol, Object>]
+  #
+  def merge(source, target)
+    source.merge(to_h(target))
+  end
+
+  # Deeply merges target object to the source one
+  #
+  # The nesting stops when a first non-hashified value reached.
+  # It do not merge arrays of hashes!
+  #
+  # @param  [Object] source
+  # @param  [Object] target
+  # @return [Object]
+  #
+  def merge_deeply(source, target)
+    source_hash = to_h(source)
+    target_hash = to_h(target)
+    return target unless source_hash && target_hash
+
+    keys = (source_hash.keys | target_hash.keys)
+    keys.each_with_object(source_hash) do |key, obj|
+      next unless target_hash.key? key
+      obj[key] = merge_deeply source_hash[key], target_hash[key]
+    end
+  end
+
+  private
+
+  def to_h(value)
+    to_hash(value)&.each_with_object({}) do |(key, val), obj|
+      obj[key.to_sym] = val
+    end
+  end
+
+  def to_hash(value)
+    if    value.is_a? Hash           then value
+    elsif value.is_a? Array          then nil
+    elsif value.nil?                 then nil
+    elsif value.respond_to? :to_h    then value.to_h
+    elsif value.respond_to? :to_hash then value.to_hash
+    end
+  end
+
+  def to_a(value)
+    if    value.is_a? Array       then value
+    elsif value.is_a? Hash        then nil
+    elsif value.nil?              then nil
+    elsif value.respond_to? :to_a then value.to_a
+    end
+  end
+end

data/spec/features/deep_merge_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe "deep merge" do
+  before do
+    class Test::Foo < Evil::Struct
+      attribute :foo
+      attribute :bar
+    end
+  end
+
+  let(:struct) do
+    Test::Foo.new foo: { bar: [{ foo: :FOO }] },
+                  bar: { baz: :FOO, qux: :QUX }
+  end
+
+  let(:result) do
+    struct.merge_deeply foo: { bar: [{ qux: :QUX }] },
+                        bar: { "qux" => :FOO }
+  end
+
+  it "works" do
+    expect { result }.not_to change { struct }
+
+    expect(result).to be_instance_of Test::Foo
+    expect(result).to eq foo: { bar: [{ qux: :QUX }] },
+                         bar: { baz: :FOO, qux: :FOO }
+  end
+end

data/spec/features/merge_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe "merge" do
+  before do
+    class Test::Foo < Evil::Struct
+      attribute :foo
+      attribute :bar
+    end
+  end
+
+  let(:struct) { Test::Foo.new foo: :FOO, bar: :BAR }
+
+  it "merges hash with symbol keys" do
+    other = { bar: :BAZ, baz: :QUX }
+    expect { struct.merge(other) }.not_to change { struct }
+
+    result = struct.merge(other)
+    expect(result).to be_instance_of Test::Foo
+    expect(result).to eq foo: :FOO, bar: :BAZ
+  end
+
+  it "merges hash with string keys" do
+    other = { "bar" => :BAZ, "baz" => :QUX }
+    expect { struct.merge(other) }.not_to change { struct }
+
+    result = struct.merge(other)
+    expect(result).to be_instance_of Test::Foo
+    expect(result).to eq foo: :FOO, bar: :BAZ
+  end
+
+  it "merges objects supporting #to_h" do
+    other = double to_h: { bar: :BAZ, baz: :QUX }
+    expect { struct.merge(other) }.not_to change { struct }
+
+    result = struct.merge(other)
+    expect(result).to be_instance_of Test::Foo
+    expect(result).to eq foo: :FOO, bar: :BAZ
+  end
+
+  it "merges objects supporting #to_hash" do
+    other = double to_hash: { bar: :BAZ, baz: :QUX }
+    expect { struct.merge(other) }.not_to change { struct }
+
+    result = struct.merge(other)
+    expect(result).to be_instance_of Test::Foo
+    expect(result).to eq foo: :FOO, bar: :BAZ
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evil-struct
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Andrew Kozin (nepalez)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-20 00:00:00.000000000 Z
+date: 2016-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-initializer
@@ -28,14 +28,14 @@ dependencies:
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
@@ -56,28 +56,28 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '11'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.44'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.44'
 description: 
@@ -101,11 +101,14 @@ files:
 - lib/evil-struct.rb
 - lib/evil/struct.rb
 - lib/evil/struct/attributes.rb
+- lib/evil/struct/utils.rb
 - spec/features/attributes_spec.rb
 - spec/features/constructor_aliases_spec.rb
 - spec/features/constructor_arguments_spec.rb
+- spec/features/deep_merge_spec.rb
 - spec/features/equalizer_spec.rb
 - spec/features/hashifier_spec.rb
+- spec/features/merge_spec.rb
 - spec/features/shared_options_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/evilmartians/evil-struct
@@ -136,7 +139,9 @@ test_files:
 - spec/features/attributes_spec.rb
 - spec/features/constructor_aliases_spec.rb
 - spec/features/constructor_arguments_spec.rb
+- spec/features/deep_merge_spec.rb
 - spec/features/equalizer_spec.rb
 - spec/features/hashifier_spec.rb
+- spec/features/merge_spec.rb
 - spec/features/shared_options_spec.rb
 - spec/spec_helper.rb