wurfl 1.0.2

data/bin/wurflcomparator.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..',  'lib')
+
+require "getoptlong"
+require "wurfl/handset"
+require "wurfl/utils"
+
+include Wurfl::Utils
+
+def usage
+  puts "Usage: wurflcomparator.rb wurfl_pstore1_db wurfl_pstore2_db  "
+  exit 1
+end
+
+if ARGV.size != 2
+  usage
+end
+
+# load the wurfl databases
+wurfl1 = wurfl2 = nil
+begin
+  wurfl1, = load_wurfl_pstore(ARGV[0])
+  wurfl2, = load_wurfl_pstore(ARGV[1])
+rescue => err
+  efile = ""
+  if wurfl1.nil?
+    efile = ARGV[0]
+  else
+    efile = ARGV[1]
+  end
+  STDERR.puts "Error with file #{efile}"
+  STDERR.puts err.message
+  exit 1
+end
+
+puts "Comparing files: #{ARGV[0]} and #{ARGV[1]}"
+puts "-------------------------------------"
+
+if wurfl1.size > wurfl2.size
+  mwurfl = wurfl1
+  lwurfl = wurfl2    
+else
+  mwurfl = wurfl2
+  lwurfl = wurfl1
+end
+
+notfound = Array.new
+different = Array.new
+mwurfl.each do |key,handset|
+  if lwurfl.key?(key)
+    if handset != lwurfl[key]
+      different<< [handset,lwurfl[key]]
+    end
+  else
+    notfound<< handset
+  end
+end
+
+
+puts "Comparision complete."
+
+puts "Not Found Handsets: #{notfound.size}"
+puts "||||||||||||||||||||||||||||||||||||"
+notfound = notfound.sort { |x,y| y.wurfl_id <=> x.wurfl_id }
+notfound.each { |hand| puts hand.wurfl_id }           
+puts "||||||||||||||||||||||||||||||||||||"
+
+puts "Different handsets: #{different.size}"
+puts "||||||||||||||||||||||||||||||||||||"
+different = different.sort { |x,y| y.first.wurfl_id <=> x.first.wurfl_id }
+different.each do |hand1,hand2|
+  puts "-------------------------------------"
+  puts "Handset: #{hand1.user_agent} :ID: #{hand1.wurfl_id}"
+  diffkeys = hand1.compare(hand2)
+  diffkeys.each do |key,oval,oid|
+    next if hand1[key].nil? || hand2[key].nil?
+    puts "Key:#{key}"
+    puts "h1>:#{hand1[key]}"
+    puts "h2<:#{hand2[key]}"
+  end
+  puts "-------------------------------------"
+end
+
+puts "||||||||||||||||||||||||||||||||||||"
+

data/bin/wurflinspector.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..',  'lib')
+
+require "getoptlong"
+require "wurfl/handset"
+require "wurfl/utils"
+
+=begin
+A class that lists wurfl handsets that match user specified search 
+criteria.
+=end
+class WurflInspector
+
+  # Constructor
+  # Parameters:
+  # handsets: A hashtable of wurfl handsets indexed by wurfl_id.
+  def initialize(handsets)
+    @handsets = handsets
+  end
+  
+  # A method to get the WurflHandset that matches the passed wurfl_id.
+  # Parameters:
+  # id: is the wurfl_id of the WurflHandset to get.
+  # Returns:
+  # The WurflHandset that has the requested wurfl_id.  If the wurfl_id
+  # is not found, then nil is returned.
+  def get_handset(id)
+    return @handsets[id]
+  end
+
+  # A method to retrieve a list of the inspector's handsets that match
+  # the passed search criteria.
+  # Parameters:
+  # proc: is a Proc object that defines a function that returns 
+  # true or false from an evaluattion with a WurflHandset.
+  # Returns:
+  # An Array of all WurflHandsets that match the proc evaluation.
+  def search_handsets(proc)
+    rez = @handsets.values.select do |hand|  
+      x = proc.call(hand)       
+    end
+    return rez if rez != nil
+    return Array::new
+  end
+
+end
+
+
+include Wurfl::Utils
+
+def usage
+  puts "Usage: wurflinspector.rb  [-s rubyblock] [-i handsetid [-q attributename]]  -d pstorefile"
+  puts "Examples:"
+  puts "wurflinspector.rb -d pstorehandsets.db -s '{ |hand| hand[\"colors\"].to_i > 2 }'"
+  puts "wurflinspector.rb -d pstorehandsets.db -i sonyericsson_t300_ver1"
+  puts "wurflinspector.rb -d pstorehandsets.db -i sonyericsson_t300_ver1 -q backlight"
+  exit 1
+end
+
+pstorefile = nil
+procstr = nil 
+handset = nil
+query = nil
+begin
+  opt = GetoptLong.new(
+                       ["-d","--database", GetoptLong::REQUIRED_ARGUMENT],
+                       ["-s","--search", GetoptLong::REQUIRED_ARGUMENT],
+                       ["-i","--id", GetoptLong::REQUIRED_ARGUMENT],
+                       ["-q","--query", GetoptLong::REQUIRED_ARGUMENT]
+                       )
+  
+  opt.each do |arg,val|
+    case arg
+    when "-d"
+      pstorefile = val
+    when "-s"
+      procstr = val.strip
+    when "-i"
+      handset = val
+    when "-q"
+      query = val
+    else
+      usage
+    end
+  end
+
+rescue => err
+  usage
+end
+
+if !pstorefile
+  puts "You must specify a Wurfl PStore db"
+  usage
+end
+
+begin
+  handsets, = load_wurfl_pstore(pstorefile)    
+  insp = WurflInspector.new(handsets)
+rescue => err
+  STDERR.puts "Error with file #{pstorefile}"
+  STDERR.puts err.message
+  exit 1
+end
+
+if procstr
+  pr = nil
+  eval("pr = proc#{procstr}")
+  
+  if pr.class != Proc
+    puts "You must pass a valid ruby block!"
+    exit 1
+  end
+  
+  puts "--------- Searching handsets -----------"
+  res = insp.search_handsets(pr)
+  puts "Number of results: #{res.size}"
+  
+  res.each { |handset| puts handset.wurfl_id }
+  exit 0
+end
+
+
+if handset
+  handset = insp.get_handset(handset)
+  puts "Handset user agent: #{handset.user_agent}"
+  if query
+    puts "Result of handset query: #{query}"
+    rez = handset.get_value_and_owner(query)
+    puts "#{rez[0]} from #{rez[1]}"
+  else
+    puts "Attributes of handset"
+    keys = handset.keys
+    keys.each do |key|
+      rez = handset.get_value_and_owner(key)
+      puts "Attr:#{key} Val:#{rez[0]} from #{rez[1]}"
+    end
+  end
+  exit 0
+end
+

