kvom 6.8.0.beta.200.809.bdfa8c3 → 6.8.0.beta.200.856.8c0fec5

data/Gemfile

@@ -1,7 +1,12 @@
 source "http://rubygems.org"
 
-gem "pry"
-gem "yajl-ruby"
+gem "activesupport" # adapter (core), storage (core), file_system_storage
+gem "couchrest"     # couchdb_adapter
+gem "aws-sdk"       # dynamodb_adapter, s3_storage
+gem "rack"          # file_system_storage
+                    # active_support/cache/file_store requires rack/utils
+
+# not that if any kvom source depends on it ;-)
+gem "pry"           # the debugging shell
 
-# Specify your gem's dependencies in kvom.gemspec
 gemspec

data/kvom.gemspec

@@ -20,12 +20,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_runtime_dependency "multi_json", "~> 1"
+  s.add_runtime_dependency "activesupport", ">= 3" # does not support rational versioning, does it?
+  s.add_runtime_dependency "activemodel", ">= 3"   # adapters
+
+  s.add_development_dependency "rspec", "~> 2.8"
   s.add_development_dependency "helpful_configuration"
+  s.add_development_dependency "yajl-ruby" # a specific json provider
 
-  s.add_runtime_dependency "couchrest"
-  s.add_runtime_dependency "activemodel"
-  s.add_runtime_dependency "aws-sdk"
-  s.add_runtime_dependency "multi_json"
-  s.add_runtime_dependency "rack" # rack/utils by active_support/cache/file_store
 end

data/lib/kvom.rb

@@ -1,11 +1,12 @@
 module Kvom
   # :nodoc:
   def self.setup_autoload(mod, mod_source)
+    @base_dir ||= File.expand_path("..", __FILE__).to_s + "/"
     dir = File.expand_path(".", mod_source)[0..-4]
     pattern = "#{dir}/*.rb"
     Dir.glob(pattern).each do |file|
       const = file[dir.length..-4].gsub(%r{[_/](.)}) {$1.upcase}
-      mod.autoload const.to_sym, file
+      mod.autoload const.to_sym, file[@base_dir.length..-1]
     end
   end
 

data/lib/kvom/adapter.rb

@@ -1,5 +1,5 @@
-module Kvom
-  module Adapter
-    Kvom.setup_autoload(self, __FILE__)
-  end
+require 'kvom'
+
+module Kvom::Adapter
+  Kvom.setup_autoload(self, __FILE__)
 end

data/lib/kvom/adapter/base.rb

@@ -1,3 +1,4 @@
+require 'kvom/adapter'
 require 'active_support/core_ext/hash/keys'
 
 module Kvom; module Adapter
@@ -28,6 +29,10 @@ class Base
     raise "implement me in subclass!"
   end
 
+  def query(hash_value, range_value)
+    raise "implement me in subclass!"
+  end
+
   protected
 
   def count_request(num_requests = 1)

data/lib/kvom/adapter/couchdb_adapter.rb

@@ -1,8 +1,10 @@
+require 'kvom/adapter'
 require 'couchrest'
 
 module Kvom; module Adapter
 
 class CouchdbAdapter < Base
+
   def new_document(key, attributes)
     new_document_from_attributes(attributes.merge("_id" => key))
   end
@@ -16,7 +18,7 @@ class CouchdbAdapter < Base
         begin
           count_request {database.get(key) }
         rescue RestClient::ResourceNotFound
-          raise Kvom::NotFound.for_key(key)
+          raise NotFound.for_key(key)
         end
     CouchdbDocument.new(doc)
   end
@@ -45,21 +47,6 @@ class CouchdbAdapter < Base
     doc.couchrest_document.destroy
   end
 
-  module BlobSupport
-
-    def blob_url(id)
-      "#{ database_url }/#{ id }/blob"
-    end
-
-    def blob_attachment(id)
-      document = count_request {database.get(id)}
-      document["_attachments"]["blob"]
-    end
-
-  end
-
-  include BlobSupport
-
   private
 
   def database_url
@@ -76,6 +63,21 @@ class CouchdbAdapter < Base
     @database ||= CouchRest.database(database_url)
   end
 
+  module BlobSupport
+
+    def blob_url(id)
+      "#{ database_url }/#{ id }/blob"
+    end
+
+    def blob_attachment(id)
+      document = count_request {database.get(id)}
+      document["_attachments"]["blob"]
+    end
+
+  end
+
+  include BlobSupport
+
 end
 
 end; end # module Kvom::Adapter

data/lib/kvom/adapter/couchdb_document.rb

@@ -1,6 +1,9 @@
+require 'kvom/adapter'
+
 module Kvom; module Adapter
 
