pebbles-uid 0.0.2 → 0.0.3

data/README.md

@@ -194,13 +194,28 @@ Or install it yourself as:
     => 'post.card:tourism.norway.fjords$1234'
 
     uid.to_hash
-    => {'genus' => 'post.card', 'path_0' => 'tourism', 'path_1' => 'norway', 'path_2' => 'fjords', 'oid' => '1234'}
+    => {'genus_0' => 'post', 'genus_1' => 'card', 'path_0' => 'tourism', 'path_1' => 'norway', 'path_2' => 'fjords', 'oid' => '1234'}
 
-    uid.to_hash(:verbose => true, :suffix => '')
-    => {'genus_0_' => 'post', 'genus_1_' => 'card', 'path_0_' => 'tourism', 'path_1_' => 'norway', 'path_2_' => 'fjords', 'oid_' => '1234'}
+## TODO
 
-    uid.to_hash(:verbose => true, :suffix => 'xyz', :genus => 'klass', :path => 'label' => :oid => 'id')
-    => {'klass_0_xyz' => 'post', 'klass_1_xyz' => 'card', 'label_0_xyz' => 'tourism', 'label_1_xyz' => 'norway', 'label_2_xyz' => 'fjords', 'id_xyz' => '1234'}
+[ ] handle caching for path-specific queries(*)
+
+(*) Caching and path-specific queries.
+
+    A realm has multiple publication channels, e.g. nuz.paper, nuz.magazine, and nuz.tv.
+    An article in the realm can be present in one or more of these paths. Assume that in
+    this instance, the article is only in the paper and tv. e.g:
+
+    ```
+    post.article:nuz.paper$123
+    post.article:nuz.tv$123
+    ```
+
+    If you search for post.article:nuz.*$123 then you will find it, but assume for a second
+    that you only want to find things that are in the `nuz.magazine` path. If you search on
+    the cache key, then you will find the `$123` article, but it should not have been returned.
+
+    I don't know what the solution to this is.
 
 ## Contributing
 

data/lib/pebbles-uid.rb

@@ -1,10 +1,10 @@
 require "pebbles-uid/version"
 
+require 'pebbles-uid/parse'
+require 'pebbles-uid/cache_key'
 require 'pebbles-uid/query'
 require "pebbles-uid/conditions"
 require "pebbles-uid/labels"
-require "pebbles-uid/genus"
-require "pebbles-uid/path"
 require "pebbles-uid/oid"
 
 module Pebbles
@@ -12,15 +12,15 @@ module Pebbles
 
     class << self
 
-      def query(s)
-        Pebbles::Uid::Query.new(s)
-      end
-
       def parse(s)
         /^(?<genus>.*):(?<path>[^\$]*)\$?(?<oid>.*)$/ =~ s
         [genus, path, oid.empty? ? nil : oid]
       end
 
+      def query(s)
+        Pebbles::Uid::Query.new(s)
+      end
+
       def genus(s)
         parse(s)[0]
       end
@@ -35,23 +35,18 @@ module Pebbles
 
       def valid_path?(path)
         return false if path.empty?
-        Path.new(path).valid_with?(/^[a-z0-9_-]+$/)
+        Labels.new(path).valid_with?(/^[a-z0-9_-]+$/)
       end
 
       def valid_genus?(genus)
         return false if genus.empty?
-        Genus.new(genus).valid_with?(/^[a-z0-9_-]+$/)
+        Labels.new(genus).valid_with?(/^[a-z0-9_-]+$/)
       end
 
       def valid_oid?(oid)
         return true if !oid || oid.empty?
         !!(oid =~ /^[^,|]+$/)
       end
-
-      def cache_key(uid)
-        genus, path, oid = parse(uid)
-        "#{genus}:#{Path.new(path).realm}.*$#{oid}"
-      end
     end
 
     attr_reader :genus, :path, :oid
@@ -81,15 +76,15 @@ module Pebbles
     end
 
     def species
-      @species ||= genus_labels.species
+      @species ||= genus_labels.tail.join('.')
     end
 
     def path_labels
