rocking_chair 0.0.2

data/lib/rocking_chair.rb

@@ -0,0 +1,33 @@
+require "rubygems"
+require "active_support"
+require "uuidtools"
+require "cgi"
+require "couchrest"
+
+
+require "rocking_chair/helper"
+require "rocking_chair/error"
+require "rocking_chair/view"
+require "rocking_chair/database"
+require "rocking_chair/server"
+require "rocking_chair/couch_rest_http_adapter"
+
+module RockingChair
+  
+  @_rocking_chair_enabled
+  
+  def self.enable
+    unless @_rocking_chair_enabled
+      HttpAbstraction.extend(RockingChair::CouchRestHttpAdapter)
+      @_rocking_chair_enabled = true
+    end
+  end
+  
+  def self.disable
+    if @_rocking_chair_enabled
+      HttpAbstraction.extend(RestClientAdapter::API)
+      @_rocking_chair_enabled = false
+    end
+  end
+  
+end

data/lib/rocking_chair/couch_rest_http_adapter.rb

@@ -0,0 +1,80 @@
+module RockingChair
+  module CouchRestHttpAdapter
+    URL_PARAMETER = /[a-zA-Z0-9\-\_\%]+/
+    
+    @_RockingChair_debug = true
+    
+    def get(uri, headers={})
+      puts "GET: #{uri.inspect}: #{headers.inspect}" if @_RockingChair_debug
+      url, parameters = RockingChair::Server.normalize_url(uri)
+      if url == ''
+        RockingChair::Server.info
+      elsif url == '_all_dbs'
+        RockingChair::Server.all_dbs(parameters)
+      elsif url == '_uuids'
+        RockingChair::Server.uuids(parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.database($1, parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/_all_docs\Z/)
+        RockingChair::Server.load_all($1, parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.load($1, $2, parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/_design\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.load($1, "_design/#{$2}", parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/_design\/(#{URL_PARAMETER})\/_view\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.view($1, $2, $3, parameters)
+      else
+        raise "GET: Unknown url: #{url.inspect}  headers: #{headers.inspect}"
+      end
+    end
+  
+    def post(uri, payload, headers={})
+      puts "POST: #{uri.inspect}: #{payload.inspect} #{headers.inspect}" if @_RockingChair_debug
+      url, parameters = RockingChair::Server.normalize_url(uri)
+      if url.match(/\A(#{URL_PARAMETER})\/?\Z/)
+        RockingChair::Server.store($1, nil, payload, parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/(#{URL_PARAMETER})\Z/) && $2 == '_bulk_docs'
+        RockingChair::Server.bulk($1, payload)
+      else
+        raise "POST: Unknown url: #{uri.inspect}: #{payload.inspect} #{headers.inspect}" 
+      end
+    end
+  
+    def put(uri, payload, headers={})
+      puts "PUT: #{uri.inspect}: #{payload.inspect} #{headers.inspect}" if @_RockingChair_debug
+      url, parameters = RockingChair::Server.normalize_url(uri)
+      if url.match(/\A(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.create_db(url)
+      elsif url.match(/\A(#{URL_PARAMETER})\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.store($1, $2, payload, parameters)
+      elsif url.match(/\A(#{URL_PARAMETER})\/_design\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.store($1, "_design/#{$2}", payload, parameters)
+      else
+        raise "PUT: Unknown url: #{uri.inspect}: #{payload.inspect} #{headers.inspect}" 
+      end
+    end
+  
+    def delete(uri, headers={})
+      puts "DELETE: #{uri.inspect}: #{headers.inspect}" if @_RockingChair_debug
+      url, parameters = RockingChair::Server.normalize_url(uri)
+      if url.match(/\A(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.delete_db(url)
+      elsif url.match(/\A(#{URL_PARAMETER})\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.delete($1, $2, parameters)
+      else
+        raise "DELETE: Unknown url: #{uri.inspect}: #{headers.inspect}"
+      end
+    end
+  
+    def copy(uri, headers)
+      puts "COPY: #{uri.inspect}: #{headers.inspect}" if @_RockingChair_debug
+      url, parameters = RockingChair::Server.normalize_url(uri)
+      if url.match(/\A(#{URL_PARAMETER})\/(#{URL_PARAMETER})\Z/)
+        RockingChair::Server.copy($1, $2, headers.merge(parameters))
+      else
+        raise "COPY: Unknown url: #{uri.inspect}: #{headers.inspect}"
+      end
+    end
+    
+  end
+end

data/lib/rocking_chair/database.rb

@@ -0,0 +1,176 @@
+module RockingChair
+  class Database
+    
+    attr_accessor :storage
+    
+    def initialize
+      @storage = {}
+    end
+    
+    def self.uuid
+      UUIDTools::UUID.random_create().to_s.gsub('-', '')
+    end
+    
+    def self.uuids(count)
+      ids = []
+      count.to_i.times {ids << uuid}
+      ids
+    end
+    
+    def rev
+      self.class.uuid
+    end
+    
+    def exists?(doc_id)
+      storage.has_key?(doc_id)
+    end
+    
+    def [](doc_id)
+      if exists?(doc_id)
+        return storage[doc_id]
+      else
+        RockingChair::Error.raise_404
+      end
+    end
+    
+    def load(doc_id, options = {})
+      options = {
+        'rev' => nil,
+        'revs' => false
+      }.update(options)
+      options.assert_valid_keys('rev', 'revs', 'revs_info')
+      
+      document = self[doc_id]
+      if options['rev'] && ( ActiveSupport::JSON.decode(document)['_rev'] != options['rev']) 
+        RockingChair::Error.raise_404
+      end
+      if options['revs'] && options['revs'] == 'true'
+        json =  ActiveSupport::JSON.decode(document)
+        json['_revisions'] = {'start' => 1, 'ids' => [json['_rev']]}
+        document = json.to_json
+      end
+      if options['revs_info'] && options['revs_info'] == 'true'
+        json =  ActiveSupport::JSON.decode(document)
+        json['_revs_info'] = [{"rev" => json['_rev'], "status" => "disk"}]
+        document = json.to_json
+      end
+      document
+    end
+    
+    def []=(doc_id, document, options ={})
+      # options are ignored for now: batch, bulk
+      json = nil
+      begin
+        json = ActiveSupport::JSON.decode(document)
+        raise "is not a Hash" unless json.is_a?(Hash)
+      rescue Exception => e
+        raise RockingChair::Error.new(500, 'InvalidJSON', "the document is not a valid JSON object: #{e}")
+      end
+      
+      if exists?(doc_id)
+        update(doc_id, json)
+      else
+        insert(doc_id, json)
+      end
+    end
+    
+    alias_method :store, :[]=
+    
+    def delete(doc_id, rev)
+      if exists?(doc_id)
+        existing = self[doc_id]
+        if matching_revision?(existing, rev)
+          storage.delete(doc_id)
+        else
+          RockingChair::Error.raise_409
+        end
+      else
+        RockingChair::Error.raise_404
+      end
+    end
+    
+    def copy(original_id, new_id, rev=nil)
+      original = JSON.parse(self[original_id])
+      if rev
+        original['_rev'] = rev
+      else
+        original.delete('_rev')
+      end
+      
+      self.store(new_id, original.to_json)
+    end
+    
+    def bulk(documents)
+      documents = JSON.parse(documents)
+      response = []
+      documents['docs'].each do |doc|
+        begin
+          if exists?(doc['_id']) && doc['_deleted'].to_s == 'true'
+            self.delete(doc['_id'], doc['_rev'])
+            state = {'id' => doc['_id'], 'rev' => doc['_rev']}
+          else
+            state = JSON.parse(self.store(doc['_id'], doc.to_json))
+          end
+          response << {'id' => state['id'], 'rev' => state['rev']}
+        rescue RockingChair::Error => e
+           response << {'id' => doc['_id'], 'error' => e.error, 'reason' => e.reason}
+        end
+      end
+      response.to_json
+    end
+    
+    def document_count
+      storage.keys.size
+    end
+    
+    def all_documents(options = {})
+      View.run_all(self, options)
+    end
+    
+    def view(design_doc_name, view_name, options = {})
+      View.run(self, design_doc_name, view_name, options)
+    end
+    
+  protected
+  
+    def state_tuple(_id, _rev)
+      {"ok" => true, "id" =>  _id, "rev" => _rev }.to_json
+    end
+  
+    def update(doc_id, json)
+      existing = self[doc_id]
+      if matching_revision?(existing, json['_rev'])
+        insert(doc_id, json)
+      else
+        RockingChair::Error.raise_409
+      end
+    end
+  
+    def insert(doc_id, json)
+      json.delete('_rev')
+      json.delete('_id')
+      json['_rev'] = rev
+      json['_id'] = doc_id || self.class.uuid
+      validate_document(json)
+      storage[doc_id] = json.to_json
+      
+      state_tuple(json['_id'], json['_rev'])
+    end
+    
+    def validate_document(doc)
+      if design_doc?(doc)
+        RockingChair::Error.raise_500 unless doc['views'].is_a?(Hash)
+      end
+    end
+    
+    def design_doc?(doc)
+      doc['_id'] && doc['_id'].match(/_design\/[a-zA-Z0-9\_\-]+/)
+    end
+    
+    def matching_revision?(existing_record, rev)
+      document = JSON.parse(existing_record)
+      RockingChair::Helper.access('_rev', document) == rev
+    end
+        
+  end
+end

data/lib/rocking_chair/error.rb

@@ -0,0 +1,44 @@
+module RockingChair
+  class Error < StandardError
+    
+    attr_reader :code, :error, :reason
+    
+    def initialize(code, error, reason)
+      @code = code
+      @error = error
+      @reason = reason
+    end
+    
+    def message
+      "#{@code} - #{@error} - #{@reason}"
+    end
+    
+    def to_json
+      {"error" => @error, "reason" => @reason }.to_json
+    end
+    
+    def raise_rest_client_error
+      case code
+      when 404
+        raise RestClient::ResourceNotFound
+      when 409
+        raise HttpAbstraction::Conflict
+      else
+        raise "Unknown error code: #{code.inspect}"
+      end
+    end
+    
+    def self.raise_404
+      raise RockingChair::Error.new(404, 'not_found', "missing")
+    end
+    
+    def self.raise_409
+      raise RockingChair::Error.new(409, 'conflict', "Document update conflict.")
+    end
+    
+    def self.raise_500
+      raise RockingChair::Error.new(500, 'invalid', "the document is invalid.")
+    end
+    
+  end
+end

data/lib/rocking_chair/helper.rb

@@ -0,0 +1,15 @@
+module RockingChair
+  module Helper
+    
+    def self.jsonfy_options(options, *keys)
+      keys.each do |key|
+        options[key] = ActiveSupport::JSON.decode(options[key]) if options[key]
+      end
+    end
+    
+    def self.access(attr_name, doc)
+      doc.respond_to?(:_document) ? doc._document[attr_name] : doc[attr_name]
+    end
+    
+  end
+end

data/lib/rocking_chair/server.rb

@@ -0,0 +1,137 @@
+module RockingChair
+  module Server
+    BASE_URL = /(http:\/\/)?127\.0\.0\.1:5984\//
+    
+    def self.databases
+      @databases ||= {}
+    end
+    
+    def self.reset
+      @databases = {}
+    end
+    
+    def self.normalize_options(options)
+      (options || {}).each do |k,v|
+        options[k] = options[k].first if options[k].is_a?(Array)
+      end
+      options
+    end
+        
+    def self.normalize_url(url)
+      url = url.to_s.gsub(BASE_URL, '') #.gsub('%2F', '/')
+      if url.match(/\A(.*)\?(.*)?\Z/)
+        return [$1, normalize_options(CGI::parse($2 || ''))]
+      else
+        return [url, {}]
+      end
+    end
+    
+    def self.info
+      respond_with({"couchdb" => "Welcome","version" => "0.10.1"})
+    end
+    
+    def self.all_dbs(options = {})
+      respond_with(databases.keys)
+    end
+    
+    def self.uuids(options = {})
+      options = {
+        'count' => 100
+      }.update(options)
+      options['count'] = options['count'].first if options['count'].is_a?(Array)
+
+      respond_with({"uuids" => RockingChair::Database.uuids(options['count']) })
+    end
+    
+    def self.create_db(name)
+      databases[name] = RockingChair::Database.new
+      respond_with({"ok" => true})
+    end
+    
+    def self.delete_db(name)
+      databases.delete(name)
+      respond_with({"ok" => true})
+    end
+    
+    def self.store(db_name, doc_id, document, options)
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].store(doc_id, document, options)
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.delete(db_name, doc_id, options = {})
+      options = {
+        'rev' => nil
+      }.update(options)
+      options['rev'] = options['rev'].first if options['rev'].is_a?(Array)
+      
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].delete(doc_id, options['rev'])
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.load(db_name, doc_id, options = {})
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].load(doc_id, options)
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.load_all(db_name, options = {})
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].all_documents(options)
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.copy(db_name, doc_id, options = {})
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      destination_id, revision = normalize_url(options['Destination'])
+      databases[db_name].copy(doc_id, destination_id, revision['rev'])
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.bulk(db_name, options = {})
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].bulk(options)
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.view(db_name, design_doc_id, view_name, options = {})
+      return respond_with_error(404) unless databases.has_key?(db_name)
+      databases[db_name].view(design_doc_id, view_name, options)
+    rescue RockingChair::Error => e
+      e.raise_rest_client_error
+    end
+    
+    def self.database(name, parameters)
+      if databases.has_key?(name)
+        respond_with({
+          "db_name" => name,
+          "doc_count" => databases[name].document_count,
+          "doc_del_count" => 0,
+          "update_seq" => 10,
+          "purge_seq" => 0,
+          "compact_running" => false,
+          "disk_size" => 16473,
+          "instance_start_time" => "1265409273572320",
+          "disk_format_version" => 4})
+      else
+        return respond_with_error(404)
+      end
+    end
+    
+    def self.respond_with(obj)
+      obj.to_json
+    end
+    
+    def self.respond_with_error(code, message=nil)
+      message ||= 'no such DB'
+      {code => message}.to_json
+    end
+  end
+end