pebblebed 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+tmp/
+coverage
+.powder

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pebblebed.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pebblebed/clients/abstract_client.rb

@@ -0,0 +1,21 @@
+require 'deepstruct'
+
+module Pebblebed
+  class AbstractClient
+    def perform(method, url = '', params = {}, &block)
+      raise NotImplementedError
+    end
+
+    def get(*args, &block)
+      perform(:get, *args, &block)
+    end
+
+    def post(*args, &block)
+      perform(:post, *args, &block)
+    end
+
+    def delete(*args, &block)
+      perform(:delete, *args, &block)
+    end
+  end
+end

data/lib/pebblebed/clients/checkpoint_client.rb

@@ -0,0 +1,45 @@
+module Pebblebed 
+  class CheckpointClient < Pebblebed::GenericClient
+    def me
+      return @identity if @identity_checked
+      @identity_checked = true
+      @identity = get("/identities/me")[:identity]
+    end
+
+    def cache_key_for_identity_id(id)
+      "identity:#{id}"
+    end
+
+    # Given a list of identity IDs it returns each identity or an empty hash for identities that doesnt exists.
+    # If pebbles are configured with memcached, results will be cached.
+    # Params: ids a list of identities
+    def find_identities(ids)
+
+      result = {}
+      uncached = ids
+
+      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]
+        uncached = ids-result.keys
+      end
+
+      if uncached.size > 0
+        request = get("/identities/#{uncached.join(',')},")
+        uncached.each_with_index do |id, i|
+          identity = request.identities[i].identity.unwrap
+          result[id] = identity
+          Pebblebed.memcached.set(cache_key_for_identity_id(id), identity, ttl=60*15) if Pebblebed.memcached
+        end
+      end
+      return DeepStruct.wrap(ids.collect {|id| result[id]})
+    end
+
+    def god?
+      me.god if me
+    end
+  end
+end

data/lib/pebblebed/clients/generic_client.rb

@@ -0,0 +1,33 @@
+require 'deepstruct'
+
+module Pebblebed
+  class GenericClient < AbstractClient
+    def initialize(session_key, root_url)
+      @root_url = root_url  
+      @root_url = URI(@root_url) unless @root_url.is_a?(URI::HTTP)
+      @session_key = session_key
+    end
+
+    def perform(method, url = '', params = {}, &block)
+      begin
+        result = Pebblebed::Http.send(method, service_url(url), service_params(params), &block)
+        return DeepStruct.wrap(Yajl::Parser.parse(result.body))        
+      rescue Yajl::ParseError
+        return result.body
+      end
+    end
+
+    def service_url(url)
+      result = @root_url.dup
+      result.path = result.path.sub(/\/+$/, "") + url
+      result
+    end
+
+    def service_params(params)
+      params ||= {}
+      params['session'] = @session_key if @session_key
+      params
+    end
+
+  end
+end

data/lib/pebblebed/clients/quorum_client.rb

@@ -0,0 +1,30 @@
+require 'deepstruct'
+require 'futurevalue'
+
+# A client that talks to a number of clients all at on
+module Pebblebed
+  class QuorumClient < AbstractClient
+    def initialize(services, session_key)
+      @clients = Hash[services.map do |service|
+        [service, Pebblebed::GenericClient.new(session_key, Pebblebed.root_url_for(service))]
+      end]
+    end
+
+    def perform(method, url = '', params = {}, &block)
+      # Using Future::Value perform the full quorum in parallel
+      results = @clients.map do |service, client|
+        response = [service]
+        response << Future::Value.new do 
+          begin
+            client.perform(method, url, params, &block) 
+          rescue HttpError => e
+            e
+          end
+        end
+        response
+      end
+      # Unwrap future values and thereby joining all threads
+      Hash[results.map{|service, response| [service, response.value]}]
+    end
+  end
+end

data/lib/pebblebed/config.rb

