locatine 0.02539 → 0.02710

data/lib/locatine/for_search/saying.rb

@@ -1,196 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # texts, errors
-    # rubocop:disable Metrics/ModuleLength
-    module Saying
-      private
-
-      def send_info(message)
-        puts "#{time}: #{message}"
-      end
-
-      def send_warn(message)
-        warn "#{time}: WARNING: #{message}"
-      end
-
-      def verb(length)
-        length > 1 ? 'elements were' : 'element was'
-      end
-
-      ##
-      # Setting attribute of locatine div (way to communicate)
-      def send_to_app(what, value, bro = engine)
-        fix_iframe
-        bro.wd.execute_script(
-          %[if (document.getElementById('locatine_magic_div')){
-            const magic_div = document.getElementById('locatine_magic_div');
-             return magic_div.setAttribute("#{what}", "#{value}")}]
-        )
-        fix_iframe
-      end
-
-      def push_title(text)
-        send_info text
-        send_to_app('locatinetitle', text)
-      end
-
-      def send_found(name, scope, length)
-        push_title("#{length} #{verb(length)} found as #{name} in #{scope}"\
-          ' using previously saved information')
-      end
-
-      def send_guessing(name, scope)
-        push_title("Locatine is trying to guess what is #{name} in #{scope}.")
-      end
-
-      def send_selected(length, name, scope)
-        push_title "#{length} #{verb(length)} selected as #{name} in "\
-                  "#{scope}. If it is correct - confirm the selection."
-      end
-
-      def send_working(tag, index)
-        push_title "You've selected //#{tag}[#{index}]."\
-        ' Wait while Locatine works'
-      end
-
-      def send_lost
-        push_title 'Selected element was lost before locatine locate it. '\
-                 'Consider choosing it from devtools or write your own locator'
-      end
-
-      def send_clear(name, scope)
-        name = 'some element' if name.to_s.empty?
-        push_title "Now nothing is selected as #{name} in #{scope}"
-      end
-
-      def send_no_guess(name, scope)
-        push_title "Locatine has no good guess for #{name} in #{scope}."
-      end
-
-      def send_has_guess(name, scope)
-        push_title "Something is guessed as #{name} in #{scope}."
-      end
-
-      def send_selecting(name, scope)
-        name = 'some element' if name.to_s.empty?
-        push_title "You are selecting #{name} in #{scope}"
-        send_to_app('locatinehint', 'Toggle single//collection mode button if '\
-          'you need. If you want to do some actions on the page toggle'\
-          ' Locatine waiting button. You also can select element on devtools '\
-          '-> Elements. Do not forget to confirm your selection.')
-      end
-
-      def send_has_response
-        push_title 'Right now you are defining nothing. So no button will work'
-        send_to_app('locatinehint', 'Your previous selection is confirmed. '\
-          'Locatine is waiting for new find request')
-      end
-
-      def send_same_entry(length, name, scope, found)
-        push_title "#{length} #{verb(length)} selected as #{name} in #{scope}."\
-        " But it was already defined #{found.length} times."
-        example = found.sample
-        same = found.select { |i| (i[:name] == name) && (i[:scope] == scope) }
-        if same.empty?
-          send_same_entry_example(example)
-        else
-          send_fully_similar
-        end
-      end
-
-      def send_same_entry_example(example)
-        send_to_app('locatinehint', "For example like #{example[:name]} in"\
-        " #{example[:scope]}")
-      end
-
-      def send_fully_similar
-        send_to_app('locatinehint', 'And it was defined with the same name'\
-        ' and in the same scope. So saving your selection will cause'\
-        ' deleting of all previously stored data about the element')
-      end
-
-      def warn_dropping(tag, index)
-        send_warn('For some reason locatine cannot proceed with'\
-          " //#{tag}[#{index}] element. You've selected. Maybe element was"\
-          ' changed somewhere in the middle of locatine work. If this error is'\
-          'repeating you can try to select element via devtools or you can'\
-          ' provide a locator')
-      end
-
-      def warn_type
-        send_warn("Check also. Maybe #{tag} element cannot be found as @type?")
-      end
-
-      def warn_acceptable_type(method)
-        send_warn "#{method} works for :look_in. But it is better to use a"\
-         ' method of Watir::Browser that returns a collection (like :divs,'\
-         ' :links, etc.)'
-      end
-
-      def warn_element_lost(name, scope)
-        send_warn "#{name} in #{scope} is//are lost. Locatine is trying "\
-                  'to find it anyway.'
-      end
-
-      def warn_cannot_highlight(data)
-        send_warn "Something was found as #{data} but we cannot highlight it"
-      end
-
-      def warn_broken_locator(locator)
-        send_warn "Can find nothing using #{locator}"
-      end
-
-      def warn_unstable
-        send_warn 'It seems that page is unstable. It may lead to problems '\
-                  'with resolving elements'
-      end
-
-      def warn_highly_unstable
-        send_warn 'It seems that page is HIGHLY unstable. No guaranties now.'
-      end
-
-      def warn_much_highlight(size)
-        send_warn "Only the first 50 elements of #{size} were highlighted."
-      end
-
-      def warn_lost_found(name, scope)
-        send_warn "Something was found as #{name} in #{scope}."
-      end
-
-      def warn_not_found(name, scope)
-        send_warn "Locatine cannot find element #{name} in #{scope}"
-      end
-
-      def warn_totally_same(how_deep)
-        send_warn('There are more than one elements with totally similar'\
-          " attributes. Custom depth for element is set to #{how_deep}.")
-      end
-
-      def warn_no_negatives
-        send_warn 'The only way to find the selected element is to use'\
-        " negative expression like //*[not(@id='something')]. Locatine does"\
-        ' not support it. So you must to provide for element a custom locator.'\
-        ' Or find it as a part of collection and than return it by index'
-      end
-
-      def raise_not_found(name, scope)
-        raise "Locatine cannot find element #{name} in #{scope}"
-      end
-
-      def raise_not_similar(name, scope)
-        raise "Locatine cannot find element similar to #{name} in #{scope}"
-      end
-
-      def raise_no_name
-        raise ArgumentError, ':name is not provided.'
-      end
-
-      def raise_no_var(thevar)
-        raise ArgumentError, ":#{thevar} must be "\
-          'provided in vars since element was defined with it'
-      end
-    end
-  end
-end
-# rubocop:enable Metrics/ModuleLength

