couch_view 0.0.3 → 0.1.0

data/features/couch_view.conditions.feature

@@ -0,0 +1,142 @@
+Feature: CouchView::Config::Conditions
+  
+  CouchView::Config::Conditions are a simple way to keep track of the conditions in a view configuration.
+
+  h2. Instantiation
+
+  To create a new CouchView::Config::Conditions instance, simply call ".new" on it.
+
+  During instantiation, you can pass some modules to it representing conditions:
+      
+      conditions_config = CouchView::Config::Conditions.new Condition1, Condition2
+
+  h2. Adding conditions
+
+  You can add more conditions to it by passing them to the "add_conditions":
+      
+      conditions_config.add_conditions Condition3, Condition4
+
+  If you add a condition that's namespaced, the name of the condition will be defaulted to the unqualified class name:
+      
+      conditions_config.add_condition Namespace::Subspace::ConditionX
+
+      conditions_Config.conditions[:condition_x] #==> Namespace::Subspace::ConditionX
+
+  h2. Adding named conditions
+
+  You can add named conditions to your config by calling a method on them with the name you want to reference the condition by:
+
+      conditions_config.published Conditions::Published
+
+  h2. Getting all of the conditions
+
+  If you call the "conditions" method without any arguments, you'll receive a hash of all of the conditions. The key is the name of a condition, the value is the condition module.
+
+      #conditions_config.conditions
+      #  #==> {
+      #      :condition1 => Condition1,
+      #      :condition2 => Condition2,
+      #      :condition3 => Condition3,
+      #      :condition4 => Condition4,
+      #      :published  => Conditions::Published
+      #    }
+
+
+  Scenario: Conditions passed during CouchView::Config::Conditions instantiation
+    Given the following conditions:
+      """
+        module Published; end
+        module Visible; end
+      """
+
+    When I instantiate a CouchView::Config::Conditions object and pass those condition modules to it:
+      """
+        @conditions_config = CouchView::Config::Conditions.new Published, Visible
+      """
+
+    Then the "conditions" method on the config should return those conditions:
+      """
+        @conditions_config.conditions.should == {
+          :published => Published, 
+          :visible => Visible
+        }
+      """
+
+
+  Scenario: Adding conditions after instantiation
+    Given the following conditions:
+      """
+        module Published; end
+        module Visible; end
+      """
+
+    And a CouchView::Config::Conditions object:
+      """
+        @conditions_config = CouchView::Config::Conditions.new
+      """
+
+    When I pass those condition modules to the condition config object's "add_conditions" method:
+      """
+        @conditions_config.add_conditions Published, Visible
+      """
+
+    Then the "conditions" method on the config should return those conditions:
+      """
+        @conditions_config.conditions.should == {
+          :published => Published, 
+          :visible => Visible
+        }
+      """
+
+  Scenario: Creating named conditions
+    Given the following conditions:
+      """
+        module Published; end
+        module Visible; end
+      """
+
+    And a CouchView::Config::Conditions object:
+      """
+        @conditions_config = CouchView::Config::Conditions.new
+      """
+
+    When I add those conditions to my config with custom names:
+      """
+        @conditions_config.filter_by_published Published
+        @conditions_config.filter_by_visible Visible
+      """
+
+    Then the "conditions" method on the config should return those conditions:
+      """
+        @conditions_config.conditions.should == {
+          :filter_by_published => Published, 
+          :filter_by_visible => Visible
+        }
+      """
+
+  Scenario: Namespaced conditions get unqualified keys
+    Given the following conditions:
+      """
+        module Conditions
+          module Published; end
+          module Visible; end
+        end
+      """
+
+    And a CouchView::Config::Conditions object:
+      """
+        @conditions_config = CouchView::Config::Conditions.new
+      """
+
+    When I pass those condition modules to the condition config object's "add_conditions" method:
+      """
+        @conditions_config.add_conditions Conditions::Published, Conditions::Visible
+      """
+
+    Then the "conditions" method on the config should return those conditions:
+      """
+        @conditions_config.conditions.should == {
+          :published => Conditions::Published, 
+          :visible => Conditions::Visible
+        }
+      """