-      @path_labels ||= Path.new(path)
+      @path_labels ||= Labels.new(path, :name => 'path')
     end
 
     def genus_labels
-      @genus_labels ||= Genus.new(genus)
+      @genus_labels ||= Labels.new(genus, :name => 'genus')
     end
 
     def valid?
@@ -122,8 +117,15 @@ module Pebbles
       [genus, path, oid].compact
     end
 
+    def to_hash
+      hash = genus_labels.to_hash.merge(path_labels.to_hash)
+      hash = hash.merge(:oid => oid) if oid?
+      hash
+    end
+
     def cache_key
       "#{genus}:#{realm}.*$#{oid}"
     end
+
   end
 end

data/lib/pebbles-uid/cache_key.rb

@@ -0,0 +1,13 @@
+module Pebbles
+  class Uid
+
+    class << self
+      def cache_key(uid)
+        genus, path, oid = parse(uid)
+        "#{genus}:#{Labels.new(path).first}.*$#{oid}"
+      end
+    end
+
+  end
+end
+

data/lib/pebbles-uid/conditions.rb

@@ -7,13 +7,12 @@ module Pebbles
 
       NO_MARKER = Class.new
 
-      attr_reader :values, :name, :suffix, :stop, :verbose
+      attr_reader :values, :name, :suffix, :stop
 
       def initialize(values, options = {})
         @values = values
         @name = options.fetch(:name) { 'label' }
         @suffix = options.fetch(:suffix) { nil }
-        @verbose = options.fetch(:verbose) { true }
         @stop = options.fetch(:stop) { NO_MARKER }
         if values.last == '*'
           @stop = NO_MARKER
@@ -21,15 +20,11 @@ module Pebbles
         end
       end
 
-      alias :verbose? :verbose
-
       def next
         label(values.length)
       end
 
       def to_hash
-        return {label => values.join('.')} unless verbose?
-
         collection = labelize
         collection.merge!(stop_label) if use_stop_marker?
         collection
@@ -57,7 +52,7 @@ module Pebbles
       end
 
       def label(i = nil)
-        [name, i, suffix].compact.join('_')
+        [name, i, suffix].compact.join('_').to_sym
       end
 
       def stop_label

data/lib/pebbles-uid/labels.rb

@@ -2,15 +2,26 @@ module Pebbles
   class Uid
     class Labels
 
-      attr_reader :values, :prefix
+      attr_reader :values, :name
       def initialize(*values)
+        options = values.pop if values.last.is_a?(Hash)
+        options ||= {}
         @values = values.flatten.compact.map {|v| v.split('.') }.flatten
+        @name = options[:name]
+      end
+
+      def first
+        values.first
       end
 
       def tail
         values[1..-1]
       end
 
+      def ambiguous?
+        value == '*' || values.empty? || wildcard?
+      end
+
       def valid_with?(pattern)
         !empty? && values.all? {|value| value[pattern] }
       end
@@ -37,7 +48,7 @@ module Pebbles
       end
 
       def to_hash(options = {})
-        Conditions.new(values, options).to_hash
+        Conditions.new(values, {:name => name}.merge(options)).to_hash
       end
 
     end

data/lib/pebbles-uid/parse.rb

@@ -0,0 +1,14 @@
+module Pebbles
+  class Uid
+
+    class << self
+
+      def parse(s)
+        /^(?<genus>.*):(?<path>[^\$]*)\$?(?<oid>.*)$/ =~ s
+        [genus, path, oid.empty? ? nil : oid]
+      end
+
+    end
+  end
+end
+

data/lib/pebbles-uid/query.rb

@@ -35,11 +35,11 @@ module Pebbles
       end
 
       def species?
-        !!Genus.new(genus).species
+        !genus_wrapper.tail.empty?
       end
 
       def species
-        Genus.new(genus).species
+        genus_wrapper.tail.join('.')
       end
 
       def oid?
@@ -50,33 +50,51 @@ module Pebbles
         terms.map { |t| Pebbles::Uid.cache_key(t) }
       end
 
+      def to_hash
+        if list?
+          raise RuntimeError.new('Cannot compute a conditions hash for a list of uids')
+        end
+
+        hash = genus_wrapper.to_hash.merge(path_wrapper.to_hash)
+        hash = hash.merge(:oid => oid) if oid?
+        hash
+      end
+
       private
 
