pebblebed 0.0.13 → 0.0.16

data/lib/pebblebed/clients/checkpoint_client.rb

@@ -20,10 +20,11 @@ module Pebblebed
 
       if Pebblebed.memcached
         cache_keys = ids.collect {|id| cache_key_for_identity_id(id) }
-        result = Hash[Pebblebed.memcached.get_multi(*cache_keys).map do |key, identity|
-                  /identity:(?<id>\d+)/ =~ key # yup, this is ugly, but an easy hack to get the actual identity id we are trying to retrieve
-                  [id.to_i, identity]
-                end]
+        result = Hash[Pebblebed.memcached.get_multi(*cache_keys).map { |key, identity|
+          if key =~ /identity:(\d+)/
+            [$1.to_i, identity]
+          end
+        }]
         uncached = ids-result.keys
       end
 

data/lib/pebblebed/parts.rb

@@ -90,8 +90,10 @@ class Pebblebed::Parts
   end
 
   def self.parse_partspec(partspec)
-    /^(?<service>[^\.]+)\.(?<part>.*)$/ =~ partspec
-    [service, part]
+    if partspec =~ /^([^\.]+)\.(.*)$/
+      service, part = $1, $2
+      [service, part]
+    end
   end
 
   # Create a string of data-attributes from a hash

data/lib/pebblebed/uid.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module Pebblebed
   class InvalidUid < StandardError; end
   class Uid
@@ -30,50 +32,6 @@ module Pebblebed
       @oid = (value.strip != "") ? value : nil
     end
 
-    def self.raw_parse(string)
-      /(?<klass>^[^:]+)\:(?<path>[^\$]*)?\$?(?<oid>.*$)?/ =~ string
-      [klass, path, oid]
-    end
-
-    def self.valid?(string)
-      begin
-        true if new(string)
-      rescue InvalidUid
-        false
-      end
-    end
-
-    def self.parse(string)
-      uid = new(string)
-      [uid.klass, uid.path, uid.oid]
-    end
-
-    def self.valid_label?(value)
-      !!(value =~ /^[a-zA-Z0-9_-]+$/)
-    end
-
-    def self.valid_klass?(value)
-      return false if value =~ /^\.+$/
-      return false if value == ""
-      value.split('.').each do |label|
-        return false unless self.valid_label?(label)
-      end
-      true
-    end
-
-    def self.valid_path?(value)
-      # catches a stupid edge case in ruby where "..".split('.') == [] instead of ["", "", ""]
-      return false if value =~ /^\.+$/
-      value.split('.').each do |label|
-        return false unless self.valid_label?(label)
-      end
-      true
-    end
-
-    def self.valid_oid?(value)
-      !value.nil? && !value.include?('/')
-    end
-
     def realm
       self.path.split(".").first if self.path
     end
@@ -95,5 +53,95 @@ module Pebblebed
       self == other
     end
 
+    class << self
+      def raw_parse(string)
+        if string =~ /\A([^:]+)\:([^\$]*)?\$?(.+)?\Z/
+          klass, path, oid = $1, $2, $3
+          [klass, path, oid]
+        end
+      end
+
+      def valid?(string)
+        begin
+          true if new(string)
+        rescue InvalidUid
+          false
+        end
+      end
+
+      def parse(string)
+        uid = new(string)
+        [uid.klass, uid.path, uid.oid]
+      end
+
+      def valid_label?(value)
+        !!(value =~ /^[a-zA-Z0-9_-]+$/)
+      end
+
+      def valid_klass?(value)
+        return false if value =~ /^\.+$/
+        return false if value == ""
+        value.split('.').each do |label|
+          return false unless self.valid_label?(label)
+        end
+        true
+      end
+
+      def valid_path?(value)
+        # catches a stupid edge case in ruby where "..".split('.') == [] instead of ["", "", ""]
+        return false if value =~ /^\.+$/
+
+        return true if valid_wildcard_path?(value)
+
+        value.split('.').all? { |s| valid_label?(s) }
+      end
+
+      def valid_oid?(value)
+        !value.nil? && !value.include?('/')
+      end
+
+      def wildcard_path?(value)
+        value =~ /[\*\|\^]/
+      end
+
+      def valid_wildcard_path?(value)
+        wildcard_path?(value) && WildcardPath.valid?(value)
+      end
+    end
+
+    module WildcardPath
+
+      class << self
+        def valid?(path)
+          stars_are_solitary?(path) && pipes_are_interleaved?(path) && carets_are_leading?(path) && stars_are_terminating?(path)
+        end
+
+        # a.*.c is valid
+        # a.*b.c is not
+        def stars_are_solitary?(path)
+          !path.split('.').any? {|s| s.match(/.+\*|\*.+/)}
+        end
+
+        # a.b|c.d is valid
+        # a.|b.c is not
+        def pipes_are_interleaved?(path)
+          !path.split('.').any? {|s| s.match(/^\||\|$/)}
+        end
+
+        # a.^b.c is valid
+        # a.b^c.d is not
+        def carets_are_leading?(path)
+          !path.split('.').any? {|s| s.match(/.+\^|\^$/) }
+        end
+
+        # a.b.* is valid
+        # *.b.c is not
+        def stars_are_terminating?(path)
+          path !~ /.*\*\.\w/
+        end
+      end
+    end
+
   end
