watirmark 5.14.16

data/lib/watirmark/page/page.rb

@@ -0,0 +1,50 @@
+require 'watirmark/page/page_definition'
+
+module Watirmark
+  class Page
+    extend PageDefinition
+
+    attr_accessor :browser
+    attr_reader   :keyed_elements
+
+    def initialize(browser=self.class.browser)
+      @browser = browser
+      @keyed_elements = []
+      create_keyword_methods
+    end
+
+    def keywords
+      self.class.keywords
+    end
+
+    def native_keywords
+      self.class.native_keywords
+    end
+
+    def process_pages
+      self.class.process_pages
+    end
+
+    def process_page(x)
+      process_pages.each { |page| return page if page.name == x }
+    end
+
+  private
+
+    def create_keyword_methods
+      keywords = self.class.keyword_metadata || {}
+      keywords.each_key do |key|
+        keyed_element = KeyedElement.new(self, keywords[key])
+        @keyed_elements << keyed_element
+        meta_def key do |*args|
+          keyed_element.get *args
+        end
+        meta_def "#{key}=" do |*args|
+          keyed_element.set *args
+        end
+      end
+    end
+  end
+end
+
+Page = Watirmark::Page

data/lib/watirmark/page/page_definition.rb

@@ -0,0 +1,187 @@
+require 'watirmark/page/process_page'
+
+module Watirmark
+  module ProcessPageDefinition
+    attr_accessor :process_pages,
+                  :process_page_navigate_method,
+                  :process_page_active_page_method,
+                  :process_page_submit_method
+
+    def process_page(name, method=nil)
+      @current_process_page = find_or_create_process_page(name)
+      yield
+      @current_process_page = @current_process_page.parent
+    end
+
+    def process_page_alias(x)
+      @current_process_page.alias << x
+    end
+
+    def always_activate_parent
+      @current_process_page.always_activate_parent = @current_process_page.parent.name
+    end
+
+    def process_page_navigate_method(proc=nil)
+      @process_page_navigate_method = proc
+    end
+
+    def process_page_submit_method(proc)
+      @process_page_submit_method = proc
+    end
+
+    def process_page_active_page_method(proc)
+      @process_page_active_page_method = proc
+    end
+
+  private
+
+    def add_superclass_process_pages_to_subclass(klass)
+      klass.process_pages = (@process_pages ? @process_pages.dup : klass.process_pages = [])
+    end
+
+
+    def create_default_process_page(klass)
+      klass.instance_variable_set :@current_process_page, ProcessPage.new
+      current_page = klass.instance_variable_get(:@current_process_page)
+      current_page.root = true
+      klass.process_pages << current_page
+    end
+
+    def find_or_create_process_page(name)
+      mypage = find_process_page(name)
+      unless mypage
+        mypage = ProcessPage.new(name,
+                                 @current_process_page,
+                                 @process_page_active_page_method,
+                                 @process_page_navigate_method,
+                                 @process_page_submit_method
+        )
+        @process_pages ||= []
+        @process_pages << mypage
+      end
+      mypage
+    end
+
+    def find_process_page(name)
+      if @current_process_page.root
+        underscored_name = name
+      else
+        underscored_name = (@current_process_page.underscored_name + '_' + name).downcase.gsub!(/\s+/, '_')
+      end
+      @process_pages.find { |p| p.underscored_name == underscored_name }
+    end
+  end
+
+
+
+  module PageDefinition
+    include ProcessPageDefinition
+    attr_accessor :kwds, :perms, :kwd_metadata
+
+    @@browser = nil
+
+    def inherited(klass)
+      add_superclass_keywords_to_subclass(klass)
+      add_superclass_keyword_metadata_to_subclass(klass)
+      add_superclass_process_pages_to_subclass(klass)
+      create_default_process_page(klass)
+    end
+
+    def keyword(name, map=nil, &block)
+      create_new_keyword(name, map, permissions={:populate => true, :verify => true}, &block)
+    end
+
+    def populate_keyword(name, map=nil, &block)
+      create_new_keyword(name, map, permissions={:populate => true}, &block)
+    end
+
+    def verify_keyword(name, map=nil, &block)
+      create_new_keyword(name, map, permissions={:verify => true}, &block)
+    end
+
+    def private_keyword(name, map=nil, &block)
+      create_new_keyword(name, map, &block)
+    end
+    alias :navigation_keyword :private_keyword
+
+    # Create an alias to an existing keyword
+    def keyword_alias(keyword_alias_name, keyword_name)
+      keyword_data = @kwd_metadata[self.to_s][keyword_name]
+      create_new_keyword(keyword_alias_name, keyword_data[:map], keyword_data[:permissions], &keyword_data[:block])
+    end
+
+    def browser
+      @@browser ||= Watirmark::Session.instance.openbrowser
+    end
+
+    def browser=(x)
+      @@browser = x
+    end
+
+    def browser_exists?
+      !! @@browser
+    end
+
+    def keywords
+      @kwds.values.flatten.uniq.sort_by { |key| key.to_s }
+    end
+
+    def native_keywords
+      @kwds[self.to_s].sort_by { |key| key.to_s }
+    end
+
+    def keyword_metadata
+      @kwd_metadata ||= nested_hash
+      @kwd_metadata.values.inject(:merge)
+    end
+
+  private
+    def nested_hash
+      Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k]=Hash.new } }
+    end
+
+    def create_new_keyword(name, map=nil, permissions, &block)
+      keyword_name = name.to_sym
+      add_to_keywords(keyword_name)
+      add_to_current_process_page(keyword_name, permissions)
+      add_keyword_metadata(keyword_name, map, permissions, block)
+    end
+
+    def add_keyword_metadata(name, map, permissions, block)
+      @kwd_metadata ||= nested_hash
+      @kwd_metadata[self.to_s][name][:keyword] = name
+      @kwd_metadata[self.to_s][name][:map] = map
+      @kwd_metadata[self.to_s][name][:permissions] = permissions
+      @kwd_metadata[self.to_s][name][:block] = block
+      @kwd_metadata[self.to_s][name][:process_page] = @current_process_page
+    end
+
+    def add_to_current_process_page(name, permissions)
+      @current_process_page << name if permissions
+    end
+
+    def add_to_keywords(method_sym)
+      @kwds ||= Hash.new { |h, k| h[k] = Array.new }
+      @kwds[self.to_s] << method_sym unless @kwds.include?(method_sym)
+    end
+
+    def add_superclass_keywords_to_subclass(klass)
+      update_subclass_variables(klass, method='kwds', default=Hash.new { |h, k| h[k] = Array.new })
+    end
+
+    def add_superclass_keyword_metadata_to_subclass(klass)
+      update_subclass_variables(klass, method='kwd_metadata', default=Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = Hash.new } })
+    end
+
+    def update_subclass_variables(klass, method, default)
+      var = self.send(method)
+      if var
+        klass.send("#{method}=", default) unless klass.send(method)
+        var.each_key do |k|
+          klass.send(method).store(k, var.fetch(k).dup)
+        end
+      end
+    end
+  end
+
+end

