couch_view 0.0.1

data/features/couch_view.array.feature

@@ -0,0 +1,28 @@
+Feature: All subsets of an array
+
+
+  Scenario: Generating all subsets of an array
+    
+    Given an array of 3 elements:
+      """
+      @array = [1,2,3]
+      """
+
+    When I call the "all_combinations" method on it:
+      """
+      @result = @array.all_combinations
+      """
+
+    Then I should receive all of the subsets of my array:
+      """
+        @result.should == [
+          [],
+          [1],
+          [2],
+          [3],
+          [1,2],
+          [1,3],
+          [2,3],
+          [1,2,3]
+        ]
+      """

data/features/couch_view.config.feature

@@ -0,0 +1,396 @@
+Feature: CouchView::Config
+  
+  A `CouchView::Config` consists of the following data:
+    * a CouchView::Map
+    * the conditions (if any) with which to extend that map
+    * the names of the views
+    * the reduce for the view
+    * the base name of the view
+
+  When you instantiate a CouchView::Config, you must provide both the model and the properties to map over:
+      
+      class Article < CouchRest::Model::Base; end
+
+      config = CouchView::Config.new Article
+      config.map :prop1, :prop2
+      config.view_names #==> ["by_prop1_and_prop2"]
+      config.base_view_name #==> "by_prop1_and_prop2"
+      config.model #==> Article
+
+  You could, alternatively, provide it with a model and a CouchView::Map class:
+      
+      class ById; include CouchView::Map; end
+      config = CouchView::Config.new Article
+      config.map ById
+      config.view_names   #==> ["by_id"]
+      config.model  #==> Article
+
+  By default, a `CouchView::Config` will assume a reduce of `_count`:
+      
+      config.reduce #==> "_count"
+
+  You can override this by supplying your own reduce:
+      
+      config.reduce "function(key, values){}"
+      config.reduce #==> "function(key, values){}" 
+
+  The base name of your view is generated by the parameters passed to the "map" method.
+
+  If you want to override that, you can pass a new name to the "base_view_name" method:
+      
+      config.base_view_name "funny"
+
+  Lastly, you can provide your `CouchView::Config` with conditions:
+
+      module Published
+        def conditions
+          "#{super} && doc.published == true"
+        end
+      end
+
+      config.conditions Published
+      config.conditions #==> [Published]
+
+  You could also add conditions by passing a block to the map method:
+      
+      config.map :label do
+        conditions Published
+      end
+  
+  You can now ask your `Config` to return a hash containing all of the views (with their corresponding map/reduce) that you should setup on your model:
+
+      class Article < CouchRest::Model::Base
+        property :label
+        property :published, TrueClass, :default => false
+      end
+      
+      config = CouchView::Config.new Article
+      config.map :label
+      
+      module Published
+        def conditions
+          "#{super} && doc.published == true"
+        end
+      end
+
+      config.conditions Published
+
+      config.views #==> 
+        {
+          "by_label" => {
+            "map" => "function....",
+            "reduce" => "_count"
+          },
+          "by_label_published" => {
+            "map" => "function....",
+            "reduce" => "_count"
+          }
+        }
+
+
+  @db
+  Scenario: Generating a name based on the properties passed in to map over
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+          property :name
+        end
+      """
+
+    When I create a CouchView::Config to map over Article labels:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label
+      """
+
+    Then the config should report "by_label" as a view name:
+      """
+        @config.view_names.should == ["by_label"]
+      """
+
+    When I create a CouchView::Config to map over Article labels and names:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label, :name
+      """
+
+    Then the config should report "by_label" as a view name:
+      """
+        @config.view_names.should == ["by_label_and_name"]
+      """
+    
+    When I create a CouchView::Map `ById`:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    And I create a CouchView::Config to map over article documents `ById`:
+      """
+        @config = CouchView::Config.new Article
+        @config.map ById
+      """
+
+    Then the config should report "by_id" as a view name:
+      """
+        @config.view_names.should == ["by_id"]
+      """
+
+
+  @db
+  Scenario: Setting a custom reduce
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+          property :name
+        end
+      """
+
+    When I create a CouchView::Config to map over Article labels:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label
+      """
+
+    Then the config should default the "reduce" to "_count":
+      """
+        @config.reduce.should == "_count"
+      """
+
+    When I change the "reduce" to a javascript function:
+      """
+        @config.reduce "function(key, values){}"
+      """
+
+    Then the config should return that function for the "reduce":
+      """
+        @config.reduce.should == "function(key, values){}" 
+      """
+
+  
+  @db
+  Scenario: Setting conditions on the view
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+          property :name
+        end
+      """
+    
+    And 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 create a CouchView::Config to map over Article labels:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label
+      """
+
+    And I add the Published and Visible conditions to it:
+      """
+        @config.conditions Published, Visible
+      """
+
+    Then the conditions should be Published and Visible:
+      """
+        @config.conditions.should == [Published, Visible]
+      """
+
+    And the view names should include views for published, visible, and published/visible documents:
+      """
+        @config.view_names.sort.should == ["by_label", "by_label_published", "by_label_published_visible", "by_label_visible"]
+      """
+    
+
+  @db @focus
+  Scenario: Creating conditions by passing a block to the map
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base; end
+      """
+    
+    And 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 create a view config and specify conditions in a block on the `map` method:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label do
+          conditions Published, Visible
+        end
+      """
+
+    Then the conditions method on my config should return the conditions specified:
+      """
+        @config.conditions.should == [Published, Visible] 
+      """
+
+  @db
+  Scenario: Getting all the views
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+          property :name
+        end
+      """
+    
+    And 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 create a CouchView::Config to map over Article labels:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label
+      """
+
+    And I add the Published and Visible conditions to it:
+      """
+        @config.conditions Published, Visible
+      """
+
+    Then the views should include a "by_label" view:
+      """
+        @config.views[:by_label][:map].should == 
+              "
+                function(doc){
+                  if (doc['couchrest-type'] == 'Article')
+                    emit(doc.label, null)
+                }
+              "
+        @config.views[:by_label][:reduce].should == "_count"
+      """
+
+    And the views should include a "by_label_published" view:
+      """
+        @config.views[:by_label_published][:map].should == 
+              "
+                function(doc){
+                  if (doc['couchrest-type'] == 'Article' && doc.published == true)
+                    emit(doc.label, null)
+                }
+              "
+        @config.views[:by_label_published][:reduce].should == "_count"
+      """
+
+    And the views should include a "by_label_visible" view:
+      """
+        @config.views[:by_label_visible][:map].should == 
+              "
+                function(doc){
+                  if (doc['couchrest-type'] == 'Article' && doc.visible == true)
+                    emit(doc.label, null)
+                }
+              "
+        @config.views[:by_label_visible][:reduce].should == "_count"
+      """
+
+    And the views should include a "by_label_published_visible" view:
+      """
+        @config.views[:by_label_published_visible][:map].should == 
+              "
+                function(doc){
+                  if (doc['couchrest-type'] == 'Article' && doc.published == true && doc.visible == true)
+                    emit(doc.label, null)
+                }
+              "
+        @config.views[:by_label_published_visible][:reduce].should == "_count"
+      """
+
+
+  @db @focus
+  Scenario: Giving your view a custom base name
+    
+    Given the following model:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          property :label
+          property :name
+        end
+      """
+    
+    And 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 create a CouchView::Config to map over Article labels:
+      """
+        @config = CouchView::Config.new Article
+        @config.map :label
+      """
+
+    And I give it a base name of "funny":
+      """
+        @config.base_view_name "funny"
+      """
+
+    And I add the Published and Visible conditions to it:
+      """
+        @config.conditions Published, Visible
+      """
+
+    Then the view names should include "funny" views for published, visible, and published/visible documents:
+      """
+        @config.view_names.sort.should == ["funny", "funny_published", "funny_published_visible", "funny_visible"]
+      """

