wurfl_device 0.0.10

data/.gitignore

@@ -0,0 +1,8 @@
+*.sw?
+.DS_Store
+coverage/
+doc/
+pkg/
+*.gem
+.bundle/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Rakefile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue LoadError
+  $stderr.puts "Bundler not installed. You should install it with: gem install bundler"
+end
+
+$LOAD_PATH << File.expand_path('./lib', File.dirname(__FILE__))
+require 'wurfl_device/version'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+
+  if RUBY_VERSION >= '1.9'
+    RSpec::Core::RakeTask.new(:cov) do |t|
+      ENV['ENABLE_SIMPLECOV'] = '1'
+      t.ruby_opts = '-w'
+      t.rcov_opts = %q[-Ilib --exclude "spec/*,gems/*"]
+    end
+  end
+rescue LoadError
+  $stderr.puts "RSpec not available. Install it with: gem install rspec-core rspec-expectations rr faker"
+end
+
+task :default => :spec
+

data/bin/wurfldevice

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'wurfl_device/cli'
+
+begin
+  WurflDevice::CLI.start
+rescue WurflDevice::WurflDeviceError => e
+  WurflDevice.ui.error e.message
+  WurflDevice.ui.debug e.backtrace.join("\n")
+  exit e.status_code
+rescue Interrupt => e
+  WurflDevice.ui.error "\nQuitting..."
+  WurflDevice.ui.debug e.backtrace.join("\n")
+  exit 1
+end

data/lib/wurfl_device.rb