data/lib/watirmark/page/process_page.rb

@@ -0,0 +1,112 @@
+module Watirmark
+  class ProcessPage
+
+    attr_reader :parent, :keywords
+    attr_accessor :alias, :name, :root, :always_activate_parent
+    attr_accessor :submit_method, :active_page_method, :navigate_method
+
+    @@navigate_method_default ||= Proc.new {}
+    @@submit_method_default ||= Proc.new {}
+    @@active_page_method_default ||= Proc.new {}
+
+    class << self
+      def navigate_method_default=(proc)
+        @@navigate_method_default = proc
+      end
+
+      def submit_method_default=(proc)
+        @@submit_method_default = proc
+      end
+
+      def active_page_method_default=(proc)
+        @@active_page_method_default = proc
+      end
+
+      def navigate_method_default
+        @@navigate_method_default
+      end
+
+      def submit_method_default
+        @@submit_method_default
+      end
+
+      def active_page_method_default
+        @@active_page_method_default
+      end
+    end
+
+    def initialize(name='', parent=nil, active_page=nil, navigate_page=nil, submit_page=nil)
+      @name = name
+      @parent = parent
+      @keywords = []
+      @root = false
+      @always_activate_parent = false
+      @alias = []
+      @active_page_method = active_page if active_page
+      @navigate_method = navigate_page if navigate_page
+      @submit_method = submit_page if submit_page
+    end
+
+    # Give the full name of this process page, including the
+    # parent process pages. The argument allows us to
+    # easily get the full path for alias names.
+    def underscored_name(name=@name)
+      u_name = (@parent && !@parent.root) ? "#{@parent.underscored_name}_#{name}" : name
+      u_name.downcase.gsub(/\s+/, '_') if u_name
+    end
+
+    def activate
+      return if (@root || active?)
+      if @always_activate_parent
+        @parent.goto_process_page
+      else
+        @parent.activate if @parent
+      end
+      goto_process_page
+    end
+
+    def <<(x)
+      @keywords << x.to_sym
+    end
+
+    def goto_process_page
+      unless navigate
+        aliases.each do |alias_name|
+          alias_process_page = self.dup
+          alias_process_page.alias = []
+          alias_process_page.name = alias_name
+          alias_process_page.alias = nil
+          alias_process_page.goto_process_page
+        end
+      end
+    end
+
+    def navigate
+      instance_eval &(@navigate_method || @@navigate_method_default)
+    end
+
+    def submit
+      instance_eval &(@submit_method || @@submit_method_default)
+    end
+
+    def active_page
+      instance_eval &(@active_page_method || @@active_page_method_default)
+    end
+
+    def aliases
+      @alias ||= []
+    end
+
+    def active?
+      page = active_page
+      return true if in_submenu(page, underscored_name)
+      aliases.each { |a| return true if in_submenu(page, underscored_name(a)) } unless aliases.empty?
+      false
+    end
+
+    def in_submenu(active_page, requested_page)
+      !!(active_page.to_s.downcase.delete('>').gsub(/\s+/, '_') =~ /^#{requested_page}/)
+    end
+
+  end
+end

data/lib/watirmark/page/radio_maps.rb

@@ -0,0 +1,53 @@
+module Watirmark
+
+  class RadioMapElement
+    attr_accessor :list, :value
+
+    def initialize(*args)
+      @list= *args
+      @value = nil
+    end
+
+    def map_to(x)
+      @value = x
+    end
+
+    alias :maps_to :map_to
+
+  end
+
+  class RadioMap
+    def initialize hash={}
+      @maps = []
+      hash.each_pair do |key, val|
+        values(key).maps_to(val)
+      end
+    end
+
+    def values(*args)
+      element = RadioMapElement.new(*args)
+      @maps << element
+      element
+    end
+
+    alias :value :values
+
+    def lookup(x)
+      return nil if x.nil?
+      @maps.each do |map|
+        if Array === map.list
+          map.list.each do |items|
+            [*items].each do |item|
+              return map.value if item.matches x
+            end
+          end
+        else
+          return map.value if map.list.matches x
+        end
+      end
+      raise Watirmark::TestError, "No map value exists for '#{x}'" unless x
+      x
+    end
+  end
+
+end

data/lib/watirmark/profile.rb

@@ -0,0 +1,22 @@
+require 'ruby-prof'
+
+class Profiler
+  def self.profile(options={}, &block)
+    RubyProf.start
+    beginning = Time.now
+    puts '-----------------------'
+    puts options[:name]
+    puts '-----------------------'
+    block.call
+    result = RubyProf.stop
+    result.eliminate_methods!([/IO/, /Net::/, /Global/])
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print(STDOUT, :min_percent=> (options[:min_percent] || 1))
+    puts "----> Time elapsed #{Time.now - beginning} seconds"
+  end
+end
+
+
+#require 'watirmark/profile'
+# Profiler.profile(:name => "#{element.keyword}, #{element}") do
+

data/lib/watirmark/rake/smoketest.rb

@@ -0,0 +1,17 @@
+module SmokeTest
+
+  class << self
+    def rspec_task(task_name, files, tag=:smoke)
+      RSpec::Core::RakeTask.new(task_name) do |spec|
+        spec.rspec_opts = "--tag #{tag} -fd -fh --out spec/reports/#{spec.name}.html --backtrace"
+        spec.pattern = files
+      end
+    end
+
+    def cucumber_task(task_name, files=nil, tag=:smoke)
+       Cucumber::Rake::Task.new(task_name) do |t|
+         t.cucumber_opts = "--tags @#{tag} -r features #{FileList[files]} -b --format html -o reports/report.html --format pretty"
+       end
+    end
+  end
+end