immutable-ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de7204bc2220b5743b2d8b3344d562377bd692a9
-  data.tar.gz: 965f9782b7d7a5b803f2ee76c3ef10d5f1203a2b
+  metadata.gz: a963e4f0565bc516534d1cf81f0206357b252f3a
+  data.tar.gz: 38a237bd2bdcef74cb66971375e1414ea36c67bd
 SHA512:
-  metadata.gz: 3e7a5faa17dfdbbcbf86ba190a30537cf9b52c7b571cee68158fed8bfa69be547aeb8af91d9f91efd875a7b21462a1f84efce0edab1283fd132b9e8e819122c2
-  data.tar.gz: b06f1d17c9f1159433c2db10a2a30788a02cf379f093da86b24e77ccefe04323582beef964dcf7d220e5c3e54ac7e98e40f794e87a408da07f9c2b38da59951b
+  metadata.gz: '040888fc5816c86d1df3333bd1e7e922096c7775e196f5bf3c9e9dedc599dc55b888cf31c1b602bcc4bfda8c06e28b436a793d4e221fca54855e69b0b2d2e523'
+  data.tar.gz: fb6bffbec4a70ccc00058140a563007cbf7617c55af03328c2a8385772caaf4d6e0d22e9e10664541ec04ad3f1dfe43f5b3b327268539841d6edb9c7683af1dc

data/lib/immutable/core_ext/struct.rb

@@ -0,0 +1,9 @@
+class Struct
+  # Implement Struct#to_h for Ruby interpreters which don't have it
+  # (such as MRI 1.9.3 and lower)
+  unless method_defined?(:to_h)
+    def to_h
+      Hash[each_pair.to_a]
+    end
+  end
+end

data/lib/immutable/enumerable.rb

@@ -30,6 +30,15 @@ module Immutable
       result
     end
 
+    # Search the collection for elements which are not `#===` to `item`. Yield
+    # them to the optional code block if provided, and return them as a new
+    # collection.
+    def grep_v(pattern, &block)
+      result = select { |item| !(pattern === item) }
+      result = result.map(&block) if block_given?
+      result
+    end
+
     # Yield all integers from 0 up to, but not including, the number of items in
     # this collection. For collections which provide indexed access, these are all
     # the valid, non-negative indices into the collection.

data/lib/immutable/hash.rb

@@ -264,6 +264,12 @@ module Immutable
       end
     end
 
+    # @private
+    # @raise NoMethodError
+    def []=(*)
+      raise NoMethodError, "Immutable::Hash doesn't support `[]='; use `put' instead"
+    end
+
     # Return a new `Hash` with a deeply nested value modified to the result of
     # the given code block.  When traversing the nested `Hash`es and `Vector`s,
     # non-existing keys are created with empty `Hash` values.
@@ -570,20 +576,54 @@ module Immutable
     end
 
     # Return a {Vector} of the values which correspond to the `wanted` keys.
-    # If any of the `wanted` keys are not present in this `Hash`, they will be skipped.
+    # If any of the `wanted` keys are not present in this `Hash`, `nil` will be
+    # placed instead, or the result of the default proc (if one is defined),
+    # similar to the behavior of {#get}.
     #
     # @example
     #   h = Immutable::Hash["A" => 1, "B" => 2, "C" => 3]
-    #   h.values_at("B", "A", "D")  # => Immutable::Vector[2, 1]
+    #   h.values_at("B", "A", "D")  # => Immutable::Vector[2, 1, nil]
     #
     # @param wanted [Array] The keys to retrieve
     # @return [Vector]
     def values_at(*wanted)
