locatine 0.02637 → 0.02651

data/lib/locatine/for_search/name_helper.rb

@@ -1,51 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # We have a module that helps name elements
-    module NameHelper
-      private
-
-      def good_name(main, vars)
-        good = %w[name title id role text]
-        tmp = main.select { |i| good.any? { |k| i['name'].include?(k) } }
-        words = (tmp.map { |i| process_string(i['value'], vars) }).uniq
-        words.sample
-      end
-
-      def so_so_name(main, vars)
-        all = main.select { |i| i['type'] == 'attribute' }
-        words = all.map { |i| process_string(i['value'], vars) }
-        words.sample
-      end
-
-      def some_name(main, vars)
-        result = good_name(main, vars)
-        result = so_so_name(main, vars) if result.nil?
-        result = "undescribed #{generate_word}" if result.nil?
-        result
-      end
-
-      def suggest_name(name, attrs, vars)
-        if name.to_s.empty?
-          tag = attrs['0'].select { |i| i['type'] == 'tag' }
-          tag = process_string(tag[0]['value'], vars)
-          name = "#{some_name(attrs['0'], vars)} #{tag}"
-        end
-        suggest = name
-        send_to_app('locatine_name', suggest)
-        send_to_app('locatine_name_mark', 'true')
-        suggest
-      end
-
-      def generate_word(pairs = 3)
-        ss = 'qwrtpsdfghjklzxcvbnm'.split('')
-        sa = 'eyuioa'.split('')
-        str = ''
-        pairs.times do
-          str += ss.sample + sa.sample
-        end
-        str
-      end
-    end
-  end
-end

data/lib/locatine/for_search/page_work.rb

@@ -1,126 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Methods about getting full information about opened page>
-    # And methods for stalkibg around the page in oreder to find something.
-    module PageWork
-      private
-
-      def matcher
-        { 'tag' => ->(data) { take_by_tag(*data) },
-          'text' => ->(data) { take_by_text(*data) },
-          'attribute' => ->(data) { take_by_attribute(*data) },
-          'css' => ->(data) { take_by_css(*data) } }
-      end
-
-      def take_dom
-        script = File.read("#{HOME}/large_scripts/page.js")
-        engine.execute_script(script)
-      end
-
-      def select_from_page(page, data, vars)
-        all = [] # No result is a valid result too
-        data.each_pair do |depth, array|
-          get_trusted(array).each do |hash|
-            all += catch(page, hash, vars, depth)
-          end
-        end
-        all
-      end
-
-      def catch(page, hash, vars, depth)
-        all = []
-        hash['value'] = process_string(hash['value'], vars)
-        page.each do |element|
-          all += take_match(element, depth, hash, vars)
-          all += catch(element['children'], hash, vars, depth)
-        end
-        all.uniq
-      end
-
-      def take_match(element, depth, hash, vars)
-        if hash['type'] == 'dimensions'
-          return take_by_dimensions(hash, element, depth, vars)
-        end
-
-        matcher.fetch(hash['type']).call([hash, element, depth])
-      end
-
-      def take_by_tag(hash, elt, depth)
-        return kids([elt], depth) if elt['tag'].downcase.include?(hash['value'])
-
-        []
-      end
-
-      def take_by_text(hash, elt, depth)
-        return kids([elt], depth) if elt['text'].include?(hash['value'])
-
-        []
-      end
-
-      def take_attribute_check(hash, elt)
-        if !hash['name'].to_s.empty? && !hash['value'].to_s.empty?
-          return elt['attrs'][hash['name']].to_s
-        end
-
-        elt['attrs'].to_s
-      end
-
-      def take_by_attribute(hash, elt, depth)
-        str = hash['value'].to_s.empty? ? hash['name'].to_s : hash['value'].to_s
-        ok = take_attribute_check(hash, elt).include?(str)
-        return kids([elt], depth) if ok
-
-        []
-      end
-
-      def dimensions_for_search(hash, vars)
-        values = hash['value'].split('*').map(&:to_i)
-        values[0] = vars[:x].to_i if vars[:x]
-        values[1] = vars[:y].to_i if vars[:y]
-        values
-      end
-
-      def dimensions_from_page(elt)
-        [elt['coordinates']['top'].to_i, elt['coordinates']['bottom'].to_i,
-         elt['coordinates']['left'].to_i, elt['coordinates']['right'].to_i]
-      end
-
-      def take_by_dimensions(hash, elt, depth, vars)
-        return [] if !visual? || hash['name'] != window_size
-
-        return kids([elt], depth) if in_recatngle?(hash, elt, vars)
-
-        []
-      end
-
-      def in_recatngle?(hash, elt, vars)
-        cleft, ctop, cwidth, cheight = dimensions_for_search(hash, vars)
-        top, bottom, left, right = dimensions_from_page(elt)
-        (cleft >= left) && (cleft + cwidth <= right) &&
-          (ctop >= top) && (ctop + cheight <= bottom)
-      end
-
-      def take_by_css(hash, elt, depth)
-        return [] unless visual?
-
-        string = "#{hash['name']}: #{hash['value']}"
-        return kids([elt], depth) if elt['style'].include?(string)
-
-        []
-      end
-
-      # If depth != 0 we should return all children subchildren.
-      def kids(array, depth)
-        answer = []
-        return array if depth.to_i.zero?
-
-        array.each do |one|
-          answer += one['children']
-          answer += kids(one['children'], depth)
-        end
-        answer
-      end
-    end
-  end
-end

data/lib/locatine/for_search/public.rb