@@ -0,0 +1,244 @@
+require 'etc'
+require 'redis'
+
+require 'wurfl_device/version'
+
+module WurflDevice
+  autoload :Capability,         'wurfl_device/capability'
+  autoload :Constants,          'wurfl_device/constants'
+  autoload :Device,             'wurfl_device/device'
+  autoload :Handset,            'wurfl_device/handset'
+  autoload :UI,                 'wurfl_device/ui'
+  autoload :CLI,                'wurfl_device/cli'
+  autoload :UserAgentMatcher,   'wurfl_device/user_agent_matcher'
+  autoload :XmlLoader,          'wurfl_device/xml_loader'
+
+  class WurflDeviceError < StandardError
+    def self.status_code(code = nil)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class CacheError    < WurflDeviceError; status_code(10); end
+
+  class << self
+    attr_writer :ui, :db
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    def db
+      @db ||= Redis.new(:db => Constants::DB_INDEX)
+    end
+
+    def tmp_dir
+      File.join(Etc.systmpdir, 'wurfl_device')
+    end
+
+    def get_actual_device(device_id)
+      capabilities = Capability.new
+      actual_device = get_actual_device_raw(device_id)
+      return nil if actual_device.nil?
+      actual_device.each_pair do |key, value|
+        if key =~ /^(.+)\:(.+)$/i
+          capabilities[$1] ||= Capability.new
+          capabilities[$1][$2] = parse_string_value(value)
+        else
+          capabilities[key] = parse_string_value(value)
+        end
+      end
+      capabilities
+    end
+
+    def get_device_from_id(device_id)
+      device = Device.new(device_id)
+      return device if device.is_valid?
+      return nil
+    end
+
+    def get_device_from_ua(user_agent)
+      matcher = UserAgentMatcher.new.match(user_agent)
+      return matcher.device
+    end
+
+    def get_device_from_ua_cache(user_agent)
+      cached_device = db.hget(Constants::WURFL_USER_AGENTS_CACHED, user_agent)
+      return Marshal::load(cached_device) unless cached_device.nil?
+      cached_device = db.hget(Constants::WURFL_USER_AGENTS, user_agent)
+      return Marshal::load(cached_device) unless cached_device.nil?
+      return nil
+    end
+
+    def save_device_in_ua_cache(user_agent, device)
+      db.hset(Constants::WURFL_USER_AGENTS_CACHED, user_agent, Marshal::dump(device))
+    end
+
+    def get_info
+      db.hgetall(Constants::WURFL_INFO)
+    end
+
+    # cache related
+    def clear_user_agent_cache
+      db.del(Constants::WURFL_USER_AGENTS_CACHED)
+    end
+
+    def clear_cache
+      db.keys("#{Constants::WURFL}*").each { |k| db.del k }
+    end
+
+    def clear_devices
+      db.keys("#{Constants::WURFL_DEVICES}*").each { |k| db.del k }
+      db.del(Contants::WURFL_INITIALIZED)
+      db.del(Contants::WURFL_INFO)
+    end
+
+    def get_user_agents
+      db.hkeys(Constants::WURFL_USER_AGENTS)
+    end
+
+    def get_user_agents_in_cache
+      db.hkeys(Constants::WURFL_USER_AGENTS_CACHED)
+    end
+
+    def get_user_agents_in_index(matcher)
+      db.hgetall("#{Constants::WURFL_DEVICES_INDEX}#{matcher}")
+    end
+
+    def get_actual_device_raw(device_id)
+      db.hgetall("#{Constants::WURFL_DEVICES}#{device_id}")
+    end
+
+    def get_devices
+      db.keys("#{Constants::WURFL_DEVICES}*")
+    end
+
+    def get_indexes
+      db.keys("#{Constants::WURFL_DEVICES_INDEX}*")
+    end
+
+    def rebuild_user_agent_cache
+      # update the cache's
+      get_indexes.each { |k| db.del k }
+      db.del(Constants::WURFL_USER_AGENTS)
+      db.del(Constants::WURFL_DEVICES_INDEX)
+
+      get_devices.each do |device_id|
+        device_id.gsub!(Constants::WURFL_DEVICES, '')
+        actual_device = get_actual_device(device_id)
+        next if actual_device.nil?
+        user_agent = actual_device.user_agent
+        next if user_agent.nil? || user_agent.empty?
+        db.hset(Constants::WURFL_USER_AGENTS, user_agent, Marshal::dump(Device.new(device_id)))
+
+        matcher = UserAgentMatcher.get_index(user_agent)
+        db.hset("#{Constants::WURFL_DEVICES_INDEX}#{matcher}", user_agent, device_id)
+      end
+
+      get_user_agents_in_cache.each do |user_agent|
+        db.hdel(Constants::WURFL_USER_AGENTS_CACHED, user_agent)
+        UserAgentMatcher.new.match(user_agent)
+      end
+    end
+
+    def is_initialized?
+      status = parse_string_value(db.get(Constants::WURFL_INITIALIZED))
+      return false if status.nil?
+      return false unless status.is_a?(TrueClass)
+      true
+    end
+
+    def initialize_cache
+      # make sure only process can initialize at a time
+      # don't initialize if there is another initializing
+      lock_the_cache_for_initializing do
+        db.set(Constants::WURFL_INITIALIZED, false)
+
+        # download & parse the wurfl xml
+        (devices, version, last_updated) = XmlLoader.load_xml_file(download_wurfl_xml_file) do |capabilities|
+          device_id = capabilities.delete('id')
+          next if device_id.nil? || device_id.empty?
+          db.del("#{Constants::WURFL_DEVICES}#{device_id}")
+          user_agent = capabilities.delete('user_agent')
+          fall_back = capabilities.delete('fall_back')
+
+          device_id.strip! unless device_id.nil?
+          user_agent.strip! unless user_agent.nil?
+          fall_back.strip! unless fall_back.nil?
+
+          db.hset("#{Constants::WURFL_DEVICES}#{device_id}", "id", device_id)
+          db.hset("#{Constants::WURFL_DEVICES}#{device_id}", "user_agent", user_agent)
+          db.hset("#{Constants::WURFL_DEVICES}#{device_id}", "fall_back", fall_back)
+
+          capabilities.each_pair do |key, value|
+            if value.is_a?(Hash)
+              value.each_pair do |k, v|
+                db.hset("#{Constants::WURFL_DEVICES}#{device_id}", "#{key.to_s}:#{k.to_s}", v)
+              end
+            else
+              db.hset("#{Constants::WURFL_DEVICES}#{device_id}", "#{key.to_s}", value)
+            end
+          end
+        end
+
+        db.set(Constants::WURFL_INITIALIZED, true)
+        db.hset(Constants::WURFL_INFO, "version", version)
+        db.hset(Constants::WURFL_INFO, "last_updated", Time.now)
+      end
+    end
+
+    def parse_string_value(value)
+      return value unless value.is_a?(String)
+      # convert to utf-8 (wurfl.xml encoding format)
+      value.force_encoding('UTF-8')
+      return false if value =~ /^false/i
+      return true if value =~ /^true/i
+      return value.to_i if (value == value.to_i.to_s)
+      return value.to_f if (value == value.to_f.to_s)
+      value
+    end
+  protected
+    def download_wurfl_xml_file
+      wurfl_xml_source = "http://sourceforge.net/projects/wurfl/files/WURFL/2.2/wurfl-2.2.xml.gz"
+      FileUtils.mkdir_p(WurflDevice.tmp_dir)
+      FileUtils.cd(WurflDevice.tmp_dir)
+      `wget --timeout=60 -qN -- #{wurfl_xml_source} > /dev/null`
+      raise "Failed to download wurfl-latest.xml.gz" unless $? == 0
+
+      wurfl_xml_filename = File.basename(wurfl_xml_source)
+      `gunzip -qc #{wurfl_xml_filename} > wurfl.xml`
+      raise 'Failed to unzip wurfl-latest.xml.gz' unless $? == 0
+
+      wurfl_xml_file_extracted = File.join(WurflDevice.tmp_dir, 'wurfl.xml')
+      raise "wurfl.xml does not exists!" unless File.exists?(wurfl_xml_file_extracted)
+
+      wurfl_xml_file_extracted
+    end
+
+    def lock_the_cache_for_initializing
+      start_at = Time.now
+      success = false
+      while Time.now - start_at < Constants::LOCK_TIMEOUT
+        success = true and break if try_lock
+        sleep Constants::LOCK_SLEEP
+      end
+      if block_given? and success
+        yield
+        unlock
+      end
+    end
+
+    def try_lock
+      now = Time.now.to_f
+      @expires_at = now + Constants::LOCK_EXPIRE
+      return true if db.setnx(Constants::WURFL_INITIALIZING, @expires_at)
+      return false if db.get(Constants::WURFL_INITIALIZING).to_f > now
+      return true if db.getset(Constants::WURFL_INITIALIZING, @expires_at).to_f <= now
+      return false
+    end
+
+    def unlock(force=false)
+      db.del(Constants::WURFL_INITIALIZING) if db.get(Constants::WURFL_INITIALIZING).to_f == @expires_at or force
+    end
+  end
+end