-class ::CouchdbDocument < Kvom::Document
+class CouchdbDocument < Document
+
   attr_accessor :couchrest_document
 
   def initialize(couchrest_document)
@@ -18,6 +21,7 @@ class ::CouchdbDocument < Kvom::Document
   def key
     couchrest_document.id
   end
+
 end
 
-end; end # module Kvom
+end; end # module Kvom::Adapter

data/lib/kvom/adapter/dynamodb_adapter.rb

@@ -1,16 +1,20 @@
+require 'kvom/adapter'
 require 'aws-sdk'
 
 module Kvom; module Adapter
 
 class DynamodbAdapter < Base
+
   def new_document(key, attributes = nil)
     DynamodbDocument.new_document(attributes, key, item_for_key(key))
   end
 
   def get(key)
     item = item_for_key(key)
-    count_request {item.exists?} or raise Kvom::NotFound.for_key(key)
-    DynamodbDocument.document_with_item(key, item)
+    count_request {
+      (attributes = item.attributes.to_h).empty? and raise NotFound.for_key(key)
+      DynamodbDocument.document_from_query(attributes, key, item)
+    }
   end
 
   def save(doc)

data/lib/kvom/adapter/dynamodb_document.rb

@@ -1,38 +1,25 @@
+require 'kvom/adapter'
+
 module Kvom; module Adapter
 
-class DynamodbDocument < Document
+class DynamodbDocument < KeyAttributesDocument
   class << self
     def new_document(attributes, key, item)
-      new(key, item, :attributes => attributes)
-    end
-
-    def document_with_item(key, item)
-      new(key, item)
+      new(key, item, attributes, nil)
     end
 
-    def document_from_query(attributes, key, item)
-      new(key, item, :item_attributes => attributes)
+    def document_from_query(item_attributes, key, item)
+      attributes = AttributesFromItemAttributes.from(item_attributes)
+      new(key, item, attributes, attributes["@rev"])
     end
 
   end
 
-  attr_reader :key
-
-  def initialize(key, item, provided_attributes = nil)
-    @key = key
+  def initialize(key, item, attributes, revision)
+    super(key, attributes)
     @dynamo_item = item
-    if provided_attributes
-      if provided_attributes.key?(:attributes)
-        @kv = provided_attributes[:attributes] || {}
-        @modified = true
-      elsif provided_attributes.key?(:item_attributes)
-        @kv = attributes_from_item_attributes(provided_attributes[:item_attributes])
-      end
-    end
-  end
-
-  def [](name)
-    kv[name]
+    @revision = revision
+    @modified = @revision == nil
   end
 
   def []=(name, value)
@@ -42,18 +29,21 @@ class DynamodbDocument < Document
     else
       raise "Unsupported value type: #{value.class.name}"
     end
-    @modified = true
-    kv[name] = value
+    unless self[name] == value
+      @modified = true
+      super
+    end
   end
 
   def save
     return unless modified?
-    dynamo_attributes = @kv.inject({}) do |memo, (key, value)|
+    raise "Not yet implemented" if AttributesFromItemAttributes === attributes
+    dynamo_attributes = attributes.inject({}) do |memo, (name, value)|
       case value
       when nil
         # skip
       when String, Fixnum, BigDecimal
-        memo[key] = value
+        memo[name] = value
       else
         raise "Unsupported value type #{value.class.to_s}"
       end
@@ -64,7 +54,7 @@ class DynamodbDocument < Document
     dynamo_attributes["@rev"] = new_revision = (@rev || 0) + 1
     # might be improved to saving only changed attributes
     @dynamo_item.table.items.put(dynamo_attributes, revision_condition)
-    @rev = new_revision
+    @revision = new_revision
     @modified = false
   end
 
@@ -78,32 +68,18 @@ class DynamodbDocument < Document
     @modified
   end
 
-  def attributes_from_item_attributes(item_attributes)
-    attributes = AttributesFromItemAttributes.from(item_attributes)
-    @rev = attributes["@rev"]
-    attributes
-  end
-
-  def kv
-    @kv ||= attributes_from_item_attributes(@dynamo_item.attributes.to_h)
-  end
-
-  def revision
-    @rev
-  end
-
   def revision_condition
-    dynamo_condition("@rev" => @rev)
+    dynamo_condition("@rev" => @revision)
   end
 
   def dynamo_condition(condition)
     present_condition = {}
     missing_condition = []
-    condition.each do |(key, value)|
+    condition.each do |(name, value)|
       if value
-        present_condition[key] = value
+        present_condition[name] = value
       else
-        missing_condition << key
+        missing_condition << name
       end
     end
     options = {}
@@ -118,7 +94,7 @@ class DynamodbDocument < Document
       attributes.delete("range_key")
       meta = attributes.delete("@meta.json")
       return attributes unless meta
