shiken 0.0.8 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 225017a78d4f589558e3d1ecd0b18d25828f0124d74c3a79de4d9293eeda34a3
-  data.tar.gz: efa0a004bc2e8151340a5426148b21322ead2e6c5d0ba37fc130afa6ae5174ca
+  metadata.gz: 3ced3037fa94afc954c1451d7232a39cbc40646b816dec0b0a677bbddd19f393
+  data.tar.gz: f5ffe32be611987465d5b999812deaff2c7db4b24903965b6a4972f1fb6a106a
 SHA512:
-  metadata.gz: 75ec30d61f061d2c2cf46457147f2fa95b9dd3ebe0f9946b1cce4482e918ea6568cf1d314f2b670ae76c8e8b10801f307e4bb7c3e161aa01653f1d105d7701f3
-  data.tar.gz: 62d12bc6afac712b083963562e04f1d0181e323266e7064786b1a2e646b6ce2627ad18c55f2cbfa34923151fdb0cb3e4280bf10c7577b592654c38027d4034d7
+  metadata.gz: cfd4db0f9c2709bb7d4fe4adc4d74a38c5c49328113d268e1c9486f169a82b648d3e794ec9f777f5121de903cecb3946044294dad72d921d7d1743cf8a4b7955
+  data.tar.gz: 55b4efe0c2714699e1f32d1e83620799e516730e84f1076858a331ea18b04f8f87e96b9852b2c48f6115db712beadf24441fa610cdb34d505ea03ddf6326c9dd

data/bin/shiken

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require "thor"
+ 
+class ShikenCLI < Thor
+
+  desc "hello NAME [FROM]", "say hello to NAME"
+  long_desc <<-LONGDESC
+    `shiken hello` will print out a message to a person of
+    your choosing.\n
+    You can optionally specify a second parameter, which will
+    print out a from message as well.\n
+    : $ shiken hello mike "Pat Conley"
+    \x5: from: Pat Conley
+    \x5: Hello mike!\n
+  LONGDESC
+
+  def hello(name, from=nil)
+    puts "from: #{from}" if from
+    puts "Hello #{name}!"
+  end
+
+  desc "install DIRECTORY", "create the directory with shiken helpers"
+  long_desc <<-LONGDESC
+    `shiken install` will create a subdirectory and populate it with
+    the shiken helper files.\n
+    The default directory is called webtests but the first parameter
+    is the name of the directory you prefer.\n
+    : $ shiken install my_tests
+  LONGDESC
+
+  def install(dir='webtests')
+    source = File.join(__dir__,"..","spec")
+    target = File.join(Dir.pwd, dir)
+    # puts "source = #{source}"
+    puts "creating and populating #{target}"
+	# puts "create complete [#{target}]"
+	FileUtils.copy_entry source, target
+	puts "copy complete"
+  end
+
+end
+
+ShikenCLI.start(ARGV)

data/spec/google/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'shiken'
+
+RSpec.configure do |config|
+
+  config.before :suite do |x|
+     # puts "*** before suite" 
+     SK::init()    
+  end
+   
+  config.after :suite do |x|
+    # puts "*** after suite"
+    SK::quit()
+  end
+          
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+end

data/spec/google/test01_simple_spec.rb

@@ -0,0 +1,11 @@
+require_relative 'spec_helper'
+
+RSpec.describe 'google search' do
+              
+  it "can get to google" do
+    SK::Browser.goto('www.google.com')
+    # SK::Trace::trace SK::Browser.url
+    expect(SK::Browser.url).to include('www.google.com')
+  end
+    
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiken
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.5
 platform: ruby
 authors:
 - Pat Conley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-25 00:00:00.000000000 Z
+date: 2018-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -40,24 +40,14 @@ dependencies:
         version: '3.8'
 description: A layer to simplify ruby use of selenium
 email: pconley312@gmail.com
-executables: []
+executables:
+- shiken
 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
+- bin/shiken
+- spec/google/spec_helper.rb
+- spec/google/test01_simple_spec.rb
 homepage: https://github.com/pconley/Shiken.git
 licenses:
 - MIT

data/lib/browser.rb

@@ -1,266 +0,0 @@
-require 'selenium-webdriver'
-require '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)
-    trace("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

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

data/lib/clickable.rb

@@ -1,22 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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 empty?
-    # make the rspec read... expect(field).to be_empty
-    self.text == ''
-  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

@@ -1,16 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

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

data/lib/page.rb

@@ -1,62 +0,0 @@
-# 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 == ""
-    SK::Trace.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
-    SK::Trace.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
-    # SK::Trace.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

@@ -1,20 +0,0 @@
-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

@@ -1,83 +0,0 @@
-require 'selenium-webdriver'
-
-# NOTE: the requires are at bottom
-
-module SK
-  
-  @driver = nil
-  
-  extend self
-        
-  def version
-    v = "0.0.8"
-    # 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 'trace'
-require 'browser'
-require 'page'
-require 'element'
-require 'field'
-require 'clickable'
-require 'button'
-require 'link'
-require 'dropdown'
-require 'radio_set'
-require 'kendo'
-require 'table'
-require 'downloads'

data/lib/table.rb

@@ -1,56 +0,0 @@
-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

@@ -1,59 +0,0 @@
-require 'colorize'
-
-module SK::Trace
-  
-  DEBUG = 3
-  WARN  = 2
-  ERROR = 1
-  QUIET = 0
-  
-  extend self
-  
-  @level = WARN # default
-  
-  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