data/lib/wurfl_device/capability.rb

@@ -0,0 +1,61 @@
+module WurflDevice
+  class Capability < ::Hash
+    def initialize(hash={})
+      super()
+      hash.each do |key, value|
+        self[convert_key(key)] = value
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      other.each do |key, value|
+        self[convert_key(key)] = value
+      end
+      self
+    end
+
+  protected
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    # Magic predicates. For instance:
+    #
+    #   capability.force?                   # => !!options['force']
+    #   capability.shebang                  # => "/usr/lib/local/ruby"
+    #   capability.test_framework?(:rspec)  # => options[:test_framework] == :rspec
+    #
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method =~ /^(\w+)\?$/
+        if args.empty?
+          !!self[$1]
+        else
+          self[$1] == args.first
+        end
+      else
+        self[method]
+      end
+    end
+  end
+end

data/lib/wurfl_device/cli.rb

@@ -0,0 +1,124 @@
+require 'thor'
+require 'wurfl_device'
+
+module WurflDevice
+  class CLI < Thor
+    include Thor::Actions
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
+      WurflDevice.ui = UI::Shell.new(the_shell)
+      WurflDevice.ui.debug! if options["verbose"]
+    end
+
+    check_unknown_options!
+
+    default_task :help
+
+    desc "help", "Show this message"
+    def help(cli=nil)
+      version
+      WurflDevice.ui.info "http://github.com/aputs/wurfl_device for README"
+      WurflDevice.ui.info ""
+      super
+    end
+
+    desc "dump DEVICE_ID|USER_AGENT", "display capabilities DEVICE_ID|USER_AGENT"
+    method_option :json, :type => :boolean, :banner => "show the dump in json format", :aliases => "-j"
+    method_option :yaml, :type => :boolean, :banner => "show the dump in yaml format", :aliases => "-y"
+    def dump(device_id)
+      device = WurflDevice.get_device_from_id(device_id)
+      device = WurflDevice.get_device_from_ua(device_id, use_cache) if device.nil?
+
+      if options.json?
+        WurflDevice.ui.info device.capabilities.to_json
+      else
+        WurflDevice.ui.info device.capabilities.to_yaml
+      end
+    end
+
+    desc "list", "list user agent cache list"
+    def list
+      WurflDevice.get_user_agents_in_cache.each do |user_agent|
+        device = WurflDevice.get_device_from_ua_cache(user_agent)
+        device_id = ''
+        device_id = device.id unless device.nil?
+        WurflDevice.ui.info user_agent + ":" + device_id
+      end
+    end
+
+    desc "update", "update the wurfl cache"
+    method_option "clear-all", :type => :boolean, :banner => "remove all wurfl cache related"
+    method_option "clear-dev", :type => :boolean, :banner => "clear the device cache first before updating"
+    method_option "clear-ua", :type => :boolean, :banner => "remove all wurfl user agents cache"
+    def update
+      opts = options.dup
+      if opts['clear-all']
+        WurflDevice.ui.info "clearing all cache entries."
+        WurflDevice.clear_devices
+        WurflDevice.clear_cache
+      end
+      if opts['clear-ua']
+        WurflDevice.ui.info "clearing user agent cache."
+        WurflDevice.clear_user_agent_cache
+      end
+      if opts['clear-dev']
+        WurflDevice.ui.info "clearing device cache."
+        WurflDevice.clear_devices
+      end
+      WurflDevice.ui.info "updating wurfl devices cache."
+      WurflDevice.initialize_cache
+      WurflDevice.ui.info "rebuilding cache."
+      WurflDevice.rebuild_user_agent_cache
+      WurflDevice.ui.info "done."
+      WurflDevice.ui.info ""
+      status true
+    end
+
+    desc "rebuild", "rebuild the existing user_agents cache"
+    def rebuild
+      WurflDevice.ui.info "rebuilding the user_agents cache."
+      WurflDevice.rebuild_user_agent_cache
+      WurflDevice.ui.info "done."
+    end
+
+    desc "status", "show wurfl cache information"
+    def status(skip_version=false)
+      version unless skip_version
+      unless WurflDevice.is_initialized?
+        WurflDevice.ui.info "cache is not initialized"
+        return
+      end
+      info = WurflDevice.get_info
+      version = info['version'] || 'none'
+      last_update = info['last_updated'] || 'unknown'
+      WurflDevice.ui.info "cache info:"
+      WurflDevice.ui.info "  wurfl-xml version: " + version
+      WurflDevice.ui.info "  cache last updated: " + last_update
+      devices = WurflDevice.get_devices
+      user_agents = WurflDevice.get_user_agents
+      user_agents_message = ''
+      user_agents_message = " (warning count should be equal to devices count)" if devices.length != user_agents.length
+      WurflDevice.ui.info "  " + commify(devices.length) + " device id's"
+      WurflDevice.ui.info "  " + commify(user_agents.length) + " exact user agents" + user_agents_message
+      WurflDevice.ui.info "  " + commify(WurflDevice.get_user_agents_in_cache.length) + " user agents found in cache"
+      WurflDevice.ui.info ""
+    end
+    map %w(stats stat info) => :status
+
+    desc "version", "show the wurfl_device version information"
+    def version
+      WurflDevice.ui.info "wurfl_device version #{WurflDevice::VERSION.freeze}"
+    end
+    map %w(-v --version) => :version
+  private
+    def commify(n)
+      n.to_s =~ /([^\.]*)(\..*)?/
+      int, dec = $1.reverse, $2 ? $2 : ""
+      while int.gsub!(/(,|\.|^)(\d{3})(\d)/, '\1\2,\3')
+      end
+      int.reverse + dec
+    end
+  end
+end