@@ -0,0 +1,57 @@
+module Pebblebed
+  class Builder
+    def host(value)
+      Pebblebed.host = value
+    end
+
+    def memcached(value)
+      Pebblebed.memcached = value
+    end
+
+    def service(name, options = {})
+      Pebblebed.require_service(name, options)
+    end
+  end
+
+  def self.config(&block)
+    Builder.new.send(:instance_eval, &block)
+  end
+
+  def self.require_service(name, options = {})
+    (@services ||= {})[name.to_sym] = options
+    Pebblebed::Connector.class_eval <<-END
+      def #{name}
+        self["#{name}"]
+      end
+    END
+  end
+
+  def self.host
+    @host
+  end
+
+  def self.host=(value)
+    @host = value
+  end
+
+  def self.memcached
+    @memcached
+  end
+
+  def self.memcached=(value)
+    @memcached = value
+  end
+
+  def self.services
+    @services.keys
+  end
+
+  def self.version_of(service)
+    return 1 unless @services && @services[service.to_sym]
+    @services[service.to_sym][:version] || 1
+  end
+
+  def self.root_url_for(service, url_opts={})
+    URI("http://#{url_opts[:host] || self.host}/api/#{service}/v#{version_of(service)}/")
+  end
+end

data/lib/pebblebed/connector.rb

@@ -0,0 +1,38 @@
+require 'active_support/inflector'
+
+module Pebblebed 
+  class Connector 
+    def initialize(key = nil, url_opts = {})
+      @key = key
+      @clients = {}
+      @url_opts = url_opts
+    end
+
+    def [](service)
+      client_class = self.class.client_class_for(service)
+      (@clients[service.to_sym] ||= client_class.new(@key, Pebblebed.root_url_for(service.to_s, @url_opts)))
+    end
+
+    # Returns a quorum client that talks to the provided list of 
+    # pebbles all at once. The result is a hash of services and their
+    # responses. If any service returned an error, their entry
+    # in the hash will be an HttpError object.
+    def quorum(services = nil, session_key = nil)
+      QuorumClient.new(services || Pebblebed.services, session_key)
+    end
+  
+      
+    def parts
+      @parts ||= Pebblebed::Parts.new(self)
+    end
+
+    def self.client_class_for(service)
+      class_name = ActiveSupport::Inflector.classify(service)+'Client'
+      begin
+        Pebblebed.const_get(class_name)
+      rescue NameError
+        GenericClient
+      end
+    end
+  end
+end

data/lib/pebblebed/http.rb

@@ -0,0 +1,98 @@
+# A wrapper for all low level http client stuff
+
+require 'uri'
+require 'curl'
+require 'yajl'
+require 'queryparams'
+require 'nokogiri'
+require 'pathbuilder'
+require 'active_support'
+
+module Pebblebed
+  class HttpError < Exception
+    attr_reader :status, :message
+    def initialize(message, status = nil)
+      @message = message
+      @status = status      
+    end
+
+    def not_found?
+      @status_code == 404
+    end
+  end
+
+  module Http
+    class CurlResult
+      def initialize(curl_result)
+        @curl_result = curl_result
+      end
+
+      def status
+        @curl_result.response_code
+      end
+
+      def url
+        @curl_result.url
+      end
+
+      def body
+        @curl_result.body_str
+      end
+    end
+
+    def self.get(url = nil, params = nil, &block)
+      url, params = url_and_params_from_args(url, params, &block)      
+      handle_curl_response(Curl::Easy.perform(url_with_params(url, params)))
+    end
+
+    def self.post(url, params, &block)
+      url, params = url_and_params_from_args(url, params, &block)      
+      handle_curl_response(Curl::Easy.http_post(url, *(QueryParams.encode(params).split('&'))))
+    end
+
+    def self.delete(url, params, &block)
+      url, params = url_and_params_from_args(url, params, &block)      
+      handle_curl_response(Curl::Easy.http_delete(url_with_params(url, params)))
+    end
+
+    private
+
+    def self.handle_http_errors(result)
+      if result.status >= 400
+        errmsg = "Service request to '#{result.url}' failed (#{result.status}):"
+        errmsg << extract_error_summary(result.body)
+        raise HttpError.new(result.status, ActiveSupport::SafeBuffer.new(errmsg)) 
+        # ActiveSupport::SafeBuffer.new is the same as errmsg.html_safe in rails
+      end
+      result
+    end
+
+    def self.handle_curl_response(curl_response)      
+      handle_http_errors(CurlResult.new(curl_response))
+    end
+
+    def self.url_with_params(url, params)
+      url.query = QueryParams.encode(params || {})
+      url.to_s
+    end
+
+    def self.url_and_params_from_args(url, params = nil, &block)
+      if block_given?
+        pathbuilder = PathBuilder.new.send(:instance_eval, &block)
+        url = url.dup
+        url.path = url.path.chomp("/")+pathbuilder.path
+        (params ||= {}).merge!(pathbuilder.params)
+      end
+      [url, params]
+    end
+
+    def self.extract_error_summary(body)
+      # Supports Sinatra error pages
+      extract = Nokogiri::HTML(body).css('#summary').text.gsub(/\s+/, ' ').strip
+      # TODO: Rails?
+      return body if extract == ''
+      extract
+    end
+
+  end
+end