data/features/couch_view.config.feature

@@ -92,11 +92,11 @@ Feature: CouchView::Config
       
       config = CouchView::Config.new Article
       config.conditions Published
-      config.conditions #==> [Published]
+      config.conditions #==> {:published => Published}
       condig.conditions Visible
-      config.conditions #==> [Published, Visible]
+      config.conditions #==> {:published => Published, :visible => Visible}
       config.conditions Published
-      config.conditions #==> [Published, Visible]
+      config.conditions #==> {:published => Published, :visible => Visible}
 
   @db
   Scenario: Generating a name based on the properties passed in to map over
@@ -225,7 +225,7 @@ Feature: CouchView::Config
 
     Then the conditions should be Published and Visible:
       """
-        @config.conditions.should == [Published, Visible]
+        @config.conditions.should == {:published => Published, :visible => Visible}
       """
 
     And the view names should include views for published, visible, and published/visible documents:
@@ -267,7 +267,7 @@ Feature: CouchView::Config
 
     Then the conditions method on my config should return the conditions specified:
       """
-        @config.conditions.should == [Published, Visible] 
+        @config.conditions.should == {:published => Published, :visible => Visible}
       """
 
   @db
@@ -439,11 +439,11 @@ Feature: CouchView::Config
     Then adding the same condition multiple times will result in the condition only being added once:
       """
         @config.conditions Published
-        @config.conditions.should == [Published]
+        @config.conditions.should == {:published => Published}
         @config.conditions Visible
-        @config.conditions.should == [Published, Visible]
+        @config.conditions.should == {:published => Published, :visible => Visible}
         @config.conditions Published
-        @config.conditions.should == [Published, Visible]
+        @config.conditions.should == {:published => Published, :visible => Visible}
         @config.conditions Visible
-        @config.conditions.should == [Published, Visible]
+        @config.conditions.should == {:published => Published, :visible => Visible}
       """

data/features/couch_view.feature

@@ -92,6 +92,67 @@ Feature: CouchView
           ["published_and_visible"]
       """
 
+  
+  @focus
+  Scenario: Define a map on your model with named conditions
+    Given the following conditions:
+      """
+        module Conditions
+          module Published
+            def conditions
+              "#{super} && doc.published == true"
+            end
+          end
+          
+          module Visible
+            def conditions
+              "#{super} && doc.visible == true"
+            end
+          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 do
+              filter_by_published  Conditions::Published
+              filter_by_visible    Conditions::Visible
+            end
+          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.filter_by_published.get!.collect(&:label).sort.should == 
+          ["published", "published_and_visible"]
+        
+        Article.map_by_label.filter_by_visible.get!.collect(&:label).sort.should == 
+          ["published_and_visible", "visible"]
+        
+        Article.map_by_label.filter_by_published.filter_by_visible.get!.collect(&:label).sort.should == 
+          ["published_and_visible"]
+      """
+
 
   Scenario: Define a map on your model with the `map` class method
     Given the following map definition:
@@ -354,7 +415,6 @@ Feature: CouchView
       """
 
 
-  @focus
   Scenario: Chaining together multiple conditions by defining a map multiple times
     
     Given the following model:

data/features/step_definitions/couch_view.conditions.rb

@@ -0,0 +1,11 @@
+Given /^a CouchView::Config::Conditions object:$/ do |string|
+  eval string
+end
+
+When /^I pass those condition modules to the condition config object's .*:$/ do |string|
+  eval string
+end
+
+When /^I add those conditions to my config with custom names:$/ do |string|
+  eval string
+end

data/lib/couch_view/conditions.rb