+
 end

data/lib/pebblebed/version.rb

@@ -1,3 +1,3 @@
 module Pebblebed
-  VERSION = "0.0.13"
+  VERSION = "0.0.16"
 end

data/spec/uid_spec.rb

@@ -1,28 +1,33 @@
 require 'spec_helper'
 
 describe Pebblebed::Uid do
-  it "parses a full uid correctly" do
-    uid = Pebblebed::Uid.new("klass:path$oid")
-    uid.klass.should eq "klass"
-    uid.path.should eq "path"
-    uid.oid.should eq "oid"
-    uid.to_s.should eq "klass:path$oid"
-  end
+  describe "parsing" do
+    context "a full uid" do
+      subject { Pebblebed::Uid.new("klass:path$oid") }
+
+      its(:klass) { should eq "klass" }
+      its(:path) { should eq "path" }
+      its(:oid) { should eq "oid" }
+      its(:to_s) { should eq "klass:path$oid" }
+    end
 
-  it "parses an uid with no oid correctly" do
-    uid = Pebblebed::Uid.new("klass:path")
-    uid.klass.should eq "klass"
-    uid.path.should eq "path"
-    uid.oid.should be_nil
-    uid.to_s.should eq "klass:path"
-  end
+    context "without oid" do
+      subject { Pebblebed::Uid.new("klass:path") }
+
+      its(:klass) { should eq "klass" }
+      its(:path) { should eq "path" }
+      its(:oid) { should be_nil }
+      its(:to_s) { should eq "klass:path" }
+    end
 
-  it "parses an uid with no path correctly" do
-    uid = Pebblebed::Uid.new("klass:$oid")
-    uid.klass.should eq "klass"
-    uid.path.should be_nil
-    uid.oid.should eq "oid"
-    uid.to_s.should eq "klass:$oid"
+    context "without path" do
+      subject { Pebblebed::Uid.new("klass:$oid") }
+
+      its(:klass) { should eq "klass" }
+      its(:path) { should be_nil }
+      its(:oid) { should eq "oid" }
+      its(:to_s) { should eq "klass:$oid" }
+    end
   end
 
   it "can be created with a string" do
@@ -43,11 +48,11 @@ describe Pebblebed::Uid do
     -> { Pebblebed::Uid.new("!:$298") }.should raise_error Pebblebed::InvalidUid
   end
 
-  it "raises an exception when you modify a uid with an invalid value" do
-    uid = Pebblebed::Uid.new("klass:path$oid")
-    -> { uid.klass = "!" }.should raise_error Pebblebed::InvalidUid
-    -> { uid.path = "..." }.should raise_error Pebblebed::InvalidUid
-    -> { uid.oid = "/" }.should raise_error Pebblebed::InvalidUid
+  describe "raises an exception when you modify a uid with an invalid value" do
+    let(:uid) { Pebblebed::Uid.new("klass:path$oid") }
+    specify { -> { uid.klass = "!" }.should raise_error Pebblebed::InvalidUid }
+    specify { -> { uid.path = "..." }.should raise_error Pebblebed::InvalidUid }
+    specify { -> { uid.oid = "/" }.should raise_error Pebblebed::InvalidUid }
   end
 
   describe "klass" do