data/lib/pebblebed/parts.rb

@@ -0,0 +1,124 @@
+# A class to help consumers of layout parts embed parts
+
+class Pebblebed::Parts
+
+  attr_reader :composition_strategy
+
+  # A composition strategy is a way to get from an url and a params hash to markup that will
+  # render the part into the page. Pluggable strategies to support different production 
+  # environments. SSI is provided by Nginx, ESI by Varnish and :direct is a fallback
+  # for the development environment.
+
+  @composition_strategies = {}
+
+  def initialize(connector)
+    @composition_strategy = :ssi # <- It's the best! Use Nginx with SSI
+    @preloadable = {} # <- A cache to remember which parts are preloadable
+    @connector = connector
+  end
+
+  # All part manifests for all configured pebbles as a hash of DeepStructs
+  def manifests
+    @manifests ||= @connector.quorum.get("/parts")
+    @manifests.each { |k,v| @manifests.delete(k) if v.is_a?(Pebblebed::HttpError) }
+    @manifests
+  end
+
+  def reload_manifest
+    @manifests = nil
+  end
+
+  # The strategy for composing multiple parts into a page. Default: `:ssi`
+  def composition_strategy=(value)
+    raise ArgumentError, "Unknown composition strategy '#{value}'" unless composition_strategies.keys.include?(value)
+    @composition_strategy = value
+  end
+
+  # Generates the markup for the part according to the composition strategy
+  def markup(partspec, params = nil)
+    ["<div data-pebbles-component=\"#{partspec}\" #{self.class.data_attributes(params || {})}>",
+     composition_markup_from_partspec(partspec, params),
+     "</div>"].join
+  end
+
+  def stylesheet_urls
+    manifests.keys.map do |service|
+      @connector[service].service_url("/parts/assets/parts.css")
+    end
+  end
+
+  def javascript_urls
+    manifests.keys.map do |service|
+      @connector[service].service_url("/parts/assets/parts.js")
+    end
+  end
+
+  # Register a new composition strategy handler. The block must accept two parameters:
+  # |url, params| and is expected to return whatever markup is needed to make it happen.
+  def self.register_composition_strategy(name, &block)
+    @composition_strategies[name.to_sym] = block
+  end
+
+  private
+
+  # Check the manifests to see if the part has a server side action implemented.
+  def preloadable?(partspec)
+    @preloadable[partspec] ||= raw_part_is_preloadable?(partspec)
+  end
+
+  def raw_part_is_preloadable?(partspec)
+    service, part = self.class.parse_partspec(partspec)
+    return false unless service = manifests[service.to_sym]
+    return false unless part_record = service[part]
+    return false if part_record.is_a?(::Pebblebed::HttpError)
+    return part_record.part.preloadable
+  end  
+
+  def composition_markup_from_partspec(partspec, params)
+    return '' unless preloadable?(partspec)
+    service, part = self.class.parse_partspec(partspec)
+    composition_markup(
+      @connector[service].service_url("/parts/#{part}"), params)
+  end
+
+  def self.composition_strategies
+    @composition_strategies
+  end
+
+  def composition_markup(url, params)
+    self.class.composition_strategies[@composition_strategy].call(url, params)
+  end
+
+  def self.parse_partspec(partspec)
+    /^(?<service>[^\.]+)\.(?<part>.*)$/ =~ partspec
+    [service, part]
+  end
+
+  # Create a string of data-attributes from a hash
+  def self.data_attributes(hash)
+    hash = hash.dup
+    hash.select{ |k| k != :session }.
+      map { |k,v| "data-#{k.to_s}=\"#{v}\"" }.join(' ')
+  end
+end
+
+# -------------------------------------------------------------------------------
+
+# SSI (Nginx): http://wiki.nginx.org/HttpSsiModule
+Pebblebed::Parts.register_composition_strategy :ssi do |url, params|
+  "<!--# include virtual=\"#{URI.parse(url.to_s).path}?#{QueryParams.encode(params || {})}\" -->"
+end
+
+# ESI (Varnish): https://www.varnish-cache.org/trac/wiki/ESIfeatures
+Pebblebed::Parts.register_composition_strategy :esi do |url, params|
+  "<esi:include src=\"#{URI.parse(url.to_s).path}?#{QueryParams.encode(params || {})}\"\/>"
+end
+
+# Just fetches the content and returns it. ONLY FOR DEVELOPMENT
+Pebblebed::Parts.register_composition_strategy :direct do |url, params|
+  begin
+    Pebblebed::Connector.new.get(url, params)
+  rescue HttpError => e
+    "<span class='pebbles_error'>'#{url}' with parameters #{params.to_json} failed (#{e.status}): #{e.message}</span>"
+  end
+end