data/lib/locatine/large_scripts/css.js

@@ -1,21 +0,0 @@
-function walk(elm, result) {
-    let node;
-
-    const tagName = elm.tagName;
-    const array = Array.prototype.slice.call( document.getElementsByTagName(tagName) );
-    const index = array.indexOf(elm);
-
-    const item = [tagName, index, getComputedStyle(elm).cssText]
-    result.push(item)
-
-    // Handle child elements
-    for (node = elm.firstChild; node; node = node.nextSibling) {
-        if (node.nodeType === 1) { // 1 == Element
-            result = walk(node, result);
-        }
-    }
-    return result
-}
-let array = walk(document.body,[]);
-array.shift();
-return array;

data/lib/locatine/large_scripts/dimensions.js

@@ -1,17 +0,0 @@
-function walk(xmi, xma, ymi, yma){
-  let x;
-  let y;
-  let array =[];
-  let one;
-  for (x = xmi; x <= xma; x++) {
-    for (y = ymi; y <= yma; y++) {
-      one = document.elementFromPoint(x, y);
-      if ((one != document.documentElement) && (one != document.body)){
-        array.push(document.elementFromPoint(x, y));
-      }
-    }
-  }
-  return [...new Set(array)];
-}
-
-return walk(parseInt(arguments[0]), parseInt(arguments[1]), parseInt(arguments[2]), parseInt(arguments[3]))

data/lib/locatine/large_scripts/element.js