data/bin/wurflloader.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..',  'lib')
+
+require "getoptlong"
+require "wurfl/utils"
+require "wurfl/loader"
+
+include Wurfl::Utils
+
+print = false
+insert = false
+verbose = false
+wurflfile = nil
+patchfile = nil
+pstorefile = nil
+pstoreload = false
+
+def usage
+  puts "Usage: wurflloader.rb [-p -v -h -e patchfile] -f wurflfile"
+  puts "       --file, -f (wurflfile): The master WURFL file to load."
+  puts "       --extension, -e (patchfile): A patch file to extend the traits of the master WURLF file."
+  puts "       --print, -p : Prints out handsets."
+  puts "       --verbose, -v : Verbose output."
+  puts "       --help, -h : Prints this message."
+  puts "       --database, -d (databasename): Makes a PStore database for quick loading of data with other tools."
+  puts "       --load, -l (databasename): Loads handsets from a PStore database instead of XML file."
+  exit 1
+end
+
+begin
+  options = GetoptLong.new(
+                           ["-p","--print", GetoptLong::NO_ARGUMENT],
+                           ["-h","--help", GetoptLong::NO_ARGUMENT],
+                           ["-v","--verbose", GetoptLong::NO_ARGUMENT],
+                           ["-f","--file", GetoptLong::REQUIRED_ARGUMENT],
+                           ["-e","--extension", GetoptLong::REQUIRED_ARGUMENT],
+                           ["-d","--database", GetoptLong::REQUIRED_ARGUMENT],
+                           ["-l","--load", GetoptLong::REQUIRED_ARGUMENT]
+                           )
+  
+  options.each do |opt,arg|
+    case opt
+    when "-p"
+      print = true
+    when "-v" 
+      verbose = true
+    when "-h"
+      usage
+      exit 1
+    when "-f"
+      wurflfile = arg
+    when "-e"
+      patchfile = arg
+    when "-d"
+      pstorefile = arg
+    when "-l"
+      pstorefile = arg
+      pstoreload = true
+    else
+      STDERR.puts "Unknown argument #{opt}"
+      usage
+    exit 1
+    end    
+  end
+rescue => err
+  STDERR.puts "Error: #{err}"
+  usage
+  exit 1
+end
+
+wurfll = Wurfl::Loader.new
+hands = nil
+fallbacks = nil
+
+if pstorefile && pstoreload
+  begin
+    puts "Loading  data from #{pstorefile}"
+    hands, fallbacks = load_wurfl_pstore(pstorefile)
+    puts "Loaded"
+  rescue => err
+    STDERR.puts "Error: Cannot load PStore file."
+    STDERR.puts err.message
+    exit 1
+  end
+else    
+  if !wurflfile 
+    STDERR.puts "You must pass a wurflfile if you want to do more."
+    usage
+    exit 1
+  end
+  
+  starttime = Time.now
+  puts "Loading wurfl file #{wurflfile}" 
+  
+  wurfll.verbose = verbose
+
+  hands, fallbacks = wurfll.load_wurfl(wurflfile)
+  restime = Time.now - starttime
+  
+  puts "Done loading wurfl.  Load took #{restime} seconds." 
+
+  if patchfile
+    starttime = Time.now
+    puts "Loading Patch file #{patchfile}"
+    hands, fallbacks = wurfll.load_wurfl(patchfile)
+    restime = Time.now - starttime
+    puts "Done loading patchfile.  Load took #{restime} seconds." 
+  end
+  
+end
+
+if pstorefile && !pstoreload
+  begin
+    puts "Saving data into #{pstorefile}"
+    save_wurfl_pstore(pstorefile, hands, fallbacks)
+    puts "Saved"
+  rescue => err
+    STDERR.puts "Error: Cannot creat PStore file."
+    STDERR.puts err.message
+  end
+end
+
+if print 
+  wurfll.print_wurfl hands
+end
+  

