collapsium 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 380030070f1838be3f5a7955fcd6e146398653f7
-  data.tar.gz: 18862980c22abb357b61c26d867a21d397c4faef
+  metadata.gz: 39373bf60c53fa0099f0f3066725d0de62448e37
+  data.tar.gz: 460a9f149f29cd83210c72e5abd2715046329499
 SHA512:
-  metadata.gz: c5be77bf133c4042d193a4f10c4dafbbc2805da3dc4497b29e11802d33a4b34726a2af79642d9f6423f9de14746a46d2a3acc7ff655d1e14d1ba11ca68ba3055
-  data.tar.gz: 55fa9036b582b1cb8f708c1d384e006b2bf822253ed213eff8204fbeae2e4a159b578ac6a1330ac380ab75b875f637e8cf4385ed8c57760ce0888e3e10d8d29c
+  metadata.gz: a1cf946152d25f4eadd5db380fc7907188b0152061b6d0be39e4676442ef272c8fb1efbfce2eba421be5e869466c09fced926dec919592d1cfc3d88228604acf
+  data.tar.gz: 39b05aa8b8d64e4608a56f241f7e97ade7a2379eb8867a315cd4480c2360d61cf4c51f90f2b5a67e421be6add9dacef01b96d3ef1c8d8d16c6d2485d4b1e570f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    collapsium (0.1.0)
+    collapsium (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/collapsium/prototype_match.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+  ##
+  # Provides prototype matching for Hashes. See #prototype_match
+  module PrototypeMatch
+    ##
+    # Given a prototype Hash, returns true if (recursively):
+    # - this hash contains all the prototype's keys, and
+    # - this hash contains all the prototype's values
+    # Note that this is not the same as equality. If the prototype provides a
+    # nil value for any key, then any value in this Hash is considered to be
+    # valid.
+    # @param prototype (Hash) The prototype to match against.
+    # @param strict (Boolean) If true, this Hash may not contain keys that are
+    #     not present in the prototype.
+    # @return (Boolean) True if matching succeeds, false otherwise.
+    def prototype_match(prototype, strict = false)
+      # Prototype contains keys not in the Hash,so that's a failure.
+      if not (prototype.keys - keys).empty?
+        return false
+      end
+
+      # In strict evaluation, the Hash may also not contain keys that are not
+      # in the prototoype.
+      if strict and not (keys - prototype.keys).empty?
+        return false
+      end
+
+      # Now we have to examine the prototype's values.
+      prototype.each do |key, value|
+        # We can skip any nil values in the prototype. They exist only to ensure
+        # the key is present.
+        if value.nil?
+          next
+        end
+
+        # If the prototype value is a Hash, then the Hash value also has to be,
+        # and we have to recurse into this Hash.
+        if value.is_a?(Hash)
+          if not self[key].is_a?(Hash)
+            return false
+          end
+
+          self[key].extend(PrototypeMatch)
+          if not self[key].prototype_match(value)
+            return false
+          end
+
+          next
+        end
+
+        # Otherwise the prototype value must be equal to the Hash's value
+        if self[key] != value
+          return false
+        end
+      end
+
+      # All other cases must be true.
+      return true
+    end
+  end # module PrototypeMatch
+end # module Collapsium

data/lib/collapsium/recursive_dup.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+  ##
+  # Provides recursive (deep) dup function for hashes.
+  module RecursiveDup
+    def recursive_dup
+      ret = map do |k, v|
+        # Hash values, recurse into them.
+        if v.is_a?(Hash)
+          n = v.dup # we duplicate v to not extend it.
+          n.extend(RecursiveDup)
+          next [k, n.recursive_dup]
+        end
+
+        begin
+          # Other duplicatable values
+          next [k, v.dup]
+        rescue TypeError
+          # Values such as e.g. Fixnum
+          next [k, v]
+        end
+      end
+      return Hash[ret]
+    end
+
+    alias deep_dup recursive_dup
+  end # module RecursiveDup
+end # module Collapsium

data/lib/collapsium/recursive_merge.rb

@@ -9,7 +9,7 @@
 
 module Collapsium
   ##
-  # Provides recursive merge functions for hashes. Used in PathedHash.
+  # Provides recursive merge functions for hashes.
   module RecursiveMerge
     ##
     # Recursively merge `:other` into this Hash.

data/lib/collapsium/recursive_sort.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+  ##
+  # Provides recursive sort functions for hashes.
+  module RecursiveSort
+    ##
+    # Recursively sort a Hash by its keys. Without a block, this function will
+    # not be able to compare keys of different size.
+    def recursive_sort!(&block)
+      return keys.sort(&block).reduce(self) do |seed, key|
+        # Delete (and later re-insert) value for ordering
+        value = self[key]
+        delete(key)
+
+        # Recurse into Hash values
+        if value.is_a?(Hash)
+          value.extend(RecursiveSort)
+          value.recursive_sort!(&block)
+        end
+
+        # re-insert value
+        self[key] = value
+
+        next seed
+      end
+    end
+
+    ##
+    # Same as #recursive_sort!, but returns a copy.
+    def recursive_sort(&block)
+      ret = nil
+      if respond_to?(:recursive_dup)
+        ret = recursive_dup
+      else
+        ret = dup
+      end
+      ret.extend(RecursiveSort)
+      return ret.recursive_sort!(&block)
+    end
+
+    #    def recursive_merge!(other, overwrite = true)
+    #      if other.nil?
+    #        return self
+    #      end
+    #
+    #      merger = proc do |_, v1, v2|
+    #        # rubocop:disable Style/GuardClause
+    #        if v1.is_a? Hash and v2.is_a? Hash
+    #          next v1.merge(v2, &merger)
+    #        elsif v1.is_a? Array and v2.is_a? Array
+    #          next v1 + v2
+    #        end
+    #        if overwrite
+    #          next v2
+    #        else
+    #          next v1
+    #        end
+    #        # rubocop:enable Style/GuardClause
+    #      end
+    #      merge!(other, &merger)
+    #    end
+    #
+    #    ##
+    #    # Same as `dup.recursive_merge!`
+    #    # @param (see #recursive_merge!)
+    #    def recursive_merge(other, overwrite = true)
+    #      copy = dup
+    #      copy.extend(RecursiveMerge)
+    #      return copy.recursive_merge!(other, overwrite)
+    #    end
+  end # module RecursiveSort
+end # module Collapsium

data/lib/collapsium/uber_hash.rb

@@ -8,15 +8,21 @@
 #
 
 require 'collapsium/recursive_merge'
+require 'collapsium/recursive_dup'
+require 'collapsium/recursive_sort'
 require 'collapsium/indifferent_access'
 require 'collapsium/pathed_access'
+require 'collapsium/prototype_match'
 
 module Collapsium
 
   # A Hash that includes all the different Hash extensions in collapsium
   class UberHash < Hash
     include RecursiveMerge
+    include RecursiveDup
+    include RecursiveSort
     include PathedAccess
+    include PrototypeMatch
 
     def initialize(*args)
       super

data/lib/collapsium/version.rb

@@ -8,5 +8,5 @@
 #
 module Collapsium
   # The current release version
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/spec/prototype_match_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/prototype_match'
+
+describe ::Collapsium::PrototypeMatch do
+  before :each do
+    @hash = {
+      'a' => 1,
+      :c => {
+        'd' => 4,
+        'f' => 6,
+        42 => 5,
+      },
+      'b' => 2,
+    }
+    @hash.extend(::Collapsium::PrototypeMatch)
+  end
+
+  it "matches a prototype containing any individual key (non-strict)" do
+    # Keys exist in hash
+    expect(@hash.prototype_match('a' => nil)).to be_truthy
+    expect(@hash.prototype_match('b' => nil)).to be_truthy
+    expect(@hash.prototype_match(c: nil)).to be_truthy
+
+    # Key doesn't exist in hash
+    expect(@hash.prototype_match(foo: nil)).to be_falsy
+  end
+
+  it "does't match a prototype containing an individual key in strict mode" do
+    expect(@hash.prototype_match({ 'a' => nil }, true)).to be_falsy
+  end
+
+  it "matches nested prototypes (non-strict)" do
+    proto = {
+      c: {
+        'd' => nil,
+      }
+    }
+    expect(@hash.prototype_match(proto)).to be_truthy
+  end
+
+  it "doesn't match nested prototypes (strict)" do
+    proto = {
+      c: {
+        'd' => nil,
+      }
+    }
+    expect(@hash.prototype_match(proto, true)).to be_falsy
+  end
+
+  it "fails if a value type mismatches a prototype value's type" do
+    proto = {
+      c: {
+        'd' => {},
+      }
+    }
+    expect(@hash.prototype_match(proto)).to be_falsy
+  end
+
+  it "fails if a value mismatches a prototype value" do
+    proto = {
+      c: {
+        'd' => 42,
+      }
+    }
+    expect(@hash.prototype_match(proto)).to be_falsy
+  end
+end

data/spec/recursive_dup_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/recursive_dup'
+
+describe ::Collapsium::RecursiveDup do
+  it "duplicates nested values" do
+    h = {
+      'a' => 1,
+      :c => {
+        'd' => 4,
+        'f' => 6,
+        42 => 5,
+      },
+      'b' => 2,
+    }
+    h.extend(::Collapsium::RecursiveDup)
+
+    h2 = h.deep_dup
+
+    expect(h2.object_id).not_to eql h.object_id
+    expect(h2[:c].object_id).not_to eql h[:c].object_id
+  end
+end

data/spec/recursive_sort_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/recursive_sort'
+
+describe ::Collapsium::RecursiveSort do
+  before :each do
+    @tester = {}
+    @tester.extend(::Collapsium::RecursiveSort)
+  end
+
+  it "sorts a nested hash with string keys in place" do
+    h = {
+      'a' => 1,
+      'c' => {
+        'd' => 4,
+        'f' => 6,
+        'e' => 5,
+      },
+      'b' => 2,
+    }
+    h.extend(::Collapsium::RecursiveSort)
+
+    h.recursive_sort!
+
+    expect(h.keys).to eql %w(a b c)
+    expect(h['c'].keys).to eql %w(d e f)
+  end
+
+  it "duplicates and sorts an outer hash (not deep)" do
+    h = {
+      'a' => 1,
+      'c' => {
+        'd' => 4,
+        'f' => 6,
+        'e' => 5,
+      },
+      'b' => 2,
+    }
+    h.extend(::Collapsium::RecursiveSort)
+
+    h2 = h.recursive_sort
+
+    # Only the new outer hash's keys are sorted
+    expect(h.keys).to eql %w(a c b)
+    expect(h2.keys).to eql %w(a b c)
+
+    # Both inner hashes are sorted because dup isn't deep
+    expect(h['c'].keys).to eql %w(d e f)
+    expect(h2['c'].keys).to eql %w(d e f)
+
+    # Similar with object IDs
+    expect(h.object_id).not_to eql h2.object_id
+    expect(h['c'].object_id).to eql h2['c'].object_id
+  end
+
+  it "it uses RecursiveDup if present" do
+    require_relative '../lib/collapsium/recursive_dup'
+    h = {
+      'a' => 1,
+      'c' => {
+        'd' => 4,
+        'f' => 6,
+        'e' => 5,
+      },
+      'b' => 2,
+    }
+    h.extend(::Collapsium::RecursiveSort)
+    h.extend(::Collapsium::RecursiveDup)
+
+    h2 = h.recursive_sort
+
+    # Only the new outer hash's keys are sorted
+    expect(h.keys).to eql %w(a c b)
+    expect(h2.keys).to eql %w(a b c)
+
+    # Only the new inner hash's keys are sorted
+    expect(h['c'].keys).to eql %w(d f e)
+    expect(h2['c'].keys).to eql %w(d e f)
+
+    # Similar with object IDs
+    expect(h.object_id).not_to eql h2.object_id
+    expect(h['c'].object_id).not_to eql h2['c'].object_id
+  end
+end

data/spec/spec_helper.rb

@@ -6,4 +6,6 @@ end
 
 # Always start SimpleCov
 require 'simplecov'
-SimpleCov.start
+SimpleCov.start do
+  add_filter 'spec'
+end

data/spec/uber_hash_spec.rb

@@ -41,4 +41,21 @@ describe Collapsium::UberHash do
     x = ::Collapsium::UberHash.new
     expect(x.empty?).to be_truthy
   end
+
+  it "has recursive_dup support" do
+    x = ::Collapsium::UberHash.new
+    expect(x.respond_to?(:recursive_dup)).to be_truthy
+    expect(x.respond_to?(:deep_dup)).to be_truthy
+  end
+
+  it "has recursive_sort support" do
+    x = ::Collapsium::UberHash.new
+    expect(x.respond_to?(:recursive_sort)).to be_truthy
+    expect(x.respond_to?(:recursive_sort!)).to be_truthy
+  end
+
+  it "has prototype_match support" do
+    x = ::Collapsium::UberHash.new
+    expect(x.respond_to?(:prototype_match)).to be_truthy
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collapsium
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jens Finkhaeuser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,12 +116,18 @@ files:
 - lib/collapsium.rb
 - lib/collapsium/indifferent_access.rb
 - lib/collapsium/pathed_access.rb
+- lib/collapsium/prototype_match.rb
+- lib/collapsium/recursive_dup.rb
 - lib/collapsium/recursive_merge.rb
+- lib/collapsium/recursive_sort.rb
 - lib/collapsium/uber_hash.rb
 - lib/collapsium/version.rb
 - spec/indifferent_access_spec.rb
 - spec/pathed_access_spec.rb
+- spec/prototype_match_spec.rb
+- spec/recursive_dup_spec.rb
 - spec/recursive_merge_spec.rb
+- spec/recursive_sort_spec.rb
 - spec/spec_helper.rb
 - spec/uber_hash_spec.rb
 homepage: https://github.com/jfinkhaeuser/collapsium
@@ -151,7 +157,10 @@ summary: Provides various Hash extensions, and an UberHash class that uses them
 test_files:
 - spec/indifferent_access_spec.rb
 - spec/pathed_access_spec.rb
+- spec/prototype_match_spec.rb
+- spec/recursive_dup_spec.rb
 - spec/recursive_merge_spec.rb
+- spec/recursive_sort_spec.rb
 - spec/spec_helper.rb
 - spec/uber_hash_spec.rb
 has_rdoc: