couch_view 0.0.1

data/features/couch_view.feature

@@ -0,0 +1,359 @@
+Feature: CouchView
+  As a programmer
+  I want a `CouchView` mixin for my `CouchRest::Model::Base` models
+  So that I can define maps and reduces on my model 
+  
+  
+  @db
+  Scenario: Define a map over a property
+    Given the following model definition:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+        end
+      """
+
+    When I pass :label to the `map` class method:
+      """
+        Article.map :label
+      """
+
+    Then my model should respond to "map_by_label" and "map_by_label!":
+      """
+        Article.should respond_to(:map_by_label)
+        Article.should respond_to(:map_by_label!)
+      """
+    
+    When I create some articles with labels:
+      """
+        Article.create :label => "moonmaster9000"
+        Article.create :label => "grantmichaels"
+      """
+
+    Then they should be indexed in my label map:
+      """
+        Article.map_by_label!.collect(&:label).should     == ["grantmichaels", "moonmaster9000"] 
+        Article.map_by_label.get!.collect(&:label).should == ["grantmichaels", "moonmaster9000"]
+      """
+
+
+  @db @focus
+  Scenario: Define a map on your model with conditions
+    Given the following conditions:
+      """
+        module Published
+          def conditions
+            "#{super} && doc.published == true"
+          end
+        end
+        
+        module Visible
+          def conditions
+            "#{super} && doc.visible == true"
+          end
+        end
+      """
+
+    When I add them as conditions to a map over my model's label property:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+
+          property :label
+          property :published, TrueClass, :default => false
+          property :visible,   TrueClass, :default => false
+
+          map :label do
+            conditions Published, Visible
+          end
+        end
+      """
+
+    And I create visible and published documents:
+      """
+        Article.create :label => "unpublished"
+        Article.create :label => "published", :published => true
+        Article.create :label => "visible", :visible => true
+        Article.create :label => "published_and_visible", :published => true, :visible => true
+      """
+
+    Then I should be able to query them through my query proxy:
+      """
+        Article.map_by_label!.collect(&:label).sort.should == 
+          ["published", "published_and_visible", "unpublished", "visible"]
+        
+        Article.map_by_label.published.get!.collect(&:label).sort.should == 
+          ["published", "published_and_visible"]
+        
+        Article.map_by_label.visible.get!.collect(&:label).sort.should == 
+          ["published_and_visible", "visible"]
+        
+        Article.map_by_label.published.visible.get!.collect(&:label).sort.should == 
+          ["published_and_visible"]
+      """
+
+
+  @db
+  Scenario: Define a map on your model with the `map` class method
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    When I mix `CouchView` into my model and define a `map ById`:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+
+          map ById
+        end
+      """
+
+    Then my model should respond to `map_by_id`:
+      """
+        Article.should respond_to(:map_by_id)
+      """
+
+    And my model should respond to `map_by_id!`:
+      """
+        Article.should respond_to(:map_by_id!)
+      """
+
+
+  @db
+  Scenario: Retrieve a map proxy
+    
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    When I mix `CouchView` into my model and define a `map ById`:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ById
+        end
+      """
+
+    And I call the "map_by_id" method on my model:
+      """
+        @proxy = Article.map_by_id
+      """
+
+    Then I should receive a view proxy:
+      """
+        @proxy.class.should == CouchView::Proxy
+      """
+
+    And my proxy should map over ":by_by_id":
+      """
+        @proxy._map.should == :by_by_id
+      """
+
+    And my proxy should map on the "Article" model:
+      """
+        @proxy._model.should == Article
+      """
+
+
+  @db
+  Scenario: Generate a reduce proxy for counting the number of results in your query
+
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    When I mix `CouchView` into my model and define a `map ById`:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ById
+        end
+      """
+    
+    Then my model should respond to `count_by_id`:
+      """
+        Article.should respond_to(:count_by_id)
+      """
+
+    And my model should respond to `count_by_id!`:
+      """
+        Article.should respond_to(:count_by_id!)
+      """
+
+    When I call the `count_by_id` method
+      """
+        @proxy = Article.count_by_id
+      """
+
+    Then I should receive a count proxy:
+      """
+        @proxy.class.should be(CouchView::Count::Proxy)
+      """
+
+  @db
+  Scenario: Counting the number of rows in a reduce query
+    
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    When I mix `CouchView` into my model and define a `map ById`:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ById
+        end
+      """
+    
+    And I create 4 articles:
+      """
+        4.times { Article.create }
+      """
+
+    Then `count_by_id!` should return 4:
+      """
+        Article.count_by_id!.should == 4
+      """
+
+  @db
+  Scenario: Query a map on your model
+    
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    When I mix `CouchView` into my model and define a `map ById`:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+
+          map ById
+        end
+      """
+
+    And I create an Article:
+      """
+        @article = Article.create
+      """
+
+    Then `map_by_id!` should return the article
+      """
+        Article.map_by_id!.first.should == @article
+      """
+
+    And `map_by_id.get!` should return the article
+      """
+        Article.map_by_id.get!.first.should == @article
+      """
+
+
+  @db
+  Scenario: Defining a custom "reduce" on your view
+    
+    Given a Article model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+        end
+      """
+
+    When I define a map over labels with a custom reduce that always returns -1:
+      """
+        Article.couch_view do
+          map :label
+          reduce <<-JS
+            function(key, values){
+              return -1;
+            }
+          JS
+        end
+      """
+
+    Then my model should respond to `reduce_by_label`:
+      """
+        Article.should respond_to(:reduce_by_label)
+      """
+
+    And my model should not respond to `count_by_label`:
+      """
+        Article.should_not respond_to(:count_by_label)
+      """
+
+    When I create two articles with the same label:
+      """
+        2.times { Article.create :label => "moonmaster9000-rocks" }
+      """
+
+    Then `reduce_by_label` should return -1:
+      """
+        Article.reduce_by_label!['rows'].first['value'].should == -1
+      """
+  
+  @db @focus
+  Scenario: Giving your view a custom name
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+        end
+      """
+    
+    When I call "couch_view" with a custom name "over_label" and specify a map over labels in a block:
+      """
+        Article.couch_view :over_label do
+          map :label
+        end
+      """
+
+    Then my model should respond to "map_over_label" and "count_over_label":
+      """
+        Article.should respond_to(:map_over_label)
+        Article.should respond_to(:map_over_label!)
+
+        Article.should respond_to(:count_over_label)
+        Article.should respond_to(:count_over_label!)
+      """
+
+    But my model should not respond to "map_by_label" or "count_by_label":
+      """
+        Article.should_not respond_to(:map_by_label)
+        Article.should_not respond_to(:map_by_label!)
+
+        Article.should_not respond_to(:count_by_label)
+        Article.should_not respond_to(:count_by_label!)
+      """
+
+    When I create two articles with labels:
+      """
+        Article.create :label => "hi"
+        Article.create :label => "there"
+      """
+
+    Then "map_over_label" should return them:
+      """
+        Article.map_over_label!.collect(&:label).should == ["hi", "there"]
+      """
+
+    And "count_over_label" should return 2:
+      """
+        Article.count_over_label!.should == 2
+      """

data/features/couch_view.map.feature

@@ -0,0 +1,117 @@
+Feature: CouchView::Map
+  As a programmer
+  I want a `CouchView::Map` mixin
+  So that I can create a class with a CouchDB map function
+
+
+  Scenario: Mixing CouchView::Map into a class should generate a map over ids
+
+    Given the following class definition:
+      """
+        class Map
+          include CouchView::Map
+        end
+      """
+
+    When I instantiate a new Map:
+      """
+        Map.new.map
+      """
+
+    Then I should receive the following CouchDB javascript map:
+      """
+        function(doc){
+          emit(doc._id, null)
+        }
+      """
+
+  Scenario: Instantiating a Map with a Model should generate a map over that model
+
+    Given the following model definition:
+      """
+        class Article < CouchRest::Model::Base
+        end
+      """
+
+    And the following map definition:
+      """
+        class Map
+          include CouchView::Map
+        end
+      """
+
+    When I instantiate a new Map with Article: 
+      """
+        Map.new(Article).map
+      """
+
+    Then I should receive the following map over the Article documents:
+      """
+        function(doc){
+          if (doc['couchrest-type'] == 'Article')
+            emit(doc._id, null)
+        }
+      """ 
+
+
+  Scenario: Defining a custom map 
+
+    Given the the following custom map:
+      """
+        class ByLabel
+          include CouchView::Map
+
+          def map
+            "
+              function(doc){
+                if (#{conditions})
+                  emit(doc.label, null)
+              }
+            "
+          end
+        end
+      """
+
+    When I instantiate a new ByLabel map:
+      """
+        ByLabel.new.map
+      """
+
+    Then I should receive a CouchDB javascript map over the labels:
+      """
+        function(doc){
+          if (true)
+            emit(doc.label, null)
+        }
+      """
+
+
+  Scenario: Decorating a map with conditions
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    And the following module:
+      """
+        module Published
+          def conditions
+            "#{super} && doc.published"
+          end
+        end
+      """
+
+    When I instantiate my map, extend it with my module, and call map:
+      """
+        ById.new.extend(Published).map
+      """
+
+    Then I should receive a CouchDB javascript map function over the published documents:
+      """
+        function(doc){
+          if (true && doc.published)
+            emit(doc._id, null)
+        }
+      """

data/features/couch_view.proxy.feature

@@ -0,0 +1,236 @@
+Feature: CouchView::Proxy
+
+  A proxy object that lets you lazily build CouchDB map queries.
+
+
+  h2. Creating a map proxy
+
+  To create a new map proxy, simply instantiate `CouchView::Proxy` with the model to call on, and the map to call:
+      
+      proxy = CouchView::Proxy.new Article, :by_id
+
+
+  h2. Adding CouchDB query parameters to the proxy
+
+  You can add CouchDB query parameters to your view proxy by calling their corresponding methods on the proxy. 
+
+  For example, suppose we'd like to limit the results of our query to 10 documents:
+
+      proxy.limit(10)
+
+  This will return a new proxy that's just like the original proxy, except that it will also include a `limit=10` query string parameter when making a call to CouchDB.
+
+  If you'd rather update the existing proxy, instead of getting a new one, you can append a "!" onto the end:
+
+      proxy.limit!(10)
+
+
+  h2. Modifying the map to call
+
+  You can modify the map to call by calling a method that doesn't correspond to a CouchDB view query parameter. 
+
+  For example, suppose our `Article` model responded to `by_label` and `by_label_published`:
+
+      proxy = CouchView::Proxy.new Article, :by_label
+
+      proxy._map #==> :by_label
+
+      proxy.published!
+
+      proxy._map #==> :by_label_published
+
+  If you call several methods on your proxy that don't correspond to CouchDB query parameters, then the proxy will alpha-sort them to generate the view name to call:
+
+      proxy = CouchView::Proxy.new Article, :by_label
+
+      proxy.published!.visible!.active!
+
+      proxy._map #==> :by_label_active_published_visible
+
+
+  h2. Triggering the call
+
+  You can trigger a call on a map proxy by calling either the `.each` method or the `get!` method:
+
+      proxy = CouchView::Proxy.new Article, :by_label
+      
+      proxy.each {...} #==> executes "Article.by_label"
+      proxy.get!       #==> executes "Article.by_label"
+
+
+  
+  Scenario: Creating a map proxy
+
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Proxy.new Article, :by_id
+      """
+
+    Then the "_map" method should return ":by_id":
+      """
+        @proxy._map.should == :by_id
+      """
+
+    And the "_model" method should return "Article":
+      """
+        @proxy._model.should == Article
+      """
+
+    And the "_options" method should return the default map option of `:reduce => false`:
+      """
+        @proxy._options.should == {:reduce => false}
+      """
+
+
+  Scenario: Generating a new proxy by adding a query option
+
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Proxy.new Article, :by_id
+      """
+
+    And I limit the results to 10:
+      """
+        @new_proxy = @proxy.limit 10
+      """
+
+    Then @new_proxy should be a new object:
+      """
+        @new_proxy.object_id.should_not == @proxy.object_id
+      """
+
+    And the "_options" method on @new_proxy should return a limit of 10:
+      """
+        @new_proxy._options.should == {:reduce => false, :limit => 10} 
+      """
+
+    And the "_options" method on the @proxy should return the default map option of `:reduce => false`:
+      """
+        @proxy._options.should == {:reduce => false}
+      """
+
+
+  Scenario: Destructively modifying the existring query by adding a query option with an exclamation point at the end
+
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Proxy.new Article, :by_id
+      """
+
+    And I destructively limit the results to 10:
+      """
+        @new_proxy = @proxy.limit! 10
+      """
+
+    Then @new_proxy should not be a new object:
+      """
+        @new_proxy.object_id.should == @proxy.object_id
+      """
+
+    And the "_options" method on the new proxy should return a limit of 10:
+      """
+        @proxy._options.should == {:reduce => false, :limit => 10} 
+      """
+
+
+  Scenario: The map name should include alpha-sorted conditions
+
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Proxy.new Article, :by_id
+      """
+
+    And I call the published! method on the proxy:
+      """
+        @proxy.published!
+      """
+
+    Then the "_map" method should return ":by_id_published":
+      """
+        @proxy._map.should == :by_id_published
+      """
+
+    When I call the active! method on the proxy:
+      """
+        @proxy.active!
+      """
+
+    Then the "_map" method should return ":by_id_active_published":
+      """
+        @proxy._map.should == :by_id_active_published
+      """
+
+    When I call the visible! method on the proxy:
+      """
+        @proxy.visible!
+      """
+
+    Then the "_map" method should return ":by_id_active_published_visible": 
+      """
+        @proxy._map.should == :by_id_active_published_visible
+      """
+  
+  @db
+  Scenario: Executing the proxy with "get!" or "each!"
+    
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Proxy.new Article, :by_id
+      """
+
+    And I call the "get!" method on the proxy
+      """
+        @call = proc { @proxy.get! }
+      """
+
+    Then the proxy should call the ":by_id" method on the Article model:
+      """
+        Article.should_receive(:by_id)
+        @call.call
+      """
+
+    When I call the "each" method on the proxy
+      """
+        Article.should_receive(:by_id).and_return ["result"]
+        @call = proc { @proxy.each {|a| a.should == "result"} }
+      """
+
+    Then the proxy should call the ":by_id" method on the Article model: 
+      """
+        @call.call
+      """