data/lib/pebblebed/sinatra.rb

@@ -0,0 +1,79 @@
+# Extends Sinatra for maximum pebble pleasure
+require 'pebblebed'
+
+module Sinatra
+  module Pebblebed
+    module Helpers      
+      # Render the markup for a part. A partspec takes the form
+      # "<kit>.<partname>", e.g. "base.post"
+      def part(partspec, params = {})
+        params[:session] ||= current_session
+        pebbles.parts.markup(partspec, params)
+      end
+
+      def parts_script_include_tags
+        @script_include_tags ||= pebbles.parts.javascript_urls.map do |url|
+          "<script src=\"#{url.to_s}\"></script>"
+        end.join
+      end
+
+      def parts_stylesheet_include_tags
+        @stylesheet_include_tags ||= pebbles.parts.stylesheet_urls.map do |url|
+          "<link rel=\"stylesheet\" type=\"text/css\" media=\"all\" href=\"#{url.to_s}\">"
+        end.join
+      end
+
+      def current_session
+        params[:session] || request.cookies['checkpoint.session']
+      end
+      alias :checkpoint_session :current_session 
+
+      def pebbles
+        @pebbles ||= ::Pebblebed::Connector.new(checkpoint_session, :host => request.host)
+      end
+
+      def current_identity
+        pebbles.checkpoint.me
+      end
+
+      def require_identity
+        unless current_identity.respond_to?(:id)
+          halt 403, "No current identity."
+        end
+      end
+
+      def current_identity_is?(identity_id)
+        require_identity
+        unless (current_identity.id == identity_id || current_identity.god)
+          halt 403, "Private resource"
+        end
+      end
+
+      def require_god
+        require_identity
+        halt 403, "Current identity #{current_identity.id} is not god" unless current_identity.god
+      end
+
+      def require_parameters(parameters, *keys)
+        missing = keys.map(&:to_s) - (parameters ? parameters.keys : [])
+        halt 409, "missing parameters: #{missing.join(', ')}" unless missing.empty?
+      end
+    end
+
+    def self.registered(app)
+      app.helpers(Sinatra::Pebblebed::Helpers)
+      app.get "/ping" do
+        "{\"name\":#{(app.service_name || 'undefined').to_s.inspect}}"
+      end
+    end
+
+    def declare_pebbles(&block)
+      ::Pebblebed.config(&block)
+    end
+
+    def i_am(service_name)
+      set :service_name, service_name
+    end
+
+  end
+end

