watirmark 5.14.16

data/lib/watirmark/extensions/ruby_extensions.rb

@@ -0,0 +1,129 @@
+module Watirmark::MatchMethod
+  def matches(x)
+    self == x
+  end
+end
+
+class String
+  include Watirmark::MatchMethod
+
+  def strip_number_formatting
+    self.gsub!(/\$|,/,'')
+    self.gsub!(/\.00/,'')
+    self
+  end
+end
+
+class Integer
+  include Watirmark::MatchMethod
+end
+
+class TrueClass
+  include Watirmark::MatchMethod
+end
+
+class FalseClass
+  include Watirmark::MatchMethod
+end
+
+class Regexp
+  def matches(x)
+    self.match(x)
+  end
+end
+
+
+class Hash
+  # Returns a hash that only contains pairs with the specified keys
+  def extract(*keys)
+    keys = keys[0] if keys[0].is_a?(Array)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end
+  alias :slice :extract
+end
+
+class Array
+  def diff(a)
+    ary = dup
+    a.each {|i| ary.delete_at(i) if i == ary.index(i)}
+    ary
+  end
+end
+
+
+#############################
+# From Why's Poignant Guide
+#############################
+class Object
+  def meta_class
+    class << self
+      self
+    end
+  end
+
+  def meta_eval &blk
+    meta_class.instance_eval &blk
+  end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end
+
+
+# This would be better to be a struct because it would match the models we're
+# using for inputs to the controllers. The problem is that with legacy code,
+# we have a lot of input hashes that don't necessarily always have a page
+# object keyword for every member of the hash. As such I've chosen to use
+# OpenStruct. Fixing this would be a little hit/miss until all input data uses
+# models
+
+require 'ostruct'
+
+class ModelOpenStruct < OpenStruct
+  def update(x)
+    x.each_pair {|key, value| self.send "#{key}=", value}
+    self
+  end
+
+  def keys
+    self.marshal_dump.keys
+  end
+  alias :keywords :keys
+
+  def has_key?(x)
+    keywords.include? x
+  end
+  alias :key? :has_key?
+
+  def to_h
+    h = {}
+    keywords.each { |name| h[name.to_sym] = self.send name}
+    h
+  end
+
+  # Stub these out so it doesn't find anything
+  def find(model)
+  end
+
+  def search_term
+  end
+
+  def model_class_name
+    'ModelOpenStruct'
+  end
+
+  def inspect
+    Watirmark.logger.info "ModelOpenStruct #{to_h}"
+  end
+
+
+end

data/lib/watirmark/extensions/webdriver_extensions.rb

@@ -0,0 +1,150 @@
+require 'watir-webdriver/extensions/select_text'
+
+Watir::always_locate = false
+
+module Watir
+
+  class Browser
+    # for modal dialogs that close on submission, these might
+    # fail to run because the window has been destroyed
+    alias :old_run_checkers :run_checkers
+
+    # this is basically a check to make sure we're not
+    # running the checkers on a modal dialog that has closed
+    # by the time the checkers have run
+    def run_checkers
+      @error_checkers.each do |checker|
+        begin
+          checker.call(self)
+        rescue Selenium::WebDriver::Error::UnknownError, Selenium::WebDriver::Error::NoSuchWindowError => e
+          Watirmark.logger.warn "Unable to run checker: #{e.message}"
+          break
+        end
+      end
+    end
+  end
+
+  # Trigger checkers when manually submitting a form
+  class Form < HTMLElement
+    alias :old_submit :submit
+    def submit
+      old_submit
+      browser.run_checkers
+    end
+  end
+
+  module Container
+    alias :row :tr
+    alias :cell :td
+
+    class DownloadLink < Anchor
+      def initialize(*args)
+        @dir = File.join(Watirmark::Configuration.instance.projectpath, "reports", "downloads")
+        super
+      end
+
+      def download(file = nil)
+        click
+        locate_file(file)
+      end
+
+      def locate_file(file = nil)
+        if file
+          new_file = "#{@dir}/#{file}"
+          File.delete(new_file) if File.file?(new_file)
+          File.rename(last_modified_file, new_file)
+          new_file
+        else
+          last_modified_file
+        end
+      end
+
+      def last_modified_file
+        Dir.new(@dir).select { |f| f!= '.' && f!='..' }.collect { |f| "#{@dir}/#{f}" }.sort { |a, b| File.mtime(b)<=>File.mtime(a) }.first
+      end
+    end
+
+    def download_link(*args)
+      DownloadLink.new(self, extract_selector(args).merge(:tag_name => "a"))
+    end
+
+    class DownloadLinkCollection < ElementCollection
+      def element_class
+        DownloadLink
+      end
+    end
+
+    def download_links(*args)
+      DownloadLinkCollection.new(self, extract_selector(args).merge(:tag_name => "a"))
+    end
+  end
+
+  class Table < HTMLElement
+    def each
+      rows.each { |x| yield x }
+    end
+  end
+
+  class TableRow < HTMLElement
+    def each
+      cells.each { |x| yield x }
+    end
+
+    def column(what)
+      column = 0
+      parent.th(:text => what).when_present.parent.cells.each do |cell|
+        if what.kind_of? String
+          return self[column] if cell.text == what
+        else
+          return self[column] if cell.text =~ what
+        end
+        column +=1 unless cell.text.strip == ''
+      end
+      raise Watir::Exception::UnknownObjectException, "unable to locate column, using '#{what}'"
+    end
+  end
+
+  class CheckBox < Input
+    alias :value= :set
+  end
+
+  class Radio < Input
+    alias :old_radio_set :set
+
+    def set(value=nil)
+      @selector.update(:value => value.to_s) if value
+      old_radio_set
+    end
+
+    alias :value= :set
+
+    alias :old_radio_set? :set?
+
+    def set?(value=nil)
+      @selector.update(:value => value.to_s) if value
+      old_radio_set?
+    end
+  end
+
+  class Select
+    alias :value= :select
+    alias :set :select
+
+    def getAllContents
+      options.map(&:text)
+    end
+  end
+
+  class Element
+    alias :prev_sibling :previous_sibling
+    alias :prevsibling :previous_sibling
+    alias :nextsibling :next_sibling
+
+    def click_if_exists
+      click if exists?
+    end
+
+    alias :click_no_wait :click
+  end
+
+end

