wurfl_device 0.1.5 → 0.1.6

data/.rvmrc

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-ruby_string="1.9.2"
+ruby_string="1.9.3"
 gemset_name="wurfl_device"
 
 if rvm list strings | grep -q "${ruby_string}" ; then
@@ -9,7 +9,7 @@ if rvm list strings | grep -q "${ruby_string}" ; then
   if [[ -d "${rvm_path:-$HOME/.rvm}/environments" && -s "${rvm_path:-$HOME/.rvm}/environments/${ruby_string}@${gemset_name}" ]] ; then
     \. "${rvm_path:-$HOME/.rvm}/environments/${ruby_string}@${gemset_name}"
   else
-    rvm --create  "${ruby_string}@${gemset_name}"
+    rvm --create "${ruby_string}@${gemset_name}"
   fi
 
   if ! command -v bundle ; then

data/README.md

@@ -1,22 +1,46 @@
-# WurflDevice
+WurflDevice
+===========
 Ruby client library for mobile handset detection
 
 
-requirements
+Requirements
 ------------
-  * [redis server](http://redis.io/)
+* [redis server](http://redis.io/)
 
 
-usage
+Installation
+------------
+install using rubygems
+
+    gem install wurfl_device
+
+or add to your Gemfile:
+
+    gem wurfl_device
+
+and install it via Bundler:
+
+    $ bundle
+
+
+Usage
 -----
 
     require 'wurfl_device'
 
+get capabilities hash from user agent
+
     user_agent = 'Mozilla/5.0 (SymbianOS/9.2; U; Series60/3.1 NokiaN95_8GB/20.0.016; Profile/MIDP-2.0 Configuration/CLDC-1.1 ) AppleWebKit/413 (KHTML, like Gecko) Safari/413'
+    capabilities = WurflDevice.capabilities_from_user_agent(user_agent)
+
+get capabilities hash from device id
 
-    device = WurflDevice.get_device_from_ua(user_agent)
+    device_id = 'generic'
+    capabilities = WurflDevice.capabilities_from_id(device_id)
 
-    # see device capabilities list for names
-    puts device.id
+get capability from user agent
 
+    user_agent = 'generic'
+    capability_name = 'id'
+    capability = WurflDevice.capabilities(capability_name, user_agent)
 

data/config/unicorn.conf.rb

@@ -5,17 +5,23 @@ require 'raindrops'
 
 $stats ||= Raindrops::Middleware::Stats.new
 
-FileUtils.mkdir_p(WurflDevice::Constants::WEBSERVICE_ROOT) unless File.directory?(WurflDevice::Constants::WEBSERVICE_ROOT)
+FileUtils.mkdir_p(WurflDevice::Settings::BASE_DIR) unless File.directory?(WurflDevice::Settings::BASE_DIR)
 
 app_env = ENV['RACK_ENV'] || 'production'
 app_root = ::File.expand_path('../..', __FILE__)
 
-timeout 60
+app_timeout       = 60
+app_workers       = WurflDevice::Settings::WEBSERVICE_WORKER
+app_listen_socket = File.join(WurflDevice::Settings::BASE_DIR, WurflDevice::Settings::WEBSERVICE_SOCKET)
+app_pid_file      = File.join(WurflDevice::Settings::BASE_DIR, WurflDevice::Settings::WEBSERVICE_PID)
+app_log_file      = File.join(WurflDevice::Settings::BASE_DIR, WurflDevice::Settings::WEBSERVICE_LOG)
+
+timeout app_timeout
 working_directory app_root
-worker_processes (app_env != 'development' ? WurflDevice::Constants::WEBSERVICE_WORKER : 1)
-listen File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_SOCKET), :backlog => 64
-pid File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_PID)
-stderr_path File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_LOG)
-stdout_path File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_LOG)
+worker_processes (app_env != 'development' ? app_workers : 1)
+listen app_listen_socket, :backlog => 64
+pid app_pid_file
+stderr_path app_log_file
+stdout_path app_log_file
 
 preload_app false

data/lib/wurfl_device/cache.rb

