user_agent_parser 0.1.1 → 2.0.0

data/Readme.md

@@ -1,12 +1,10 @@
-# UserAgentParser
+# UserAgentParser [![Build Status](https://secure.travis-ci.org/toolmantim/user_agent_parser.png?branch=master)](http://travis-ci.org/toolmantim/user_agent_parser)
 
-UserAgentParser is a simple, comprehensive Ruby gem for parsing user agent strings. It utilises [BrowserScope](http://www.browserscope.org/)'s UA parser via the most excellent [ua-parser project](https://github.com/tobie/ua-parser) by [Tobie Langel](https://github.com/tobie/).
+UserAgentParser is a simple, comprehensive Ruby gem for parsing user agent strings. It uses [BrowserScope](http://www.browserscope.org/)'s [parsing patterns](https://github.com/tobie/ua-parser).
 
 ## Requirements
 
-* Ruby >= 1.9.2
-
-Ruby 1.8.7 is not supported due to the requirement for the newer psych YAML parser. If you can get it working on 1.8.7 please send a pull request.
+* Ruby >= 1.8.7
 
 ## Installation
 
@@ -19,49 +17,48 @@ $ gem install user_agent_parser
 ```ruby
 require 'user_agent_parser'
 => true
-ua = UserAgentParser.parse 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0;)'
+user_agent = UserAgentParser.parse 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0;)'
 => #<UserAgentParser::UserAgent IE 9.0 (Windows Vista)>
-ua.to_s
-=> "IE 9.0 (Windows Vista)"
-ua.family
+user_agent.to_s
+=> "IE 9.0"
+user_agent.name
 => "IE"
-ua.version.to_s
+user_agent.version.to_s
 => "9.0"
-ua.version[0]
-=> 9
-ua.version[1]
-=> 0
-ua.os.name
+user_agent.version.major
+=> "9"
+user_agent.version.minor
+=> "0"
+operating_system = user_agent.os
+=> #<UserAgentParser::OperatingSystem Windows Vista>
+operating_system.to_s
 => "Windows Vista"
+
+# The parser database will be loaded and parsed on every call to
+# UserAgentParser.parse. To avoid this, instantiate your own Parser instance.
+parser = UserAgentParser::Parser.new
+parser.parse 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0;)'
+=> #<UserAgentParser::UserAgent IE 9.0 (Windows Vista)>
+parser.parse 'Opera/9.80 (Windows NT 5.1; U; ru) Presto/2.5.24 Version/10.53'
+=> #<UserAgentParser::UserAgent Opera 10.53 (Windows XP)>
 ```
 
 ## The pattern database
 
 The [ua-parser database](https://github.com/tobie/ua-parser/blob/master/regexes.yaml) is included via a [git submodule](http://help.github.com/submodules/). To update the database the submodule needs to be updated and the gem re-released (pull requests for this are very welcome!).
 
-You can also specify the path to your own, updated and/or customised `regexes.yaml` file:
+You can also specify the path to your own, updated and/or customised `regexes.yaml` file as a second argument to `UserAgentParser.parse`:
 
 ```ruby
-UserAgentParser.patterns_path = '/some/path/to/regexes.yaml'
+UserAgentParser.parse(ua_string, patterns_path: '/some/path/to/regexes.yaml')
 ```
 
-## Comprehensive you say?
-
-```bash
-$ rake test
-...
-    
-Finished tests in 144.220280s, 89.0027 tests/s, 234.9739 assertions/s.
+or when instantiating a `UserAgentParser::Parser`:
 
-12836 tests, 33888 assertions, 0 failures, 0 errors, 0 skips
+```ruby
+UserAgentParser::Parser.new(patterns_path: '/some/path/to/regexes.yaml').parse(ua_string)
 ```
 
-## Limitations
-
-Unlike the original Browserscope code there's no support for providing overrides from Javascript user agent detection. There's no current intention of adding support as the Javascript overrides were only necessary for IE 9 Platform Preview and older versions of [Chrome Frame](https://developers.google.com/chrome/chrome-frame/).
-
-Chrome Frame detection is not yet included, but once [ua-parser issue #14](https://github.com/tobie/ua-parser/issues/14) is resolved this gem will be updated along with it.
-
 ## Contributing
 
 1. Fork
@@ -73,4 +70,4 @@ All accepted pull requests will earn you commit and release rights.
 
 ## License
 
-MIT
+MIT

data/lib/user_agent_parser.rb

@@ -2,24 +2,13 @@ require 'user_agent_parser/parser'
 require 'user_agent_parser/user_agent'
 require 'user_agent_parser/version'
 require 'user_agent_parser/operating_system'
+require 'user_agent_parser/device'
 
 module UserAgentParser
-
-  # Path to the ua-parser regexes pattern database
-  def self.patterns_path
-    @patterns_path
-  end
-  
-  # Sets the path to the ua-parser regexes pattern database
-  def self.patterns_path=(path)
-    @patterns_path = path
-  end
-  
-  self.patterns_path = File.join(File.dirname(__FILE__), "../vendor/ua-parser/regexes.yaml")
+  DefaultPatternsPath = File.join(File.dirname(__FILE__), "../vendor/ua-parser/regexes.yaml")
 
   # Parse the given +user_agent_string+, returning a +UserAgent+
-  def self.parse user_agent_string
-    Parser.new.parse user_agent_string
+  def self.parse(user_agent_string, options={})
+    Parser.new(options).parse(user_agent_string)
   end
-
 end

data/lib/user_agent_parser/device.rb

@@ -0,0 +1,23 @@
+module UserAgentParser
+  class Device
+    attr_reader :name
+
+    def initialize(name = nil)
+      @name = name || 'Other'
+    end
+
+    def to_s
+      name
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) && name == other.name
+    end
+
+    alias_method :==, :eql?
+  end
+end

data/lib/user_agent_parser/operating_system.rb

@@ -1,28 +1,30 @@
 module UserAgentParser
-
   class OperatingSystem
-  
-    attr_accessor :name, :version
-  
-    def initialize(name="Other", version=nil)
-      self.name = name
-      self.version = version
+    attr_reader :name, :version
+
+    def initialize(name = 'Other', version = nil)
+      @name = name
+      @version = version
     end
-  
+
     def to_s
-      s = name
-      s += " #{version}" if version
-      s
+      string = name
+      unless version.nil?
+        string += " #{version}"
+      end
+      string
     end
-  
+
     def inspect
       "#<#{self.class} #{to_s}>"
     end
-  
-    def ==(other)
-      name == other.name && version == other.version
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        name == other.name &&
+        version == other.version
     end
-  
-  end
 
-end
+    alias_method :==, :eql?
+  end
+end

data/lib/user_agent_parser/parser.rb

@@ -1,41 +1,49 @@
 require 'yaml'
 
 module UserAgentParser
-
+  
   class Parser
+    attr_reader :patterns_path
 
-    def parse user_agent
-      ua = parse_ua(user_agent)
-      ua.os = parse_os(user_agent)
-      ua
+    def initialize(options={})
+      @patterns_path = options[:patterns_path] || UserAgentParser::DefaultPatternsPath
+      @ua_patterns, @os_patterns, @device_patterns = load_patterns(patterns_path)
     end
-  
-  private
 
-    def all_patterns
-      @all_patterns ||= YAML.load(File.read(UserAgentParser.patterns_path))
+    def parse(user_agent)
+      os = parse_os(user_agent)
+      device = parse_device(user_agent)
+      parse_ua(user_agent, os, device)
     end
 
-    def patterns type
-      @patterns ||= {}
-      @patterns[type] ||= begin
-        all_patterns[type].each do |p|
-          p["regex"] = Regexp.new(p["regex"])
+  private
+
+    def load_patterns(path)
+      yml = YAML.load_file(path)
+
+      # Parse all the regexs
+      yml.each_pair do |type, patterns|
+        patterns.each do |pattern|
+          pattern["regex"] = Regexp.new(pattern["regex"])
         end
       end
+
+      [ yml["user_agent_parsers"], yml["os_parsers"], yml["device_parsers"] ]
     end
-  
-    def parse_ua user_agent
-      pattern, match = first_pattern_match(patterns("user_agent_parsers"), user_agent)
+
+    def parse_ua(user_agent, os = nil, device = nil)
+      pattern, match = first_pattern_match(@ua_patterns, user_agent)
+
       if match
-        user_agent_from_pattern_match(pattern, match)
+        user_agent_from_pattern_match(pattern, match, os, device)
       else
-        UserAgent.new
+        UserAgent.new(nil, nil, os, device)
       end
     end
-  
-    def parse_os user_agent
-      pattern, match = first_pattern_match(patterns("os_parsers"), user_agent)
+
+    def parse_os(user_agent)
+      pattern, match = first_pattern_match(@os_patterns, user_agent)
+
       if match
         os_from_pattern_match(pattern, match)
       else
@@ -43,45 +51,90 @@ module UserAgentParser
       end
     end
 
-    def first_pattern_match patterns, value
-      for p in patterns
-        if m = p["regex"].match(value)
-          return [p, m]
+    def parse_device(user_agent)
+      pattern, match = first_pattern_match(@device_patterns, user_agent)
+
+      if match
+        device_from_pattern_match(pattern, match)
+      else
+        Device.new
+      end
+    end
+
+    def first_pattern_match(patterns, value)
+      patterns.each do |pattern|
+        if match = pattern["regex"].match(value)
+          return [pattern, match]
         end
       end
       nil
     end
 
-    def user_agent_from_pattern_match pattern, match
-      family, v1, v2, v3 = match[1], match[2], match[3], match[4]
+    def user_agent_from_pattern_match(pattern, match, os = nil, device = nil)
+      name, v1, v2, v3 = match[1], match[2], match[3], match[4]
+
       if pattern["family_replacement"]
-        family = pattern["family_replacement"].sub('$1', family || '')
+        name = pattern["family_replacement"].sub('$1', name || '')
+      end
+
+      if pattern["v1_replacement"]
+        v1 = pattern["v1_replacement"].sub('$1', v1 || '')
+      end
+
+      if pattern["v2_replacement"]
+        v2 = pattern["v2_replacement"].sub('$1', v2 || '')
+      end
+
+      if pattern["v3_replacement"]
+        v3 = pattern["v3_replacement"].sub('$1', v3 || '')
       end
-      v1 = pattern["v1_replacement"].sub('$1', v1 || '') if pattern["v1_replacement"]
-      v2 = pattern["v2_replacement"].sub('$1', v2 || '') if pattern["v2_replacement"]
-      v3 = pattern["v3_replacement"].sub('$1', v3 || '') if pattern["v3_replacement"] 
-      ua = UserAgent.new(family)
-      ua.version = version_from_segments(v1, v2, v3)
-      ua
+
+      version = version_from_segments(v1, v2, v3)
+
+      UserAgent.new(name, version, os, device)
     end
-  
-    def os_from_pattern_match pattern, match
+
+    def os_from_pattern_match(pattern, match)
       os, v1, v2, v3, v4 = match[1], match[2], match[3], match[4], match[5]
-      os = pattern["os_replacement"].sub('$1', os || '') if pattern["os_replacement"]
-      v1 = pattern["v1_replacement"].sub('$1', v1 || '') if pattern["v1_replacement"]
-      v2 = pattern["v2_replacement"].sub('$1', v2 || '') if pattern["v2_replacement"]
-      v3 = pattern["v3_replacement"].sub('$1', v3 || '') if pattern["v3_replacement"]
-      v4 = pattern["v3_replacement"].sub('$1', v3 || '') if pattern["v4_replacement"]
-      os = OperatingSystem.new(os)
-      os.version = version_from_segments(v1, v2, v3, v4)
-      os
+
+      if pattern["os_replacement"]
+        os = pattern["os_replacement"].sub('$1', os || '')
+      end
+
+      if pattern["os_v1_replacement"]
+        v1 = pattern["os_v1_replacement"].sub('$1', v1 || '')
+      end
+
+      if pattern["os_v2_replacement"]
+        v2 = pattern["os_v2_replacement"].sub('$1', v2 || '')
+      end
+
+      if pattern["os_v3_replacement"]
+        v3 = pattern["os_v3_replacement"].sub('$1', v3 || '')
+      end
+
+      if pattern["os_v4_replacement"]
+        v4 = pattern["os_v4_replacement"].sub('$1', v4 || '')
+      end
+
+      version = version_from_segments(v1, v2, v3, v4)
+
+      OperatingSystem.new(os, version)
     end
-  
+
+    def device_from_pattern_match(pattern, match)
+      device = match[1]
+
+      if pattern["device_replacement"]
+        device = pattern["device_replacement"].sub('$1', device || '')
+      end
+
+      Device.new(device)
+    end
+
     def version_from_segments(*segments)
       version_string = segments.compact.join(".")
       version_string.empty? ? nil : Version.new(version_string)
     end
-  
   end
-
 end

data/lib/user_agent_parser/user_agent.rb

@@ -1,32 +1,37 @@
 module UserAgentParser
-
   class UserAgent
+    attr_reader :name, :version, :os, :device
 
-    attr_accessor :family, :version, :os
+    # For backwards compatibility with older versions of this gem.
+    alias_method :family, :name
 
-    def initialize(family="Other", version=nil, os=nil)
-      self.family = family
-      self.version = version
-      self.os = os
+    def initialize(name = nil, version = nil, os = nil, device = nil)
+      @name = name || 'Other'
+      @version = version
+      @os = os
+      @device = device
     end
 
     def to_s
-      s = family
-      s += " #{version}" if version
-      s += " (#{os})" if os
-      s
+      string = name
+      string += " #{version}" if version
+      string
     end
 
     def inspect
-      "#<#{self.class} #{to_s}>"
+      string = to_s
+      string += " (#{os})" if os
+      string += " (#{device})" if device
+      "#<#{self.class} #{string}>"
     end
-    
-    def ==(other)
-      family == other.family &&
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+      name == other.name &&
         version == other.version &&
         os == other.os
     end
 
+    alias_method :==, :eql?
   end
-  
 end

data/lib/user_agent_parser/version.rb

@@ -1,32 +1,47 @@
 module UserAgentParser
-  
   class Version
 
-    attr_accessor :version
+    # Private: Regex used to split version string into major, minor, patch,
+    # and patch_minor.
+    SEGMENTS_REGEX = /\d+\-\d+|\d+[a-zA-Z]+$|\d+|[A-Za-z][0-9A-Za-z-]*$/
+
+    attr_reader :version
     alias :to_s :version
 
     def initialize(version)
-      self.version = version.to_s.strip
+      @version = version.to_s.strip
     end
 
-    def segments
-      version.scan(/\d+\-\d+|\d+[a-zA-Z]+$|\d+|[A-Za-z][0-9A-Za-z-]*$/).map do |s|
-        /^\d+$/ =~ s ? s.to_i : s
-      end
+    def major
+      segments[0]
+    end
+
+    def minor
+      segments[1]
+    end
+
+    def patch
+      segments[2]
     end
 
-    def [](segment)
-      segments[segment]
+    def patch_minor
+      segments[3]
     end
-  
+
     def inspect
       "#<#{self.class} #{to_s}>"
     end
-    
-    def ==(other)
-      version == other.version
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        version == other.version
     end
 
-  end
+    alias_method :==, :eql?
 
-end
+    # Private
+    def segments
+      @segments ||= version.scan(SEGMENTS_REGEX)
+    end
+  end
+end