vapir-common 1.7.2 → 1.8.0

data/lib/vapir-common/external/core_extensions.rb

@@ -0,0 +1,62 @@
+class Module
+  def alias_deprecated(to, from)
+    define_method to do |*args|
+      if !respond_to?(:config) || config.warn_deprecated
+        Kernel.warn_with_caller "DEPRECATION WARNING: #{self.class.name}\##{to} is deprecated. Please use #{self.class.name}\##{from}"
+      end
+      send(from, *args)
+    end
+  end
+end
+
+class String
+  if method_defined?(:ord)
+    alias vapir_ord ord
+  else
+    def vapir_ord
+      unpack("U*")[0] # assume it's unicode 
+    end
+  end
+end
+
+unless :to_proc.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    #   # The same as people.collect { |p| p.name }
+    #   people.collect(&:name)
+    #
+    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    #   people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args[0].__send__(self, *args[1..-1]) }
+    end
+  end
+end
+
+module Kernel
+  # this is the Y-combinator, which allows anonymous recursive functions. for a simple example, 
+  # to define a recursive function to return the length of an array:
+  #
+  # length = ycomb do |len|
+  #   proc{|list| list == [] ? 0 : len.call(list[1..-1]) }
+  # end
+  #
+  # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
+  # and chapter 9 of the little schemer, available as the sample chapter at http://www.ccs.neu.edu/home/matthias/BTLS/
+  def ycomb
+    proc{|f| f.call(f) }.call(proc{|f| yield proc{|*x| f.call(f).call(*x) } })
+  end
+  module_function :ycomb
+
+  def warn_with_caller(message)
+    Kernel.warn "#{message}\ncalled from: #{caller[1..-1].map{|c|"\n\t"+c}}"
+  end
+  module_function :warn_with_caller
+end
+
+require 'enumerator'
+module Vapir
+  Enumerator = Object.const_defined?('Enumerator') ? ::Enumerator : Enumerable::Enumerator
+end
+

data/lib/vapir-common/handle_options.rb

@@ -6,7 +6,7 @@
 def handle_options(given_options, default_options, other_allowed_keys=[])
   given_options=given_options.dup
   unless (unknown_keys=(given_options.keys-default_options.keys-other_allowed_keys)).empty?
-    raise ArgumentError, "Unknown options: #{(given_options.keys-default_options.keys).map(&:inspect).join(', ')}. Known options are #{(default_options.keys+other_allowed_keys).map(&:inspect).join(', ')}"
+    raise ArgumentError, "Unknown options: #{unknown_keys.map(&:inspect).join(', ')}. Known options are #{(default_options.keys+other_allowed_keys).uniq.map(&:inspect).join(', ')}"
   end
   (default_options.keys-given_options.keys).each do |key|
     given_options[key]=default_options[key]

data/lib/vapir-common/keycodes.rb

