double_agent 0.0.1

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2011 Jordan Hollinger
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/data/browsers.yml

@@ -0,0 +1,57 @@
+# The ordering is very important; matches are performed in the specified order.
+# This allows for greatly simplified regexes.
+
+- :name: Internet Explorer %s
+  :sym: :msie
+  :family_sym: :msie
+  :regex: 'msie \d+'
+  :version: '(?<=msie )[0-9]+'
+  :safe_version: ["msie [0-9]+", "[0-9]+"]
+
+- :name: Chromium %s
+  :sym: :chromium
+  :family_sym: :chromium
+  :regex: 'chromium/\d+'
+  :version: '(?<=chromium/)[0-9]+'
+  :safe_version: ["chromium/[0-9]+", "[0-9]+"]
+
+- :name: Chrome %s
+  :sym: :chrome
+  :family_sym: :chromium
+  :regex: 'chrome/\d+'
+  :version: '(?<=chrome/)[0-9]+'
+  :safe_version: ["chrome/[0-9]+", "[0-9]+"]
+
+- :name: Android %s
+  :sym: :android
+  :family_sym: :chromium
+  :regex: android
+  :version: '(?<=android )[0-9]+(\.[0-9]+)?'
+  :safe_version: ["android [0-9]+(\.[0-9]+)?", "[0-9]+(\.[0-9]+)?"]
+
+- :name: Safari %s
+  :sym: :safari
+  :family_sym: :safari
+  :regex: safari
+  :version: '(?<=version/)[0-9]+'
+  :safe_version: ["version/[0-9]+", "[0-9]+"]
+
+- :name: Opera %s
+  :sym: :opera
+  :family_sym: :opera
+  :regex: opera
+  :version: '(?<=version/)[0-9]+'
+  :safe_version: ["version/[0-9]+", "[0-9]+"]
+
+- :name: Firefox %s
+  :sym: :firefox
+  :family_sym: :firefox
+  :regex: firefox
+  :version: '(?<=firefox/)[0-9]+'
+  :safe_version: ["firefox/[0-9]+", "[0-9]+"]
+
+- :name: Unknown
+  :sym: :unknown
+  :family_sym: :unkown
+  :regex: .+
+  :version: .+

data/data/oses.yml

@@ -0,0 +1,52 @@
+- :name: Android
+  :sym: :android
+  :family_sym: :linux
+  :regex: android
+
+- :name: Ubuntu
+  :sym: :ubuntu
+  :family_sym: :linux
+  :regex: ubuntu
+
+- :name: GNU/Linux
+  :sym: :linux
+  :family_sym: :linux
+  :regex: linux
+
+- :name: iOS
+  :sym: :ios
+  :family_sym: :osx
+  :regex: (iphone)|(ipad)
+
+- :name: OS X
+  :sym: :osx
+  :family_sym: :osx
+  :regex: macintosh
+
+- :name: Windows XP
+  :sym: :windows_xp
+  :family_sym: :windows
+  :regex: windows nt 5\.1
+  :icon: windows
+
+- :name: Windows Vista
+  :sym: :windows_vista
+  :family_sym: :windows
+  :regex: windows nt 6\.0
+  :icon: windows
+
+- :name: Windows 7
+  :sym: :windows_7
+  :family_sym: :windows
+  :regex: windows nt 6\.1
+  :icon: windows
+
+- :name: Windows
+  :sym: :windows
+  :family_sym: :windows
+  :regex: windows
+
+- :family: Unknown
+  :sym: :unknown
+  :name: Unknown
+  :regex: .+

data/lib/double_agent.rb

@@ -0,0 +1,3 @@
+require 'double_agent/core'
+require 'double_agent/resources'
+require 'double_agent/stats'

data/lib/double_agent/all.rb

@@ -0,0 +1,2 @@
+require 'double_agent'
+require 'double_agent/logs'

data/lib/double_agent/core.rb

