special_agent 0.1.3

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in agent_orange.gemspec
+gemspec

data/README.md

@@ -0,0 +1,193 @@
+Special Agent
+=============
+
+User Agent detection for Ruby. Based on [agent_orange](https://github.com/kevinelliott/agent_orange) 
+but we didn't like the name so we forked it.
+
+About
+-----
+
+There are quite a few User Agent parsing libraries already, but none of them make adequate
+detection of mobile browsers and clients. With such a significant number of requests
+coming from mobile users a library with the ability to detect what type of device a user
+is coming from is necessary.
+
+This library for Ruby will allow you to detect whether a user is on a computer, a mobile
+device, or is a bot (such as Google). It was composed by using techniques gathered from
+several other libraries/gems in an effort to be consistent and cover as many types
+of agents as possible.
+
+Installation
+------------
+
+```bash
+gem install special_agent
+```
+
+If you're going to use it with Rails then add the gem to your Gemfile.
+
+Example Usage
+-------------
+
+Create new user agent parser
+
+```ruby
+ua = SpecialAgent::UserAgent.new(user_agent_string)
+```
+
+Looking at the device
+
+```ruby
+>> device = ua.device
+=> "Mobile"
+>> device.type
+=> "mobile"
+>> device.name
+=> "Mobile"
+>> device.version
+=> nil
+```
+
+Check to see if the device is mobile, a desktop/laptop/server computer, or a bot
+
+```ruby
+>> device.is_mobile?
+=> true
+>> device.is_computer?
+=> false
+>> device.is_bot?
+=> false
+```
+
+Use the proxies to check if the user is on a mobile device
+
+```ruby
+>> ua.is_mobile?
+=> true
+```
+
+Looking at the platform
+
+```ruby
+>> platform = ua.device.platform
+=> "iPhone"
+>> platform.type
+=> "iphone"
+>> platform.name
+=> "iPhone"
+>> platform.version
+=> "3GS"
+```
+  
+Looking at the operating system
+
+```ruby
+>> os = ua.device.os
+=> "iPhone OS 4.3"
+>> os.type
+=> "iphone_os"
+>> os.name
+=> "iPhone OS"
+>> os.version
+=> "4.3"
+```
+  
+Looking at the web engine
+
+```ruby
+>> engine = ua.device.engine
+=> "WebKit 5.3"
+>> engine.type
+=> "webkit"
+>> engine.name
+=> "WebKit"
+>> engine.version
+=> "5.3.1.2321"
+```
+
+Looking at the browser
+
+```ruby
+  >> browser = ua.device.engine.browser
+  => "Internet Explorer 10"
+  >> browser.type
+  => "ie"
+  >> browser.name
+  => "Internet Explorer"
+  >> browser.version
+  => "10.0.112"
+```
+
+Quickly get to the browser version
+
+```ruby
+>> SpecialAgent::UserAgent.new(user_agent_string).device.engine.browser.version
+=> "10.0.112"
+```
+
+
+General Class Definition
+------------------------
+
+  SpecialAgent::UserAgent
+    device
+    parse
+    is_computer?   # proxy
+    is_mobile?     # proxy
+    is_bot?        # proxy
+    to_s
+  
+  SpecialAgent::Device
+    parse
+    type
+    name
+    version
+    is_computer?(name=nil) # 
+    is_mobile?(name=nil)   # accepts a :symbol or "String"
+    is_bot?(name=nil)      #
+    to_s
+  
+  SpecialAgent::Engine
+    parse
+    type
+    name
+    version
+    to_s
+  
+  SpecialAgent::Version
+    parse
+    major
+    minor
+    patch_level
+    build_number
+    to_s
+  
+Credit
+------
+
+As noted above, special_agent is just a fork of Kevin Elliot's [agent_orange](https://github.com/kevinelliott/agent_orange) gem.
+He deserves all the credit for writing them gem. We just didn't want to perpetuate the use of such a culturally sensitive name.
+
+License
+-------
+
+(The MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+Dir.glob('./lib/tasks/*.rake').each { |r| import r }
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc "Run all specs"
+  RSpec::Core::RakeTask.new do |t|
+    # t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+    # Put spec opts in a file named .rspec in root
+  end
+
+  task :default => :spec
+end

data/lib/special_agent.rb

@@ -0,0 +1,8 @@
+require 'special_agent/version'
+require 'special_agent/user_agent'
+require 'special_agent/device'
+require 'special_agent/engine'
+require 'special_agent/browser'
+
+module SpecialAgent
+end

data/lib/special_agent/base.rb

@@ -0,0 +1,58 @@
+module SpecialAgent
+  class Base
+    
+    def initialize(user_agent)
+      self.parse(user_agent)
+    end
+    
+    def parse_user_agent_string_into_groups(user_agent)
+      results = user_agent.scan(/([^\/[:space:]]*)(\/([^[:space:]]*))?([[:space:]]*\[[a-zA-Z][a-zA-Z]\])?[[:space:]]*(\((([^()]|(\([^()]*\)))*)\))?[[:space:]]*/i)
+      groups = []
+      results.each do |result|
+        if result[0] != "" # Add the group of content if name isn't blank
+          groups << { :name => result[0], :version => result[2], :comment => result[5] }
+        end
+      end
+      groups
+    end
+    
+    def parse_comment(comment)
+      groups = []
+      comment.split('; ').each do |piece|
+        content = { :name => nil, :version => nil }
+        
+        # Remove 'like Mac OS X' or similar since it distracts from real results
+        piece = piece.scan(/(.+) like .+$/i)[0][0] if piece =~ /(.+) like (.+)$/i
+        
+        if piece =~ /(.+)[ \/]([\w.]+)$/i
+          chopped = piece.scan(/(.+)[ \/]([\w.]+)$/i)[0]
+          groups << { :name => chopped[0], :version => chopped[1] }
+        end
+      end
+      groups
+    end
+
+    def determine_type(types={}, content="")
+      # Determine type
+      type = nil
+      types.each do |key, value|
+        type = key if content =~ /(#{value})/i
+      end
+      type = "other" if type.nil?
+      type
+    end
+    
+    def debug_raw_content(content)
+      SpecialAgent.debug "  Raw Name   : #{content[:name]}", 2
+      SpecialAgent.debug "  Raw Version: #{content[:version]}", 2
+      SpecialAgent.debug "  Raw Comment: #{content[:comment]}", 2
+    end
+    
+    def debug_content(content)
+      SpecialAgent.debug "  Type: #{self.type}", 2
+      SpecialAgent.debug "  Name: #{self.name}", 2
+      SpecialAgent.debug "  Version: #{self.version}", 2
+    end
+    
+  end
+end

data/lib/special_agent/browser.rb

@@ -0,0 +1,61 @@
+require 'special_agent/base'
+require 'special_agent/version'
+
+module SpecialAgent
+  class Browser < Base
+    attr_accessor :type, :name, :version
+    attr_accessor :security
+
+    BROWSERS = {
+      :ie       => 'MSIE|Internet Explorer|IE',
+      :firefox  => 'Firefox',
+      :opera    => 'Opera',
+      :safari   => 'Safari'
+    }
+
+    def parse(user_agent)
+      SpecialAgent.debug "BROWSER PARSING", 2
+
+      groups = parse_user_agent_string_into_groups(user_agent)
+      groups.each_with_index do |content,i|
+        if content[:name] =~ /(#{BROWSERS.collect{|cat,regex| regex}.join(')|(')})/i
+          # Matched group against name
+          self.populate(content)
+        elsif content[:comment] =~ /(#{BROWSERS.collect{|cat,regex| regex}.join(')|(')})/i
+          # Matched group against comment
+          chosen_content = { :name => nil, :version => nil }
+          additional_groups = parse_comment(content[:comment])
+          additional_groups.each do |additional_content|
+            if additional_content[:name] =~ /(#{BROWSERS.collect{|cat,regex| regex}.join(')|(')})/i
+              chosen_content = additional_content
+            end
+          end
+
+          self.populate(chosen_content)
+        end
+      end
+
+      self.analysis
+    end
+
+    def populate(content={})
+      self.debug_raw_content(content)
+      SpecialAgent.debug "", 2
+
+      self.type = self.determine_type(BROWSERS, content[:name])
+      self.name = content[:name]
+      self.version = SpecialAgent::Version.new(content[:version])
+      self
+    end
+
+    def analysis
+      SpecialAgent.debug "BROWSER ANALYSIS", 2
+      self.debug_content(:type => self.type, :name => self.name, :version => self.version)
+      SpecialAgent.debug "", 2
+    end
+
+    def to_s
+      [self.name, self.version].compact.join(' ')
+    end
+  end
+end

data/lib/special_agent/device.rb

@@ -0,0 +1,97 @@
+require 'special_agent/base'
+require 'special_agent/platform'
+require 'special_agent/operating_system'
+require 'special_agent/engine'
+require 'special_agent/version'
+
+module SpecialAgent
+  class Device < Base
+    attr_accessor :type, :name, :version
+    attr_accessor :platform
+    attr_accessor :operating_system
+    attr_accessor :engine
+
+    DEVICES = {
+      :computer => 'windows|macintosh|x11|linux',
+      :mobile => 'ipod|ipad|iphone|palm|android|opera mini|hiptop|windows ce|smartphone|mobile|treo|psp',
+      :bot => 'bot|googlebot|crawler|spider|robot|crawling'
+    }
+
+    def parse(user_agent)
+      SpecialAgent.debug "DEVICE PARSING", 2
+
+      groups = parse_user_agent_string_into_groups(user_agent)
+      groups.each_with_index do |content,i|
+        if content[:comment] =~ /(#{DEVICES.collect{|cat,regex| regex}.join(')|(')})/i
+          # Matched group against name
+          self.populate(content)
+        end
+      end
+
+      self.analysis
+
+      self.platform = SpecialAgent::Platform.new(user_agent)
+      self.operating_system = SpecialAgent::OperatingSystem.new(user_agent)
+      self.engine = SpecialAgent::Engine.new(user_agent)
+    end
+
+    def populate(content={})
+      self.debug_raw_content(content)
+      SpecialAgent.debug "", 2
+
+      self.type = self.determine_type(DEVICES, content[:comment])
+      self.name = self.type.to_s.capitalize
+      self.version = nil
+      self
+    end
+
+    def analysis
+      SpecialAgent.debug "DEVICE ANALYSIS", 2
+      self.debug_content(:type => self.type, :name => self.name, :version => self.version)
+      SpecialAgent.debug "", 2
+    end
+
+    def is_computer?(name=nil)
+      if name
+        case name
+        when String
+          return self.platform.name.downcase.include?(name.downcase)
+        when Symbol
+          return self.platform.name.downcase.include?(name.to_s.downcase)
+        end
+      else
+        (self.type == :computer)
+      end
+    end
+
+    def is_mobile?(name=nil)
+      if !name.nil? && !self.platform.name.nil?
+        case name
+        when String
+          return self.platform.name.downcase.include?(name.downcase) || self.platform.version.downcase.include?(name.downcase)
+        when Symbol
+          return self.platform.name.downcase.include?(name.to_s.downcase) || self.platform.version.to_s.downcase.include?(name.to_s.downcase)
+        end
+      else
+        (self.type == :mobile)
+      end
+    end
+
+    def is_bot?(name=nil)
+      if name
+        case name
+        when String
+          return self.name.downcase.include?(name.downcase)
+        when Symbol
+          return self.name.downcase.include?(name.to_s.downcase)
+        end
+      else
+        (self.type == :bot)
+      end
+    end
+
+    def to_s
+      [self.name, self.version].compact.join(' ')
+    end
+  end
+end