@@ -1,31 +0,0 @@
-
-function one_element(target){
-  console.log("TARGET ==", target);
-
-  let element = {};
-  let attribute = {};
-
-  element = {attrs: [], text: "", tag: ""};
-  if (target.childNodes){
-    for (let i = 0; i < target.childNodes.length; ++i){
-      if (target.childNodes[i].nodeType === 3){
-        element.text += target.childNodes[i].textContent;
-      }
-    }
-  } else {
-    element.text = target.textContent
-  }
-  element.tag = target.tagName.toLowerCase();
-  let atts = target.attributes;
-  if (atts) {
-    for (var k = 0, n = atts.length; k < n; k++){
-      att = atts[k];
-      attribute = {};
-      attribute[att.nodeName] = att.nodeValue;
-      element.attrs.push(attribute);
-    }
-  }
-  return element;
-}
-let x = one_element(arguments[0]);
-return x;

data/lib/locatine/large_scripts/page.js

@@ -1,60 +0,0 @@
-
-function walk(elm) {
-    let node;
-
-    const tagName = elm.tagName.toLowerCase();
-    const array = Array.prototype.slice.call( document.getElementsByTagName(tagName) );
-    const index = array.indexOf(elm);
-    const relative = elm.getBoundingClientRect();
-
-    // init item
-    const item = {tag: tagName,
-                  index: index,
-                  style: getComputedStyle(elm).cssText,
-                  text: "",
-                  attrs: {},
-                  coordinates: {top:0, bottom:0, left:0, right:0},
-                  children: []};
-
-    // text for item
-    if (elm.childNodes) {
-      for (let z = 0; z < elm.childNodes.length; ++z){
-        if (elm.childNodes[z].nodeType === 3){
-          item.text += elm.childNodes[z].textContent;
-        }
-      }
-    } else {
-      item.text = elm.textContent
-    }
-
-    // attributes for item
-    atts = elm.attributes;
-    if (atts) {
-      for (var att, k = 0, n = atts.length; k < n; k++){
-        att = atts[k];
-        item.attrs[att.nodeName] = att.nodeValue;
-      }
-    }
-
-    item.coordinates.top = relative["top"] + window.scrollY;
-    item.coordinates.bottom = relative["bottom"] + window.scrollY;
-    item.coordinates.left = relative["left"] + window.scrollX;
-    item.coordinates.right = relative["right"] + window.scrollX;
-
-    // Handle child elements (not magic ones)
-    for (node = elm.firstChild; node; node = node.nextSibling) {
-        if (node.nodeType === 1) { // 1 == Element
-          if (node.attributes['id']) {
-            if (node.attributes['id'].value !== 'locatine_magic_div') {
-              item.children.push(walk(node))
-            }
-          } else {
-            item.children.push(walk(node))
-          }
-        }
-    }
-
-    return item;
-}
-let result = walk(document.body);
-return [result];

data/lib/locatine/scope.rb