-      array = []
-      wanted.each { |key| array << get(key) if key?(key) }
+      Vector.new(wanted.map { |key| get(key) }.freeze)
+    end
+
+    # Return a {Vector} of the values which correspond to the `wanted` keys.
+    # If any of the `wanted` keys are not present in this `Hash`, raise `KeyError`
+    # exception.
+    #
+    # @example
+    #   h = Immutable::Hash["A" => 1, "B" => 2, "C" => 3]
+    #   h.fetch_values("C", "A")  # => Immutable::Vector[3, 1]
+    #   h.fetch_values("C", "Z")  # => KeyError: key not found: "Z"
+    #
+    # @param wanted [Array] The keys to retrieve
+    # @return [Vector]
+    def fetch_values(*wanted)
+      array = wanted.map { |key| fetch(key) }
       Vector.new(array.freeze)
     end
 
+    # Return the value of successively indexing into a nested collection.
+    # If any of the keys is not present, return `nil`.
+    #
+    # @example
+    #   h = Immutable::Hash[a: 9, b: Immutable::Hash[c: 'a', d: 4], e: nil]
+    #   h.dig(:b, :c) # => "a"
+    #   h.dig(:b, :f) # => nil
+    #
+    # @return [Object]
+    def dig(key, *rest)
+      value = self[key]
+      if rest.empty? || value.nil?
+        value
+      else
+        value.dig(*rest)
+      end
+    end
+
     # Return a new {Set} containing the keys from this `Hash`.
     #
     # @example
@@ -734,6 +774,50 @@ module Immutable
       self.eql?(other) || (other.respond_to?(:to_hash) && to_hash.eql?(other.to_hash))
     end
 
+    # Return true if this `Hash` is a proper superset of `other`, which means
+    # all `other`'s keys are contained in this `Hash` with identical
+    # values, and the two hashes are not identical.
+    #
+    # @param other [Immutable::Hash] The object to compare with
+    # @return [Boolean]
+    def >(other)
+      self != other && self >= other
+    end
+
+    # Return true if this `Hash` is a superset of `other`, which means all
+    # `other`'s keys are contained in this `Hash` with identical values.
+    #
+    # @param other [Immutable::Hash] The object to compare with
+    # @return [Boolean]
+    def >=(other)
+      other.each do |key, value|
+        if self[key] != value
+          return false
+        end
+      end
+      true
+    end
+
+    # Return true if this `Hash` is a proper subset of `other`, which means all
+    # its keys are contained in `other` with the identical values, and the two
+    # hashes are not identical.
+    #
+    # @param other [Immutable::Hash] The object to compare with
+    # @return [Boolean]
+    def <(other)
+      other > self
+    end
+
+    # Return true if this `Hash` is a subset of `other`, which means all its
+    # keys are contained in `other` with the identical values, and the two
+    # hashes are not identical.
+    #
+    # @param other [Immutable::Hash] The object to compare with
+    # @return [Boolean]
+    def <=(other)
+      other >= self
+    end
+
     # See `Object#hash`.
     # @return [Integer]
     def hash
@@ -801,6 +885,22 @@ module Immutable
     end
     alias :to_h :to_hash
 
+    # Return a `Proc` which accepts a key as an argument and returns the value.
+    # The `Proc` behaves like {#get} (when the key is missing, it returns nil or
+    # the result of the default proc).
+    #
+    # @example
+    #   h = Immutable::Hash["A" => 1, "B" => 2, "C" => 3]
+    #   h.to_proc.call("B")
+    #   # => 2
+    #   ["A", "C", "X"].map(&h)   # The & is short for .to_proc in Ruby
+    #   # => [1, 3, nil]
+    #
+    # @return [Proc]
+    def to_proc
+      lambda { |key| get(key) }
+    end
+
     # @return [::Hash]
     # @private
     def marshal_dump

data/lib/immutable/list.rb

@@ -1,6 +1,6 @@
 require "thread"
 require "set"
-require "concurrent/atomics"
+require "concurrent"
 
 require "immutable/undefined"
 require "immutable/enumerable"
@@ -1311,23 +1311,23 @@ module Immutable
     def initialize(&block)
       @head   = block # doubles as storage for block while yet unrealized
       @tail   = nil