data/lib/wurfl_device/constants.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+module WurflDevice
+  class Constants
+    LOCK_TIMEOUT                  = 3
+    LOCK_EXPIRE                   = 10
+    LOCK_SLEEP                    = 0.1
+
+    DB_INDEX                      = "7".freeze
+    GENERIC                       = 'generic'
+    WURFL                         = "wurfl:"
+    WURFL_INFO                    = "wurfl:info"
+    WURFL_DEVICES                 = "wurfl:devices:"
+    WURFL_DEVICES_INDEX           = "wurfl:index:"
+    WURFL_INITIALIZED             = "wurfl:is_initialized"
+    WURFL_INITIALIZING            = "wurfl:is_initializing"
+    WURFL_USER_AGENTS             = "wurfl:user_agents"
+    WURFL_USER_AGENTS_CACHED      = "wurfl:user_agents_cached"
+
+    USER_AGENT_MATCHERS =
+    [
+      "Alcatel", "Android", "AOL", "Apple", "BenQ", "BlackBerry", "Bot", "CatchAll", "Chrome", "DoCoMo",
+      "Firefox", "Grundig", "HTC", "Kddi", "Konqueror", "Kyocera", "LG", "Mitsubishi", "Motorola", "MSIE",
+      "Nec", "Nintendo", "Nokia", "Opera", "OperaMini", "Panasonic", "Pantech", "Philips", "Portalmmm", "Qtek",
+      "Safari", "Sagem", "Samsung", "Sanyo", "Sharp", "Siemens", "SonyEricsson", "SPV", "Toshiba", "Vodafone", "WindowsCE"
+    ]
+
+    MOBILE_BROWSERS   =  [
+      'cldc', 'symbian', 'midp', 'j2me', 'mobile', 'wireless', 'palm', 'phone', 'pocket pc', 'pocketpc', 'netfront',
+      'bolt', 'iris', 'brew', 'openwave', 'windows ce', 'wap2.', 'android', 'opera mini', 'opera mobi', 'maemo', 'fennec',
+      'blazer', 'vodafone', 'wp7', 'armv'
+    ]
+
+    ROBOTS            = [ 'bot', 'crawler', 'spider', 'novarra', 'transcoder', 'yahoo! searchmonkey', 'yahoo! slurp', 'feedfetcher-google', 'toolbar', 'mowser' ]
+    DESKTOP_BROWSERS  = [ 'slcc1', '.net clr', 'wow64', 'media center pc', 'funwebproducts', 'macintosh', 'aol 9.', 'america online browser', 'googletoolbar' ]
+  end
+end

