gom 0.1.0 → 0.2.0

data/README.rdoc

@@ -103,6 +103,76 @@ example, the call
 
 will return the instance variable <tt>@name</tt> ("Mr. Storyteller") from the author object.
 
+== Views
+
+Views are a kind of prepared queries to the data store. They are initialized during the setup and provide collections
+of results at runtime. There are several kinds of views.
+
+=== Class views
+
+There views simply provides a collection of all object of a specified class. They are defined at the storage
+configuration.
+
+  storage_name:
+    adapter: filesystem
+    directory: /var/project-name/data
+    views:
+      users:
+        type: class
+        class: User
+
+The example defines a class view for all objects of the class <tt>User</tt>. The result can be fetched via...
+
+  users = GOM::Storage.collection :storage_name, :users
+
+Collections can be handled like (read-only) ruby-arrays and the data will be fetched by the first read access to that
+array.
+
+=== Map/Reduce views
+
+These views are also defined in the storage configuration.
+
+  storage_name:
+    adapter: couchdb
+    views:
+      active_user_count:
+        type: map_reduce
+        map:
+          function(document) {
+            if (document['model_class'] == 'User' && document['active']) {
+              emit(document['_id'], 1);
+            }
+          }
+        reduce:
+          function(keys, values, rereduce) {
+            return sum(values);
+          }
+
+The example defined a map/reduce view that results in a single row with the count of all active users. This row can be
+fetched by...
+
+  rows = GOM::Storage.collection :storage_name, :active_user_count
+  rows.first.value # => 123
+
+If no <tt>reduce</tt> method is given, <tt>GOM</tt> will try to map the fetched data back to ruby-objects. The
+definition would be...
+
+  storage_name:
+    adapter: couchdb
+    views:
+      active_users:
+        type: map_reduce
+        map:
+          function(document) {
+            if (document['model_class'] == 'User') {
+              emit(document['_id'], null);
+            }
+          }
+
+...and the fetch is done by...
+
+  active_users = GOM::Storage.collection :storage_name, :active_users
+
 == Development
 
 Development has been done test-driven and the code follows at most the Clean Code paradigms. Code smells has been

data/lib/gom/object.rb

@@ -3,8 +3,11 @@ module GOM
 
   module Object
 
+    autoload :Builder, File.join(File.dirname(__FILE__), "object", "builder")
+    autoload :CachedBuilder, File.join(File.dirname(__FILE__), "object", "cached_builder")
+    autoload :Collection, File.join(File.dirname(__FILE__), "object", "collection")
+    autoload :Draft, File.join(File.dirname(__FILE__), "object", "draft")
     autoload :Id, File.join(File.dirname(__FILE__), "object", "id")
-    autoload :Injector, File.join(File.dirname(__FILE__), "object", "injector")
     autoload :Inspector, File.join(File.dirname(__FILE__), "object", "inspector")
     autoload :Mapping, File.join(File.dirname(__FILE__), "object", "mapping")
     autoload :Proxy, File.join(File.dirname(__FILE__), "object", "proxy")

data/lib/gom/object/builder.rb

@@ -0,0 +1,47 @@
+
+module GOM
+
+  module Object
+
+    # Build an object out of the given draft.
+    class Builder
+
+      attr_accessor :draft
+      attr_writer :object
+
+      def initialize(draft, object = nil)
+        @draft, @object = draft, object
+      end
+
+      def object
+        initialize_object unless @object
+        set_properties
+        set_relations
+        @object
+      end
+
+      private
+
+      def initialize_object
+        klass = Object.const_get @draft.class_name
+        arity = [ klass.method(:new).arity, 0 ].max
+        @object = klass.new *([ nil ] * arity)
+      end
+
+      def set_properties
+        @draft.properties.each do |name, value|
+          @object.instance_variable_set :"@#{name}", value
+        end
+      end
+
+      def set_relations
+        @draft.relations.each do |name, value|
+          @object.instance_variable_set :"@#{name}", value
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/gom/object/cached_builder.rb