data/lib/watirmark/formatters/snapshot_formatter.rb

@@ -0,0 +1,23 @@
+require 'rspec/core/formatters/base_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+      class SnapshotFormatter < BaseFormatter
+        def initialize(output)
+          super
+          @path=output.path + "_dir/"
+          Dir.mkdir(@path) if not File::directory?( @path )
+        end
+
+        def example_failed(example)
+          if Page.browser_exists?
+            append_text = example.description.gsub(/([^\w-])/, "_")
+            snapshot = "#{Time.now.to_i} - #{append_text}.png"
+            Page.browser.screenshot.save "#{@path}/#{snapshot}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watirmark/loader.rb

@@ -0,0 +1,87 @@
+module Watirmark
+
+  def self.loader &block
+    ActiveSupport::Dependencies.mechanism = :require if defined? ActiveSupport::Dependencies
+    Loader.new.instance_eval &block
+  end
+  
+  # This can be used for files that are page classes or flows.
+  # Autoloading them
+  # will not actually 'require' the file until a class in that file is used. 
+  # Note that this does not apply to modules so it's most useful for the
+  # page accessors and any files in admin, user, etc.   
+  class Loader  
+
+    def autoload_files(directory)
+      mod = "Watirmark::#{product}"
+      each_file_in directory do |file|
+        libpath = library_path(file)
+        IO.readlines(file).each do |line|
+          _autoload_(mod, $1, libpath) if line =~ /^\s*class\s+([^<]\S+)[\s<]/
+          _autoload_(mod, $1, libpath) if line =~ /^\s+([A-Z]\S+)\s+=\s+[A-Z]\S+/
+        end
+      end
+    end
+    alias :autoload_file :autoload_files
+
+    def _autoload_(mod, klass, path)
+      return if klass =~ /\./
+      namespaces = mod.split('::')
+      m = Kernel.const_get(namespaces.shift)
+      m = namespaces.inject(m){|result, ns| result.const_get(ns)}
+      m.send(:autoload, klass.to_sym, path)
+    end
+    private :_autoload_
+
+    def load_files(directory) # product not used
+      each_file_in directory do | file |
+        require library_path(file)
+      end
+    end
+    
+    def base_directory arg=nil
+      if arg
+        @base_directory = arg
+      elsif @base_directory
+        @base_directory
+      else
+        raise "base_directory not set"
+      end
+    end
+    
+    def product arg=nil
+      if arg
+        @product = arg
+      elsif @product
+        @product
+      else 
+        raise "product not set"
+      end
+    end
+    
+    def module arg=nil
+      if arg
+        @module = arg
+      elseif 
+      end
+    end
+    
+    private
+
+    def library_path(file)
+      File.join(File.dirname(file), File.basename(file, '.rb'))
+    end
+
+    def each_file_in(directory)
+      lib_path = File.join(base_directory, directory)
+      if File.directory?(lib_path)
+        files = Dir.glob(File.join(lib_path, '*.rb'))
+      else
+        files = Dir.glob(lib_path)
+      end
+      files.each do |file|
+        yield file unless File.directory? file
+      end
+    end    
+  end
+end

data/lib/watirmark/model.rb

@@ -0,0 +1,3 @@
+require 'watirmark/models/factory'
+require 'watirmark/models/upload_csv'
+require 'watirmark/models/trait'

data/lib/watirmark/models/cucumber_helper.rb

@@ -0,0 +1,49 @@
+module Watirmark
+  module Model
+
+    module CucumberHelper
+
+      def format_value(value)
+        value = insert_model(value)
+        case value
+          when String
+            if value[0, 1].eql?("=") #straight eval
+              eval(value[1..value.length])
+            elsif value == "true"
+              true
+            elsif value == "false"
+              false
+            elsif value.strip == ''
+              nil
+            else
+              value
+            end
+          else
+            value
+        end
+      end
+
+      def insert_model(text)
+        result = text
+        regexp = /\[([^\]]+)\]\.(\w+)/
+        while result =~ regexp #get value from models
+          model_name = $1
+          method     = $2
+          value = DataModels[model_name].send method.to_sym
+          result.sub!(regexp, value.to_s)
+        end
+        result
+      end
+
+      def merge_cucumber_table(cuke_table)
+        cuke_table.rows_hash.each do |key, value|
+          method_chain = key.to_s.split('.')
+          method = method_chain.pop
+          method_chain.inject(self) { |obj, m| obj.send m}.send "#{method}=", format_value(value)
+        end
+        Watirmark.logger.info "Updated #{inspect}"
+        self
+      end
+    end
+  end
+end