data/lib/wurfl_device/device.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+require 'redis'
+
+module WurflDevice
+  class Device
+    attr_accessor :capabilities
+
+    def initialize(device_id=nil)
+      raise WurflDevice::CacheError, "wurfl cache is not initialized" unless WurflDevice.is_initialized?
+      if device_id.nil?
+        @capabilities = WurflDevice.get_actual_device(WurflDevice::Constants::GENERIC)
+      else
+        @capabilities = build_device(device_id)
+      end
+    end
+
+    def is_valid?
+      return false if @capabilities.nil?
+      return false if @capabilities.id.nil?
+      return false if @capabilities.id.empty?
+      return true
+    end
+
+    def is_generic?
+      is_valid? && @capabilities.id !~ Regexp.new(WurflDevice::Constants::GENERIC, Regexp::IGNORECASE)
+    end
+
+    def build_device(device_id)
+      capabilities = Capability.new
+      device = WurflDevice.get_actual_device_raw(device_id)
+      return nil if device.nil?
+
+      capabilities['fall_back_tree'] ||= Array.new
+
+      if !device['fall_back'].nil? && !device['fall_back'].empty? && device['id'] != WurflDevice::Constants::GENERIC
+        fall_back = build_device(device['fall_back'])
+        unless fall_back.nil?
+          capabilities['fall_back_tree'].unshift(fall_back['id'])
+          fall_back.each_pair do |key, value|
+            if value.kind_of?(Hash)
+              capabilities[key] ||= Capability.new
+              value.each_pair do |k, v|
+                capabilities[key][k] = v
+              end
+            elsif value.is_a?(Array)
+              capabilities[key] ||= Array.new
+              capabilities[key] |= value
+            else
+              capabilities[key] = value
+            end
+          end
+        end
+      end
+
+      device.each_pair do |key, value|
+        if key =~ /^(.+)\:(.+)$/i
+          capabilities[$1] ||= Capability.new
+          capabilities[$1][$2] = WurflDevice.parse_string_value(value)
+        else
+          capabilities[key] = WurflDevice.parse_string_value(value)
+        end
+      end
+
+      capabilities
+    end
+
+    # Magic predicates
+    # slower than going directly to capabilities
+    def method_missing(method, *args, &block)
+      return nil if @capabilities.nil?
+      meth = method.to_s
+      meth.gsub!(/\?/, '')
+      return @capabilities.send(method, args, block) if @capabilities.has_key?(meth)
+      @capabilities.each_pair do |key, value|
+        if value.is_a?(Hash)
+          return value.send(method, args, block) if value.has_key?(meth)
+        end
+      end
+      return nil
+    end
+  end
+end

