shiken 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5edfc3ceb874cd976dd729485e38e8752cdc693a
+  data.tar.gz: ec9dd9bfc1143a913e956c3d96b50ad659db0468
+SHA512:
+  metadata.gz: 21d62b4814a02148e10f94a1a64be9cc993af62a04c4402d4202a4fb51dad74ef8d55c9271e6a03ae75e865682c96bcfd7d005f42a84218f5d1bf5e622d3b9cb
+  data.tar.gz: 90b5dc74cff9bead2d8461e0e48a0005da7e43981b2ae426b7a28bc95a73326ac7b58ec7b91174f95c71cc5cc3d47a8790edbc0799b7567bad98c6699f94f74c

data/lib/browser.rb

@@ -0,0 +1,266 @@
+require 'selenium-webdriver'
+require 'shiken/trace'
+require 'uri'
+
+module SK::Browser
+  
+  extend self 
+  
+  ### local utilities
+  
+  def pause(secs,text="")
+    trace("pause #{secs} seconds #{text}")
+    sleep secs
+  end
+  def trace(s)
+    SK::Trace.trace(s)
+  end
+  def error(s)
+    SK::Trace.error(s)
+  end
+  def warn(s)
+    SK::Trace.notice(s)
+  end
+  
+  ###### main stuff #########
+  
+  def goto(site,page='')
+    gotourl("https://#{site}/#{page}")
+  end
+  def gotox(site,page='')
+    gotourl("http://#{site}/#{page}")
+  end
+  def gotourl(url,seconds=1)
+    uri = URI.escape(url)
+    puts("go to #{uri}")
+    rescue_exceptions { SK::driver.get uri }
+    sleep seconds
+  end
+    
+  def option(dd)
+      warn "browser.option is depricated. use SK::Dropdown instead"
+      Selenium::WebDriver::Support::Select.new(dd)
+   end
+
+  def select(locator,value)
+      dropdown(locator,"option",value)
+  end
+
+  def dropdown(locator,tagname,list_option)
+      warn "browser.dropdown is depricated. use SK::Dropdown instead. locator=#{locator}"
+      # actually returns the option object for the dropdown
+      # so the calling code can chain a select by method
+      # option(find({name: name}))
+      select_box = find(locator)
+      # select_box = $driver.find_element(locator)
+      _dropdown_el(select_box,tagname,list_option)
+  end
+    def _dropdown_el(select_box,tagname,list_option)
+      # trace "dropdown el... select_box=#{select_box}"
+      # trace "dropdown el... tagname=#{tagname} option=#{list_option}"
+
+      # actually returns the option object for the dropdown
+      # so the calling code can chain a select by method
+      # option(find({name: name}))
+      options = select_box.find_elements(:tag_name => "#{tagname}")
+
+      options.each do |option_field|
+        # trace "looking at #{option_field.text}"
+        if option_field.text == "#{list_option}"
+          option_field.click
+          break
+        end
+      end
+    end
+
+    def search(base_locator,target_locator,value,attr='text')
+      # search within the locator element for all matching tags (by name)
+      # return that element that has the attribute of text that matches
+      # the text_value passed 
+      element = find(base_locator)
+      unless element # was found
+        error "wt search: element not found. locator = #{base_locator}"
+        return false
+      end
+      elements = element.find_elements(target_locator)
+      elements.each do |el|
+        el_attr = _get_attribute(el,attr)
+        # trace "wt search at #{el_attr} for #{value}"
+        return el if el_attr == "#{value}"          
+      end
+      return false
+    end
+    
+    def _get_attribute(el,attr)
+      attr == 'text' ? el.text : el.attribute(attr)
+    end
+
+    def radio(locator)
+      warn "browser.radio is depricated. use SK::RadioSet instead. locator=#{locator}"
+      self.click(locator,0)
+    end
+
+    def set(locator,value)
+      # set now accepts a single or an
+      # array of locators, by using newfind
+      el = find(locator)
+      error "cannot set #{locator}" unless el
+      _set_el(el,value) if el
+    end
+    def _set_el(el,value)
+      el.clear
+      el.send_keys(value)
+    end
+
+    def submit(name,secs=1)
+      click(name: name)
+      sleep secs
+    end
+
+    def find(param)
+      # find accepts a single value or array
+      # of locators to find an element.  the array
+      # is meant to be a this under this structure
+      if param.kind_of?(Array)
+        base = driver
+        param.reverse.each do |loc|
+          base = _find_inside(loc,base)
+        end  
+        return base     
+      else
+        # not an array, a single
+        _find_inside(param,driver)
+      end
+    end
+        
+    def _find_inside(locator, base)
+      # trace "find inside. locator=#{locator} base=#{base}"
+      # find an element by locator inside another element (base)
+      case
+      when locator.has_key?(:value)
+        # trace "... locate by value: #{locator[:value]}}"
+        find_input(:value,locator[:value]) 
+      when locator.has_key?(:type)
+        # trace "... locate by type: #{locator[:type]}" 
+        find_input(:type,locator[:type]) 
+      else
+        # a standard selenium locator so just use it
+        rescue_exceptions { base.find_element(locator) } 
+      end
+    end
+    
+    def find_input(key,type)
+      # selenium does not support a locator search by type
+      # so we need a specialized function to find the element
+      elements = all({tag_name: 'input'})
+      elements.find do |e| 
+        # trace "> #{e.attribute(key)} :: #{type}"
+        e.attribute(key) == type
+      end
+    end
+  
+    def all(locator)
+      rescue_exceptions { driver.find_elements(locator) }
+    end
+  
+    def match(text,locator)
+      elements = all(locator)
+      # trace("searching #{elements.length} links...")
+      elements.find{ |e| e.text.include? text }
+    end
+  
+    def count_refs(ref, locator)
+      elements = all(locator)
+      # trace("count from #{elements.length} links...")
+      elements.count{ |e| e.attribute('href').include? ref }    
+    end   
+ 
+    def has_content?(content)
+      # puts trace("has content? #{content}")
+      return self.source.include? content
+    end
+
+    def has_el?(locator)
+      find(locator)
+      # rescue_exceptions { driver.find_element(locator) }
+    end
+    
+    def has_text?(locator,text)
+      find(locator).text == text
+    end
+    
+    def get_rows(locator,less_row)
+      rest  = less_row.to_i
+      #table = rescue_exceptions { driver.find_elements(table_count) }
+      table = all(locator)
+      return table.count-rest
+    end
+
+    def get_text(locator)
+      find(locator).text
+      # return rescue_exceptions { driver.find_element(locator).text }
+    end
+    
+    def get_value(locator)
+      find(locator).attribute('value')
+    end
+    
+    ### Actions ####
+    
+    def click(locator,pause=0)
+      SK::Trace.trace("*** click is depricated")
+      el = find(locator)
+      _click_el(el,pause) if el
+    end
+    
+    def _click_el(el,extra)
+      SK::Trace.trace("*** click_el")
+      rescue_exceptions { el.click }
+      sleep 1+extra
+      self
+    end
+    
+    ### Key Core Operations ###
+    
+    def rescue_exceptions
+      # we do not want our tests to fail because selenium throws an error
+      # instead we want to explicitly test using "expects" in the cases
+      begin
+        yield
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+        warn "Element does not exist."
+        false
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError
+        warn "Element is stale."
+        false
+      rescue Selenium::WebDriver::Error::ElementNotVisibleError
+        warn "Element is not visible."
+        false
+      rescue Selenium::WebDriver::Error::WebDriverError => e
+        error "Webdriver Error. #{e}"
+        false
+      rescue Net::ReadTimeout
+        error "Network Timeout - no response."
+        false
+      rescue IOError   
+        error "IOError"
+        false
+      end
+    end
+     
+    ### Simple Accessors ####
+
+    def driver
+      SK::driver
+    end    
+    def source
+      driver.page_source
+    end
+    def url
+      driver.current_url
+    end
+    def title
+      driver.title
+    end
+           
+end