-      @atomic = Concurrent::Atomic.new(0) # haven't yet run block
+      @atomic = Concurrent::Atom.new(0) # haven't yet run block
       @size   = nil
     end
 
     def head
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @head
     end
     alias :first :head
 
     def tail
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @tail
     end
 
     def empty?
-      realize if @atomic.get != 2
+      realize if @atomic.value != 2
       @size == 0
     end
 
@@ -1348,7 +1348,7 @@ module Immutable
     def realize
       while true
         # try to "claim" the right to run the block which realizes target
-        if @atomic.compare_and_swap(0,1) # full memory barrier here
+        if @atomic.compare_and_set(0,1) # full memory barrier here
           begin
             list = @head.call
             if list.empty?
@@ -1357,22 +1357,22 @@ module Immutable
               @head, @tail = list.head, list.tail
             end
           rescue
-            @atomic.set(0)
+            @atomic.reset(0)
             MUTEX.synchronize { QUEUE.broadcast }
             raise
           end
-          @atomic.set(2)
+          @atomic.reset(2)
           MUTEX.synchronize { QUEUE.broadcast }
           return
         end
         # we failed to "claim" it, another thread must be running it
-        if @atomic.get == 1 # another thread is running the block
+        if @atomic.value == 1 # another thread is running the block
           MUTEX.synchronize do
             # check value of @atomic again, in case another thread already changed it
             #   *and* went past the call to QUEUE.broadcast before we got here
-            QUEUE.wait(MUTEX) if @atomic.get == 1
+            QUEUE.wait(MUTEX) if @atomic.value == 1
           end
-        elsif @atomic.get == 2 # another thread finished the block
+        elsif @atomic.value == 2 # another thread finished the block
           return
         end
       end
@@ -1591,5 +1591,5 @@ module Immutable
         true
       end
     end
-  end
-end.freeze
+  end.freeze
+end

data/lib/immutable/nested.rb

@@ -5,6 +5,7 @@ require "immutable/vector"
 require "immutable/sorted_set"
 require "immutable/list"
 require "immutable/deque"
+require "immutable/core_ext/struct"
 
 module Immutable
   class << self
@@ -30,6 +31,8 @@ module Immutable
       when ::Array
         res = obj.map { |element| from(element) }
         Immutable::Vector.new(res)
+      when ::Struct
+        from(obj.to_h)
       when ::SortedSet
         # This clause must go before ::Set clause, since ::SortedSet is a ::Set.
         res = obj.map { |element| from(element) }

data/lib/immutable/vector.rb

@@ -279,6 +279,24 @@ module Immutable
       end
     end
 
+    # Return the value of successively indexing into a nested collection.
+    # If any of the keys is not present, return `nil`.
+    #
+    # @example
+    #   v = Immutable::Vector[9, Immutable::Hash[c: 'a', d: 4]]
+    #   v.dig(1, :c) # => "a"
+    #   v.dig(1, :f) # => nil
+    #
+    # @return [Object]
+    def dig(key, *rest)
+      value = self[key]
+      if rest.empty? || value.nil?
+        value
+      else
+        value.dig(*rest)
+      end
+    end
+
     # Return specific objects from the `Vector`. All overloads return `nil` if
     # the starting index is out of range.
     #
@@ -536,17 +554,9 @@ module Immutable
     # @return [Vector]
     def uniq(&block)
       array = self.to_a
-      if block_given?
-        if array.frozen?
-          self.class.new(array.uniq(&block).freeze)
-        elsif array.uniq!(&block) # returns nil if no changes were made
-          self.class.new(array.freeze)
-        else
-          self
-        end
-      elsif array.frozen?
-        self.class.new(array.uniq.freeze)
-      elsif array.uniq! # returns nil if no changes were made
+      if array.frozen?
+        self.class.new(array.uniq(&block).freeze)
+      elsif array.uniq!(&block) # returns nil if no changes were made
         self.class.new(array.freeze)
       else
         self

