pebbles-uid 0.0.11 → 0.0.12

data/lib/pebbles-uid/class_methods.rb

@@ -2,6 +2,10 @@ module Pebbles
   class Uid
     class << self
 
+      def roots(uids)
+        Pebbles::Uid::Roots.new(uids).unique
+      end
+
       def parse(s)
         /^(?<species>.*):(?<path>[^\$]*)\$?(?<oid>.*)$/ =~ s
         [species, path, oid && oid.empty? ? nil : oid]

data/lib/pebbles-uid/labels.rb

@@ -25,6 +25,7 @@ module Pebbles
       end
 
       def parent_of?(other)
+        return false if values == other.values
         parent = true
         values.each_with_index do |value, i|
           parent = false unless value == other.values[i]
@@ -32,6 +33,16 @@ module Pebbles
         parent
       end
 
+      def child_of?(other)
+        child = true
+        other.values.each_with_index do |label, i|
+          if label != values[i]
+            child = false
+          end
+        end
+        child && other.size != size
+      end
+
       def ambiguous?
         value == '*' || values.empty? || wildcard?
       end

data/lib/pebbles-uid/roots.rb

@@ -1,14 +1,27 @@
 module Pebbles
   class Uid
-    def self.root_paths(uids)
-      paths = uids.map { |uid| Labels.new(Pebbles::Uid.path(uid)) }
-      roots = [paths.first]
-      paths[1..-1].each { |path|
-        roots.each { |root|
-          roots << path unless root.parent_of?(path)
+    class Roots
+
+      attr_reader :paths
+      def initialize(uids)
+        @paths = {}
+        uids.each { |uid|
+          @paths[uid] = Labels.new(Pebbles::Uid.path(uid))
         }
-      }
-      roots.map(&:to_s)
+      end
+
+      def unique
+        unless @unique
+          @unique = []
+          paths.each do |uid, path|
+            unless paths.any? { |_, other| path.child_of?(other) }
+              @unique << uid
+            end
+          end
+        end
+        @unique
+      end
+
     end
   end
 end

data/lib/pebbles-uid/version.rb

@@ -1,5 +1,5 @@
 module Pebbles
   class Uid
-    VERSION = "0.0.11"
+    VERSION = "0.0.12"
   end
 end

data/spec/labels_spec.rb

@@ -49,10 +49,21 @@ describe Pebbles::Uid::Labels do
     let(:a_b_c) { Pebbles::Uid::Labels.new('a.b.c') }
     let(:a_b_d) { Pebbles::Uid::Labels.new('a.b.d') }
 
-    it "works" do
-      a.parent_of?(a_b_c).should == true
-      a_b_c.parent_of?(a_b_d).should == false
-    end
+    specify { a.parent_of?(a).should == false }
+    specify { a_b_c.parent_of?(a).should == false }
+    specify { a.parent_of?(a_b_c).should == true }
+    specify { a_b_c.parent_of?(a_b_d).should == false }
+  end
+
+  context "#child_of?" do
+    let(:a) { Pebbles::Uid::Labels.new('a') }
+    let(:b) { Pebbles::Uid::Labels.new('b') }
+    let(:a_b) { Pebbles::Uid::Labels.new('a.b') }
+
+    specify { a.child_of?(a).should == false }
+    specify { a_b.child_of?(a).should == true }
+    specify { a.child_of?(b).should == false }
+    specify { a.child_of?(a_b).should == false }
   end
 
 end

data/spec/roots_spec.rb

@@ -1,21 +1,33 @@
 require 'pebbles-uid'
 
-describe Pebbles::Uid do
+describe Pebbles::Uid::Roots do
 
-  specify "single node" do
-    Pebbles::Uid.root_paths(['person:a$1']).should eq(['a'])
+  specify "empty list is empty :)" do
+    Pebbles::Uid::Roots.new([]).unique.should eq([])
   end
 
-  specify "occluded node" do
-    Pebbles::Uid.root_paths(['person:a$1', 'person:a.b$2']).should eq(['a'])
+  specify "with one, has a single root" do
+    Pebbles::Uid::Roots.new(['boy:a$1']).unique.should eq(['boy:a$1'])
   end
 
-  specify "non-intersecting nodes" do
-    Pebbles::Uid.root_paths(['person:a.b$1', 'person:a.c$2']).should eq(['a.b', 'a.c'])
+  specify "does not keep duplicates" do
+    Pebbles::Uid::Roots.new(['girl:a$1', 'girl:a$1']).unique.should eq(['girl:a$1'])
   end
 
-  specify "weird non-intersecting nodes" do
-    Pebbles::Uid.root_paths(['person:a.b.c$1', 'person:a.c.d$2']).should eq(['a.b.c', 'a.c.d'])
+  specify "with two, returns just the parent" do
+    Pebbles::Uid::Roots.new(['kid:a$1', 'kid:a.b$2']).unique.should eq(['kid:a$1'])
+  end
+
+  specify "with two, returns just the parent, regardless of sort order" do
+    Pebbles::Uid::Roots.new(['baby:a.b$1', 'baby:a$2']).unique.should eq(['baby:a$2'])
+  end
+
+  specify "with non-intersecting nodes, returns both" do
+    Pebbles::Uid::Roots.new(['goat:a.b$1', 'goat:a.c$2']).unique.should eq(['goat:a.b$1', 'goat:a.c$2'])
+  end
+
+  specify "with similar, but non-intersecting nodes, returns both" do
+    Pebbles::Uid::Roots.new(['pig:a.b.c$1', 'pig:a.c.d$2']).unique.should eq(['pig:a.b.c$1', 'pig:a.c.d$2'])
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebbles-uid
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70189435613420 !ruby/object:Gem::Requirement
+  requirement: &70359179077380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70189435613420
+  version_requirements: *70359179077380
 description: Handle pebble UIDs conveniently.
 email:
 - katrina.owen@gmail.com