+      def genus_wrapper
+        @genus_wrapper ||= Labels.new(genus, :name => 'genus')
+      end
+
+      def path_wrapper
+        @path_wrapper ||= Labels.new(path, :name => 'path')
+      end
+
       def wildcard_query?
         return false if term.include?(',')
-        species, _, oid = Pebbles::Uid.parse(term)
-        return true if Genus.new(species).wildcard?
+        genus, _, oid = Pebbles::Uid.parse(term)
+        return true if Labels.new(genus).wildcard?
         return true if oid.nil? || oid.empty? || oid == '*'
         false
       end
 
       def extract_terms
         term.split(',').map do |uid|
-          species, path, oid = Pebbles::Uid.parse(uid)
-          species_labels = Genus.new(species)
-          path_labels = Path.new(path)
-          oid_box = Oid.new(oid)
+          _genus, _path, _oid = Pebbles::Uid.parse(uid)
+          genus_labels = Labels.new(_genus)
+          path_labels = Labels.new(_path)
+          oid_box = Oid.new(_oid)
 
-          raise ArgumentError.new('Realm must be specified') unless path_labels.realm?
-          raise ArgumentError.new('Genus must unambiguous') if species_labels.ambiguous?
+          raise ArgumentError.new('Realm must be specified') if path_labels.empty? || path_labels.first == '*'
+          raise ArgumentError.new('Genus must unambiguous') if genus_labels.ambiguous?
           raise ArgumentError.new('Oid must be unambiguous') if oid_box.ambiguous?
 
-          @realm ||= path_labels.realm
-          raise ArgumentError.new('One realm at a time, please') if @realm != path_labels.realm
+          @realm ||= path_labels.first
+          raise ArgumentError.new('One realm at a time, please') if @realm != path_labels.first
 
           if oid_box.multiple?
-            oid.split('|').map do |s|
-              "#{species}:#{path}$#{s}"
+            _oid.split('|').map do |s|
+              "#{_genus}:#{_path}$#{s}"
             end
           else
             uid

data/lib/pebbles-uid/version.rb

@@ -1,5 +1,5 @@
 module Pebbles
   class Uid
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/spec/conditions_spec.rb

@@ -4,52 +4,42 @@ describe Pebbles::Uid::Conditions do
 
   subject { Pebbles::Uid::Conditions.new(%w(a b c)) }
 