data/lib/button.rb

@@ -0,0 +1,7 @@
+class SK::Button < SK::Clickable
+
+  def initialize(locator,delay: 2)
+    super(locator,delay: delay)
+  end
+    
+end

data/lib/clickable.rb

@@ -0,0 +1,22 @@
+class SK::Clickable < SK::Element
+
+  # a clickable element can be created with a custom delay
+  # so that the tester does not have to set the delay at 
+  # every calling point... just once at the creation oint
+  
+  def initialize(locator,delay: 0)
+    super(locator) # creates the el and locator
+    @delay = delay
+  end
+  
+  def click(delay = @delay)
+    if self.el
+      # SK::Trace.trace "SK::Clickable.click #{self.locator} #{self.el}"
+      self.el.click
+      sleep delay
+    else
+      SK::Trace.error "SK::Clickable.click: element not initialized for #{locator}"
+    end
+  end
+    
+end

data/lib/downloads.rb

@@ -0,0 +1,80 @@
+module SK::Downloads
+  
+  @path = nil
+
+  extend self
+  
+  def path=(p)
+    @path = p
+  end
+  
+  def path
+    @path = @path || determine_mac_path
+  end
+
+  def determine_mac_path
+    parts = File.dirname(__FILE__).split("/")
+    # will work for AR and PC on a Mac (for now)
+    "/#{parts[1]}/#{parts[2]}/downloads"
+  end
+  
+  def files
+    # NOTE: every time this is called it goes out to the OS for
+    # a fresh list of the files... we may want to change to a 
+    # "refresh" or "readfiles" model for performance
+    Dir["#{self.path}/*"]
+  end
+
+  def names    
+    files.collect {|f| File.basename(f) }
+  end
+  
+  def include?(filename)
+    filepath = "#{path}/#{filename}"
+    files.include? filepath
+  end
+
+  def last
+    files.max_by {|f| File.mtime(f)}   
+  end
+  
+  def last_name
+    File.basename last # just the file name
+  end
+  
+  def count
+    files.length
+  end
+  
+  # def first
+  #   files.first
+  # end
+  
+  # def first_content
+  #   wait_for_download
+  #   File.read(first)
+  # end
+
+  def wait_for_download
+    Timeout.timeout(1) do
+      sleep 0.1 until downloaded?
+    end
+  end
+
+  def downloaded?
+    !downloading? && files.any?
+  end
+
+  def downloading?
+    files.grep(/\.part$/).any?
+  end
+
+  def delete_any(name)
+    list = files.select { |f|  File.basename(f).include?(name)  } 
+    FileUtils.rm_f(list)  
+  end
+  
+  def delete_all
+    FileUtils.rm_f(files)
+  end
+end