data/lib/pebblebed/uid.rb

@@ -0,0 +1,76 @@
+module Pebblebed
+  class InvalidUid < StandardError; end
+  class Uid
+    def initialize(uid)
+      self.klass, self.path, self.oid = self.class.raw_parse(uid)
+      raise InvalidUid, "Missing klass in uid" unless self.klass
+      raise InvalidUid, "A valid uid must specify either path or oid" unless self.path || self.oid
+    end
+
+    attr_reader :klass, :path, :oid
+    def klass=(value)
+      return @klass = nil if value == '' || value.nil?
+      raise InvalidUid, "Invalid klass '#{value}'" unless self.class.valid_klass?(value)
+      @klass = value
+    end
+    def path=(value)
+      return @path = nil if value == '' || value.nil?
+      raise InvalidUid, "Invalid path '#{value}'" unless self.class.valid_path?(value)
+      @path = (value.strip != "") ? value : nil
+    end
+    def oid=(value)
+      return @oid = nil if value == '' || value.nil?
+      raise InvalidUid, "Invalid oid '#{value}'" unless self.class.valid_oid?(value)
+      @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)
+      self.valid_label?(value)
+    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)
+      self.valid_label?(value)
+    end
+
+    def inspect
+      "#<Pebblebed::Uid '#{to_s}'>"
+    end
+
+    def to_s
+      "#{@klass}:#{@path}$#{@oid}".chomp("$")
+    end
+    alias_method :to_uid, :to_s 
+
+  end
+end

data/lib/pebblebed/version.rb

@@ -0,0 +1,3 @@
+module Pebblebed
+  VERSION = "0.0.1"
+end

data/lib/pebblebed.rb

@@ -0,0 +1,10 @@
+require "pebblebed/version"
+require 'pebblebed/http'
+require 'pebblebed/connector'
+require 'pebblebed/config'
+require 'pebblebed/uid'
+require 'pebblebed/clients/abstract_client'
+require 'pebblebed/clients/generic_client'
+require 'pebblebed/clients/checkpoint_client'
+require 'pebblebed/clients/quorum_client'
+require 'pebblebed/parts'

data/pebblebed.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pebblebed/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pebblebed"
+  s.version     = Pebblebed::VERSION
+  s.authors     = ["Katrina Owen", "Simen Svale Skogsrud"]
+  s.email       = ["katrina@bengler.no", "simen@bengler.no"]
+  s.homepage    = ""
+  s.summary     = %q{Development tools for working with Pebblebed}
+  s.description = %q{Development tools for working with Pebblebed}
+
+  s.rubyforge_project = "pebblebed"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "simplecov"
+  
+  s.add_runtime_dependency "deepstruct"
+  s.add_runtime_dependency "curb"
+  s.add_runtime_dependency "yajl-ruby"
+  s.add_runtime_dependency "queryparams"
+  s.add_runtime_dependency "futurevalue"
+  s.add_runtime_dependency "pathbuilder"
+  s.add_runtime_dependency "nokogiri"
+  s.add_runtime_dependency "i18n"
+  s.add_runtime_dependency "activesupport"
+
+end