@@ -107,51 +112,74 @@ describe Pebblebed::Uid do
     Pebblebed::Uid.valid_klass?("").should be_false
   end
 
-  describe "path" do
-    it "accepts valid paths" do
-      Pebblebed::Uid.valid_path?("").should be_true
-      Pebblebed::Uid.valid_path?("abc123").should be_true
-      Pebblebed::Uid.valid_path?("abc.123").should be_true
-      Pebblebed::Uid.valid_path?("abc.de-f.123").should be_true
-    end
-
-    it "rejects invalid paths" do
-      Pebblebed::Uid.valid_path?("abc!.").should be_false
-      Pebblebed::Uid.valid_path?(".").should be_false
-      Pebblebed::Uid.valid_path?("ab. 123").should be_false
+  describe "validating paths" do
+    specify { Pebblebed::Uid.valid_path?("").should be_true }
+    specify { Pebblebed::Uid.valid_path?("abc123").should be_true }
+    specify { Pebblebed::Uid.valid_path?("abc.123").should be_true }
+    specify { Pebblebed::Uid.valid_path?("abc.de-f.123").should be_true }
+
+    specify { Pebblebed::Uid.valid_path?("abc!.").should be_false }
+    specify { Pebblebed::Uid.valid_path?(".").should be_false }
+    specify { Pebblebed::Uid.valid_path?("ab. 123").should be_false }
+
+    context "with wildcards" do
+      specify { Pebblebed::Uid.valid_path?('*').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.b.c.*').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.b|c.d').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.b|c.*').should be_true }
+      specify { Pebblebed::Uid.valid_path?('^a').should be_true }
+      specify { Pebblebed::Uid.valid_path?('^a.b').should be_true }
+      specify { Pebblebed::Uid.valid_path?('^a.b.c').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.^b.c').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.^b.c|d.e').should be_true }
+      specify { Pebblebed::Uid.valid_path?('a.^b.c.*').should be_true }
+
+      specify { Pebblebed::Uid.valid_path?('*a').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a*').should be_false }
+      specify { Pebblebed::Uid.valid_path?('*.b').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a.*.b').should be_false }
+      specify { Pebblebed::Uid.valid_path?('|').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a.|b').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a.b|').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a.|b.c').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a.b|.c').should be_false }
+      specify { Pebblebed::Uid.valid_path?('^').should be_false }
+      specify { Pebblebed::Uid.valid_path?('^.a').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a^').should be_false }
+      specify { Pebblebed::Uid.valid_path?('a^b.c').should be_false }
     end
   end
 
-  it "knows how to parse in place" do
-    Pebblebed::Uid.parse("klass:path$oid").should eq ['klass', 'path', 'oid']
-    Pebblebed::Uid.parse("post:this.is.a.path.to$object_id").should eq ['post', 'this.is.a.path.to', 'object_id']
-    Pebblebed::Uid.parse("post:$object_id").should eq ['post', nil, 'object_id']
+  describe "wildcard paths" do
+    specify { Pebblebed::Uid.wildcard_path?('*').should be_true }
+    specify { Pebblebed::Uid.wildcard_path?('a.b|c.d').should be_true }
+    specify { Pebblebed::Uid.wildcard_path?('a.^b.d').should be_true }
+    specify { Pebblebed::Uid.wildcard_path?('a.b.d').should be_false }
   end
 
-  it "knows the valid uids from the invalid ones" do
-    Pebblebed::Uid.valid?("F**ing H%$#!!!").should be_false
-    Pebblebed::Uid.valid?("").should be_false
-    Pebblebed::Uid.valid?("bang:").should be_false
-    Pebblebed::Uid.valid?(":bang").should be_false
-    Pebblebed::Uid.valid?(":bang$paff").should be_false
-    Pebblebed::Uid.valid?("$paff").should be_false
-    Pebblebed::Uid.valid?("a:b.c.d$e").should be_true
-    Pebblebed::Uid.valid?("a:$e").should be_true
-    Pebblebed::Uid.valid?("a:b.c.d").should be_true
+  describe "parsing in place" do
+    specify { Pebblebed::Uid.parse("klass:path$oid").should eq ['klass', 'path', 'oid'] }
+    specify { Pebblebed::Uid.parse("post:this.is.a.path.to$object_id").should eq ['post', 'this.is.a.path.to', 'object_id'] }
+    specify { Pebblebed::Uid.parse("post:$object_id").should eq ['post', nil, 'object_id'] }
   end
 
-  it "knows how to extract the realm from the path" do
-    Pebblebed::Uid.new("klass:realm.other.stuff$3").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:realm$3").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:realm").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:$3").realm.should eq nil
+  describe "validating uids" do
+    specify { Pebblebed::Uid.valid?("a:b.c.d$e").should be_true }
+    specify { Pebblebed::Uid.valid?("a:$e").should be_true }
+    specify { Pebblebed::Uid.valid?("a:b.c.d").should be_true }
+    specify { Pebblebed::Uid.valid?("F**ing H%$#!!!").should be_false }
+    specify { Pebblebed::Uid.valid?("").should be_false }
+    specify { Pebblebed::Uid.valid?("bang:").should be_false }
+    specify { Pebblebed::Uid.valid?(":bang").should be_false }
+    specify { Pebblebed::Uid.valid?(":bang$paff").should be_false }
+    specify { Pebblebed::Uid.valid?("$paff").should be_false }
   end
 
