locatine 0.02247 → 0.02542

data/lib/locatine/for_search/find_logic.rb

@@ -15,6 +15,8 @@ module Locatine
         result = find_by_data(@data[scope][name], vars)
         attributes = generate_data(result, vars) if result
         if !result && !exact
+          @autolearn = true if @autolearn.nil?
+          @save = true
           result, attributes = find_by_magic(name, scope,
                                              @data[scope][name], vars)
         end
@@ -29,9 +31,10 @@ module Locatine
       end
 
       def full_search(name, scope, vars, locator, exact)
+        @save = @autolearn
         result, attributes = search_steps(name, scope, vars, locator, exact)
         raise_not_found(name, scope) if !result && !@current_no_f
-        store(attributes, scope, name) if result
+        store(attributes, scope, name) if result && (@save || @learn)
         return result, attributes
       end
 
@@ -48,8 +51,9 @@ module Locatine
       end
 
       def locator_search(locator, vars)
-        result = find_by_locator(locator) if locator != {}
+        result = find_by_locator(locator) unless locator == {}
         attributes = generate_data(result, vars) if result
+        warn_broken_locator(locator) if locator.to_h != {} && !result
         return result, attributes
       end
 

data/lib/locatine/for_search/helpers.rb

@@ -16,21 +16,32 @@ module Locatine
         (@iframe || @browser)
       end
 
+      def take_html
+        engine.locate
+        engine.html.gsub(/<div.*id="locatine_magic_div".*>/, '')
+      end
+
       def time
         t = Time.now
-        "#{t.year}.#{t.month}.#{t.day}  #{t.hour.to_s.rjust(2, '0')}:"\
-        "#{t.min.to_s.rjust(2, '0')}:#{t.sec.to_s.rjust(2, '0')}"
+        t.strftime('%F %T')
       end
 
       def fix_iframe
         @iframe = @browser.iframe(@iframe.selector) if @iframe && @iframe.stale?
       end
 
-      def set_env_for_search(look_in, iframe, tolerance, no_fail)
+      def set_env_for_search(look_in,
+                             iframe,
+                             tolerance,
+                             no_fail,
+                             trusted,
+                             untrusted)
         @type = look_in
         @iframe = iframe
         @current_t = tolerance || @tolerance
         @current_no_f = no_fail || @no_fail
+        @trust_now = trusted || @trusted
+        @untrust_now = untrusted || @untrusted
       end
 
       def not_magic_div
@@ -57,15 +68,6 @@ module Locatine
         Watir::Browser.new(:chrome, switches: ["--load-extension=#{HOME}/app"])
       end
 
-      def import_browser(browser)
-        selenium = browser.class.superclass == Selenium::WebDriver::Driver
-        b = right_browser unless browser
-        b = browser if browser.class == Watir::Browser
-        b = Watir::Browser.new(browser) if selenium
-        @browser = b
-        @default_styles = default_styles.to_a
-      end
-
       def css_text_to_hash(text)
         almost_hash = []
         array = text[0..-2].split('; ')
@@ -92,6 +94,13 @@ module Locatine
         raise_no_var(thevar) unless value
         process_string(str.gsub('#{' + thevar + '}', value.to_s), vars)
       end
+
+      def most_common_of(all)
+        max = all.count(all.max_by { |i| all.count(i) })
+        return (all.select { |i| all.count(i) == max }).uniq unless max.zero?
+
+        []
+      end
     end
   end
 end

data/lib/locatine/for_search/listening.rb

@@ -23,6 +23,7 @@ module Locatine
       def start_listening(scope, name)
         send_to_app('locatinestyle', 'blocked', @browser) if @iframe
         send_to_app('locatinestyle', 'set_true')
+        send_to_app('locatineconfirmed', 'ok')
         send_selecting(name, scope)
         sleep 0.5
       end

data/lib/locatine/for_search/merge.rb

@@ -18,7 +18,8 @@ module Locatine
         array.each do |hash|
           item = second[depth]
           to_add = item.nil? ? [] : select_same(second[depth], hash)
-          to_add = stability_bump(to_add, hash) if stability_up
+          max = max_stability(second[depth]).to_i + 1
+          to_add = stability_bump(to_add, hash, max) if stability_up
           result += to_add
         end
         result

data/lib/locatine/for_search/page_work.rb

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

@@ -19,8 +19,8 @@ module Locatine
       # +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 to
-      # consider it trusted.
+      # +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"
       #
@@ -28,24 +28,26 @@ module Locatine
       # 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
-      def initialize(json: './Locatine_files/default.json',
-                     depth: 3,
-                     browser: nil,
-                     learn: ENV['LEARN'].nil? ? false : true,
-                     stability_limit: 1000,
-                     scope: 'Default',
-                     tolerance: 67,
-                     visual_search: false,
-                     no_fail: false)
-        import_browser browser
-        import_file(json)
-        @depth = depth
-        @learn = learn
-        @stability_limit = stability_limit
-        @scope = scope
-        @tolerance = tolerance
-        @visual_search = visual_search
-        @no_fail = no_fail
+      #
+      # +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
 
       ##
@@ -80,6 +82,14 @@ module Locatine
       #
       # +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,
@@ -91,9 +101,12 @@ module Locatine
                return_locator: false,
                collection: false,
                tolerance: nil,
-               no_fail: nil)
+               no_fail: nil,
+               trusted: nil,
+               untrusted: nil)
         name = set_name(simple_name, name)
-        set_env_for_search(look_in, iframe, tolerance, no_fail)
+        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 &&

data/lib/locatine/for_search/saying.rb

@@ -68,8 +68,8 @@ module Locatine
         push_title "Locatine has no good guess for #{name} in #{scope}."
       end
 
-      def send_has_guess(length, name, scope)
-        push_title "#{length} #{verb(length)} guessed as #{name} in #{scope}."
+      def send_has_guess(name, scope)
+        push_title "Something is guessed as #{name} in #{scope}."
       end
 
       def send_selecting(name, scope)
@@ -137,6 +137,19 @@ module Locatine
         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

data/lib/locatine/for_search/xpath_generator.rb

@@ -7,14 +7,20 @@ module Locatine
 
       def get_trusted(array)
         if !array.empty?
-          max_stability = (array
-                          .max_by { |i| i['stability'].to_i })['stability']
-          (array.select { |i| i['stability'].to_i == max_stability.to_i }).uniq
+          max = max_stability(array)
+          (array.select { |i| i['stability'].to_i == max.to_i }).uniq
         else
           []
         end
       end
 
+      def max_stability(array)
+        max = (array.max_by { |i| i['stability'].to_i }) if array
+        return max['stability'] if max
+
+        0
+      end
+
       def generate_xpath(data, vars)
         xpath = "[not(@id = 'locatine_magic_div')]"
         data.each_pair do |_depth, array|
@@ -35,16 +41,9 @@ module Locatine
         when 'text'
           "[contains(text(), '#{value}')]"
         when 'attribute'
-          generate_xpath_part_from_attribute(hash, value)
+          "[contains(@#{hash['name']}, '#{value}')]"
         end
       end
-
-      def generate_xpath_part_from_attribute(hash, value)
-        full = '[@*'
-        hash['name'].split('_')
-                    .each { |part| full += "[contains(name(), '#{part}')]" }
-        full + "[contains(., '#{value}')]]"
-      end
     end
   end
 end

data/lib/locatine/large_scripts/element.js

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

@@ -0,0 +1,60 @@
+
+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];