@@ -0,0 +1,215 @@
+require 'redis/connection/hiredis' unless defined?(FakeRedis)
+require 'redis'
+
+module WurflDevice
+  module Cache
+    class Entries
+      class << self
+        def clear
+          entries.each { |key| Cache.storage.del(build_cache_id(key)) }
+        end
+
+        def set(id, key, value)
+          Cache.storage.hset(build_cache_id(id), key, value)
+        end
+
+        def get(id, key)
+          Cache.storage.hget(build_cache_id(id), key)
+        end
+
+        def keys(id)
+          Cache.storage.hkeys(build_cache_id(id))
+        end
+
+        def keys_values(id)
+          Cache.storage.hgetall(build_cache_id(id))
+        end
+
+        def entries
+          entry_ids = Array.new
+          Cache.storage.keys(build_cache_id('*')).each do |key|
+            entry_ids << key.gsub(build_cache_id(''), '')
+          end
+          entry_ids
+        end
+
+        def get_value(id)
+          Cache.storage.get(build_cache_id(id))
+        end
+
+        def set_value(id, value)
+          Cache.storage.set(build_cache_id(id), value)
+        end
+
+        def build_cache_id(id)
+          "#{self.name}:#{id}"
+        end
+      end
+    end
+
+    class Devices < Entries; end
+    class UserAgents < Entries; end
+    class UserAgentsManufacturers < Entries; end
+
+    class Status < Entries
+      def self.version
+        keys 'version' || ''
+      end
+
+      def self.last_updated
+        get_value('last_updated') || ''
+      end
+    end
+
+    class << self
+      attr_writer :storage
+
+      def storage
+        @storage ||= Redis.new(:db => 7)
+      end
+
+      def clear
+        Status.clear
+        Devices.clear
+        UserAgents.clear
+        UserAgentsManufacturers.clear
+      end
+
+      def initialized?
+        Status.get_value('initialized').to_actual_value
+      end
+
+      def initialize_cache(xml_file)
+        version_list = Array.new
+
+        XmlLoader.load_xml_file(xml_file) do |capabilities|
+          version = capabilities.delete(:version)
+          version_list << version unless version.nil?
+
+          device_id = capabilities.delete('id')
+          next if device_id.nil? || device_id.empty?
+
+          user_agent = capabilities.delete('user_agent')
+          user_agent = Settings::GENERIC if user_agent.nil? || user_agent.empty?
+          user_agent.strip!
+
+          fall_back = capabilities.delete('fall_back')
+          fall_back = '' if fall_back.nil?
+          fall_back.strip!
+
+          Devices.set device_id, 'id', device_id
+          Devices.set device_id, 'user_agent', user_agent
+          Devices.set device_id, 'fall_back', fall_back
+
+          user_agent = UserAgent.new user_agent
+          UserAgents.set user_agent, 'id', device_id
+          unless user_agent =~ /^DO_NOT_MATCH/i
+            UserAgentsManufacturers.set user_agent.manufacturer, user_agent, device_id 
+          end
+
+          capabilities.each_pair do |key, value|
+            if value.is_a?(Hash)
+              value.each_pair do |k, v|
+                Devices.set device_id, "#{key.to_s}:#{k.to_s}", v
+              end
+            else
+              Devices.set device_id, key.to_s, value
+            end
+          end
+        end
+
+        version_list.each do |ver|
+          Status.set 'version', ver, Time.now
+        end
+        Status.set_value 'last_updated', Time.now
+        Status.set_value 'initialized', true
+      end
+
+      def rebuild_user_agents
+        UserAgents.clear
+        UserAgentsManufacturers.clear
+        Devices.entries.each do |device_id|
+          device = Devices.keys_values device_id
+          user_agent = UserAgent.new device['user_agent']
+          UserAgents.set user_agent, 'id', device_id
+          unless user_agent =~ /^DO_NOT_MATCH/i
+            UserAgentsManufacturers.set user_agent.manufacturer, user_agent, device_id 
+          end
+        end
+      end
+
+      def update_actual_capabilities(user_agent, capabilities)
+        capabilities.each_pair do |key, value|
+          if value.kind_of?(Hash)
+            value.each_pair do |k, v|
+              UserAgents.set user_agent, "#{key}:#{k}", v
+            end
+          elsif value.is_a?(Array)
+            value.each_with_index do |v, i|
+              UserAgents.set user_agent, "#{key}:#{i}", v
+            end
+          else
+            UserAgents.set user_agent, key, value
+          end
+        end
+      end
+
+      def parse_actual_capabilities(actual_capabilities)
+        capabilities = Capability.new
+
+        actual_capabilities.each_pair do |key, value|
+          if key =~ /^(.+)\:(\d+)$/i
+            capabilities[$1] ||= Array.new
+            capabilities[$1][$2.to_i] = value.to_actual_value
+          elsif key =~ /^(.+)\:(.+)$/i
+            capabilities[$1] ||= Capability.new
+            capabilities[$1][$2] = value.to_actual_value
+          else
+            capabilities[key] = value.to_actual_value
+          end
+        end
+
+        capabilities
+      end
+
+      def build_capabilities(device_id)
+        capabilities = Capability.new
+        actual_capabilities = Devices.keys_values(device_id)
+        return capabilities if actual_capabilities.nil?
+
+        capabilities['fall_back_tree'] ||= Array.new
+
+        if !actual_capabilities['fall_back'].nil? && !actual_capabilities['fall_back'].empty? && actual_capabilities['fall_back'] != 'root'
+          fall_back = build_capabilities(actual_capabilities['fall_back'])
+          if !fall_back.nil? && !fall_back['id'].nil? && !fall_back['id'].empty?
+            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.to_actual_value
+                end
+              elsif value.is_a?(Array)
+                capabilities[key] ||= Array.new
+                capabilities[key] |= value.to_actual_value
+              else
+                capabilities[key] = value.to_actual_value
+              end
+            end
+          end
+        end
+
+        actual_capabilities.each_pair do |key, value|
+          if key =~ /^(.+)\:(.+)$/i
+            capabilities[$1] ||= Capability.new
+            capabilities[$1][$2] = value.to_actual_value
+          else
+            capabilities[key] = value.to_actual_value
+          end
+        end
+
+        capabilities
+      end
+    end
+  end
+end