data/lib/dropdown.rb

@@ -0,0 +1,30 @@
+class SK::Dropdown < SK::Element
+  
+  def initialize(locator)
+    super(locator) # creates the el and locator via 
+    SK::Trace.warn "Dropdown failed to initialize. locator = #{locator}" unless el
+    @options = el.find_elements(tag_name: "option")  
+  end
+  
+  def select(value)
+    select_by('text',value)
+  end
+  
+  def select_by(attr,value)
+    @options.each do |option|
+      optval = option.attribute(attr)
+      # trace "looking at #{optval}"
+      if optval == value
+        option.click
+        break
+      end
+    end
+  end
+  
+  def select_index(index)
+    n = [@options.length-1,index].min
+    @options[n].click
+    return @options[n].attribute('text')
+  end
+  
+end

data/lib/element.rb

@@ -0,0 +1,104 @@
+class SK::Element
+  
+  def initialize(arg,src="xxx")
+    # puts "element init arg=#{arg} src=#{src}"
+    if !arg
+      # sometimes we want to create an element from
+      # a find that fails... so create a dummy element
+      @locator = { src: src }
+      @el = false
+    elsif arg.instance_of?(Selenium::WebDriver::Element)
+      @locator = { src: src }
+      @el = arg
+    else # it is a locator
+      @locator = arg # remember
+      @el = SK::Browser.find(arg)
+      SK::Trace.debug "element locator=#{arg} el=#{@el}"
+      SK::Trace.warn "element failed to initialize with locator = #{arg}" unless @el
+    end
+  end
+  
+  attr_reader :el
+  attr_reader :locator
+  
+  def to_s
+    "<SK::Element #{locator}>"
+  end
+
+  def exists?
+    !!el
+  end
+  alias :exist? :exists?
+
+  def displayed?
+    puts "+++ element displayed?"
+    SK::Browser.rescue_exceptions { self.el.displayed? } 
+  end
+  
+  def html
+    # useful to see for debugging
+    self.el.attribute('innerHTML')
+  end
+
+  def enabled?
+    puts "enabled? 1:#{exists?}"
+    false unless exists?
+    puts "enabled? 2:#{el.enabled?}"
+    el.enabled?
+  end
+
+  def text
+    # useful to see contents for debugging
+    str1 = self.el ? self.el.text : ''
+    # str2 = str1.gsub(/\n\s+/, " ") # shrink white space
+    str1.gsub(/\n+/, " ").strip # remove new lines
+  end
+  
+  def find(locator,klass=SK::Element)
+    # trace "find #{locator} in #{self.locator}"
+    child_el = find_child_el(locator)
+    # trace "child el = #{child_el}"
+    klass.new(child_el,"#{locator}")
+  end
+  alias :child :find
+
+  def find_child_el(locator)
+      # trace "find child of #{self.locator}. locator=#{locator}"
+      # find an element by locator inside another element (base)
+      case
+      when locator.has_key?(:value)
+        # trace "... locate by value: #{locator[:value]}}"
+        search(:value,locator[:value]) 
+      when locator.has_key?(:type)
+        # trace "... locate by type: #{locator[:type]}" 
+        search(:type,locator[:type]) 
+      else
+        # a standard selenium locator so just use selenium
+        SK::Browser.rescue_exceptions { self.el.find_element(locator) } 
+      end
+  end
+
+  def children(locator,klass=SK::Element)
+      # get the matching children elements
+      els = SK::Browser.rescue_exceptions { self.el.find_elements(locator) } 
+      # but return as one of our class types
+      els.map { |el| klass.new(el) }
+  end
+
+  def search(key,val)
+    trace "element#search key=#{key} val=#{val}"
+    # selenium does not support a locator search by type
+    # so we need a specialized function to find the element
+    elements = self.el.find_elements({})
+    #elements = all({tag_name: 'input'})
+    elements.find do |e| 
+        # trace "> #{e.attribute(key)} :: #{val}"
+        e.attribute(key) == val
+    end
+  end
+    
+  def parent_el
+    self.el.find_element({xpath: ".."})
+  end
+    
+end