@@ -1,179 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Public methods of the Search class
-    module Public
-      ##
-      # Creates a new instance of Search
-      #
-      # Params:
-      #
-      # +json+ is the name of file to store//read data. Default =>
-      # "./Locatine_files/default.json"
-      #
-      # +depth+ shows how many data will be stored for element.
-      #
-      # +browser+ is the instance of Watir::Browser. Unless provided it gonna
-      # be created with locatine-app onboard.
-      #
-      # +learn+ shows will locatine ask for assistance from user or will fail
-      # on error. learn is true when LEARN parameter is set in environment.
-      #
-      # +stability_limit+ shows max times attribute should be present and
-      # checked to consider it trusted.
-      #
-      # +scope+ will be used in search (if not provided) defaulkt is "Default"
-      #
-      # +tolerance+ Shows how similar must be an element found as alternative
-      # to the lost one. Default is 67 which means that if less than 33% of
-      # metrics of alternative elements are the same as of the lost element
-      # will not be returned
-      #
-      # +visual_search+ locatine will use position and style if true
-      #
-      # +no_fail+ if true locatine is not producing errors on element loss.
-      #
-      # +trusted+ array of names of attributes and element params to use
-      # in search always.
-      #
-      # +untrusted+ array of names of attributes and element params to use
-      # in search never.
-      #
-      # +autolearn+ determines will locatine study an element or not. true means
-      # locatine will always study it (slow). false means it won't study it
-      # unless it was lost and found. If not stated locatine will turn set it
-      # true if at least one element was lost.
-      def initialize(config = {})
-        init_config = default_init_config.merge(config)
-        import_browser init_config.delete :browser
-        import_file init_config.delete :json
-        import_config init_config
-      end
-
-      ##
-      # Looking for the element
-      #
-      # Params:
-      #
-      # +scope+ is a parameter that is used to get information about the
-      # element from @data. Default is "Default"
-      #
-      # +name+ is a parameter that is used to get information about the
-      # element from @data. Must not be nil.
-      #
-      # +exact+ if true locatine will be forced to use only basic search.
-      # Default is false
-      #
-      # +locator+ if not empty it is used for the first attempt to find the
-      # element. Default is {}
-      #
-      # +vars+ hash of variables that will be used for dynamic attributes.
-      # See readme for example
-      #
-      # +look_in+ only elements of that kind will be used. Use Watir::Browser
-      # methods returning collections (:text_fields, :links, :divs, etc.)
-      #
-      # +iframe+ if provided locatine will look for elements inside of it
-      #
-      # +return_locator+ is to return a valid locator of the result
-      #
-      # +collection+ when true an array will be returned. When false - a
-      # single element
-      #
-      # +tolerance+ It is possible to set a custom tolerance for every find. See
-      # examples in README
-      #
-      # +no_fail+ if true locatine is not producing errors on element loss.
-      #
-      # +trusted+ array of names of attributes and element params to use
-      # in search always.
-      #
-      # +untrusted+ array of names of attributes and element params to use
-      # in search never.
-      def find(simple_name = nil,
-               name: nil,
-               scope: nil,
-               exact: false,
-               locator: {},
-               vars: {},
-               look_in: nil,
-               iframe: nil,
-               return_locator: false,
-               collection: false,
-               tolerance: nil,
-               no_fail: nil,
-               trusted: nil,
-               untrusted: nil)
-        name = set_name(simple_name, name)
-        set_env_for_search(look_in, iframe, tolerance,
-                           no_fail, trusted, untrusted)
-        scope ||= @scope.nil? ? 'Default' : @scope
-        result, attributes = full_search(name, scope, vars, locator, exact)
-        return { xpath: generate_xpath(attributes, vars) } if result &&
-                                                              return_locator
-
-        to_subtype(result, collection)
-      end
-
-      ##
-      # Find alias with return_locator option enforced
-      def lctr(*args)
-        enforce({ return_locator: true }, *args)
-      end
-
-      ##
-      # Find alias with collection option enforced
-      def collect(*args)
-        enforce({ collection: true }, *args)
-      end
-
-      def json=(value)
-        import_file(value)
-      end
-
-      def browser=(value)
-        import_browser(value)
-      end
-
-      ##
-      # Returns an instance of the Scope class. Starts define if learn == true
-      #
-      # Params:
-      #
-      # +name+ is a parameter that stores name of the scope.
-      # Default is "Default"
-      #
-      # +vars+ is a hash which will be used to generate dynamic attributes.
-      # See readme for explanation.
-      def get_scope(name: 'Default', vars: {})
-        answer = Scope.new(name, self)
-        answer.define(vars) if @learn
-        answer
-      end
-
-      ##
-      # Find alias with zero tolerance option enforced
-      def check(*args)
-        enforce({ tolerance: 0 }, *args)
-      end
-
-      ##
-      # Collection alias with zero tolerance option enforced
-      def check_collection(*args)
-        enforce({ tolerance: 0, collection: true }, *args)
-      end
-
-      ##
-      # Collection alias with exact option on
-      def exact_collection(*args)
-        enforce({ exact: true, collection: true }, *args)
-      end
-
-      ##
-      # Find alias with exact option on
-      def exact(*args)
-        enforce({ exact: true }, *args)
-      end
-    end
-  end
-end

data/lib/locatine/for_search/saying.rb

@@ -1,199 +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, data, vars)
-        xpath = generate_xpath(data, vars)
-        send_warn "#{name} in #{scope} by xpath: ```#{xpath}``` 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, data, vars)
-        xpath = generate_xpath(data, vars)
-        send_warn "Something was found as #{name} in #{scope} by xpath:"\
-                  "```#{xpath}```"
-      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/for_search.rb

@@ -1,6 +0,0 @@
-module Locatine
-  ##
-  # One module to collect all parts of search
-  module ForSearch
-  end
-end

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,30 +0,0 @@
-
-function one_element(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];