@@ -0,0 +1,42 @@
+
+module GOM
+
+  module Object
+
+    # Build an object out of the given draft using Builder. Uses the object-id mapping
+    # for caching the results.
+    class CachedBuilder
+
+      attr_accessor :draft
+      attr_accessor :id
+
+      def initialize(draft, id = nil)
+        @draft, @id = draft, id
+      end
+
+      def object
+        check_mapping
+        build_object
+        set_mapping
+        @object
+      end
+
+      private
+
+      def check_mapping
+        @object = GOM::Object::Mapping.object_by_id @id
+      end
+
+      def build_object
+        @object = GOM::Object::Builder.new(@draft, @object).object
+      end
+
+      def set_mapping
+        GOM::Object::Mapping.put @object, @id
+      end
+
+    end
+
+  end
+
+end

data/lib/gom/object/collection.rb

@@ -0,0 +1,72 @@
+
+module GOM
+
+  module Object
+
+    # A class for a collection of objects.
+    class Collection
+
+      def initialize(fetcher)
+        @fetcher = fetcher
+      end
+
+      def total_count
+        @fetcher.total_count
+      end
+
+      def respond_to?(method_name)
+        (@object_proxies || @rows).respond_to?(method_name)
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        load unless (@object_proxies || @rows)
+        (@object_proxies || @rows).send method_name, *arguments, &block
+      end
+
+      private
+
+      def load
+        if fetcher_has_drafts?
+          load_object_proxies_from_drafts
+        elsif fetcher_has_ids?
+          load_object_proxies_from_ids
+        elsif fetcher_has_rows?
+          load_rows
+        else
+          raise NotImplementedError, "the collection fetcher doesn't provide drafts, ids nor rows."
+        end
+      end
+
+      def fetcher_has_drafts?
+        @fetcher.respond_to?(:drafts) && @fetcher.drafts
+      end
+
+      def load_object_proxies_from_drafts
+        @object_proxies = @fetcher.drafts.map do |draft|
+          GOM::Object::Proxy.new GOM::Object::CachedBuilder.new(draft).object
+        end
+      end
+
+      def fetcher_has_ids?
+        @fetcher.respond_to?(:ids) && @fetcher.ids
+      end
+
+      def load_object_proxies_from_ids
+        @object_proxies = @fetcher.ids.map do |id|
+          GOM::Object::Proxy.new id
+        end
+      end
+
+      def fetcher_has_rows?
+        @fetcher.respond_to?(:rows) && @fetcher.rows
+      end
+
+      def load_rows
+        @rows = @fetcher.rows
+      end
+
+    end
+
+  end
+
+end

data/lib/gom/object/draft.rb

@@ -0,0 +1,34 @@
+
+module GOM
+
+  module Object
+
+    # A draft for an object
+    class Draft
+
+      attr_accessor :id
+      attr_accessor :class_name
+      attr_writer :properties
+      attr_writer :relations
+
+      def initialize(id = nil, class_name = nil, properties = { }, relations = { })
+        @id, @class_name, @properties, @relations = id, class_name, properties, relations
+      end
+
+      def properties
+        @properties || { }
+      end
+
+      def relations
+        @relations || { }
+      end
+
+      def ==(other)
+        id == other.id && class_name == other.class_name && properties == other.properties && relations == other.relations
+      end
+
+    end
+
+  end
+
+end

data/lib/gom/object/inspector.rb

@@ -6,38 +6,44 @@ module GOM
     # Inspect an object and returns it's class and it's properties
     class Inspector
 
-      attr_reader :object
-      attr_reader :object_hash
+      attr_accessor :object
 
       def initialize(object)
         @object = object
-        @object_hash = { }
       end
 
-      def perform
-        read_class
-        read_properties
-        read_relations
+      def draft
+        initialize_draft
+        set_class
+        set_properties
+        set_relations
+        @draft
       end
 
       private
 
-      def read_class
-        @object_hash[:class] = @object.class.to_s
+      def initialize_draft
+        @draft = Draft.new
       end
 
-      def read_properties
-        @object_hash[:properties] = { }
+      def set_class
+        @draft.class_name = @object.class.to_s
+      end
+
+      def set_properties
+        properties = { }
         read_instance_variables do |key, value|
-          @object_hash[:properties][key] = value unless value.is_a?(GOM::Object::Proxy)
+          properties[key] = value if self.class.property_value?(value)
         end
+        @draft.properties = properties
       end
 
-      def read_relations
-        @object_hash[:relations] = { }
+      def set_relations
+        relations = { }
         read_instance_variables do |key, value|