data/lib/wurfl_device/capability.rb

@@ -3,7 +3,11 @@ module WurflDevice
     def initialize(hash={})
       super()
       hash.each do |key, value|
-        self[convert_key(key)] = value
+        if value.kind_of?(Hash)
+          self[convert_key(key)] = Capability.new(value)
+        else
+          self[convert_key(key)] = value
+        end
       end
     end
 

data/lib/wurfl_device/cli.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
 require 'thor'
-require 'yaml'
+require 'benchmark'
 require 'wurfl_device'
+require 'yaml'
 
 module WurflDevice
   class CLI < Thor
@@ -25,18 +27,19 @@ module WurflDevice
       super
     end
 
-    desc "server [start|stop|restart|status]", "start a wurfl_device server"
-    method_option "base-dir", :type => :string, :banner => "set base directory for data files", :aliases => "-d", :default => WurflDevice::Constants::WEBSERVICE_ROOT
-    method_option :host, :type => :string, :banner => "set webservice host", :aliases => "-h", :default => WurflDevice::Constants::WEBSERVICE_HOST
-    method_option :port, :type => :numeric, :banner => "set webservice port", :aliases => "-p", :default => WurflDevice::Constants::WEBSERVICE_PORT
-    method_option :socket, :type => :string, :banner => "use unix domain socket", :aliases => "-s", :default => File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_SOCKET)
+    desc "webservice [start|stop|restart|status]", "start a wurfl_device server"
+    method_option "base-dir", :type => :string, :banner => "set base directory for data files", :aliases => "-d", :default => WurflDevice::Settings::BASE_DIR
+    method_option :host, :type => :string, :banner => "set webservice host", :aliases => "-h", :default => WurflDevice::Settings::WEBSERVICE_HOST
+    method_option :port, :type => :numeric, :banner => "set webservice port", :aliases => "-p", :default => WurflDevice::Settings::WEBSERVICE_PORT
+    method_option :worker, :type => :numeric, :banner => "set worker count", :aliases => "-w", :default => WurflDevice::Settings::WEBSERVICE_WORKER
+    method_option :socket, :type => :string, :banner => "use unix domain socket", :aliases => "-s", :default => File.join(WurflDevice::Settings::BASE_DIR, WurflDevice::Settings::WEBSERVICE_SOCKET)
     method_option :socket_only, :type => :boolean, :banner => "start as unix domain socket listener only", :aliases => "-t", :default => false
-    def server(action=nil)
+    def webservice(action=nil)
       opts = options.dup
 
       action ||= 'status'
 
-      pid_file = File.join(WurflDevice::Constants::WEBSERVICE_ROOT, WurflDevice::Constants::WEBSERVICE_PID)
+      pid_file = File.join(WurflDevice::Settings::BASE_DIR, WurflDevice::Settings::WEBSERVICE_PID)
       base_dir = opts['base-dir']
 
       FileUtils.mkdir_p(base_dir) unless File.directory?(base_dir)