@@ -0,0 +1,37 @@
+module CouchView
+  class Config
+    class Conditions
+      attr_reader :conditions
+
+      def initialize(*conditions)
+        @conditions = {}
+        add_condition_modules conditions
+      end
+
+      def add_conditions(*args)
+        add_condition_modules args
+      end
+
+      alias :add_condition :add_conditions
+
+      def method_missing(condition_name, *args, &block)
+        super if block
+        super unless args.count == 1
+
+        add_condition_module condition_name, args.first
+      end
+
+      private
+      def add_condition_modules(condition_modules)
+        condition_modules.each do |condition_module|
+          condition_name = condition_module.to_s.underscore.gsub(/^.*\/([^\/]+)$/) { $1 }
+          add_condition_module condition_name, condition_module
+        end
+      end
+
+      def add_condition_module(condition_name, condition_module)
+        @conditions[condition_name.to_sym] = condition_module
+      end
+    end
+  end
+end

data/lib/couch_view/config.rb

@@ -4,7 +4,7 @@ module CouchView
 
     def initialize(model_class)
       @model     = model_class
-      @conditions = []
+      @conditions = CouchView::Config::Conditions.new
     end
 
     def map(*args, &block)
@@ -20,12 +20,12 @@ module CouchView
       end
     end
 
-    def conditions(*args)
-      if args.empty?
-        @conditions
+    def conditions(*args, &block)
+      if args.empty? && block.nil?
+        @conditions.conditions
       else
-        @conditions += args
-        @conditions.uniq!
+        @conditions.add_conditions *args
+        @conditions.instance_eval &block if block
       end
     end
 
@@ -57,17 +57,17 @@ module CouchView
 
     private
     def condition_views
-      all_condition_subsets = @conditions.all_combinations.reject &:empty?
+      all_condition_subsets = @conditions.conditions.keys.all_combinations.reject &:empty?
 
       all_condition_subsets.reject(&:empty?).inject({}) do |result, condition_combination|
         condition_combination.sort! {|a,b| a.to_s <=> b.to_s}
         
         view_name = 
           "#{base_view_name}_" + 
-          condition_combination.map {|condition| condition.to_s.underscore}.join("_")
+          condition_combination.map {|condition| condition.to_s}.join("_")
 
         map_instance = @map_class.new @model, *@properties