data/spec/checkpoint_client_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'json'
+
+describe Pebblebed::CheckpointClient do
+
+  let(:checkpoint_client) { Pebblebed::Connector.new('session_key')[:checkpoint] }
+
+  describe "me" do
+    let(:canned_response_for_me) {
+          DeepStruct.wrap({:body=>{:identity => {:id => 1, :god => true}}.to_json})
+        }
+
+    it "returns current user identity upon request and caches it as an instance variable" do
+      checkpoint_client = Pebblebed::Connector.new('session_key')[:checkpoint]
+
+      Pebblebed::Http.should_receive(:get) { |url|
+                url.path.should match("/identities/me")
+                canned_response_for_me
+              }.once
+      checkpoint_client.me
+      checkpoint_client.me
+    end
+
+    it "tells us whether we are dealing with god allmighty himself or just another average joe" do
+      checkpoint_client = Pebblebed::Connector.new('session_key')[:checkpoint]
+      Pebblebed::Http.should_receive(:get) { |url|
+                url.path.should match("/identities/me")
+                canned_response_for_me
+              }.once
+      checkpoint_client.god?.should eq true
+    end
+  end
+
+  describe "cache_key_for_identity_id" do
+    it "creates a nice looking cache key for memcache" do
+      checkpoint_client = Pebblebed::Connector.new('session_key')[:checkpoint]
+      checkpoint_client.cache_key_for_identity_id(2).should eq "identity:2"
+    end
+  end
+
+  describe "find_identities" do
+    let(:canned_response) {
+      DeepStruct.wrap({:body=>
+                         {:identities =>
+                            [{:identity => {:id => 1}}, {:identity => {}}, {:identity => {:id => 3}}, {:identity => {}}]
+                         }.to_json
+                      })
+    }
+
+    describe "without memcache configured" do
+      before(:each) do
+        Pebblebed.config do
+          host "checkpoint.dev"
+          service :checkpoint
+        end
+      end
+
+      it "issues an http request every time" do
+        Pebblebed::Http.should_receive(:get).twice.and_return canned_response
+        checkpoint_client.find_identities([1, 2])
+        checkpoint_client.find_identities([1, 2])
+      end
+    end
+
+    describe "with memcached configured" do
+      before(:each) do
+        Pebblebed.config do
+          host "checkpoint.dev"
+          memcached $memcached
+          service :checkpoint
+        end
+      end
+
+      it "issues an http request and caches it" do
+        Pebblebed::Http.should_receive(:get).once.and_return(canned_response)
+        checkpoint_client.find_identities([1, 2])
+        checkpoint_client.find_identities([1, 2])
+
+        $memcached.get(checkpoint_client.cache_key_for_identity_id(1)).should eq({"id"=>1})
+        $memcached.get(checkpoint_client.cache_key_for_identity_id(2)).should eq({})
+      end
+
+      it "returns exactly the same data no matter if it is cached or originating from a request" do
+        Pebblebed::Http.should_receive(:get).once.and_return(canned_response)
+
+        http_requested_result = checkpoint_client.find_identities([1, 2, 3])
+        cached_result = checkpoint_client.find_identities([1, 2, 3])
+
+        http_requested_result.unwrap.should eq cached_result.unwrap
+      end
+
+      it "issues a request only for not previously cached identities" do
+        Pebblebed::Http.should_receive(:get) { |url|
+          url.path.should match("/identities/1,2,4")
+          canned_response
+        }.once
+        checkpoint_client.find_identities([1, 2, 4])
+
+        Pebblebed::Http.should_receive(:get) { |url|
+          url.path.should match("/identities/3,") # Note the extra comma. Will ensure that a list is returned
+          canned_response
+        }.once
+        checkpoint_client.find_identities([1, 2, 3, 4])
+      end
+
+      it "will always return identities in the order they are requested" do
+        Pebblebed::Http.should_receive(:get).once.and_return(canned_response)
+
+        checkpoint_client.find_identities([1, 2, 3, 4])
+        identities = checkpoint_client.find_identities([4, 3, 2, 1])
+        identities[1].id.should eq 3
+        identities[3].id.should eq 1
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Pebblebed do
+  it "has a nice dsl that configures stuff" do
+    Pebblebed.config do
+      host "example.org"
+      memcached $memcached
+      service :checkpoint
+    end
+
+    Pebblebed.host.should eq "example.org"
+    Pebblebed.memcached.should eq $memcached
+    Pebblebed::Connector.instance_methods.should include :checkpoint
+  end
+
+  it "can calculate the root uri of any pebble" do
+    Pebblebed.config do
+      service :checkpoint
+      service :foobar, :version => 2
+    end
+    Pebblebed.host = "example.org"
+    Pebblebed.root_url_for(:checkpoint).to_s.should eq "http://example.org/api/checkpoint/v1/"
+    Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s.should eq "http://checkpoint.dev/api/checkpoint/v1/"
+    Pebblebed.root_url_for(:foobar).to_s.should eq "http://example.org/api/foobar/v2/"
+  end
+
+end

