divining_rod 0.3.1 → 0.4.0

data/README.markdown

@@ -5,20 +5,43 @@ A tool to help format your sites mobile pages.
 ## Installation
 
     gem install divining_rod
+
+## Example
+  
+  Using the example configuration (found in [example_config.rb](http://github.com/markpercival/divining_rod/blob/master/example_config.rb)])
+  
+    # For a request with the user agent
+    # "Mozilla/5.0 (iPhone; U; CPU iPhone OS 2_2_1 like Mac OS X; en-us) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5H11 Safari/525.20"
+    
+    profile = DiviningRod::Profile.new(request)
+    profile.iphone?           #=> true
+    profile.name              #=> 'iPhone'
+    profile.youtube_capable?  #=> true
+    profile.format            #=> :webkit
+    
     
 ## Usage
 
 _initializers/divining\_rod.rb_
 
-    DiviningRod::Matchers.define do |map|
-        # map.ua /user_agent_regex/, :format, :tags => []
-        map.ua /iPhone/, :webkit, :tags => [:iphone, :youtube_capable]
-        map.ua /Android/, :webkit, :tags => [:android, :youtube_capable, :google_gears]
-        map.subdomain /wap/, :wap, :tags => [:crappy_old_phone]
+    DiviningRod::Mappings.define do |map|
+        # Android based phones
+        map.ua /Android/, :format => :webkit, :name => 'Android', :tags => [:android, :youtube_capable, :google_gears]
+
+        # Apple iPhone OS
+        map.ua /Apple.*Mobile.*Safari/, :format => :webkit, :tags => [:apple, :iphone_os, :youtube_capable] do |iphone|
+          iphone.ua /iPad/, :tags => :ipad, :name => 'iPad'
+          iphone.ua /iPod/, :tags => :ipod, :name => 'iPod Touch'
+          iphone.ua /iPhone/, :tags => [:iphone], :name => 'iPhone'
+        end
+
+        #Blackberry, needs more detail here
+        map.ua /BlackBerry/, :tags => :blackberry, :name => 'BlackBerry'
+        map.subdomain /wap/, :format => :wap, :tags => [:crappy_old_phone]
         
         # Enable this to forces a default format if unmatched
         # otherwise it will return the request.format
-        # map.default :html 
+        # map.default :format => :html 
     end
 
 _initializers/mime\_types.rb_
@@ -53,10 +76,10 @@ _app/views/mobile/show.webkit.html_
     
 ## Note on the development
 
-This is still very much in beta, but we are using it in production. As such we plan
-to do our best to keep the API the same.
+Tags always merge, while all other hash keys get overridden. Tags also will always allow you to call them as
+booleans. Ex @profile.iphone? 
 
-The user agent definitions will be updated here later this week.
+If the :format key isn't available we default to request.format.
 
 ## Todo
 

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/divining_rod.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{divining_rod}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mark Percival"]
-  s.date = %q{2010-02-18}
+  s.date = %q{2010-02-23}
   s.description = %q{A mobile phone web request profiler using definitions that look like rails routes}
   s.email = %q{mark@mpercival.com}
   s.extra_rdoc_files = [
@@ -24,8 +24,19 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "divining_rod.gemspec",
+     "example_config.rb",
      "lib/divining_rod.rb",
-     "spec/basic_spec.rb",
+     "lib/divining_rod/definition.rb",
+     "lib/divining_rod/mapper.rb",
+     "lib/divining_rod/mappings.rb",
+     "lib/divining_rod/matchers.rb",
+     "lib/divining_rod/murge.rb",
+     "lib/divining_rod/profile.rb",
+     "spec/definition_spec.rb",
+     "spec/example_mapping_spec.rb",
+     "spec/mapper_spec.rb",
+     "spec/mapping_spec.rb",
+     "spec/profile_spec.rb",
      "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/markpercival/divining_rod}
@@ -34,7 +45,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{A mobile phone web request profiler}
   s.test_files = [
-    "spec/basic_spec.rb",
+    "spec/definition_spec.rb",
+     "spec/example_mapping_spec.rb",
+     "spec/mapper_spec.rb",
+     "spec/mapping_spec.rb",
+     "spec/profile_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/example_config.rb

@@ -0,0 +1,31 @@
+DiviningRod::Mappings.define do |map|
+    # Android based phones
+    map.ua /Android/, :format => :webkit, :name => 'Android', :tags => [:android, :youtube_capable, :google_gears]
+    
+    # Apple iPhone OS
+    map.ua /Apple.*Mobile.*Safari/, :format => :webkit, :tags => [:apple, :iphone_os, :youtube_capable] do |iphone|
+      iphone.ua /iPad/, :tags => :ipad, :name => 'iPad'
+      iphone.ua /iPod/, :tags => :ipod, :name => 'iPod Touch'
+      iphone.ua /iPhone/, :tags => [:iphone], :name => 'iPhone'
+    end
+    
+    #Blackberry, needs more detail here
+    map.ua /BlackBerry/, :tags => :blackberry, :name => 'BlackBerry'
+    
+    # The desktop browsers, we don't set a format on these to let it pass through
+    map.with_options :tags => :desktop do |desktop|
+      desktop.ua /Chrome/, :tags => :chrome, :name => 'Chrome'
+      desktop.ua /Firefox/, :tags => :firefox, :name => 'Firefox'
+      desktop.ua /Safari/, :tags => :safari, :name => 'Safari'
+      desktop.ua /Opera/, :tags => :opera, :name => 'Opera'
+      desktop.ua /MSIE/, :tags => :ie, :name => 'Internet Explorer' do |msie|
+        msie.ua /MSIE 6/, :version => 6
+        msie.ua /MSIE 7/, :version => 7
+        msie.ua /MSIE 8/, :version => 8
+      end
+    end
+    
+    # Enable this to forces a default format if unmatched
+    # otherwise it will return the request.format
+    # map.default :format => :html 
+end

data/lib/divining_rod.rb

@@ -1,107 +1,8 @@
-require 'yaml'
-
-module DiviningRod
-
-  class Profile
-
-    attr_reader :match
-
-    def initialize(request)
-      @request = request.clone #Lets not mess with the real one
-      matchers.each do |matcher|
-        @match = matcher if matcher.matches?(request)
-        break if @match
-      end
-      nil
-    end
-
-    def group
-      if @match
-        @match.group
-      else
-        @request.format
-      end
-    end
-    alias_method :format, :group
-
-    def recognized?
-      !!@match
-    end
-
-    def method_missing(meth)
-      if meth.to_s.match(/(.+)\?$/)
-        tag = $1
-        if @match
-          @match.tags.include?(tag.to_s) ||  @match.tags.include?(tag.to_sym) || @match.tags == tag
-        else
-          false
-        end
-      else
-        super
-      end
-    end
-
-    def matchers
-      DiviningRod::Matchers.definitions || []
-    end
-
-  end
-
-  class Matchers
-
-    class << self
-
-      attr_accessor :definitions
-
-      def define
-        yield(self)
-      end
-
-      def clear_definitions
-        @definitions = []
-      end
-
-      def ua(pattern, group, opts={})
-        @definitions ||= []
-        @definitions << Definition.new(group, opts) { |request|
-          if pattern.match(request.user_agent)
-            true
-          end
-        }
-      end
-      
-      def subdomain(pattern, group, opts={})
-        @definitions ||= []
-        @definitions << Definition.new(group, opts) { |request|
-          if pattern.match(request.subdomains[0])
-            true
-          end
-        }
-      end
-
-      def default(group, opts = {})
-        @definitions ||= []
-        @definitions << Definition.new(group, opts) { |request| true }
-      end
-
-    end
-
-  end
-
-  class Definition
-
-    attr_accessor :prc, :tags, :group
-
-    def initialize(group, opts={}, &blk)
-      @group = group
-      @tags = opts[:tags] || []
-      @prc = blk
-    end
-
-    def matches?(request)
-      !!@prc.call(request)
-    end
-
-  end
-
-end
+module DiviningRod; end
+
+require 'divining_rod/profile'
+require 'divining_rod/murge'
+require 'divining_rod/definition'
+require 'divining_rod/mappings'
+require 'divining_rod/mapper'
+require 'divining_rod/matchers'

data/lib/divining_rod/definition.rb

@@ -0,0 +1,53 @@
+module DiviningRod
+  class Definition
+    include Murge
+
+    attr_accessor :prc, :group, :opts, :parent
+    attr_writer :children
+
+    def initialize(opts={}, &blk)
+      @prc = blk
+      @opts = opts
+    end
+
+    def evaluate(request)
+      result = nil
+      child_result = nil
+      if @prc.call(request)
+        result = self
+        unless self.children.empty?
+          self.children.each do |child|
+            child_result = child.evaluate(request)
+            break if child_result
+          end
+        end
+      end
+      child_result || result
+    end
+
+    def tags
+      opts[:tags] || []
+    end
+    
+    def opts
+      if parent
+        @murged_opts ||= murge(parent.opts, @opts)
+      else
+        @opts
+      end
+    end
+    
+    def format
+      opts[:format]
+    end
+    
+    def children
+      @children ||= []
+      @children.each do |child|
+        child.parent ||= self
+      end
+      @children
+    end
+
+  end
+end

data/lib/divining_rod/mapper.rb

@@ -0,0 +1,55 @@
+module DiviningRod
+  class Mapper
+    include Murge
+    
+    def initialize(parent, default_opts = {})
+      @parent = parent
+      @default_opts = default_opts
+    end
+
+    def pattern(type, pattern, opts = {})
+      opts = murge(default_options, opts)
+      definition = Matchers.send(type.to_sym, pattern, opts)
+      append_to_parent(definition)
+      if block_given?
+        yield self.class.new(definition)
+      end
+      definition
+    end
+    
+    def with_options(opts)
+      yield self.class.new(@parent, opts)
+    end
+
+    def default(opts = {})
+      definition = Definition.new(opts) { true }
+      append_to_parent(definition)
+      definition
+    end
+
+    def method_missing(meth, *args, &blk)
+      # Lets us use map.ua instead of map.pattern :ua
+      if Matchers.respond_to?(meth.to_sym)
+        self.pattern(meth, args[0], args[1,], &blk)
+      else
+        super
+      end
+    end
+
+    private
+    
+      def default_options
+        @default_opts || {}
+      end
+
+      def append_to_parent(definition)
+        if @parent
+          @parent.children << definition
+        end
+        definition
+      end
+
+  end
+
+
+end

data/lib/divining_rod/mappings.rb

@@ -0,0 +1,20 @@
+module DiviningRod
+  class Mappings
+
+    class << self
+
+      attr_accessor :root_definition
+      
+      def define(opts = {})
+        @root_definition = Definition.new { true }
+        yield Mapper.new(@root_definition, opts)
+      end
+      
+      def evaluate(obj)
+        @root_definition.evaluate(obj)
+      end
+      
+    end
+
+  end
+end

data/lib/divining_rod/matchers.rb

@@ -0,0 +1,23 @@
+module DiviningRod
+  class Matchers
+    class << self
+      
+      def ua(pattern, opts = {})
+        Definition.new(opts) { |request|
+          if pattern.match(request.user_agent)
+            true
+          end
+        }
+      end
+      
+      def subdomain(pattern, opts={})
+        Definition.new(opts) { |request|
+          if pattern.match(request.subdomains[0])
+            true
+          end
+        }
+      end
+      
+    end
+  end
+end

data/lib/divining_rod/murge.rb

@@ -0,0 +1,16 @@
+module DiviningRod
+  module Murge
+    
+    # This is tacky, but I'm preserving tags in the option hash
+    # and only want to have to write this once
+    #
+    def murge(old_opts, new_opts)
+      old_opts = old_opts || {}
+      tags = Array(old_opts[:tags]) | Array(new_opts[:tags])
+      opts = old_opts.merge(new_opts)
+      opts[:tags] = tags
+      opts
+    end
+    
+  end
+end

data/lib/divining_rod/profile.rb

@@ -0,0 +1,39 @@
+module DiviningRod
+  class Profile
+
+    attr_reader :match
+
+    def initialize(request)
+      @request = request.clone #Lets not mess with the real one
+      @match = DiviningRod::Mappings.evaluate(request)
+    end
+
+    def format
+      if @match && @match.format
+        @match.format
+      else
+        @request.format
+      end
+    end
+
+    def recognized?
+      @match != DiviningRod::Mappings.root_definition
+    end
+
+    def method_missing(meth)
+      if meth.to_s.match(/(.+)\?$/)
+        tag = $1
+        if @match
+          @match.tags.include?(tag.to_s) ||  @match.tags.include?(tag.to_sym) || @match.tags == tag
+        else
+          false
+        end
+      elsif @match.opts.include?(meth.to_sym)
+        @match.opts[meth]
+      else
+        super
+      end
+    end
+
+  end
+end

data/spec/definition_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe DiviningRod::Definition do
+  
+  it "should work with no children not match" do
+    definition = DiviningRod::Definition.new(:format => :iphone, :tags => [:overpriced, :easy_to_break]) { |request|
+      request == 'iphone'
+    }
+    definition.evaluate('foo').should be_nil
+  end
+  
+  it "should work with no children and match" do
+    definition = DiviningRod::Definition.new(:format => :iphone, :tags => [:overpriced, :easy_to_break]) { |request|
+      request == 'iphone'
+    }
+    definition.evaluate('iphone').should eql(definition)
+  end
+  
+  describe "with children" do
+    
+    it "should work with children that match" do
+      definition = DiviningRod::Definition.new(:format => :iphone, :tags => [:overpriced, :easy_to_break]) { |request|
+        request.match(/iphone/)
+      }
+      definition.children << DiviningRod::Definition.new(:format => :ipod, :tags => [:big, :lacks_a_camera]) { |request|
+        request.match(/ipod/)
+      }
+      definition.children << DiviningRod::Definition.new(:format => :ipad, :tags => [:big, :lacks_a_camera]) { |request|
+        request.match(/ipad/)
+      }
+      result = definition.evaluate('iphone ipad')
+      result.should_not eql(definition)
+      result.format.should eql(:ipad)
+      result.tags.should include(:overpriced)
+    end
+    
+    
+  end
+  
+end

data/spec/example_mapping_spec.rb

@@ -0,0 +1,65 @@
+require 'spec/spec_helper'
+require 'example_config'
+
+
+def request_mock(ua, subdomain = [])
+  mock('RailsRequest', :user_agent => ua, :subdomain => subdomain)
+end
+
+def profile_ua(ua)
+  DiviningRod::Profile.new(request_mock(ua))
+end
+  
+
+describe 'the example config' do
+
+  describe "recognizing Apple devices" do
+
+    it "should recognize an iPad" do
+      profile = profile_ua("Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B314 Safari/531.21.10")
+      profile.ipad?.should be_true
+    end
+    
+    it "should recognize an iPod touch 2.2.1" do
+      profile = profile_ua("Mozilla/5.0 (iPod; U; CPU iPhone OS 2_2_1 like Mac OS X; en-us) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5H11 Safari/525.20")
+      profile.ipod?.should be_true
+    end
+    
+    it "should recognize an iPod touch 3.1.2" do
+      profile = profile_ua("Mozilla/5.0 (iPod; U; CPU iPhone OS 3_1_2 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7D11 Safari/528.16")
+      profile.ipod?.should be_true
+    end
+    
+    it "should recognize an iPhone 3.1.2" do
+      profile = profile_ua("Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_1_2 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7D11 Safari/528.16")
+      profile.iphone?.should be_true
+    end
+    
+    it "should recognize an iPhone 2.1.2" do
+      profile = profile_ua("Mozilla/5.0 (iPhone; U; CPU iPhone OS 2_2_1 like Mac OS X; en-us) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5H11 Safari/525.20")
+      profile.iphone?.should be_true
+    end
+    
+  end
+  
+  describe "recognizing Android devices" do
+    
+    it "should recognize a basic android" do
+      profile = profile_ua("Mozilla/5.0 (Linux; U; Android 1.0; en-us; dream) AppleWebKit/525.10+ (KHTML, like Gecko) Version/3.0.4 Mobile Safari/523.12.2")
+      profile.android?.should be_true
+    end
+    
+  end
+  
+  describe "recognizing desktop browsers" do
+    
+    it "should recognize Internet Explorer 7" do
+      profile = profile_ua("Mozilla/4.0 (compatible; MSIE 7.0b; Windows NT 6.0)")
+      profile.desktop?.should be_true
+      profile.version.should eql(7)
+    end
+    
+  end
+
+
+end

data/spec/mapper_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe DiviningRod::Mapper do
+  
+  before :each do
+    @root_definition = DiviningRod::Definition.new { true }
+    mapper = DiviningRod::Mapper.new(@root_definition, {:tags => [:fuck], :foo => true})
+    mapper.ua /Safari/, :tags => [:baz] do |map|
+      map.with_options :tags => :awsome do |awesome|
+        awesome.ua /Apple/, :tags => [:foo]
+      end
+    end
+  end
+  
+  it "should map a definition" do
+    request = mock("rails_request", :user_agent => 'Apple Mobile Safari', :format => :html)
+    result = @root_definition.evaluate(request)
+    result.tags.should include(:fuck)
+  end
+  
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe DiviningRod::Mappings do
+
+  before :each do
+    DiviningRod::Mappings.define(:tags => :mobile) do |map|
+      map.ua /Apple/, :format => :webkit, :tags => [:apple] do |apple|
+
+        # iPod, iPhone, and iPad
+        apple.with_options :tags => [:youtube, :geolocate, :iphone] do |advanced|
+          advanced.ua /iPad/, :tags => :ipad do |ipad|
+            ipad.ua /OS\s4/, :tags => :version4
+            ipad.ua /OS\s3/, :tags => :version3 do |v3|
+              v3.ua /Unicorns/, :tags => :omg_unicorns do |unicorns|
+                unicorns.ua /eat kittens/, :tags => [:omg_they_eat_kittens]
+              end
+            end
+            ipad.ua /OS\s2/, :tags => :version2
+          end
+          advanced.ua /iPod/, :tags => [:ipod, :ipod_touch]
+        end
+
+        # Also an apple but actualy a newton
+        apple.ua /Newton/, :tags => [:apple] do |newton|
+          newton.ua /OS 8/, :tags => :os8
+        end
+      end
+    end
+  end
+
+  it "should match a top level user agent" do
+    request = mock("rails_request", :user_agent => 'Apple Mobile Safari', :format => :html)
+    result = DiviningRod::Mappings.root_definition.evaluate(request)
+    result.should_not be_nil
+    result.tags.should include(:apple)
+    result.tags.should_not include(:ipad)
+    result.tags.should include(:mobile)
+  end
+
+  it "should match a child definition" do
+    ipad_request = mock("rails_request", :user_agent => 'Apple iPad', :format => :html)
+    result = DiviningRod::Mappings.evaluate(ipad_request)
+    result.tags.should include(:ipad)
+  end
+
+  it "should match a sub child definition" do
+    ipad_request = mock("rails_request", :user_agent => 'Apple iPad - now powered by Unicorns - OS 3.3', :format => :html)
+    result = DiviningRod::Mappings.evaluate(ipad_request)
+    result.tags.should include(:ipad)
+    result.tags.should include(:omg_unicorns)
+    result.tags.should include(:version3)
+  end
+
+  it "should match a really really deep child definition" do
+    ipad_request = mock("rails_request", :user_agent => 'Apple iPad - now powered by Unicorns who eat kittens - OS 3.3', :format => :html)
+    result = DiviningRod::Mappings.evaluate(ipad_request)
+    result.tags.should include(:ipad, :youtube)
+    result.tags.should include(:omg_unicorns)
+    result.tags.should include(:omg_they_eat_kittens)
+    result.tags.should include(:version3)
+  end
+
+  it "should match a in order defined" do
+    ipad_request = mock("rails_request", :user_agent => 'Apple iPad - now powered by Unicorns who eat kittens - OS 2', :format => :html)
+    result = DiviningRod::Mappings.evaluate(ipad_request)
+    result.tags.should include(:ipad, :youtube)
+    result.tags.should_not include(:omg_they_eat_kittens, :omg_unicorns)
+    result.tags.should include(:version2)
+  end
+
+  it "should match a in order defined" do
+    ipad_request = mock("rails_request", :user_agent => 'Apple Newton - OS 8', :format => :html)
+    result = DiviningRod::Mappings.evaluate(ipad_request)
+    result.tags.should_not include(:omg_they_eat_kittens, :omg_unicorns)
+    result.tags.should include(:os8)
+  end
+
+end

data/spec/{basic_spec.rb → profile_spec.rb}

@@ -3,10 +3,12 @@ require 'spec_helper'
 describe DiviningRod do
 
   before :each do
-    @request = mock("rails_request", :user_agent => 'My iPhone')
-    DiviningRod::Matchers.clear_definitions
-    DiviningRod::Matchers.define do |map|
-      map.ua /iPhone/, :webkit, :tags => [:iphone, :youtube, :geolocate]
+    @request = mock("rails_request", :user_agent => 'My iPhone which is actually an iPad')
+    
+    DiviningRod::Mappings.define do |map|
+      map.ua /iPhone/, :format => :webkit, :tags => [:iphone, :youtube, :geolocate] do |iphone|
+        iphone.ua /iPad/, :tags => [:ipad]
+      end
     end
   end
 
@@ -17,7 +19,7 @@ describe DiviningRod do
 
   it "should know if it belongs to a category tag" do
     profile = DiviningRod::Profile.new(@request)
-    profile.geolocate?.should be_true
+    profile.ipad?.should be_true
   end
 
   it "should know if it does not belongs to a category" do
@@ -29,9 +31,9 @@ describe DiviningRod do
     
     before :each do
       @request = mock("rails_request", :user_agent => 'My Foo Fone', :format => :html)
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.ua /iPhone/, :webkit, :tags => [:iphone, :youtube, :geolocate]
+      
+      DiviningRod::Mappings.define do |map|
+        map.ua /iPhone/, :format => :webkit, :tags => [:iphone, :youtube, :geolocate]
       end
     end
 
@@ -48,10 +50,10 @@ describe DiviningRod do
     
     before :each do
       @request = mock("rails_request", :user_agent => 'My Foo Fone')
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.ua /iPhone/, :webkit, :tags => [:iphone, :youtube, :geolocate]
-        map.default :html
+      
+      DiviningRod::Mappings.define do |map|
+        map.ua /iPhone/, :format => :webkit, :tags => [:iphone, :youtube, :geolocate]
+        map.default :format => :html
       end
     end
 
@@ -67,9 +69,9 @@ describe DiviningRod do
 
     before :each do
       @request = mock("rails_request", :user_agent => 'Foo Fone', :format => :html)
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.ua /iPhone/, :webkit, :tags => [:iphone, :youtube, :geolocate]
+      
+      DiviningRod::Mappings.define do |map|
+        map.ua /iPhone/, :format => :webkit, :tags => [:iphone, :youtube, :geolocate]
       end
     end
 
@@ -83,9 +85,9 @@ describe DiviningRod do
 
     before :each do
       @request = mock("rails_request", :user_agent => 'Foo Fone', :subdomains => ['wap'])
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.subdomain /wap/, :wap, :tags => [:shitty]
+      
+      DiviningRod::Mappings.define do |map|
+        map.subdomain /wap/, :format => :wap, :tags => [:shitty]
       end
     end
 
@@ -101,9 +103,9 @@ describe DiviningRod do
 
     before :each do
       @request = mock("rails_request", :user_agent => nil, :subdomains => [])
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.ua /iPhone/, :wap, :tags => [:shitty]
+      
+      DiviningRod::Mappings.define do |map|
+        map.ua /iPhone/, :format => :wap, :tags => [:shitty]
       end
     end
 
@@ -114,38 +116,3 @@ describe DiviningRod do
   end
 
 end
-
-
-describe DiviningRod::Matchers do
-
-  before :each do
-    @request = mock("rails_request", :user_agent => 'iPhone Foo')
-    DiviningRod::Matchers.clear_definitions
-    DiviningRod::Matchers.define do |map|
-      map.ua /iPhone/, :iphone, :tags => [:iphone, :youtube]
-    end
-  end
-
-  it "should recognize an iPhone" do
-    DiviningRod::Matchers.definitions.first.matches?(@request).should be_true
-    DiviningRod::Matchers.definitions.first.group.should eql(:iphone)
-  end
-
-  describe "defining a default definition" do
-
-    before :each do
-      @request = mock("rails_request", :user_agent => 'Foo Fone')
-      DiviningRod::Matchers.clear_definitions
-      DiviningRod::Matchers.define do |map|
-        map.default :unknown, :tags => [:html]
-      end
-    end
-
-    it "should use the default route if no other match is found" do
-      DiviningRod::Matchers.definitions.first.matches?(@request).should be_true
-      DiviningRod::Matchers.definitions.first.group.should eql(:unknown)
-    end
-
-  end
-
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: divining_rod
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Mark Percival
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-18 00:00:00 -05:00
+date: 2010-02-23 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,8 +39,19 @@ files:
 - Rakefile
 - VERSION
 - divining_rod.gemspec
+- example_config.rb
 - lib/divining_rod.rb
-- spec/basic_spec.rb
+- lib/divining_rod/definition.rb
+- lib/divining_rod/mapper.rb
+- lib/divining_rod/mappings.rb
+- lib/divining_rod/matchers.rb
+- lib/divining_rod/murge.rb
+- lib/divining_rod/profile.rb
+- spec/definition_spec.rb
+- spec/example_mapping_spec.rb
+- spec/mapper_spec.rb
+- spec/mapping_spec.rb
+- spec/profile_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/markpercival/divining_rod
@@ -71,5 +82,9 @@ signing_key:
 specification_version: 3
 summary: A mobile phone web request profiler
 test_files: 
-- spec/basic_spec.rb
+- spec/definition_spec.rb
+- spec/example_mapping_spec.rb
+- spec/mapper_spec.rb
+- spec/mapping_spec.rb
+- spec/profile_spec.rb
 - spec/spec_helper.rb