@@ -0,0 +1,135 @@
+require 'vapir-common/external/core_extensions'
+module Vapir
+  KeyCodes = (('0'..'9').to_a+('a'..'z').to_a).inject({}){|hash, char| hash.merge(char.to_sym => char.vapir_ord) }.merge(
+  {
+    :cancel        => 3,
+    :help          => 6,
+    :back_space    => 8,
+    :tab           => 9,
+    :clear         => 12,
+    :return        => 13,
+    :enter         => 14,
+    :shift         => 16,
+    :control       => 17,
+    :alt           => 18,
+    :pause         => 19,
+    :caps_lock     => 20,
+    :escape        => 27,
+    :space         => 32,
+    :page_up       => 33,
+    :page_down     => 34,
+    :end           => 35,
+    :home          => 36,
+    :left          => 37,
+    :up            => 38,
+    :right         => 39,
+    :down          => 40,
+    :printscreen   => 44,
+    :insert        => 45,
+    :delete        => 46,
+    :semicolon     => 59,
+    :equals        => 61,
+    :context_menu  => 93,
+    :numpad0       => 96,
+    :numpad1       => 97,
+    :numpad2       => 98,
+    :numpad3       => 99,
+    :numpad4       => 100,
+    :numpad5       => 101,
+    :numpad6       => 102,
+    :numpad7       => 103,
+    :numpad8       => 104,
+    :numpad9       => 105,
+    :multiply      => 106,
+    :add           => 107,
+    :separator     => 108,
+    :subtract      => 109,
+    :decimal       => 110,
+    :divide        => 111,
+    :f1            => 112,
+    :f2            => 113,
+    :f3            => 114,
+    :f4            => 115,
+    :f5            => 116,
+    :f6            => 117,
+    :f7            => 118,
+    :f8            => 119,
+    :f9            => 120,
+    :f10           => 121,
+    :f11           => 122,
+    :f12           => 123,
+    :f13           => 124,
+    :f14           => 125,
+    :f15           => 126,
+    :f16           => 127,
+    :f17           => 128,
+    :f18           => 129,
+    :f19           => 130,
+    :f20           => 131,
+    :f21           => 132,
+    :f22           => 133,
+    :f23           => 134,
+    :f24           => 135,
+    :num_lock      => 144,
+    :scroll_lock   => 145,
+    :comma         => 188,
+    :dash          => 189,
+    :period        => 190,
+    :slash         => 191,
+    :back_quote    => 192,
+    :open_bracket  => 219,
+    :back_slash    => 220,
+    :close_bracket => 221,
+    :quote         => 222,
+    :meta          => 224,
+  })
+  PrintKeyCodes = (('0'..'9').to_a+('a'..'z').to_a).inject({}){|hash, char| hash.merge(char => char.to_sym) }.merge(
+  {
+    "\t" => :tab,
+    #"\n" => :return,
+    #"\n" => :enter,
+    ' '  => :space,
+    ';'  => :semicolon,
+    '='  => :equals,
+    ','  => :comma,
+    '.'  => :period,
+    '/'  => :slash,
+    "`"  => :back_quote,
+    '['  => :open_bracket,
+    "\\" => :back_slash,
+    ']'  => :close_bracket,
+    "'"  => :quote,
+  }).inject({}){|hash, (key, key_codes_key)| hash.merge(key => KeyCodes[key_codes_key]) }
+  ShiftPrintKeyCodes = ('A'..'Z').to_a.inject({}){|hash, char| hash.merge(char => char.downcase.to_sym) }.merge(
+  {
+    ')' => :'0',
+    '!' => :'1',
+    '@' => :'2',
+    '#' => :'3',
+    '$' => :'4',
+    '%' => :'5',
+    '^' => :'6',
+    '&' => :'7',
+    '*' => :'8',
+    '(' => :'9',
+    ':' => :semicolon,
+    '+' => :equals,
+    '<' => :comma,
+    '>' => :period,
+    '?' => :slash,
+    '~' => :back_quote,
+    '{' => :open_bracket,
+    '|' => :back_slash,
+    '}' => :close_bracket,
+    '"' => :quote,
+  }).inject({}){|hash, (key, key_codes_key)| hash.merge(key => KeyCodes[key_codes_key]) }
+  NumpadKeyCodes = ('0'..'9').inject({}){|hash, char| hash.merge(char => "numpad#{char}".to_sym) }.merge(
+  {
+    '*' => :multiply,
+    '+' => :add,
+    #? => :separator,
+    '-' => :subtract,
+    '.' => :decimal,
+    '/' => :divide,
+  }).inject({}){|hash, (key, key_codes_key)| hash.merge(key => KeyCodes[key_codes_key]) }
+end

data/lib/vapir-common/options.rb

@@ -1,49 +1,16 @@
-require 'user-choices'
-
 module Vapir
-  @@options_file = nil
-  @@options = nil
   class << self
-    # Specify the location of a yaml file containing Vapir options. Must be
-    # specified before the options are parsed.
-    def options_file= file
-      @@options_file = file
+    def options_file=(file) # :nodoc:
+      raise NotImplementedError, "this method of specifying options is deprecated and gone. see documentation for Vapir.config"
     end
     def options_file
-      @@options_file
+      raise NotImplementedError, "this method of specifying options is deprecated and gone. see documentation for Vapir.config"
     end
     def options= x
-      @@options = x
+      raise NotImplementedError, "this method of specifying options is deprecated and gone. see documentation for Vapir.config"
     end
-    # Return the Vapir options, as a hash. If they haven't been parsed yet,
-    # they will be now.
     def options
-      @@options ||= Vapir::Options.new.execute
+      raise NotImplementedError, "this method of specifying options is deprecated and gone. see documentation for Vapir.config"
     end
   end
-
-  class Options < UserChoices::Command
-    include UserChoices
-    def add_sources builder
-      builder.add_source EnvironmentSource, :with_prefix, 'watir_'
-      if Vapir.options_file
-        builder.add_source YamlConfigFileSource, :from_complete_path, 
-          Vapir.options_file
-      end
-    end
-    def add_choices builder
-      builder.add_choice :browser, 
-      :type => Vapir::Browser.browser_names, 
-      :default => Vapir::Browser.default
-      builder.add_choice :speed, 
-      :type => ['slow', 'fast', 'zippy'], 
-      :default => 'fast'
-      builder.add_choice :visible,
-      :type => :boolean
-    end
-    def execute 
-      @user_choices[:speed] = @user_choices[:speed].to_sym
-      @user_choices
-    end 
-  end
 end