data/spec/connector_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Pebblebed::Connector" do
+  it "can configure clients for any service" do
+    connector = Pebblebed::Connector.new("session_key")
+    client = connector['foobar']
+    client.class.name.should eq "Pebblebed::GenericClient"
+    client.instance_variable_get(:@session_key).should eq "session_key"
+    client.instance_variable_get(:@root_url).to_s.should =~ /api\/foobar/
+  end
+
+  it "caches any given client" do
+    connector = Pebblebed::Connector.new("session_key")
+    connector['foobar'].should eq connector['foobar']
+  end
+
+  it "fetches specific client implementations if one is provided" do
+    connector = Pebblebed::Connector.new("session_key")
+    connector['checkpoint'].class.name.should eq "Pebblebed::CheckpointClient"
+    connector['foobar'].class.name.should eq "Pebblebed::GenericClient"
+  end
+
+end

data/spec/generic_client_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Pebblebed::GenericClient do 
+  it "always forwards the session key" do
+    client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
+    client.service_params({})['session'].should eq "session_key"
+  end
+
+  it "always converts urls to URI-objects" do
+    client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
+    client.instance_variable_get(:@root_url).class.name.should eq ("URI::HTTP")
+  end
+
+  it "knows how to generate a service specific url" do
+    client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
+    client.service_url("/test").to_s.should eq "http://example.org/test"
+    client.service_url("").to_s.should eq "http://example.org"
+  end
+
+  it "wraps JSON-results in a deep struct" do
+    curl_result = DeepStruct.wrap({status:200, body:'{"hello":"world"}'})
+    Pebblebed::Http.stub(:get).and_return(curl_result)
+    client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
+    result = client.get "/"
+    result.class.name.should eq "DeepStruct::HashWrapper"
+    result.hello.should eq "world"
+  end
+
+  it "does not wrap non-json results" do
+    curl_result = DeepStruct.wrap({status:200, body:'Ok'})
+    Pebblebed::Http.stub(:get).and_return(curl_result)
+    client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
+    result = client.get "/"
+    result.class.name.should eq "String"
+    result.should eq "Ok"
+  end
+
+end

data/spec/http_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Pebblebed::Http do 
+  it "knows how to pack params into a http query string" do
+    Pebblebed::Http.send(:url_with_params, URI("/dingo/"), {a:1}).should eq "/dingo/?a=1"
+  end
+
+  it "knows how to combine url and parmas with results of pathbuilder" do
+    url, params = Pebblebed::Http.send(:url_and_params_from_args, URI("http://example.org/api"), {a:1}) do
+      foo.bar(:b => 2)
+    end
+    params.should eq(:a => 1, :b => 2)
+    url.to_s.should eq "http://example.org/api/foo/bar"
+  end
+
+  it "raises an exception if there is a http-error" do
+    -> { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status:400, url:"/foobar", body:"Oh noes")) }.should raise_error Pebblebed::HttpError
+  end
+
+end

data/spec/mockcached.rb

@@ -0,0 +1,25 @@
+class Mockcached
+  def initialize
+    @store = {}
+  end
+
+  def set(*args)
+    @store[args[0]] = args[1]
+  end
+
+  def get(*args)
+    @store[args[0]]
+  end
+
+  def get_multi(*keys)
+    result = {}
+    keys.each do |key|
+      result[key] = get(key) if @store.has_key?(key)
+    end
+    result
+  end
+
+  def delete(*args)
+    @store.delete(args[0])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+require './spec/mockcached'
+require 'bundler'
+require 'rspec'
+
+SimpleCov.add_filter 'spec'
+SimpleCov.add_filter 'config'
+SimpleCov.start
+
+Bundler.require
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+  c.around(:each) do |example|
+    clear_cookies if respond_to?(:clear_cookies)
+    $memcached = Mockcached.new
+    example.run
+  end
+end