data/lib/wurfl_device/ui.rb

@@ -0,0 +1,73 @@
+require 'rubygems/user_interaction'
+
+module WurflDevice
+  class UI
+    def warn(message)
+    end
+
+    def debug(message)
+    end
+
+    def error(message)
+    end
+
+    def info(message)
+    end
+
+    def confirm(message)
+    end
+
+    class Shell < UI
+      attr_writer :shell
+
+      def initialize(shell)
+        @shell = shell
+        @quiet = false
+        @debug = ENV['DEBUG']
+      end
+
+      def debug(msg)
+        @shell.say(msg) if @debug && !@quiet
+      end
+
+      def info(msg)
+        @shell.say(msg) if !@quiet
+      end
+
+      def confirm(msg)
+        @shell.say(msg, :green) if !@quiet
+      end
+
+      def warn(msg)
+        @shell.say(msg, :yellow)
+      end
+
+      def error(msg)
+        @shell.say(msg, :red)
+      end
+
+      def be_quiet!
+        @quiet = true
+      end
+
+      def debug!
+        @debug = true
+      end
+    end
+
+    class RGProxy < ::Gem::SilentUI
+      def initialize(ui)
+        @ui = ui
+        super()
+      end
+
+      def say(message)
+        if message =~ /native extensions/
+          @ui.info "with native extensions "
+        else
+          @ui.debug(message)
+        end
+      end
+    end
+  end
+end

data/lib/wurfl_device/user_agent_matcher.rb