data/lib/immutable/version.rb

@@ -1,5 +1,5 @@
 module Immutable
   # Current released gem version. Note that master will often have the same
   # value as a release gem but with different code.
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/immutable/hash/dig_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "immutable/hash"
+
+describe Immutable::Hash do
+  describe "#dig" do
+    let(:h) { H[:a => 9, :b => H[:c => 'a', :d => 4], :e => nil] }
+    it "returns the value with one argument to dig" do
+      expect(h.dig(:a)).to eq(9)
+    end
+
+    it "returns the value in nested hashes" do
+      expect(h.dig(:b, :c)).to eq('a')
+    end
+
+    it "returns nil if the key is not present" do
+      expect(h.dig(:f, :foo)).to eq(nil)
+    end
+
+    it "returns nil if you dig out the end of the hash" do
+      expect(h.dig(:f, :foo, :bar)).to eq(nil)
+    end
+
+    # This is a bit different from Ruby's Hash; it raises TypeError for
+    #   objects which don't respond to #dig
+    it "raises a NoMethodError if a value does not support #dig" do
+      expect { h.dig(:a, :foo) }.to raise_error(NoMethodError)
+    end
+
+    it "returns the correct value when there is a default proc" do
+      default_hash = H.new { |k, v| "#{k}-default" }
+      expect(default_hash.dig(:a)).to eq("a-default")
+    end
+  end
+end

data/spec/lib/immutable/hash/fetch_values_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "immutable/hash"
+
+describe Immutable::Hash do
+  describe "#fetch_values" do
+    context "when the all the requested keys exist" do
+      it "returns a vector of values for the given keys" do
+        h = H[:a => 9, :b => 'a', :c => -10, :d => nil]
+        h.fetch_values.should be_kind_of(Immutable::Vector)
+        h.fetch_values.should eql(V.empty)
+        h.fetch_values(:a, :d, :b).should be_kind_of(Immutable::Vector)
+        h.fetch_values(:a, :d, :b).should eql(V[9, nil, 'a'])
+      end
+    end
+
+    context "when the key does not exist" do
+      it "raises a KeyError" do
+        -> { H["A" => "aye", "C" => "Cee"].fetch_values("A", "B") }.should raise_error(KeyError)
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/put_spec.rb

@@ -1,6 +1,15 @@
 require "spec_helper"
 
 describe Immutable::Hash do
+  describe "#[]=" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+    it 'raises error pointing to #put' do
+      expect { hash[:A] = 'aye' }
+        .to raise_error(NoMethodError, /Immutable::Hash.*`put'/)
+    end
+  end
+
   describe "#put" do
     let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 

data/spec/lib/immutable/hash/subset_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "immutable/hash"
+
+describe Immutable::Hash do
+  describe "#<=" do
+    [
+      [{}, {}, true],
+      [{"A" => 1}, {}, false],
+      [{}, {"A" => 1}, true],
+      [{"A" => 1}, {"A" => 1}, true],
+      [{"A" => 1}, {"A" => 2}, false],
+      [{"B" => 2}, {"A" => 1, "B" => 2, "C" => 3}, true],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 2}, false],
+      [{"B" => 0}, {"A" => 1, "B" => 2, "C" => 3}, false],
+    ].each do |a, b, expected|
+      describe "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          expect(H[a] <= H[b]).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#<" do
+    [
+      [{}, {}, false],
+      [{"A" => 1}, {}, false],
+      [{}, {"A" => 1}, true],
+      [{"A" => 1}, {"A" => 1}, false],
+      [{"A" => 1}, {"A" => 2}, false],
+      [{"B" => 2}, {"A" => 1, "B" => 2, "C" => 3}, true],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 2}, false],
+      [{"B" => 0}, {"A" => 1, "B" => 2, "C" => 3}, false],
+    ].each do |a, b, expected|
+      describe "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          expect(H[a] < H[b]).to eq(expected)
+        end
+      end
+    end
+  end
+end