data/lib/field.rb

@@ -0,0 +1,16 @@
+class SK::Field < SK::Element
+  
+  def initialize(locator)
+    super(locator) # creates the el and locator
+  end
+  
+  def set(value)
+    if self.el
+      self.el.clear
+      self.el.send_keys(value)
+    else
+      SK::Trace.error "SK::Field.set: element not initialized for #{locator}"
+    end
+  end
+    
+end

data/lib/kendo.rb

@@ -0,0 +1,138 @@
+class SK::KElement
+  
+  def initialize(el)
+    @element = el
+  end
+
+  def el
+    @element
+  end
+
+  def exists?
+    !!el
+  end
+
+  def text
+    # useful to see for debugging
+    self.el.text
+  end
+  
+  def html
+    # useful to see for debugging
+    self.el.attribute('innerHTML')
+  end
+  
+end
+
+class SK::KCell < SK::KElement
+  def as_num
+    # trace "cell = #{cell.text}"
+    sign = self.text.include?('(') ? -1 : 1
+    sign * self.text.gsub(/[$,()]/, '').to_f
+  end
+end
+
+class SK::KRow < SK::KElement
+  def cells()
+    self.el.find_elements({tag_name: 'td'}).collect{ |e| SK::KCell.new(e) }
+  end
+end
+
+class SK::KGrid < SK::KElement
+  def initialize(locator={id: 'grid'})
+    super(SK::Browser.find(locator))
+  end
+  def grid
+    el
+  end
+  def items_label()
+    return nil unless grid
+    self.grid.find_element({class: 'k-pager-info'})
+  end
+  def items_count()
+    return 0 unless self.grid
+    return 0 unless self.items_label
+    # trace "*** items label = #{self.items_label.text}"
+    count = /(\d*) items/.match(self.items_label.text)[1].to_i
+    return count
+  end
+  def pages_count
+    last_page_button.attribute('data-page').to_i
+  end
+  def last_page_button
+    self.grid.find_element({class: 'k-pager-last'})
+  end
+  def first_page_button
+    self.grid.find_element({class: 'k-pager-first'})
+  end
+  def prev_page_button
+    # there is an easily identifiable span inside the button
+    span = self.grid.find_element({class: 'k-i-arrow-w'})
+    span.find_element({xpath: '..'})
+  end
+  def next_page_button
+    # there is an easily identifiable span inside the button
+    span = self.grid.find_element({class: 'k-i-arrow-e'})
+    span.find_element({xpath: '..'})
+  end
+  def rows
+    set = self.grid.find_elements({tag_name: 'tr'})
+    # trace "wt grid rows length = #{set.length}"
+    set
+  end
+  def row(n)
+    SK::KRow.new(self.rows[n])
+  end
+  
+end
+
+class SK::KFilter
+  def initialize(n)
+    @filter = nil # in case of error    
+    # first check that the current page has a kendo grid
+    grid = SK::KGrid.new()
+    return if ! grid 
+    # then work our way throught the page/grid...
+    # list of all the column headers; this is a little
+    # fragile if the page has other tables before the grid
+    th_list = SK::Browser.all({tag_name: 'th'})
+    return if !th_list
+    return if th_list.length < n
+    header = th_list[n] # the nth header for the column
+    # puts "attribute = #{header.attribute('data-field')}"
+    @filter = header.find_element({class: 'k-grid-filter'})
+    # puts "find filter = #{@filter}"
+  end
+  def click
+    # puts "click filter = #{@filter}"
+    @filter.click() # makes AC it visible
+    # pause 1
+  end
+  def clear
+    buttons = SK::Browser.all({tag_name: 'button'})
+    button = buttons.find { |el| el.text == 'Clear' } 
+    button.click if button
+    sleep 1
+  end
+  def select(value)
+    containers = SK::Browser.all({class: 'k-animation-container'})
+    container = containers.find { |c| c.displayed? }
+    sleep 1 # to find the textbox???
+    textbox = container.find_element({class: 'k-textbox'})
+    trace "filter's textbox is not visisble" unless textbox.displayed?
+    textbox.send_keys(value)    
+    button = container.find_element({class: 'k-primary'})
+    button.click()
+    sleep 1
+  end
+end
+
+module SK::Kendo
+  class << self 
+  
+    def grid()
+      return SK::KGrid.new()
+    end
+
+  end
+end