data/lib/vapir-common/page_container.rb

@@ -1,21 +1,26 @@
-module Vapir
-  module PageContainer
-    include Vapir::Container
-    def containing_object
-      document_object
-    end
-    def document_element
-      document_object.documentElement || raise(Exception::ExistenceFailureException, "document_object.documentElement was nil")
-    end
-    def title
-      document_object.title
-    end
-    # The url of the page object. 
-    def url
-      document_object.location.href
-    end
-    def page_container
-      self
-    end
-  end
-end
+module Vapir
+  module PageContainer
+    include Vapir::Container
+    def containing_object
+      document_object
+    end
+    def document_element_object
+      document_object.documentElement || raise(Exception::ExistenceFailureException, "document_object.documentElement was nil")
+    end
+    alias document_element document_element_object
+    
+    def title
+      document_object.title
+    end
+    # The url of the page object. 
+    def url
+      document_object.location.href
+    end
+    def page_container
+      self
+    end
+    def active_element
+      base_element_class.new(nil, nil, extra_for_contained.merge(:candidates => proc{|container| [container.document_object.activeElement] })).to_subtype
+    end
+  end
+end

data/lib/vapir-common/specifier.rb

@@ -50,7 +50,7 @@ module Vapir
     
     # this is a list of what users can specify (there are additional possible hows that may be given
     # to the Element constructor, but not generally for use by users, such as :element_object or :label
-    HowList=[:attributes, :xpath, :custom, :element_object, :label]
+    HowList=[:attributes, :xpath, :css, :custom, :element_object, :label]
 
     # returns an Enumerable of element objects that _may_ match (note, not do match, necessarily)
     # the given specifiers on the given container. these are obtained from the container's containing_object
@@ -141,7 +141,7 @@ module Vapir
       unless specifiers_list.is_a?(Enumerable) && specifiers_list.all?{|spec| spec.is_a?(Hash)}
         raise ArgumentError, "specifiers_list should be a list of Hashes!"
       end
-      if candidates.length != 0 && Object.const_defined?('JsshObject') && (candidates.is_a?(JsshObject) || candidates.all?{|c| c.is_a?(JsshObject)})
+      if Object.const_defined?('JsshObject') && (candidates.is_a?(JsshObject) || (candidates.length != 0 && candidates.all?{|c| c.is_a?(JsshObject)}))
         # optimize for JSSH by moving code to the other side of the socket, rather than talking across it a whole lot
         # this javascript should be exactly the same as the ruby in the else (minus WIN32OLE optimization) - 
         # just written in javascript instead of ruby. 

data/lib/vapir-common/version.rb

@@ -0,0 +1,5 @@
+module Vapir
+  module Common
+    VERSION = '1.8.0'
+  end
+end

data/lib/vapir-common/waiter.rb

@@ -1,100 +1,53 @@
 require 'vapir-common/exceptions'
 
 module Vapir
+  class Waiter # :nodoc:all
+    # How long to wait between each iteration through the wait_until
+    # loop. In seconds.
+    attr_accessor :polling_interval
   
-  def wait_until(*args)
-    Waiter.wait_until(*args) {yield}
-  end
-
-class TimeKeeper
-  attr_reader :sleep_time
-  def initialize 
-    @sleep_time = 0.0
-  end
-  def sleep seconds
-    @sleep_time += Kernel.sleep seconds
-  end
-  def now
-    Time.now
-  end
-end
-
-class Waiter
-  # This is an interface to a TimeKeeper which proxies
-  # calls to "sleep" and "Time.now".
-  # Useful for unit testing Waiter.
-  attr_accessor :timer
-
-  # How long to wait between each iteration through the wait_until
-  # loop. In seconds.
-  attr_accessor :polling_interval
-
-  # Timeout for wait_until.
-  attr_accessor :timeout
+    # Timeout for wait_until.
+    attr_accessor :timeout
+    
+    @@default_polling_interval = 0.5
+    @@default_timeout = 60.0
   