data/bin/wurflsanitycheck.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..',  'lib')
+
+# A simple command line tool to make sure that a wurfl file properly parses.
+# Used to make sure changes to Wurfl/Patch files are OK.
+if ARGV.size != 1
+   puts "Must have the path of the wurfl file to check"
+   exit 1
+end
+lines = File.open(ARGV[0],"r").readlines
+
+curdev = nil
+c = 0
+
+lines.each do |line|
+  line = line.strip
+  if line =~ /^(<d)evice.*[^\/]>$/
+    curdev = line
+  elsif line =~ /^(<d)evice.*\/>$/
+    if curdev
+      puts "#{c}:A device was not closed and we got a new device! #{curdev}"
+    end
+    curdev = nil
+  elsif line =~ /^(<\/d)evice>$/
+    if curdev.nil?
+      puts "#{c}:A closing device with no opening! #{curdev}"
+    end
+    curdev=nil
+  end
+  c += 1
+end
+
+if curdev
+  puts "The curent device was not closed #{curdev}"
+end
+
+
+puts "Done"

data/lib/wurfl/handset.rb

@@ -0,0 +1,117 @@
+require "singleton"
+
+module Wurfl; end
+
+=begin
+A class that represents a handset based on information taken from the WURFL.
+=end
+class Wurfl::Handset
+
+  extend Enumerable
+
+  attr_accessor :wurfl_id, :user_agent
+
+  # Constructor
+  # Parameters:
+  # wurfl_id: is the WURFL ID of the handset
+  # useragent: is the user agent of the handset
+  # fallback: is the fallback handset that this handset
+  #           uses for missing details.
+  def initialize (wurfl_id, useragent, fallback = nil) 
+    # A hash to hold keys and values specific to this handset
+    @capabilityhash = Hash::new 
+    @wurfl_id = wurfl_id
+    @user_agent = useragent
+    @fallback = fallback || NullHandset.instance
+  end
+
+  def fallback=(v)
+    @fallback = v || NullHandset.instance
+  end
+
+  # Hash accessor
+  # Parameters: 
+  # key: the WURFL key whose value is desired
+  # Returns:
+  # The value of the key, nil if the handset does not have the key.
+  def [] (key)
+    @capabilityhash.key?(key) ? @capabilityhash[key] : @fallback[key]
+  end
+
+  # like the above accessor, but also to know who the value
+  # comes from
+  # Returns:
+  # the value and the id of the handset from which the value was obtained
+  def get_value_and_owner(key)
+    if @capabilityhash.key?(key)
+      [ @capabilityhash[key], @wurfl_id ]
+    else
+      @fallback.get_value_and_owner(key)
+    end
+  end
+
+  # Setter, A method to set a key and value of the handset.
+  def []= (key,val)
+    @capabilityhash[key] = val
+  end
+
+  # A Method to iterate over all of the keys and values that the handset has.
+  # Note: this will abstract the hash iterator to handle all the lower level
+  # calls for the fallback values.
+  def each
+    self.keys.each do |key|
+      # here is the magic that gives us the key and value of the handset
+      # all the way up to the fallbacks end.  
+      # Call the pass block with the key and value passed
+      yield key, self[key]
+    end
+  end
+  
+  # A method to get all of the keys that the handset has.
+  def keys
+    @capabilityhash.keys | @fallback.keys
+  end
+
+  # A method to do a simple equality check against two handsets.
+  # Parameter:
+  # other: Is the another WurflHandset to check against.
+  # Returns:
+  # true if the two handsets are equal in all values.
+  # false if they are not exactly equal in values, id and user agent.
+  # Note: for a more detailed comparison, use the compare method.
+  def ==(other)
+    return false unless other.instance_of?(Wurfl::Handset)
+    return false unless self.wurfl_id == other.wurfl_id && self.user_agent == other.user_agent
+    other.each do |key,value|
+      return false if value != self[key]
+    end
+    true
+  end
+
+  # A method to compare a handset's values against another handset.
+  # Parameters:
+  # other: is the another WurflHandset to compare against
+  # Returns:
+  # An array of the different values.
+  # Each entry in the Array is an Array of three values.
+  # The first value is the key in which both handsets have different values.
+  # The second is the other handset's value for the key.
+  # The third is the handset id from where the other handset got it's value.
+  def compare(other)
+    differences = Array.new
+    self.keys.each do |key|
+      oval,oid = other.get_value_and_owner(key)
+      if @capabilityhash[key].to_s != oval.to_s
+	differences << [key,oval,oid]
+      end
+    end
+    differences
+  end
+
+  class NullHandset
+    include Singleton
+    def [](key) nil end
+    def get_value_and_owner(key) [ nil, nil ] end
+    def keys; [] end
+  end
+end