@@ -0,0 +1,156 @@
+require 'text'
+
+module WurflDevice
+  class UserAgentMatcher
+    attr_accessor :user_agent, :user_agent_cleaned, :device
+
+    def match(user_agent)
+      @user_agent = user_agent
+      @user_agent_cleaned = UserAgentMatcher.clean_user_agent(user_agent)
+      @device = nil
+
+      # exact match
+      @device = WurflDevice.get_device_from_ua_cache(@user_agent)
+      @device = WurflDevice.get_device_from_ua_cache(@user_agent_cleaned) if @device.nil?
+
+      # already in cache so return immediately
+      return self if !@device.nil? && @device.is_valid?
+
+      # ris match
+      if @device.nil?
+        user_agent = @user_agent
+        user_agent_list = WurflDevice.get_user_agents_in_index(UserAgentMatcher.get_index(user_agent)).sort { |a, b| a[0] <=> b[0] }
+        tolerance = UserAgentMatcher.first_slash(user_agent)-1
+        curlen = user_agent.length
+        while curlen >= tolerance
+          user_agent_list.map do |ua, device_id|
+            if ua.index(user_agent) == 0
+              @device = Device.new(device_id)
+              break
+            end
+          end
+          break unless @device.nil?
+          user_agent = user_agent.slice(0, curlen-1)
+          curlen = user_agent.length
+        end
+      end
+
+      # last attempts
+      if @device.nil?
+        user_agent = @user_agent
+        device_id = WurflDevice::Constants::GENERIC
+        device_id = 'opwv_v7_generic' if user_agent.index('UP.Browser/7')
+        device_id = 'opwv_v6_generic' if user_agent.index('UP.Browser/6')
+        device_id = 'upgui_generic' if user_agent.index('UP.Browser/5')
+        device_id = 'uptext_generic' if user_agent.index('UP.Browser/4')
+        device_id = 'uptext_generic' if user_agent.index('UP.Browser/3')
+        device_id = 'nokia_generic_series60' if user_agent.index('Series60')
+        device_id = 'generic_web_browser' if user_agent.index('Mozilla/4.0')
+        device_id = 'generic_web_browser' if user_agent.index('Mozilla/5.0')
+        device_id = 'generic_web_browser' if user_agent.index('Mozilla/6.0')
+        @device = WurflDevice.get_device_from_id(device_id)
+      end
+
+      WurflDevice.save_device_in_ua_cache(@user_agent, @device)
+
+      return self
+    end
+
+    class << self
+      def get_index(user_agent)
+        # create device index
+        matcher = 'Generic'
+        WurflDevice::Constants::USER_AGENT_MATCHERS.each do |m|
+          if Regexp.new(m, Regexp::IGNORECASE) =~ user_agent
+            matcher = m
+            break
+          end
+        end
+        return matcher
+      end
+
+      def clean_user_agent(user_agent)
+        user_agent = remove_up_link_from_ua(user_agent)
+
+        # remove nokia-msisdn header
+        user_agent = remove_nokia_msisdn(user_agent)
+
+        # clean up myphone id's
+        user_agent = user_agent.sub("'M', 'Y' 'P', 'H', 'O', 'N', 'E'", "MyPhone")
+        
+        # remove serial numbers
+        user_agent = user_agent.sub(/\/SN\d{15}/, '/SNXXXXXXXXXXXXXXX')
+        user_agent = user_agent.sub(/\[(ST|TF|NT)\d+\]/, '')
+
+        # remove locale identifiers
+        user_agent = user_agent.sub(/([ ;])[a-zA-Z]{2}-[a-zA-Z]{2}([ ;\)])/, '\1xx-xx\2')
+
+        user_agent = normalize_blackberry(user_agent)
+        user_agent = normalize_android(user_agent)
+
+        return user_agent.strip
+      end
+
+      def first_slash(user_agent)
+        pos = user_agent.index('/')
+        return user_agent.length if pos.nil?
+        return pos
+      end
+
+      def second_slash(user_agent)
+        first = user_agent.index('/')
+        return user_agent.length if first.nil?
+        first = first + 1
+        second = user_agent.index('/', first)
+        return user_agent.length if second.nil?
+        return second
+      end
+
+      def first_space(user_agent)
+        pos = user_agent.index(' ')
+        return user_agent.length if pos.nil?
+        return pos
+      end
+
+      def first_open_paren(user_agent)
+        pos = user_agent.index('(')
+        return user_agent.length if pos.nil?
+        return pos
+      end
+
+      def remove_nokia_msisdn(user_agent)
+        if user_agent =~ /^(.+)NOKIA-MSISDN\:\ (.+)$/i
+          user_agent = $1
+        end
+        return user_agent
+      end
+
+      def remove_up_link_from_ua(user_agent)
+        pos = user_agent.index('UP.Link')
+        return user_agent unless pos
+        return user_agent.slice(0..(pos-1))
+      end
+
+      def normalize_blackberry(user_agent)
+        pos = user_agent.index('BlackBerry')
+        return user_agent if pos.nil?
+        return user_agent.slice(pos, user_agent.length - pos)
+      end
+
+      def normalize_android(user_agent)
+        return user_agent.sub(/(Android \d\.\d)([^; \/\)]+)/, '\1')
+      end
+
+      def parse(user_agent)
+        # grab all Agent/version strings as 'agents'
+        agents = Array.new
+        user_agent.split(/\s+/).each do |string| 
+          if string =~ /\//
+            agents << string
+          end
+        end
+        return agents
+      end
+    end
+  end
+end

data/lib/wurfl_device/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+module WurflDevice
+  VERSION = "0.0.10".freeze
+end

data/lib/wurfl_device/xml_loader.rb

@@ -0,0 +1,49 @@
+require 'etc'
+require 'nokogiri'
+
+module WurflDevice
+  class XmlLoader
+    def self.load_xml_file(wurfl_file, &blk)
+      devices = Hash.new
+
+      xml = Nokogiri::XML File.open(wurfl_file)
+
+      version = xml.xpath('//version/ver')[0].children.to_s rescue nil
+      last_updated = DateTime.parse(xml.xpath('//version/last_updated')[0].children.to_s) rescue nil
+
+      xml.xpath('//devices/*').each do |element|
+        wurfl_id = 'generic'
+        user_agent = 'generic'
+        fall_back = nil
+        if element.attributes["id"].to_s != "generic"
+          wurfl_id = element.attributes["id"].to_s
+          user_agent = element.attributes["user_agent"].to_s
+          user_agent = 'generic' if user_agent.empty?
+          fall_back = element.attributes["fall_back"].to_s
+        end
+
+        device = Hash.new
+        device['id'] = wurfl_id
+        device['user_agent'] = user_agent
+        device['fall_back'] = fall_back
+
+        element.xpath('.//*').each do |group|
+          group_id = group.attributes["id"].to_s
+          next if group_id.empty?
+          group_capa = Hash.new
+          group.xpath('.//*').each do |capability|
+            name = capability.attributes["name"].to_s
+            next if name.empty?
+            group_capa[name] = WurflDevice.parse_string_value(capability.attributes["value"].to_s)
+          end
+          device[group_id] = group_capa
+        end
+
+        devices[wurfl_id] = device
+        yield device if block_given?
+      end
+
+      [devices, version, last_updated]
+    end
+  end
+end