-  @@default_polling_interval = 0.5
-  @@default_timeout = 60.0
-
-  def initialize(timeout=@@default_timeout,
-                 polling_interval=@@default_polling_interval)
-    @timeout = timeout
-    @polling_interval = polling_interval
-    @timer = TimeKeeper.new
-  end
-
-  # Execute the provided block until either (1) it returns true, or
-  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
-  # a TimeOutException will be raised. The block will always
-  # execute at least once.
-  # 
-  # waiter = Waiter.new(5)
-  # waiter.wait_until {puts 'hello'}
-  # 
-  # This code will print out "hello" for five seconds, and then raise a 
-  # Vapir::TimeOutException.
-  def wait_until # block
-    start_time = now
-    until yield do
-      if (duration = now - start_time) > @timeout
-        raise Vapir::Exception::TimeOutException.new(duration, @timeout),
-          "Timed out after #{duration} seconds."
+    def initialize(timeout=@@default_timeout, polling_interval=@@default_polling_interval)
+      @timeout = timeout
+      @polling_interval = polling_interval
+    end
+  
+    module WaitUntil
+      public
+      # Execute the provided block until either (1) it returns true, or
+      # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+      # a TimeOutException will be raised. The block will always
+      # execute at least once.
+      # 
+      # waiter = Waiter.new(5)
+      # waiter.wait_until {puts 'hello'}
+      # 
+      # This code will print out "hello" for five seconds, and then raise a 
+      # Vapir::TimeOutException.
+      def wait_until(timeout=::Vapir::Waiter.send(:class_variable_get, '@@default_timeout'), polling_interval=::Vapir::Waiter.send(:class_variable_get, '@@default_polling_interval'), &block)
+        ::Waiter.try_for(timeout, :interval => polling_interval, &block)
       end
-      sleep @polling_interval
     end
+    include ::Vapir::Waiter::WaitUntil
+    extend ::Vapir::Waiter::WaitUntil
   end
-
-  # Execute the provided block until either (1) it returns true, or
-  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
-  # a TimeOutException will be raised. The block will always
-  # execute at least once.
-  # 
-  # Waiter.wait_until(5) {puts 'hello'}
-  # 
-  # This code will print out "hello" for five seconds, and then raise a 
-  # Vapir::TimeOutException.
-
-  # IDEA: wait_until: remove defaults from Waiter.wait_until
-  def self.wait_until(timeout=@@default_timeout,
-                      polling_interval=@@default_polling_interval)
-    waiter = new(timeout, polling_interval)
-    waiter.wait_until { yield }
-  end
-     
-  private
-  def sleep seconds
-    @timer.sleep seconds
-  end
-  def now
-    @timer.now
+  include ::Vapir::Waiter::WaitUntil
+  extend ::Vapir::Waiter::WaitUntil
+  class Browser
+    include ::Vapir::Waiter::WaitUntil
+    extend ::Vapir::Waiter::WaitUntil
   end
-end
-    
 end # module
 
 require 'vapir-common/handle_options'
 
 class WaiterError < StandardError; end
-class Waiter
+module Waiter
   # Tries for +time+ seconds to get the desired result from the given block. Stops when either:
   # 1. The :condition option (which should be a proc) returns true (that is, not false or nil)
   # 2. The block returns true (that is, anything but false or nil) if no :condition option is given
@@ -104,17 +57,18 @@ class Waiter
   #
   # Returns the value of the block, which can be handy for things that return nil on failure and some 
   # other object on success, like Enumerable#detect for example: 
-  # found_thing=Waiter.try_for(30) { all_things().detect {|thing| thing.name=="Bill" } }
+  #  found_thing=Waiter.try_for(30){ all_things().detect{|thing| thing.name=="Bill" } }
   #
   # Examples:
-  # Waiter.try_for(30) do
-  #   Time.now.year == 2015
-  # end
+  #  Waiter.try_for(30) do
+  #    Time.now.year == 2015
+  #  end
   # Raises a WaiterError unless it is called between the last 30 seconds of December 31, 2014 and the end of 2015
   #
-  # Waiter.try_for(365.242199*24*60*60, :interval => 0.1, :exception => nil, :condition => proc{ 2+2==5 }) do
-  #   STDERR.puts "any decisecond now ..."
-  # end
+  #  Waiter.try_for(365*24*60*60, :interval => 0.1, :exception => nil, :condition => proc{ 2+2==5 }) do
+  #    STDERR.puts "any decisecond now ..."
+  #  end
+  # 
   # Complains to STDERR for one year, every tenth of a second, as long as 2+2 does not equal 5. Does not 
   # raise an exception if 2+2 does not become equal to 5. 
   def self.try_for(time, options={})