@@ -0,0 +1,156 @@
+require 'yaml'
+
+module DoubleAgent
+  # 
+  # Map browser/os ids to names, families and icons
+  # 
+  BROWSER_DATA = YAML.load_file(File.expand_path('../../../data/browsers.yml', __FILE__))
+  OS_DATA = YAML.load_file(File.expand_path('../../../data/oses.yml', __FILE__))
+
+  BROWSERS = {}
+  OSES = {}
+
+  class BrowserParser
+    BLANK = ''
+    MIN_VERSION = '1.9.2'
+    attr_reader :sym, :family_sym, :icon
+
+    def initialize(attrs={})
+      @family_sym = attrs[:family_sym]
+      @name = attrs[:name]
+      @sym = attrs[:sym]
+      @icon = attrs[:icon] || @sym
+      if RUBY_VERSION < MIN_VERSION and attrs[:safe_version]
+        @safe_version = attrs[:safe_version].map { |r| Regexp.new r, Regexp::IGNORECASE }
+      else
+        @version = Regexp.new(attrs[:version], Regexp::IGNORECASE)
+      end
+    end
+
+    def browser(ua=nil)
+      if ua
+        @name % version(ua)
+      else
+        (@name % BLANK).rstrip
+      end
+    end
+
+    def icon
+      @icon || @sym
+    end
+
+    def family
+      BROWSERS[family_sym]
+    end
+    
+    private
+
+    def version(ua)
+      if @safe_version and RUBY_VERSION < MIN_VERSION
+        ua.slice(@safe_version[0]).slice(@safe_version[1])
+      else
+        ua.slice(@version)
+      end
+    end
+  end
+
+  class OSParser
+    attr_reader :os, :sym, :family_sym, :icon
+
+    def initialize(attrs={})
+      @family_sym = attrs[:family_sym]
+      @os = attrs[:name]
+      @sym = attrs[:sym]
+      @icon = attrs[:icon] || @sym
+    end
+
+    def family
+      OSES[family_sym]
+    end
+  end
+
+  # 
+  # Methods for getting browser/os names, families, and icons either by passing a user agent string.
+  # 
+
+  def self.browser(ua)
+    browser_parser(ua).browser(ua)
+  end
+
+  def self.browser_sym(user_agent)
+  end
+
+  def self.browser_icon(ua)
+    browser_parser(ua).icon
+  end
+
+  def self.browser_family(ua)
+    browser_parser(ua).family.browser
+  end
+
+  def self.browser_family_sym(ua)
+    browser_parser(ua).family_sym
+  end
+
+  def self.browser_family_icon(ua)
+    browser_parser(ua).family.icon
+  end
+
+  def self.os(ua)
+    os_parser(ua).os
+  end
+
+  def self.os_sym(user_agent)
+  end
+
+  def self.os_icon(ua)
+    os_parser(ua).icon
+  end
+
+  def self.os_family(ua)
+    os_parser(ua).family.os
+  end
+
+  def self.os_family_sym(ua)
+    os_parser(ua).family_sym
+  end
+
+  def self.os_family_icon(ua)
+    os_parser(ua).family.icon
+  end
+
+  # Get a browser parser with either a user agent or symbol
+  def self.browser_parser(ua_or_sym)
+    BROWSERS[ua_or_sym.is_a?(Symbol) ? ua_or_sym : browser_sym(ua_or_sym)]
+  end
+
+  # Get an OS parser with either a user agent or symbol
+  def self.os_parser(ua_or_sym)
+    OSES[ua_or_sym.is_a?(Symbol) ? ua_or_sym : os_sym(ua_or_sym)]
+  end
+
+  def self.load_browsers!
+    BROWSERS.clear
+    str = "case user_agent\n"
+    BROWSER_DATA.each do |data|
+      BROWSERS[data[:sym]] = BrowserParser.new(data)
+      str << "  when %r{#{data[:regex]}}i then :#{data[:sym]}\n"
+    end
+    str << 'end'
+    module_eval "def self.browser_sym(user_agent); #{str}; end"
+  end
+
+  def self.load_oses!
+    OSES.clear
+    str = "case user_agent\n"
+    OS_DATA.each do |data|
+      OSES[data[:sym]] = OSParser.new(data)
+      str << "  when %r{#{data[:regex]}}i then :#{data[:sym]}\n"
+    end
+    str << 'end'
+    module_eval "def self.os_sym(user_agent); #{str}; end"
+  end
+end
+
+DoubleAgent.load_browsers!
+DoubleAgent.load_oses!

data/lib/double_agent/logs.rb