-  it "knows how to extract the realm from the path" do
-    Pebblebed::Uid.new("klass:realm.other.stuff$3").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:realm$3").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:realm").realm.should eq 'realm'
-    Pebblebed::Uid.new("klass:$3").realm.should eq nil
+  describe "extracting realm from path" do
+    specify { Pebblebed::Uid.new("klass:realm.other.stuff$3").realm.should eq 'realm' }
+    specify { Pebblebed::Uid.new("klass:realm$3").realm.should eq 'realm' }
+    specify { Pebblebed::Uid.new("klass:realm").realm.should eq 'realm' }
+    specify { Pebblebed::Uid.new("klass:$3").realm.should eq nil }
   end
 
   describe "equality" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebblebed
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.16
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-23 00:00:00.000000000Z
+date: 2012-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70137844473260 !ruby/object:Gem::Requirement
+  requirement: &70227836596560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70137844473260
+  version_requirements: *70227836596560
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70137844608900 !ruby/object:Gem::Requirement
+  requirement: &70227836595980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70137844608900
+  version_requirements: *70227836595980
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70137844757700 !ruby/object:Gem::Requirement
+  requirement: &70227836595040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70137844757700
+  version_requirements: *70227836595040
 - !ruby/object:Gem::Dependency
   name: deepstruct
-  requirement: &70137844911300 !ruby/object:Gem::Requirement
+  requirement: &70227836594380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137844911300
+  version_requirements: *70227836594380
 - !ruby/object:Gem::Dependency
   name: curb
-  requirement: &70137845088040 !ruby/object:Gem::Requirement
+  requirement: &70227836593660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,10 +66,10 @@ dependencies:
         version: 0.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *70137845088040
+  version_requirements: *70227836593660
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70137845087440 !ruby/object:Gem::Requirement
+  requirement: &70227836628500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +77,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845087440
+  version_requirements: *70227836628500
 - !ruby/object:Gem::Dependency
   name: queryparams
-  requirement: &70137845086220 !ruby/object:Gem::Requirement
+  requirement: &70227836634040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845086220
+  version_requirements: *70227836634040
 - !ruby/object:Gem::Dependency
   name: futurevalue
-  requirement: &70137845085320 !ruby/object:Gem::Requirement
+  requirement: &70227836637420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845085320
+  version_requirements: *70227836637420
 - !ruby/object:Gem::Dependency
   name: pathbuilder
-  requirement: &70137845084560 !ruby/object:Gem::Requirement
+  requirement: &70227836642820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,10 +110,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845084560
+  version_requirements: *70227836642820
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70137845083420 !ruby/object:Gem::Requirement
+  requirement: &70227836646700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -121,10 +121,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845083420
+  version_requirements: *70227836646700
 - !ruby/object:Gem::Dependency
   name: i18n
-  requirement: &70137845082680 !ruby/object:Gem::Requirement
+  requirement: &70227836873840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -132,10 +132,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845082680
+  version_requirements: *70227836873840
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70137845081960 !ruby/object:Gem::Requirement
+  requirement: &70227837080040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -143,7 +143,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137845081960
+  version_requirements: *70227837080040
 description: Development tools for working with Pebblebed
 email:
 - katrina@bengler.no