data/lib/link.rb

@@ -0,0 +1,7 @@
+class SK::Link < SK::Clickable
+
+	def initialize(locator,delay: 1)
+    	super(locator,delay: delay)
+  	end
+    
+end

data/lib/page.rb

@@ -0,0 +1,62 @@
+# TODO: move some of the browser methods to page
+
+class SK::Page
+  
+  def initialize(base,page)
+    @url = "#{base}/#{page}"
+  end  
+      
+  def url
+    @url
+  end
+  
+  # def goto
+  #   SK::Browser.gotox(url)
+  # end
+
+  def goto(opts={})
+    query = opts.map { |k,v| k.to_s+"="+v.to_s }.join("&")
+    url = @url 
+    url += "?" + query unless query == ""
+    trace("goto: url=#{url}")
+    SK::Browser.gotox(url)
+  end 
+
+
+  def present?
+    urls_match?
+  end
+
+  def urls_match?
+    # change to the looser include instead of equal
+    return true if SK::Browser.url.include? self.url
+
+    # return true if SK::Browser.url == self.url # old code
+
+    # because we almost always need to see some clues when the expected page is 
+    # not present we trace some outpout the the tester
+    trace "SK::Page url_match? expected: #{url} did not match current: #{SK::Browser.url}"
+    false # returned    
+  end
+  
+  def has_content?(content)
+    result = SK::Browser.source.include? content
+    # trace "missing content = #{content}" unless result
+    return result
+  end
+  
+  def here?(text)
+    return false unless urls_match?
+    # urls do match, but also require that
+    has_content? text
+  end
+  
+  def source
+    SK::Browser.source
+  end
+  
+  def title
+    SK::Browser.title
+  end
+  
+end