data/features/couch_view.count.proxy.feature

@@ -0,0 +1,284 @@
+Feature: CouchView::Count::Proxy
+  
+  A `CouchView::Count::Proxy` is like a regular `CouchView::Proxy`, except that it defaults the CouchDB "reduce" option to "true".
+
+      proxy = CouchView::Count::Proxy SomeModel, :some_view
+      proxy._options #==> { "reduce" => true }
+
+  Another noticable difference: you can't call ".each" on the proxy unless you've set the "group" option to "true":
+      
+      proxy = CouchView::Count::Proxy SomeModel, :some_view
+
+      proxy.each {...} #==> raises an exception "You can't call 'each' on a count proxy that doesn't set 'group' to 'true'."
+
+  If you've set "group" to true, then when you call ".each" on it, you will iterate over the key/value pairs in the response:
+
+      proxy.group(true).each do |key, value|
+        ...
+      end
+
+  If you'd rather work with the raw (hash) response on a group level query, simply use the "get!" method:
+
+      proxy.get!
+
+  If you're not running a group level query, then "get!" will return the actual count (`Fixnum`):
+
+      proxy = CouchView::Count::Proxy SomeModel, :some_view
+      proxy.get! #==> 0, or some other positive integer
+
+
+  @db
+  Scenario: Options default to "reduce" => true
+    
+    Given an Article model with a view "by_id":
+      """
+        class Article < CouchRest::Model::Base
+          view_by :id
+        end
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_id
+      """
+
+    Then the options on the proxy should default to "reduce" => true
+      """
+        @proxy._options.should == {:reduce => true}
+      """
+
+
+  @db
+  Scenario: ".each" should iterate over the key/value pairs of the 'rows' result:
+    
+    Given the following map definition:
+      """
+        class ByLabel
+          include CouchView::Map
+
+          def map
+            "
+              function(doc){
+                if (#{conditions})
+                  emit(doc.label, null)
+              }
+            "
+          end
+        end
+      """
+
+    And an Article model that maps ByLabel:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ByLabel
+        end
+      """
+
+    And several articles:
+      """
+        Article.create :label => "fun-article"
+        Article.create :label => "awesome-article"
+        Article.create :label => "awesome-article"
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_by_label
+      """
+
+    And I set the CouchDB "group" query option to "true":
+      """
+        @proxy.group! true
+      """
+
+    Then the ".each" method should iterate over the keys and values in the 'rows' array in the query response: 
+      """
+        @results = []
+        @proxy.each {|label, count| @results << {label => count}}
+        @results.first.should == {"awesome-article" => 2}
+        @results.last.should  == {"fun-article"     => 1}
+        @results.count.should == 2
+      """
+
+
+  @db @focus
+  Scenario: ".get!" should return 0 when the reduce returns an empty 'rows' response:
+    
+    Given the following map definition:
+      """
+        class ByLabel
+          include CouchView::Map
+
+          def map
+            "
+              function(doc){
+                if (#{conditions})
+                  emit(doc.label, null)
+              }
+            "
+          end
+        end
+      """
+
+    And an Article model that maps ByLabel:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ByLabel
+        end
+      """
+
+    And there are no articles:
+      """
+        Article.all.count.should == 0
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_by_label
+      """
+
+    Then the ".get!" method should return 0: 
+      """
+        @proxy.get!.should == 0
+      """
+
+
+  @db @focus
+  Scenario: ".get!" should return the 'value' of the first row of the 'rows' reduce response:
+    
+    Given the following map definition:
+      """
+        class ById
+          include CouchView::Map
+        end
+      """
+
+    And an Article model that maps ByLabel:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ById
+        end
+      """
+
+    And there are 2 articles:
+      """
+        2.times { Article.create }
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_by_id":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_by_id
+      """
+
+    Then the ".get!" method should return 2: 
+      """
+        @proxy.get!.should == 2
+      """
+
+
+ 
+  @db @focus
+  Scenario: ".get!" should return the raw JSON (hash) response from CouchDB for a group query:
+    
+    Given the following map definition:
+      """
+        class ByLabel
+          include CouchView::Map
+
+          def map
+            "
+              function(doc){
+                if (#{conditions})
+                  emit(doc.label, null)
+              }
+            "
+          end
+        end
+      """
+
+    And an Article model that maps ByLabel:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ByLabel
+        end
+      """
+
+    And several articles:
+      """
+        Article.create :label => "fun-article"
+        Article.create :label => "awesome-article"
+        Article.create :label => "awesome-article"
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_id":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_by_label
+      """
+
+    And I set the CouchDB "group" query option to "true":
+      """
+        @proxy.group! true
+      """
+
+    Then the ".get!" method should return the raw JSON response from CouchDB as a hash: 
+      """
+        @proxy.get!.should == {
+          "rows" => [
+            { "key" => "awesome-article", "value" => 2 },
+            { "key" => "fun-article",     "value" => 1 }
+          ]
+        }
+      """
+ 
+
+  @db
+  Scenario: You can't call ".each" on a count proxy unless the CouchDB "group" option is set to true
+    
+    Given the following map definition:
+      """
+        class ByLabel
+          include CouchView::Map
+
+          def map
+            "
+              function(doc){
+                if (#{conditions})
+                  emit(doc.label, null)
+              }
+            "
+          end
+        end
+      """
+
+    And an Article model that maps ByLabel:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchView
+          map ByLabel
+        end
+      """
+
+    When I instantiate a new CouchView::Map::Proxy with "Article" and ":by_label":
+      """
+        @proxy = CouchView::Count::Proxy.new Article, :by_by_label
+      """
+    
+    Then ".each" should raise an exception:
+      """
+        proc { @proxy.each {|k,v|} }.should raise_exception("You can't call 'each' on a count proxy that doesn't set 'group' to 'true'.")
+      """
+    
+    When I set the CouchDB "group" query option to "true":
+      """
+        @proxy.group!(true)
+      """
+
+    Then ".each" should not raise an exception:
+      """
+        proc { @proxy.each {|k,v|} }.should_not raise_exception
+      """
+