data/spec/uid_spec.rb

@@ -0,0 +1,76 @@
+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
+
+  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
+
+  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"
+  end
+
+  it "raises an exception when you try to create an invalid uid" do
+    -> { Pebblebed::Uid.new("!:$298") }.should raise_error Pebblebed::InvalidUid
+  end
+
+  it "raises an exception when you modify an 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
+  end
+
+  it "rejects invalid labels for klass and oid" do
+    Pebblebed::Uid.valid_klass?("abc123").should be_true
+    Pebblebed::Uid.valid_klass?("abc123!").should be_false
+    Pebblebed::Uid.valid_klass?("").should be_false
+    Pebblebed::Uid.valid_oid?("abc123").should be_true
+    Pebblebed::Uid.valid_oid?("abc123!").should be_false
+    Pebblebed::Uid.valid_oid?("abc 123").should be_false
+    Pebblebed::Uid.valid_oid?("").should be_false
+  end
+
+  it "rejects invalid paths" do
+    Pebblebed::Uid.valid_path?("abc123").should be_true
+    Pebblebed::Uid.valid_path?("abc.123").should be_true
+    Pebblebed::Uid.valid_path?("").should be_true
+    Pebblebed::Uid.valid_path?("abc!.").should be_false
+    Pebblebed::Uid.valid_path?(".").should be_false
+    Pebblebed::Uid.valid_path?("ab. 123").should be_false
+  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']
+  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
+  end
+
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: pebblebed
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Katrina Owen
+- Simen Svale Skogsrud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-18 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70362516223620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70362516223620
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70362516220480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70362516220480
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70362516217900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70362516217900
+- !ruby/object:Gem::Dependency
+  name: deepstruct
+  requirement: &70362516215200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516215200
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: &70362516213740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516213740
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70362516211060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516211060
+- !ruby/object:Gem::Dependency
+  name: queryparams
+  requirement: &70362516207240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516207240
+- !ruby/object:Gem::Dependency
+  name: futurevalue
+  requirement: &70362516206260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516206260
+- !ruby/object:Gem::Dependency
+  name: pathbuilder
+  requirement: &70362516175980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516175980
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70362516172200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516172200
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70362516170520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516170520
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70362516163800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70362516163800
+description: Development tools for working with Pebblebed
+email:
+- katrina@bengler.no
+- simen@bengler.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- lib/pebblebed.rb
+- lib/pebblebed/clients/abstract_client.rb
+- lib/pebblebed/clients/checkpoint_client.rb
+- lib/pebblebed/clients/generic_client.rb
+- lib/pebblebed/clients/quorum_client.rb
+- lib/pebblebed/config.rb
+- lib/pebblebed/connector.rb
+- lib/pebblebed/http.rb
+- lib/pebblebed/parts.rb
+- lib/pebblebed/sinatra.rb
+- lib/pebblebed/uid.rb
+- lib/pebblebed/version.rb
+- pebblebed.gemspec
+- spec/checkpoint_client_spec.rb
+- spec/config_spec.rb
+- spec/connector_spec.rb
+- spec/generic_client_spec.rb
+- spec/http_spec.rb
+- spec/mockcached.rb
+- spec/spec_helper.rb
+- spec/uid_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: pebblebed
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Development tools for working with Pebblebed
+test_files:
+- spec/checkpoint_client_spec.rb
+- spec/config_spec.rb
+- spec/connector_spec.rb
+- spec/generic_client_spec.rb
+- spec/http_spec.rb
+- spec/mockcached.rb
+- spec/spec_helper.rb
+- spec/uid_spec.rb