-      meta = MultiJson.decode(meta)
+      meta = Lib::Json.load(meta)
       coding = meta["coding"]
       return attributes if !coding || coding.empty?
       new(attributes, coding)
@@ -136,10 +112,9 @@ class DynamodbDocument < Document
       self[name] =
           case coding
           when "json"
-            MultiJson.decode(value)
+            Lib::Json.load(value)
           when "jsonvalue"
-            # currently the only values to decode are: null, true, false, ""
-            MultiJson.decode("{\"k\":#{value}}")["k"]
+            Lib::JsonValue.load(value)
           else
             raise "Unexpected coding #{coding} for attribute #{name}"
           end
@@ -151,6 +126,7 @@ class DynamodbDocument < Document
     end
 
   end
+
 end
 
 end; end # module Kvom::Adapter

data/lib/kvom/adapter/filesystem_adapter.rb

@@ -0,0 +1,130 @@
+require 'kvom/adapter'
+require 'fileutils'
+require 'pathname'
+
+module Kvom; module Adapter
+
+class FilesystemAdapter < Base
+
+  EXT = ".doc"
+  EXT_SIZE = EXT.length
+  EXT_OFFSET = -(EXT_SIZE + 1)
+
+  def new_document(key, attributes)
+    # there is no "was loaded from db" yet (e.g. for conditional put)
+    FilesystemDocument.new(key, attributes)
+  end
+
+  def get(key)
+    count_request { document_for_key(key) } or raise NotFound.for_key(key)
+  end
+
+  def destroy(doc)
+    FileUtils.rm_f(filepath_for_document(doc))
+  end
+
+  def save(doc)
+    path = filepath_for_document(doc)
+    FileUtils.mkdir_p(path.dirname)
+    # TODO: conditional put
+    File.open(path, "w") {|f| f.write(doc.to_json)}
+  end
+
+  def query(hash_value, range_value)
+    pathes_and_range_values =
+        count_request do
+          case range_value
+          when Range
+            range_file_query(hash_value, range_value.first, range_value.last)
+          else
+            single_file_query(hash_value, range_value)
+          end
+        end
+    pathes_and_range_values.inject([]) do |memo, (path, doc_range_value)|
+      key = [hash_value, doc_range_value].join("|")
+      doc = document_for_key_and_path(key, path)
+      memo << doc if doc
+      memo
+    end
+  end
+
+  private
+
+  def base_dir
+    @dir ||= begin
+      dir = Pathname.new(connection_spec[:path])
+      FileUtils.mkdir_p(dir)
+      dir
+    end
+  end
+
+  def document_for_key(key)
+    document_for_key_and_path(key, filepath_for_key(key))
+  end
+
+  def document_for_key_and_path(key, path)
+    begin
+      serialized_doc = File.read(path)
+    rescue ::Errno::ENOENT
+      return nil
+    end
+    # there is no "was loaded from db" yet (e.g. for conditional put)
+    FilesystemDocument.new(key, Lib::Json.load(serialized_doc))
+  end
+
+  def filepath_for_document(doc)
+    filepath_for_key(doc.key)
+  end
+
+  def filepath_for_key(key)
+    filepath_for_hash_and_range(*(key.split("|", 2)))
+  end
+
+  def filepath_for_hash_and_range(hash_value, range_value)
+    dir_for_hash_value(hash_value) + path_component_for_range_value(range_value)
+  end
+
+  def dir_for_hash_value(hash_value)
+    base_dir + path_component_for_value(hash_value)
+  end
+
+  def path_component_for_value(value)
+    # value should not have a pipe character
+    value.gsub("/", "|")
+  end
+
+  def path_component_for_range_value(range_value)
+    path_component_for_value(range_value) << EXT
+  end
+
+  def value_from_path_component(path_component)
+    path_component.to_s.gsub("|", "/")
+  end
+
+  def range_value_from_path_component(path_component)
+    value_from_path_component(path_component.to_s[0..EXT_OFFSET])
+  end
+
+  def single_file_query(hash_value, range_value)
+    path = filepath_for_hash_and_range(hash_value, range_value)
+    [[path, range_value]]
+  end
+
+  def range_file_query(hash_value, start_range_value, end_range_value)
+    hash_dir = dir_for_hash_value(hash_value)
+    Dir.foreach(hash_dir).inject([]) do |memo, entry|
+      if entry[-EXT_SIZE..-1] == EXT
+        range_value = range_value_from_path_component(entry)
+        if start_range_value <= range_value && range_value <= end_range_value
+          memo << [hash_dir + entry, range_value]
+        end
+      end
+      memo
+    end
+  rescue Errno::ENOENT
+    []
+  end
+
+end
+
+end; end # module Kvom::Adapter