-          @object_hash[:relations][key] = value if value.is_a?(GOM::Object::Proxy)
+          relations[key] = value if self.class.relation_value?(value)
         end
+        @draft.relations = relations
       end
 
       def read_instance_variables
@@ -48,6 +54,14 @@ module GOM
         end
       end
 
+      def self.property_value?(value)
+        !relation_value?(value)
+      end
+
+      def self.relation_value?(value)
+        value.is_a?(GOM::Object::Proxy)
+      end
+
     end
 
   end

data/lib/gom/spec/acceptance/adapter_with_stateful_storage.rb

@@ -24,6 +24,7 @@ shared_examples_for "an adapter connected to a stateful storage" do
     end
 
     after :each do
+      GOM::Storage.remove @related_object
       GOM::Storage.remove @object
     end
 
@@ -40,16 +41,20 @@ shared_examples_for "an adapter connected to a stateful storage" do
     end
 
     it "should also fetch the related object" do
-      related_object = @object.instance_variable_get :@related_object
-      related_object.should be_instance_of(GOM::Object::Proxy)
-      related_object.object.should == @related_object
-      related_object.object.instance_variable_get(:@number).should == 16
+      related_object_proxy = @object.instance_variable_get :@related_object
+      related_object_proxy.should be_instance_of(GOM::Object::Proxy)
+      related_object_proxy.object.instance_variable_get(:@number).should == 16
     end
 
   end
 
   describe "storing an object" do
 
+    after :each do
+      GOM::Storage.remove @related_object
+      GOM::Storage.remove @object
+    end
+
     it "should store the object" do
       GOM::Storage.store @object, :test_storage
       object = GOM::Storage.fetch GOM::Object.id(@object)
@@ -69,7 +74,6 @@ shared_examples_for "an adapter connected to a stateful storage" do
     it "should store the related object" do
       GOM::Storage.store @object, :test_storage
       related_object = GOM::Storage.fetch GOM::Object.id(@related_object)
-      related_object.should == @related_object
       related_object.instance_variable_get(:@number).should == 16
     end
 
@@ -108,4 +112,69 @@ shared_examples_for "an adapter connected to a stateful storage" do
 
   end
 
+  describe "fetching a class collection" do
+
+    before :each do
+      @another_object = mock Object, :class => mock(Class, :to_s => "Test")
+      @another_object.instance_variable_set :@number, 17
+
+      GOM::Storage.store @object, :test_storage
+      GOM::Storage.store @another_object, :test_storage
+    end
+
+    after :each do
+      GOM::Storage.remove @another_object
+      GOM::Storage.remove @related_object
+      GOM::Storage.remove @object
+    end
+
+    it "should provide a collection of the class view" do
+      collection = GOM::Storage.collection :test_storage, :test_object_class_view
+      collection.should be_instance_of(GOM::Object::Collection)
+    end
+
+    it "should provide a collection of all objects of the class from a class view" do
+      collection = GOM::Storage.collection :test_storage, :test_object_class_view
+      collection.size.should > 0
+      collection.each do |object_proxy|
+        object_proxy.should be_instance_of(GOM::Object::Proxy)
+        [
+          @object.instance_variable_get(:@number),
+          @related_object.instance_variable_get(:@number)
+        ].should include(object_proxy.object.instance_variable_get(:@number))
+        [
+          @another_object.instance_variable_get(:@number)
+        ].should_not include(object_proxy.object.instance_variable_get(:@number))
+      end
+    end
+
+  end
+
+  describe "fetching a map collection" do
+
+    before :each do
+      GOM::Storage.store @object, :test_storage
+    end
+
+    after :each do
+      GOM::Storage.remove @related_object
+      GOM::Storage.remove @object
+    end
+
+    it "should provide a collection" do
+      collection = GOM::Storage.collection :test_storage, :test_map_view
+      collection.should be_instance_of(GOM::Object::Collection)
+    end
+
+    it "should provide a collection of the objects emitted by the map reduce view" do
+      collection = GOM::Storage.collection :test_storage, :test_map_view
+      collection.size.should > 0
+      collection.each do |object_proxy|
+        object_proxy.should be_instance_of(GOM::Object::Proxy)
+        object_proxy.object.instance_variable_get(:@number).should == @object.instance_variable_get(:@number)
+      end
+    end
+
+  end
+
 end