@@ -0,0 +1,28 @@
+require 'zlib'
+
+module DoubleAgent
+  def self.log_entries(glob_str, regex=nil)
+    entries, gz_regexp = [], /\.gz\Z/i
+    Dir.glob(glob_str).each do |f|
+      File.open(f) do |file|
+        handle = f =~ gz_regexp ? Zlib::GzipReader.new(file) : file
+        while ( line = handle.gets )
+          entries << LogEntry.new(line) if regex.nil? or line =~ regex
+        end
+      end
+    end
+    entries
+  end
+
+  class LogEntry
+    USER_AGENT_REGEXP = /[^"]+(?="$)/
+    include DoubleAgent::Resource
+
+    attr_reader :user_agent
+
+    def initialize(line)
+      #@line = line
+      @user_agent = line.slice(USER_AGENT_REGEXP)
+    end
+  end
+end

data/lib/double_agent/resources.rb

@@ -0,0 +1,65 @@
+module DoubleAgent
+  # 
+  # Any class with a "user_agent" method which returns a User Agent string
+  # may include this module to easily parse out Browser and OS info.
+  # 
+  module Resource
+    def browser
+      _browser_parser.browser(user_agent)
+    end
+
+    def browser_sym
+      _browser_parser.sym
+    end
+
+    def browser_icon
+      _browser_parser.icon
+    end
+
+    def browser_family
+      _browser_parser.family.browser
+    end
+
+    def browser_family_sym
+      _browser_parser.family_sym
+    end
+
+    def browser_family_icon
+      _browser_parser.family.icon
+    end
+
+    def os
+      _os_parser.os
+    end
+
+    def os_sym
+      _os_parser.sym
+    end
+
+    def os_icon
+      _os_parser.icon
+    end
+
+    def os_family
+      _os_parser.family.os
+    end
+
+    def os_family_sym
+      _os_parser.family_sym
+    end
+
+    def os_family_icon
+      _os_parser.family.icon
+    end
+
+    private
+
+    def _browser_parser
+      @browser_parser ||= DoubleAgent.browser_parser(user_agent)
+    end
+
+    def _os_parser
+      @os_parser ||= DoubleAgent.os_parser(user_agent)
+    end
+  end
+end

data/lib/double_agent/stats.rb

@@ -0,0 +1,48 @@
+# Time for some monkey patching!
+
+module DoubleAgent
+  BAD_RUBY = RUBY_VERSION < '1.9.0'
+
+  if BAD_RUBY
+    require 'bigdecimal'
+    def self.better_round(f, n)
+      d = BigDecimal.new f.to_s
+      d.round(n).to_f
+    end
+  end
+
+  # 
+  # For the given "things", returns the share of the group that each attr has.
+  # 
+  # "things" is an array of objects who's classes "include DoubleAgent::Resource".
+  # 
+  # "attrs" is one or more method symbols from DoubleAgent::Resource. The *_sym methods
+  # are probably the most useful here, as you can use the symbol results to query DoubleAgent 
+  # methods and get the browser/os name, family and icons.
+  # 
+  # Example, Browser Family share:
+  # DoubleAgent.percentages_for(logins, :browser_family)
+  # => [['Firefox', 50.4], ['Chrome', 19.6], ['Internet Explorer', 15], ['Safari', 10], ['Unknown', 5]]
+  # 
+  # Example, Browser/OS share, asking for symbols back:
+  # DoubleAgent.percentages_for(server_log_entries, :browser_sym, :os_sym)
+  # => [[:firefox_4, :windows_7, 50.4], [:firefox_3, :osx, 19.6], [:msie, :windows_xp, 15], [:safari, :osx, 10], [:other, :other, 5]]
+  # 
+  def self.percentages_for(things, *attrs)
+    p = {}
+    things.each do |h|
+      syms = attrs.map { |attr| h.send attr }
+      p[syms] = 0 unless p.has_key? syms
+      p[syms] += 1
+    end
+    size = things.size.to_f
+    p = p.to_a
+    if BAD_RUBY
+      p.collect! { |k,n| [*k.<<(better_round(((n * 100) / size), 2))] }
+    else
+      p.collect! { |k,n| [*k.<<(((n * 100) / size).round(2))] }
+    end
+    p.sort! { |a,b| b.last <=> a.last }
+    p
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: double_agent
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jordan Hollinger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-30 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Browser User Agent string parser with resource, stats, and a log reader
+email: jordan@jordanhollinger.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/double_agent.rb
+- lib/double_agent/all.rb
+- lib/double_agent/stats.rb
+- lib/double_agent/resources.rb
+- lib/double_agent/core.rb
+- lib/double_agent/logs.rb
+- data/browsers.yml
+- data/oses.yml
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/jhollinger/double_agent
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Browser User Agent string parser
+test_files: []
+