user_agent_parser 1.0.1 → 2.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 066f29cb9f46c928c8dbca73076bdf2e6da63b2c
+  data.tar.gz: 0a171a4c0efa6c0601a4844a68f49bf1316f18d6
+SHA512:
+  metadata.gz: 2636ff74bef1fcef2c8be5070d97fdd0a70c969faafc76106531bf8986fa8336ca744cabe0babf5d6198d1455a3b25e04246abac9a1afb77b16dc5d79890d9dc
+  data.tar.gz: 06836d83ae49433ffdace34ebcf8f838768e7f533228ba4f48e662e5968744f7a0c29c4c9c64b60e7c9c196fd286f649e9ff577b25dc096065368235666b5059

data/Readme.md

@@ -4,9 +4,7 @@ UserAgentParser is a simple, comprehensive Ruby gem for parsing user agent strin
 
 ## Requirements
 
-* Ruby >= 1.9.2
-
-Note: 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,48 +17,62 @@ $ 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
+user_agent.to_s
 => "IE 9.0"
-ua.family
+user_agent.name
 => "IE"
-ua.version.to_s
+user_agent.version.to_s
 => "9.0"
-ua.version.major
-=> 9
-ua.version.minor
-=> 0
-os = ua.os
+user_agent.version.major
+=> "9"
+user_agent.version.minor
+=> "0"
+operating_system = user_agent.os
 => #<UserAgentParser::OperatingSystem Windows Vista>
-os.to_s
+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
+In a larger application, you could store a parser in a global to avoid repeat pattern loading:
 
-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!).
+```ruby
+module MyApplication
 
-You can also specify the path to your own, updated and/or customised `regexes.yaml` file:
+  # Instantiate the parser on load as it's quite expensive
+  USER_AGENT_PARSER = UserAgentParser::Parser.new
 
-```ruby
-UserAgentParser.patterns_path = '/some/path/to/regexes.yaml'
+  def self.user_agent_parser
+    USER_AGENT_PARSER
+  end
+
+end
 ```
 
-## Comprehensive you say?
+## The pattern database
 
-```bash
-$ rake test
-...
-    
-Finished tests in 144.220280s, 89.0027 tests/s, 234.9739 assertions/s.
+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 as a second argument to `UserAgentParser.parse`:
 
-12836 tests, 33888 assertions, 0 failures, 0 errors, 0 skips
+```ruby
+UserAgentParser.parse(ua_string, patterns_path: '/some/path/to/regexes.yaml')
 ```
 
-## Limitations
+or when instantiating a `UserAgentParser::Parser`:
 
-There's no support for providing overrides from Javascript user agent detection like there is with original BrowserScope library. The Javascript overrides were only necessary for detecting IE 9 Platform Preview and older versions of [Chrome Frame](https://developers.google.com/chrome/chrome-frame/).
+```ruby
+UserAgentParser::Parser.new(patterns_path: '/some/path/to/regexes.yaml').parse(ua_string)
+```
 
 ## Contributing
 
@@ -71,6 +83,18 @@ There's no support for providing overrides from Javascript user agent detection
 
 All accepted pull requests will earn you commit and release rights.
 
+## Releasing a new version
+
+1. Update the version in `user_agent_parser.gemspec`
+2. `git commit user_agent_parser.gemspec` with the following message format:
+
+        Version x.x.x
+
+        Changelog:
+        * Some new feature
+        * Some new bug fix
+3. `rake release`
+
 ## 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(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,94 @@ 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, v4 = match[1], match[2], match[3], match[4], match[5]
+
       if pattern["family_replacement"]
-        family = pattern["family_replacement"].sub('$1', family || '')
-      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
+        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
+
+      if pattern["v4_replacement"]
+        v4 = pattern["v4_replacement"].sub('$1', v4 || '')
+      end
+
+      version = version_from_segments(v1, v2, v3, v4)
+
+      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,33 +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
+      string = name
+      string += " #{version}" if version
+      string
     end
 
     def inspect
-      s = to_s
-      s += " (#{os})" if os
-      "#<#{self.class} #{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