-        condition_combination.map { |condition| map_instance.extend condition }
+        condition_combination.map { |condition| map_instance.extend @conditions.conditions[condition] }
 
         result[view_name.to_sym] = {
           :map => map_instance.map,

data/lib/couch_view.rb

@@ -8,3 +8,4 @@ require 'couch_view/map_property'
 require 'couch_view/count_proxy'
 require 'couch_view/query_options'
 require 'couch_view/array'
+require 'couch_view/conditions'

data/readme.markdown

@@ -15,7 +15,7 @@ This gem integrates with the `couchrest_model` gem (version ~> 1.0.0)
 Install it as a gem:
 
 ```sh
-    $ gem install couch_view
+$ gem install couch_view
 ```
 
 ## Your first view
@@ -25,28 +25,28 @@ Let's imagine that we want to create a map on our model that includes all of the
 We can start by simply calling the "map" method on our model, passing in the :label property:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
-      
-      property :label
+class Article < CouchRest::Model::Base
+  include CouchView
+  
+  property :label
 
-      map :label
-    end
+  map :label
+end
 ```
 
 This will generate a javascript map function that looks like this:
 
 ```javascript
-    function(doc){
-      if (doc['couchrest-type'] == 'Article')
-        emit(doc.label, null)
-    }
+function(doc){
+  if (doc['couchrest-type'] == 'Article')
+    emit(doc.label, null)
+}
 ```
 
 We can query this map by using the "map_by_label!" method:
 
 ```ruby
-    Article.map_by_label! #==> all of the articles, in order of label
+Article.map_by_label! #==> all of the articles, in order of label
 ```
 
 You can use any of the standard CouchDB query options on this view; see the section "Query Proxy" for more information.
@@ -54,28 +54,28 @@ You can use any of the standard CouchDB query options on this view; see the sect
 We can also count all of the articles in the "by_label" map using the `count_by_label!` method:
 
 ```ruby
-    Article.count_by_label! #==> 0, assuming we haven't created any articles
+Article.count_by_label! #==> 0, assuming we haven't created any articles
 ```
 
 Next, let's imagine that we'd like to create a view with a compound key: let's index all of the articles in the system by author and created_at:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
-      property :author
-      timestamps!
+class Article < CouchRest::Model::Base
+  include CouchView
+  property :author
+  timestamps!
 
-      map :author, :created_at
-    end
+  map :author, :created_at
+end
 ```
 
 And it's as simple as that. `CouchView` generated the following javascript map function:
 
 ```javascript
-    function(doc){
-      if (doc['couchrest-type'] == 'Article')
-        emit([doc.author, doc.created_at], null)
-    }
+function(doc){
+  if (doc['couchrest-type'] == 'Article')
+    emit([doc.author, doc.created_at], null)
+}
 ```
 
 We can now iterate over the map using the `map_by_author_and_created_at!` method, and we can count it using the `count_by_author_and_created_at!` method.
@@ -87,48 +87,48 @@ But what if you need to create a more complex view? `CouchView` is your friend h
 We'll start by creating a map class:
 
 ```ruby
-    class ByCommentCount
-      include CouchView::Map
-
-      def map
-        <<-JS
-          function(doc){
-            if (#{conditions})
-              emit(doc.comments.length, null)
-          }
-        JS
-      end
-    end
+class ByCommentCount
+  include CouchView::Map
+
+  def map
+    <<-JS
+      function(doc){
+        if (#{conditions})
+          emit(doc.comments.length, null)
+      }
+    JS
+  end
+end
 ```
 
 Notice that we call the "conditions" method inside of our map. This method is mixed into our class by the `CouchView::Map` module. You'll learn how this method allows us to decorate our views with conditions in the next section. For now, let's see what happens if we simply instantiate this class and call the "map" method on it:
 
 ```ruby
-    ByCommentCount.new.map #==> 
-      "
-        function(doc){
-          emit(doc.comments.length, null)
-        }
-      "
+ByCommentCount.new.map #==> 
+  "
+    function(doc){
+      emit(doc.comments.length, null)
+    }
+  "
 ```
 
 Well that's not very interesting... However, what if we use this map in a model?
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
-      property :comments, [String]
-      map ByCommentCount
-    end
+class Article < CouchRest::Model::Base
+  include CouchView
+  property :comments, [String]
+  map ByCommentCount
+end
 ```
 
 Now, CouchView will generate a map function on our Article design document that will look like this:
 
 ```javascript
-    function(doc){
-      if (doc['couchrest-type'] == 'Article')
-        emit(doc.comments.length, null)
-    }
+function(doc){
+  if (doc['couchrest-type'] == 'Article')
+    emit(doc.comments.length, null)
+}
 ```
 
 Similar to before, we can query this index with `map_by_comment_count!` and `count_by_comment_count!`.
@@ -141,6 +141,59 @@ Next, let's imagine that sometimes we'd like to constrain our Article views to p
 To start, let's define the following condition modules:
 
 ```ruby
+module WebExclusive
+  def conditions
+    "#{super} && doc.web_exclusive == true"
+  end
+end
+
+module Published
+  def conditions
+    "#{super} && doc.published == true"
+  end
+end
+```
+
+We can then add them into our map definitions thusly:
+
+```ruby
+class Article < CouchRest::Model::Base
+  include CouchView
+
+  property :label
+  property :web_exclusive,  TrueClass, :default => false
+  property :published,      TrueClass, :default => false
+
+  map :label do
+    conditions WebExclusive, Published
+  end
+end
+```
+
+Now, we can constrain our `map_by_label` query proxy to consider only web exlusive articles, published articles, or both:
+
+```ruby
+Article.map_by_label.published.get!               
+  #==> published articles ordered by label
+
+Article.map_by_label.web_exclusive.get!           
+  #==> web exclusive articles ordered by label
+
+Article.map_by_label.published.web_exclusive.get! 
+  #==> published, web exclusive articles ordered by label
+```
+
+### Naming conditions
+
+By default, the conditions were named after the module (i.e., "web_exclusive" for WebExclusive, "published" for Published).
+
+In a real app, it's likely that you'll end up namespacing your condition modules, in which case, the autogenerated names for your modules won't work. 
+
+Let's go back to our article example, and imagine that we namespaced our conditions under "Article::Conditions":
+
+```ruby
+class Article
+  module Conditions
     module WebExclusive
       def conditions
         "#{super} && doc.web_exclusive == true"
@@ -152,38 +205,37 @@ To start, let's define the following condition modules:
         "#{super} && doc.published == true"
       end
     end
+  end
+end
 ```
 
-We can then add them into our map definitions thusly:
+If we added these conditions to a map, the condition names would not be qualified.
+
+If you'd prefer that they be qualified, you'll need to tell `couch_view` what to name them:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
+class Article < CouchRest::Model::Base
+  include CouchView
 
-      property :label
-      property :web_exclusive,  TrueClass, :default => false
-      property :published,      TrueClass, :default => false
+  property :label
+  property :web_exclusive,  TrueClass, :default => false
+  property :published,      TrueClass, :default => false
 
-      map :label do
-        conditions WebExclusive, Published
-      end
+  map :label do
+    conditions do
+      filter_by_web_exclusive Conditions::WebExclusive
+      filter_by_published     Conditions::Published
     end
+  end
+end
 ```
 
-Now, we can constrain our `map_by_label` query proxy to consider only web exlusive articles, published articles, or both:
+Now you can use these conditions on your proxy:
 
 ```ruby
-    Article.map_by_label.published.get!               
-      #==> published articles ordered by label
-    
-    Article.map_by_label.web_exclusive.get!           
-      #==> web exclusive articles ordered by label
-    
-    Article.map_by_label.published.web_exclusive.get! 
-      #==> published, web exclusive articles ordered by label
+Article.map_by_label.filter_by_web_exclusive.filter_by_published.each {...}
 ```
 
-
 ## Query Proxy
 
 CouchView includes a simple query proxy system for building your map/reduce queries. 
@@ -191,66 +243,66 @@ CouchView includes a simple query proxy system for building your map/reduce quer
 Given the following model:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
-      map :label
-    end
+class Article < CouchRest::Model::Base
+  include CouchView
+  map :label
+end
 ```
 
 When you call `map_by_label`, you'll recieve a proxy for the query you want to run:
 
 ```ruby
-  proxy = Article.map_by_label
+proxy = Article.map_by_label
 ```
 
 You can now begin modifying your proxy with the standard CouchDB query options. For example, suppose we'd like to limit our result to 10. We can call either the `limit` method, or the `limit!` method. The former will return a new proxy, and leave the original untouched. The latter will modify the proxy it was called on.
 
 ```ruby
-  # generate a new proxy
-  new_proxy = proxy.limit 10
+# generate a new proxy
+new_proxy = proxy.limit 10
 
-  # or update the existing property
-  proxy.limit!(10)
+# or update the existing property
+proxy.limit!(10)
 ```
 
 Here's the full list of CouchDB query parameters that `CouchView` supports:
 
 ```ruby
-    limit       
-    skip           
-    startkey       
-    endkey         
-    startkey_docid 
-    endkey_docid   
-    stale          
-    descending     
-    group          
-    group_level    
-    reduce         
-    include_docs   
-    update_seq     
+limit       
+skip           
+startkey       
+endkey         
+startkey_docid 
+endkey_docid   
+stale          
+descending     
+group          
+group_level    
+reduce         
+include_docs   
+update_seq     
 ```
 
 Your query will execute when you call `each` or `get!` on it:  
 
 ```ruby
-    Article.map_by_label.startkey!("a").endkey!("b").each do |articles|
-      # do something with the articles
-    end
+Article.map_by_label.startkey!("a").endkey!("b").each do |articles|
+  # do something with the articles
+end
 
-    # or...
+# or...
 
-    articles = Article.map_by_label.startkey!("a").endkey!("b").get!
+articles = Article.map_by_label.startkey!("a").endkey!("b").get!
 ```
 
 You can also make your `map_by_label` and `count_by_label` return immediately by adding an `!` onto the end:
 
 ```ruby
-    Article.map_by_label!
-      #==> [Article<#848283>,...]
+Article.map_by_label!
+  #==> [Article<#848283>,...]
 
-    Article.count_by_label!
-      #==> 5
+Article.count_by_label!
+  #==> 5
 ```
 
 ## Arbitrary Reduce
@@ -258,26 +310,26 @@ You can also make your `map_by_label` and `count_by_label` return immediately by
 You can add any arbitrary reduce onto your view by using the `reduce` class method. Just make sure to group it with a map by placing them both within a `couch_view` block:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
-
-      property :label
-      
-      couch_view do
-        map :label
-        reduce <<-JS
-          function(key, values){
-            return sum(values)
-          }
-        JS
-      end
-    end
+class Article < CouchRest::Model::Base
+  include CouchView
+
+  property :label
+  
+  couch_view do
+    map :label
+    reduce <<-JS
+      function(key, values){
+        return sum(values)
+      }
+    JS
+  end
+end
 ```
 
 And now you can call it with:
    
 ```ruby
-    Article.reduce_by_label.get!
+Article.reduce_by_label.get!
 ```
 
 Note that you can still call `map_by_label` as well. You can't, however, call `count_by_label`.
@@ -290,18 +342,18 @@ As you've seen, `CouchView` will generate names for your views based on the prop
 You can override this default name by passing a name to the `couch_view` method:
 
 ```ruby
-    class Article < CouchRest::Model::Base
-      include CouchView
+class Article < CouchRest::Model::Base
+  include CouchView
 
-      couch_view :over_label do
-        map :label
-      end
-    end
+  couch_view :over_label do
+    map :label
+  end
+end
 ```
 
 You can now call your view using the `map_over_label` and `count_over_label` methods:
 
 ```ruby
-    Article.map_over_label!
-    Article.count_over_label!
+Article.map_over_label!
+Article.count_over_label!
 ```

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: couch_view
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 3
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Matt Parker
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-18 00:00:00 Z
+date: 2011-08-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: couchrest
@@ -101,6 +101,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/couch_view/array.rb
+- lib/couch_view/conditions.rb
 - lib/couch_view/config.rb
 - lib/couch_view/couch_view.rb
 - lib/couch_view/count_proxy.rb
@@ -111,6 +112,7 @@ files:
 - lib/couch_view.rb
 - readme.markdown
 - features/couch_view.array.feature
+- features/couch_view.conditions.feature
 - features/couch_view.config.feature
 - features/couch_view.count.proxy.feature
 - features/couch_view.feature
@@ -119,6 +121,7 @@ files:
 - features/setup/env.rb
 - features/setup/hooks.rb
 - features/step_definitions/couch_view.array.rb
+- features/step_definitions/couch_view.conditions.rb
 - features/step_definitions/couch_view.config.rb
 - features/step_definitions/couch_view.count.proxy.rb
 - features/step_definitions/couch_view.map.rb
@@ -159,6 +162,7 @@ specification_version: 3
 summary: Powerful views for CouchRest::Model::Base
 test_files: 
 - features/couch_view.array.feature
+- features/couch_view.conditions.feature
 - features/couch_view.config.feature
 - features/couch_view.count.proxy.feature
 - features/couch_view.feature
@@ -167,6 +171,7 @@ test_files:
 - features/setup/env.rb
 - features/setup/hooks.rb
 - features/step_definitions/couch_view.array.rb
+- features/step_definitions/couch_view.conditions.rb
 - features/step_definitions/couch_view.config.rb
 - features/step_definitions/couch_view.count.proxy.rb
 - features/step_definitions/couch_view.map.rb