@@ -77,102 +80,90 @@ module WurflDevice
 
           system(args.join(' '))
         end
+        FileUtils.rm_f(pid_file)
       elsif action == 'restart'
         server('stop')
+        sleep(0.3)
         server('start')
       else
         #status
       end
     end
+    map %w(server) => :webservice
 
     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) if device.nil?
+      capabilities = WurflDevice.capabilities_from_id(device_id)
+      capabilities = WurflDevice.capabilities_from_user_agent(device_id) if capabilities['id'].nil?
 
-      if options.json?
-        WurflDevice.ui.info device.capabilities.to_json
+      if capabilities.nil?
+        WurflDevice.ui.info "Nothing to dump"
+      elsif options.json?
+        WurflDevice.ui.info capabilities.to_json
       else
-        WurflDevice.ui.info device.capabilities.to_yaml
+        WurflDevice.ui.info capabilities.to_yaml
       end
     end
 
     desc "list", "list user agent cache list"
+    method_option "matched-only", :type => :boolean, :banner => "show user agents that were matched", :aliases => "-m"
     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 || ''
-        user_agent ||= ''
-        WurflDevice.ui.info user_agent + ":" + device_id
+      matched_only = options['matched-only']
+      WurflDevice::Cache::UserAgents.entries.each do |user_agent|
+        kv = WurflDevice::Cache::UserAgents.keys_values user_agent
+        next if kv.count <= 1 && matched_only
+        WurflDevice.ui.info "#{user_agent}:#{kv['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
+    desc "init [WURFL_XML_FILE]", "initialize the wurfl device cache"
+    method_option :update, :type => :boolean, :banner => "don't clear previous cache", :aliases => "-u", :default => false
+    def init(xml_file=nil)
+      xml_file ||= Settings.default_wurfl_xml_file
+      unless options.update?
+        WurflDevice.ui.info "clearing existing device cache."
+        WurflDevice::Cache.clear
       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 ""
+      WurflDevice.ui.info "initializing wurfl device cache."
+      WurflDevice::Cache.initialize_cache(xml_file)
       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?
+      unless WurflDevice::Cache.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
+      WurflDevice.ui.info "  wurfl-xml version: " + WurflDevice::Cache::Status.version.join(' ')
+      WurflDevice.ui.info "  cache last updated: " + WurflDevice::Cache::Status.last_updated
+      devices = WurflDevice::Cache::Devices.entries
+      user_agents = WurflDevice::Cache::UserAgents.entries
       user_agents_message = ''
-      user_agents_message = " (warning count should be equal to devices count)" if devices.length != user_agents.length
+      user_agents_message = " (warning count should be greater than or equal to devices count)" if user_agents.length < devices.length 
+
+      matched_count = 0
+      WurflDevice::Cache::UserAgents.entries.each do |user_agent|
+        kv = WurflDevice::Cache::UserAgents.keys_values user_agent
+        next if kv.count == 1
+        matched_count = matched_count + 1
+      end
       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"
-      indexes = Array.new
-      WurflDevice.get_indexes.each do |index|
-        index.gsub!(WurflDevice::Constants::WURFL_DEVICES_INDEX, '')
-        indexes << "#{index}(" + commify(WurflDevice.get_user_agents_in_index(index).length) + ")"
+      WurflDevice.ui.info "  " + commify(matched_count) + " user agents matched found in cache"
+
+      user_agent_manufacturers = Array.new
+      WurflDevice::Cache::UserAgentsManufacturers.entries.each do |index|
+        user_agent_manufacturers << "#{index}(" + commify(WurflDevice::Cache::UserAgentsManufacturers.keys(index).length) + ")"
       end
-      indexes.sort!
-      WurflDevice.ui.info "wurfl user agent indexes:"
-      while !indexes.empty?
-        sub = indexes.slice!(0, 7)
+      user_agent_manufacturers.sort!
+      WurflDevice.ui.info "wurfl user agent manufacturers:"
+      while !user_agent_manufacturers.empty?
+        sub = user_agent_manufacturers.slice!(0, 7)
         WurflDevice.ui.info "  " + sub.join(', ')
       end
       WurflDevice.ui.info ""
@@ -184,6 +175,7 @@ module WurflDevice
       WurflDevice.ui.info "wurfl_device version #{WurflDevice::VERSION.freeze}"
     end
     map %w(-v --version) => :version
+
   private
     def commify(n)
       n.to_s =~ /([^\.]*)(\..*)?/