data/lib/radio_set.rb

@@ -0,0 +1,20 @@
+class SK::RadioSet
+  
+  def initialize(locator)
+    # get all the elements for the radio
+    @els = SK::Browser.all(locator)
+    # trace("radio els = #{@els}")
+  end
+  
+  def select(value)
+    # trace("radio els = #{@els}")
+    @els.each do |el|
+       #trace "radio looking at #{el.text}: #{value}"
+      if el.attribute('value') == value
+        el.click
+        break
+      end
+    end
+  end
+  
+end

data/lib/shiken.rb

@@ -0,0 +1,83 @@
+require 'selenium-webdriver'
+
+# NOTE: the requires are at bottom
+
+module SK
+  
+  @driver = nil
+  
+  extend self
+        
+  def version
+    v = "0.0.1"
+    # Trace.trace "version: #{v}"
+    return v
+  end
+  
+  def init(seconds=2, browser=:safari)
+    
+    # browser_stack_url = "http://patconley2:LBqJyYGj5TsyNBWe2Bjy@hub.browserstack.com/wd/hub"
+    # $driver = Selenium::WebDriver.for(:remote, :url => browser_stack_url)
+    
+    # Trace.trace "SK::init"
+    # seconds = max time to wait for the element to appear
+    wait = Selenium::WebDriver::Wait.new(:timeout => seconds)
+        
+    profile = Selenium::WebDriver::Firefox::Profile.new
+    profile["javascript.enabled"] = false # NOT SURE WHY????
+    # trace "wt init download path = #{SK::Downloads.path}"
+    profile['browser.download.dir'] = SK::Downloads.path
+    #
+    # # The value of browser.download.folderList can be set to either 0, 1, or 2.
+    # # When set to 0, Firefox will save all files downloaded via the browser on the
+    # # user's desktop. When set to 1, these downloads are stored in the Downloads folder.
+    # # When set to 2, the location specified for the most recent download is utilized again
+    profile['browser.download.folderList'] = 2  # use the specified directory
+      
+    # Suppress "open with" dialog for a file types    
+    profile['browser.helperApps.neverAsk.saveToDisk'] = "text/csv,application/pdf,application/xls,image/tiff"
+    profile['browser.helperApps.alwaysAsk.force'] = false    
+    # disable Firefox's built-in PDF viewer
+    profile["pdfjs.disabled"] = true
+    # disable Adobe Acrobat PDF preview plugin
+    profile["plugin.scan.plid.all"] = false
+    profile["plugin.scan.Acrobat"] = "99.0"
+    
+    @driver = Selenium::WebDriver.for(browser)
+
+    # NOTE 3/4/17 the profile code failed for safari... see use of FIREFOX in creating profile!!
+
+    # @driver = Selenium::WebDriver.for(browser, :profile => profile)
+    # $driver = Selenium::WebDriver.for :firefox # :safari :chrome
+    
+    # TODO: what does this do... overried the above???
+    # @driver.manage.timeouts.implicit_wait = 5
+    
+    @driver # returned ????
+  end
+  
+  def quit
+    # Trace.trace "SK::quit"
+    driver.quit if driver 
+    @driver = nil 
+  end
+  
+  def driver
+    @driver
+  end
+    
+end
+
+require 'shiken/trace'
+require 'shiken/browser'
+require 'shiken/page'
+require 'shiken/element'
+require 'shiken/field'
+require 'shiken/clickable'
+require 'shiken/button'
+require 'shiken/link'
+require 'shiken/dropdown'
+require 'shiken/radio_set'
+require 'shiken/kendo'
+require 'shiken/table'
+require 'shiken/downloads'