-  its(:to_hash) { should eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
+  its(:to_hash) { should eq(:label_0 => "a", :label_1 => "b", :label_2 => "c") }
 
   describe "customized labels" do
     subject { Pebbles::Uid::Conditions.new(%w(p r q), :name => 'dot', :suffix => '') }
-    its(:to_hash) { should eq('dot_0_' => 'p', 'dot_1_' => 'r', 'dot_2_' => 'q') }
-  end
-
-  it "has a non-verbose mode" do
-    uid = Pebbles::Uid::Conditions.new(%w(k l m), :name => 'stuff', :verbose => false)
-    uid.to_hash.should eq({'stuff' => 'k.l.m'})
-  end
-
-  specify "non-verbose still takes a suffix" do
-    uid = Pebbles::Uid::Conditions.new(%w(k l m), :name => 'stuff', :verbose => false, :suffix => 'xyz')
-    uid.to_hash.should eq({'stuff_xyz' => 'k.l.m'})
+    its(:to_hash) { should eq(:dot_0_ => 'p', :dot_1_ => 'r', :dot_2_ => 'q') }
   end
 
   describe "with a stop label" do
     subject { Pebbles::Uid::Conditions.new(%w(x y z), :stop => nil) }
-    its(:to_hash) {  should eq('label_0' => "x", 'label_1' => "y", 'label_2' => "z", 'label_3' => nil) }
+    its(:to_hash) {  should eq(:label_0 => "x", :label_1 => "y", :label_2 => "z", :label_3 => nil) }
   end
 
   describe "next label" do
     subject { Pebbles::Uid::Conditions.new(%w(h j k l), :name => 'vim') }
-    its(:next) { should eq('vim_4') }
+    its(:next) { should eq(:vim_4) }
   end
 
   describe "with pipes" do
     subject { Pebbles::Uid::Conditions.new(%w(a b|c d), :stop => nil) }
-    its(:to_hash) {  should eq('label_0' => "a", 'label_1' => ['b', 'c'], 'label_2' => "d", 'label_3' => nil) }
+    its(:to_hash) {  should eq(:label_0 => "a", :label_1 => ['b', 'c'], :label_2 => "d", :label_3 => nil) }
   end
 
   describe "with an asterisk" do
     # ignores stop marker if it is terminated by an asterisk
     subject { Pebbles::Uid::Conditions.new(%w(a b *), :stop => nil) }
-    its(:to_hash) {  should eq('label_0' => "a", 'label_1' => 'b') }
+    its(:to_hash) {  should eq(:label_0 => "a", :label_1 => 'b') }
   end
 
   describe "with an asterisk" do
     subject { Pebbles::Uid::Conditions.new(%w(a ^b c), :stop => nil) }
-    its(:to_hash) {  should eq('label_0' => "a", 'label_1' => ['b', nil], 'label_2' => ['c', nil], 'label_3' => nil) }
+    its(:to_hash) {  should eq(:label_0 => "a", :label_1 => ['b', nil], :label_2 => ['c', nil], :label_3 => nil) }
   end
 
   describe "complicated stuff" do
     subject { Pebbles::Uid::Conditions.new(%w(a ^b|c d *), :stop => nil) }
-    its(:to_hash) {  should eq('label_0' => "a", 'label_1' => ['b', 'c', nil], 'label_2' => ['d', nil]) }
+    its(:to_hash) {  should eq(:label_0 => "a", :label_1 => ['b', 'c', nil], :label_2 => ['d', nil]) }
   end
 
 end

data/spec/labels_spec.rb

@@ -3,16 +3,12 @@ require 'pebbles-uid/labels'
 
 describe Pebbles::Uid::Labels do
 
-  subject { Pebbles::Uid::Labels.new('a.b.c') }
+  subject { Pebbles::Uid::Labels.new('a.b.c', :name => 'thing') }
   its(:to_s) { should eq('a.b.c') }
   its(:to_a) { should eq(%w(a b c)) }
-  its(:to_hash) {  should eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
+  its(:to_hash) {  should eq(:thing_0 => "a", :thing_1 => "b", :thing_2 => "c") }
   its(:tail) { should eq(%w(b c)) }
 
-  it "delegates to conditions" do
-    subject.to_hash(:name => 'thing', :verbose => false).should eq({'thing' => 'a.b.c'})
-  end
-
   it "has a size" do
     subject.size.should eq(3)
   end

data/spec/query_spec.rb

@@ -1,4 +1,9 @@
-require 'pebbles-uid'
+require 'pebbles-uid/parse'
+require 'pebbles-uid/cache_key'
+require 'pebbles-uid/labels'
+require 'pebbles-uid/conditions'
+require 'pebbles-uid/oid'
+require 'pebbles-uid/query'
 
 describe Pebbles::Uid::Query do
 
@@ -39,9 +44,14 @@ describe Pebbles::Uid::Query do
 
     its(:cache_keys) { should eq(['post:area51.*$abc', 'post:area51.*$xyz']) }
 
-    it "handles a pipe-delimited list of oids" do
-      query = Pebbles::Uid::Query.new("post:area51$abc|xyz")
-      query.terms.should eq(['post:area51$abc', 'post:area51$xyz'])
+    context "by oid" do
+      subject { Pebbles::Uid::Query.new("post:area51$abc|xyz") }
+
+      its(:terms) { should eq(['post:area51$abc', 'post:area51$xyz']) }
+
+      it "can't do hashes under these circumstances" do
+        ->{ subject.to_hash }.should raise_error(RuntimeError)
+      end
     end
 
     it "ignores crazy wildcard stuff in the path" do
@@ -89,6 +99,8 @@ describe Pebbles::Uid::Query do
       its(:genus?) { should == false }
       its(:path?) { should == false }
       its(:oid?) { should == false }
+
+      its(:to_hash) { should == {} }
     end
 
     context "everything, with any oid" do
@@ -97,6 +109,7 @@ describe Pebbles::Uid::Query do
       its(:genus?) { should == false }
       its(:path?) { should == false }
       its(:oid?) { should == false }
+      its(:to_hash) { should == {} }
     end
 
     context "a genus" do
@@ -104,23 +117,27 @@ describe Pebbles::Uid::Query do
       its(:genus?) { should == true }
       its(:genus) { should eq('beast') }
       its(:species?) { should == false }
+      its(:to_hash) { should == {:genus_0 => 'beast'} }
     end
 
     context "a species" do
       subject { Pebbles::Uid::Query.new('beast.mythical.hairy:*$*') }
       its(:species?) { should == true }
       its(:species) { should eq('mythical.hairy') }
+      its(:to_hash) { should == {:genus_0 => 'beast', :genus_1 => 'mythical', :genus_2 => 'hairy'} }
     end
 
     context "a path" do
       subject { Pebbles::Uid::Query.new('*:area51.*') }
       its(:path?) { should == true }
+      its(:to_hash) { should == {:path_0 => 'area51'} }
     end
 
     context "one oid" do
       subject { Pebbles::Uid::Query.new('*:*$yak') }
       its(:oid?) { should == true }
       its(:oid) { should == 'yak' }
+      its(:to_hash) { should == {:oid => 'yak'} }
     end
 
   end

data/spec/uid_spec.rb

@@ -4,16 +4,6 @@ describe Pebbles::Uid do
 
   let(:uid) { 'post.card:tourism.norway.fjords$1234' }
 
-  describe "extracting single elements" do
-    specify { Pebbles::Uid.oid(uid).should eq('1234') }
-    specify { Pebbles::Uid.path(uid).should eq('tourism.norway.fjords') }
-    specify { Pebbles::Uid.genus(uid).should eq('post.card') }
-
-    describe "with missing oid" do
-      specify { Pebbles::Uid.oid('post:a.b.c').should eq(nil) }
-    end
-  end
-
   describe "query" do
     it "returns a query object" do
       s = 'post:tourism.*$*'
@@ -22,58 +12,58 @@ describe Pebbles::Uid do
     end
   end
 
-  describe "requirements" do
-    it "must have a genus" do
+  describe "extracts elements" do
+    specify "genus" do
+      Pebbles::Uid.genus(uid).should eq('post.card')
+    end
+
+    specify "path" do
+      Pebbles::Uid.path(uid).should eq('tourism.norway.fjords')
+    end
+
+    specify "oid" do
+      Pebbles::Uid.oid(uid).should eq('1234')
+    end
+
+    specify "non-existant oid" do
+      Pebbles::Uid.oid('post:a.b.c').should be_nil
+    end
+  end
+
+  describe "must" do
+    specify "have a genus" do
       ->{ Pebbles::Uid.new(':tourism.norway$1') }.should raise_error(ArgumentError)
     end
 
-    it "must have a realm" do
+    specify "have a realm" do
       ->{ Pebbles::Uid.new('post:$1') }.should raise_error(ArgumentError)
     end
+  end
 
-    it "can skip the oid" do
+  describe "may" do
+    specify "have no oid" do
       ->{ Pebbles::Uid.new('post:tourism') }.should_not raise_error
     end
+  end
 
-    it "doesn't accept wildcard genus" do
+  describe "rejects" do
+    it "wildcard genus" do
       ->{ Pebbles::Uid.new('post.*:tourism$1') }.should raise_error(ArgumentError)
       ->{ Pebbles::Uid.new('post|card:tourism$1') }.should raise_error(ArgumentError)
       ->{ Pebbles::Uid.new('post.^b.c:tourism$1') }.should raise_error(ArgumentError)
     end
 
-    it "doesn't accept wildcard paths" do
+    it "wildcard paths" do
       ->{ Pebbles::Uid.new('post:tourism.*$1') }.should raise_error(ArgumentError)
       ->{ Pebbles::Uid.new('post:tourism|blogging$1') }.should raise_error(ArgumentError)
       ->{ Pebbles::Uid.new('post:tourism.^b.c$1') }.should raise_error(ArgumentError)
     end
 
-    it "doesn't accept wildcard oid" do
+    it "wildcard oid" do
       ->{ Pebbles::Uid.new('post:tourism$*') }.should raise_error(ArgumentError)
     end
   end
 
-  subject { Pebbles::Uid.new(uid) }
-
-  its(:to_s) { should eq(uid) }
-  its(:realm) { should eq('tourism') }
-  its(:genus) { should eq('post.card') }
-  its(:species) { should eq('card') }
-  its(:path) { should eq('tourism.norway.fjords') }
-  its(:oid) { should eq('1234') }
-  its(:oid?) { should == true }
-
-  its(:cache_key) { should eq('post.card:tourism.*$1234') }
-
-  context "when pending creation" do
-
-    let(:uid) { 'post.doc:universities.europe.norway' }
-    subject { Pebbles::Uid.new(uid) }
-
-    its(:to_s) { should eq(uid) }
-    its(:oid) { should be_nil }
-
-  end
-
   context "paths" do
     ["abc123", "abc.123", "abc.de-f.123"].each do |path|
       specify "#{path} is a valid path" do
@@ -103,9 +93,6 @@ describe Pebbles::Uid do
   end
 
   context "oids" do
-    it "can be empty" do
-      Pebbles::Uid.new("beast:mythical").oid?.should == false
-    end
 
     it "cannot contain pipes" do
       Pebbles::Uid.valid_oid?("abc|xyz").should == false
@@ -127,4 +114,38 @@ describe Pebbles::Uid do
       Pebbles::Uid.valid_oid?("holy+%^&*s!").should == true
     end
   end
+
+  describe "A Uid" do
+    subject { Pebbles::Uid.new(uid) }
+
+    its(:to_s) { should eq(uid) }
+    its(:realm) { should eq('tourism') }
+    its(:genus) { should eq('post.card') }
+    its(:species) { should eq('card') }
+    its(:path) { should eq('tourism.norway.fjords') }
+    its(:oid) { should eq('1234') }
+    its(:oid?) { should == true }
+
+    its(:cache_key) { should eq('post.card:tourism.*$1234') }
+
+    its(:to_hash) do
+      should eq(:genus_0 => 'post', :genus_1 => 'card', :path_0 => 'tourism', :path_1 => 'norway', :path_2 => 'fjords', :oid => '1234')
+    end
+
+    context "without an oid" do
+      it "excludes the oid key from the hash" do
+        Pebbles::Uid.new('post.doc:a.b.c').to_hash.should eq(:genus_0 => 'post', :genus_1 => 'doc', :path_0 => 'a', :path_1 => 'b', :path_2 => 'c')
+      end
+    end
+
+    context "when pending creation" do
+
+      let(:uid) { 'post.doc:universities.europe.norway' }
+      subject { Pebbles::Uid.new(uid) }
+
+      its(:to_s) { should eq(uid) }
+      its(:oid) { should be_nil }
+
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebbles-uid
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-01 00:00:00.000000000 Z
+date: 2012-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70278976164860 !ruby/object:Gem::Requirement
+  requirement: &70108731034840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70278976164860
+  version_requirements: *70108731034840
 description: Handle pebble UIDs conveniently.
 email:
 - katrina.owen@gmail.com
@@ -35,21 +35,19 @@ files:
 - README.md
 - Rakefile
 - lib/pebbles-uid.rb
+- lib/pebbles-uid/cache_key.rb
 - lib/pebbles-uid/conditions.rb
-- lib/pebbles-uid/genus.rb
 - lib/pebbles-uid/labels.rb
 - lib/pebbles-uid/oid.rb
-- lib/pebbles-uid/path.rb
+- lib/pebbles-uid/parse.rb
 - lib/pebbles-uid/query.rb
 - lib/pebbles-uid/version.rb
 - lib/pebbles-uid/wildcard.rb
 - lib/pebbles/uid.rb
 - pebbles-uid.gemspec
 - spec/conditions_spec.rb
-- spec/genus_spec.rb
 - spec/labels_spec.rb
 - spec/oid_spec.rb
-- spec/path_spec.rb
 - spec/query_spec.rb
 - spec/uid_spec.rb
 - spec/wildcard_spec.rb
@@ -80,10 +78,8 @@ summary: Unique identifiers in the Pebblestack universe, in the format species[.
   where the path is a dot-delimited set of labels, the first of which (realm) is required.
 test_files:
 - spec/conditions_spec.rb
-- spec/genus_spec.rb
 - spec/labels_spec.rb
 - spec/oid_spec.rb
-- spec/path_spec.rb
 - spec/query_spec.rb
 - spec/uid_spec.rb
 - spec/wildcard_spec.rb

data/lib/pebbles-uid/genus.rb

@@ -1,25 +0,0 @@
-module Pebbles
-  class Uid
-    class Genus < Labels
-
-      def ambiguous?
-        value == '*' || values.empty? || wildcard?
-      end
-
-      def species
-        return if size <= 1
-
-        tail.join('.')
-      end
-
-      def species?
-        species != '*'
-      end
-
-      def to_hash(options = {})
-        super({:verbose => false, :name => 'genus'}.merge(options))
-      end
-
-    end
-  end
-end

data/lib/pebbles-uid/path.rb

@@ -1,20 +0,0 @@
-module Pebbles
-  class Uid
-    class Path < Labels
-
-      def realm
-        values.first
-      end
-
-      def realm?
-        return false if realm == '*'
-        !!realm
-      end
-
-      def to_hash(options = {})
-        super({:name => 'path'}.merge(options))
-      end
-
-    end
-  end
-end

data/spec/genus_spec.rb

@@ -1,33 +0,0 @@
-require 'pebbles-uid/labels'
-require 'pebbles-uid/conditions'
-require 'pebbles-uid/genus'
-
-describe Pebbles::Uid::Genus do
-
-  subject { Pebbles::Uid::Genus.new('unicorn') }
-
-  its(:to_s) { should eq('unicorn') }
-
-  its(:species) { should be_nil }
-  its(:to_hash) { should eq('genus' => 'unicorn') }
-
-  context "subtypes" do
-
-    subject { Pebbles::Uid::Genus.new('unicorn', 'dust', 'sparkles') }
-    its(:to_s) { should eq('unicorn.dust.sparkles') }
-    its(:species) { should eq('dust.sparkles') }
-    its(:to_hash) { should eq('genus' => 'unicorn.dust.sparkles') }
-
-    it "doesn't have a species if there's a wildcard" do
-      genus = Pebbles::Uid::Genus.new('unicorn.*')
-      genus.species?.should == false
-    end
-
-    it "can customize the hash" do
-      subject.to_hash(:verbose => true).should eq('genus_0' => 'unicorn', 'genus_1' => 'dust', 'genus_2' => 'sparkles')
-    end
-  end
-
-  it { Pebbles::Uid::Genus.new('unicorn.horn').species.should eq('horn') }
-
-end

data/spec/path_spec.rb

@@ -1,24 +0,0 @@
-require 'pebbles-uid/conditions'
-require 'pebbles-uid/labels'
-require 'pebbles-uid/path'
-
-describe Pebbles::Uid::Path do
-
-  subject { Pebbles::Uid::Path.new('magical', 'forrest', 'clearing') }
-
-  its(:realm) { should eq('magical') }
-  its(:realm?) { should == true }
-  its(:to_s) { should eq('magical.forrest.clearing') }
-  its(:to_a) { should eq(%w(magical forrest clearing)) }
-  its(:to_hash) { should eq({'path_0' => 'magical', 'path_1' => 'forrest', 'path_2' => 'clearing'}) }
-  its(:wildcard?) { should == false }
-
-  it "can customize the hash" do
-    subject.to_hash(:name => 'label').should eq({'label_0' => 'magical', 'label_1' => 'forrest', 'label_2' => 'clearing'})
-  end
-
-  specify "wildcard realm" do
-    Pebbles::Uid::Path.new('*').realm?.should == false
-  end
-
-end