data/spec/cache/device_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'yaml'
+
+describe WurflDevice do
+  describe :devices do
+    it "cache should be available" do
+      WurflDevice.is_initialized?.should == true
+    end
+
+    it "generic device should exists" do
+      device = WurflDevice.get_actual_device(WurflDevice::Constants::GENERIC)
+      device.id.should == WurflDevice::Constants::GENERIC
+    end
+
+    it "check for user agent matcher" do
+      user_agent = 'Mozilla/5.0 (SymbianOS/9.2; U; Series60/3.1 Nokia6120c/6.01; Profile/MIDP-2.0 Configuration/CLDC-1.1 ) AppleWebKit/413 (KHTML, like Gecko) Safari/413'
+      device = WurflDevice.get_device_from_ua(user_agent)
+      device.id.should == 'nokia_6120c_ver1_sub601'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+if RUBY_VERSION >= '1.9'
+  if ENV['ENABLE_SIMPLECOV']
+    require 'simplecov'
+    SimpleCov.start
+  end
+else
+  require 'rubygems'
+end
+
+require 'faker'
+require 'rspec/core'
+
+$LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  config.color_enabled = true
+end
+
+require 'wurfl_device'

data/wurfl_device.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "wurfl_device/version"
+
+Gem::Specification.new do |s|
+  s.name        = "wurfl_device"
+  s.version     = WurflDevice::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Allan Ralph Hutalla"]
+  s.email       = ["ahutalla@gmail.com"]
+  s.homepage    = "http://github.com/aputs/wurfl_device"
+  s.summary     = %q{Ruby client library for mobile handset detection}
+  s.description = %q{Ruby client library for mobile handset detection}
+
+  s.add_dependency 'thor'
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'redis'
+  s.add_dependency 'text'
+
+  s.add_development_dependency 'bundler', '>= 1.0.10'
+  s.add_development_dependency 'rake', '>= 0.9.2'
+  s.add_development_dependency 'rspec-core', '~> 2.0'
+  s.add_development_dependency 'rspec-expectations', '~> 2.0'
+  s.add_development_dependency 'rr', '~> 1.0'
+  s.add_development_dependency 'faker', '~> 0.9'
+  s.add_development_dependency 'simplecov', '~> 0.5.3'
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+  s.extra_rdoc_files = ["LICENSE", "README.md"]
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: wurfl_device
+version: !ruby/object:Gem::Version
+  version: 0.0.10
+  prerelease: 
+platform: ruby
+authors:
+- Allan Ralph Hutalla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &66803460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *66803460
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &66802960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *66802960
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &66802500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *66802500
+- !ruby/object:Gem::Dependency
+  name: text
+  requirement: &66802060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *66802060
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &66801540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.10
+  type: :development
+  prerelease: false
+  version_requirements: *66801540
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &66801020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *66801020
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: &66800540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *66800540
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: &66800060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *66800060
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &66799560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *66799560
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: &66799000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *66799000
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &66798340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :development
+  prerelease: false
+  version_requirements: *66798340
+description: Ruby client library for mobile handset detection
+email:
+- ahutalla@gmail.com
+executables:
+- wurfldevice
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/wurfldevice
+- lib/wurfl_device.rb
+- lib/wurfl_device/capability.rb
+- lib/wurfl_device/cli.rb
+- lib/wurfl_device/constants.rb
+- lib/wurfl_device/device.rb
+- lib/wurfl_device/ui.rb
+- lib/wurfl_device/user_agent_matcher.rb
+- lib/wurfl_device/version.rb
+- lib/wurfl_device/xml_loader.rb
+- spec/cache/device_spec.rb
+- spec/spec_helper.rb
+- wurfl_device.gemspec
+homepage: http://github.com/aputs/wurfl_device
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby client library for mobile handset detection
+test_files:
+- spec/cache/device_spec.rb
+- spec/spec_helper.rb