data/lib/table.rb

@@ -0,0 +1,56 @@
+class SK::Cell < SK::Element
+
+  # row is an element that "remembers" it's index in the row
+
+  attr_reader :index
+
+  def initialize(locator,index)
+    super(locator) # creates the el and locator
+    @index = index # remember your position
+  end
+
+  def as_num
+    # trace "cell = #{cell.text}"
+    sign = self.text.include?('(') ? -1 : 1
+    sign * self.text.gsub(/[$,()]/, '').to_f
+  end
+
+  def to_s
+    "<SK::Cell #{@index} [#{self.text}]>"
+  end
+
+end
+
+class SK::Row < SK::Element
+
+  # row is an element that "remembers" it's index in the table
+
+  attr_reader :index
+
+  def initialize(locator,index)
+    super(locator) # creates the el and locator
+    @index = index # remember your position
+  end
+
+  def cells()
+    ds = self.el.find_elements({tag_name: 'td'})
+    ds.map.with_index { |e,i| SK::Cell.new(e,i) }
+  end
+
+  def to_s
+    text = cells.map { |cell| cell.text }.join("][")
+    "<SK::Row #{@index} [#{text}] >"
+  end
+end
+
+class SK::Table < SK::Element
+
+  def rows
+    rs = self.el.find_elements({tag_name: 'tr'})
+    SK::Trace.debug "SK::Table el rows length = #{rs.length}"
+    ws = rs.map.with_index { |r,i| SK::Row.new(r,i) } 
+    SK::Trace.debug "SK::Table wt rows length = #{ws.length}"
+    ws # returned
+  end
+  
+end

data/lib/trace.rb

@@ -0,0 +1,59 @@
+require 'colorize'
+
+module SK::Trace
+  
+  DEBUG = 3
+  WARN  = 2
+  ERROR = 1
+  QUIET = 0
+  
+  extend self
+  
+  @level = DEBUG
+  
+  def level=(value)
+    case value
+    when :debug
+      n = DEBUG
+    when :warn
+      n = WARN
+    when :error
+      n = ERROR
+    when :quiet
+      n = QUIET
+    else
+      n = value.to_i
+    end
+    @level = n
+  end
+  
+  def level
+    @level
+  end
+  
+  def trace(s)
+    write "SK::Trace : #{s}".cyan, DEBUG
+  end  
+  def debug(s)
+    write "SK::Debug : #{s}".cyan, DEBUG
+  end
+  def error(s)
+    write "SK::Error: #{s}".red, ERROR
+  end
+  def notice(s)
+    write "SK::Notice: #{s}".yellow, WARN
+  end
+  def warn(s)
+    write "SK::Warn  : #{s}".yellow, WARN
+  end
+  
+  def write(text,lev)
+    puts text if level >= lev
+  end
+
+  # def xfail(num,s)
+  #   error num, s
+  #   fail
+  # end
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: shiken
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Pat Conley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-05 00:00:00.000000000 Z
+dependencies: []
+description: A layer to simplify ruby use of selenium
+email: pconley312@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/browser.rb
+- lib/button.rb
+- lib/clickable.rb
+- lib/downloads.rb
+- lib/dropdown.rb
+- lib/element.rb
+- lib/field.rb
+- lib/kendo.rb
+- lib/link.rb
+- lib/page.rb
+- lib/radio_set.rb
+- lib/shiken.rb
+- lib/table.rb
+- lib/trace.rb
+homepage: https://github.com/pconley/Shiken.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A Selenium Facade in Ruby
+test_files: []