@@ -1,88 +0,0 @@
-module Locatine
-  ##
-  # Scope is the class representing group of elements
-  #
-  # Locatine has scopes
-  class Scope
-    def initialize(scope, search)
-      @search = search
-      @scope = scope
-    end
-
-    ##
-    # Way to define locatine a bunch elements at once. Elements will be taken
-    # from user selection one by one and saved in scope.
-    #
-    # Params:
-    #
-    # +vars+ hash of vars used for dynamic attributes. Same as in :find
-    def define(vars = {})
-      find_all(vars, false, true) if data.to_h != {}
-      new_define(vars)
-    end
-
-    ##
-    # Getting all the elements of the scope at once
-    #
-    # Params:
-    #
-    # +vars+ hash of vars used for dynamic attributes. Same as in :find
-    def all(vars = {})
-      find_all(vars)
-    end
-
-    ##
-    # Checking all the elements of the scope at once.
-    # Will fail if something was lost
-    #
-    # Params:
-    #
-    # +vars+ hash of vars used for dynamic attributes. Same as in :find
-    def check(vars = {})
-      success = []
-      result = find_all(vars, true)
-      result.each_pair do |name, hash|
-        success.push name if hash[:elements].empty?
-      end
-      raise "Check of #{@scope} failed! Lost: #{success}" unless success.empty?
-
-      result
-    end
-
-    private
-
-    def data
-      @search.data[@scope]
-    end
-
-    def find_one(name, hash, vars, strict)
-      locator = { xpath: @search.send(:generate_xpath, hash, vars) } if strict
-      elements = @search.collect(scope: @scope, name: name,
-                                 locator: locator,
-                                 exact: strict,
-                                 no_fail: strict)
-      locator = { xpath: @search.send(:generate_xpath, hash, vars) }
-      { elements: elements, locator: locator }
-    end
-
-    def find_all(vars = {}, strict = false, define = false)
-      learn = @search.learn
-      @search.learn = define
-      result = {}
-      data.each_pair do |name, hash|
-        result[name] = find_one(name, hash, vars, strict)
-      end
-      @search.learn = learn
-      result
-    end
-
-    def new_define(vars)
-      item = @search.send(:ask, @scope, '', nil, vars)
-      return find_all(vars) if item[:element].nil?
-
-      @search.send(:set_env_for_search, nil, nil, nil, nil, nil, nil)
-      @search.send(:store, item[:attributes], @scope, item[:name])
-      new_define(vars)
-    end
-  end
-end

data/lib/locatine/search.rb

@@ -1,67 +0,0 @@
-require 'watir'
-require 'json'
-require 'fileutils'
-require 'webdrivers'
-
-# Internal requires
-require 'locatine/for_search/merge'
-require 'locatine/for_search/public'
-require 'locatine/for_search/saying'
-require 'locatine/for_search/helpers'
-require 'locatine/for_search/defaults'
-require 'locatine/for_search/file_work'
-require 'locatine/for_search/page_work'
-require 'locatine/for_search/listening'
-require 'locatine/for_search/highlight'
-require 'locatine/for_search/data_logic'
-require 'locatine/for_search/find_logic'
-require 'locatine/for_search/name_helper'
-require 'locatine/for_search/dialog_logic'
-require 'locatine/for_search/find_by_magic'
-require 'locatine/for_search/find_by_guess'
-require 'locatine/for_search/data_generate'
-require 'locatine/for_search/xpath_generator'
-require 'locatine/for_search/find_by_locator'
-require 'locatine/for_search/element_selection'
-
-module Locatine
-  ##
-  # Search is the main class of the Locatine
-  #
-  # Locatine can search.
-  class Search
-    include Locatine::ForSearch::Merge
-    include Locatine::ForSearch::Public
-    include Locatine::ForSearch::Saying
-    include Locatine::ForSearch::Helpers
-    include Locatine::ForSearch::Defaults
-    include Locatine::ForSearch::FileWork
-    include Locatine::ForSearch::PageWork
-    include Locatine::ForSearch::DataLogic
-    include Locatine::ForSearch::Listening
-    include Locatine::ForSearch::FindLogic
-    include Locatine::ForSearch::Highlight
-    include Locatine::ForSearch::NameHelper
-    include Locatine::ForSearch::FindByMagic
-    include Locatine::ForSearch::DialogLogic
-    include Locatine::ForSearch::FindByGuess
-    include Locatine::ForSearch::DataGenerate
-    include Locatine::ForSearch::FindByLocator
-    include Locatine::ForSearch::XpathGenerator
-    include Locatine::ForSearch::ElementSelection
-
-    attr_accessor :data,
-                  :depth,
-                  :learn,
-                  :stability_limit,
-                  :scope,
-                  :tolerance,
-                  :visual_search,
-                  :no_fail,
-                  :trusted,
-                  :untrusted,
-                  :autolearn
-    attr_reader   :json,
-                  :browser
-  end
-end