locatine 0.02535 → 0.02539

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47bfe24e1d440f14261360ee0a4b262a7b495624
-  data.tar.gz: ac4af7f07c3db70cbbb745cc68702701f97e442a
+  metadata.gz: 63c1d452b58e6881483141749a4cd5fc572a1a34
+  data.tar.gz: 5436ddbbd222888ab16ef121750e871be2d0b330
 SHA512:
-  metadata.gz: 62e7a41f9b48b5187bff739b44591632e4a0e98dd69ec72f1683eaeca4d48347d16c78aeb97082db53d7d2a32ba38d743d0abc0dc7f4a7fb330ba86fd5203b4f
-  data.tar.gz: be450e5dd42e70b9fc0050c5349932fe43901377d35ef2d6c719fabc22419e2dc80eabb4f3415f3133e58fcc6a1d7cd0c9d6cb2cb5148f9a4a7fd1d642d62173
+  metadata.gz: 875b40b1ebc3294dc60868c4f029a3eb2c37b984509002c30fadecad20d7e26f0df207eab8ed3466cc7021777d9a89baa6a0a6c4ba7dc655bea1109b573031cb
+  data.tar.gz: 9c36756f4c0388acf60d1009ed79ebed732b2401daa387930a3f61c8c97b745f2c1bc0bdeeced30e300543d88b09459c7bdf0f7320ef4630dbd47e83c9b58550

data/README.md

@@ -16,7 +16,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02535** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
+Version of Locatine is **0.02539** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
 
 ## Installation
 
@@ -98,7 +98,8 @@ Locatine::Search.new(json: "./Locatine_files/default.json",
                      visual_search: false,
                      no_fail: false,
                      trusted: [],
-                     untrusted: [])
+                     untrusted: [],
+                     autolearn: nil)
 ```
 
 ### json
@@ -241,7 +242,7 @@ vars = {tag: random_tag} # The tag
 vars = {attribute_name: random_attr} # If attribute is dynamic (use name of the attribute)
 # And two lines work with visual_search == true only
 vars = {css_option: random_value} # If your css is dynamic
-vars = {x: random_x} # x, y, width, height for element size and position
+vars = {x: random_x} # x, y for element position
 ```
 
 And if you do not like it you can do:

data/lib/locatine/app/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "Locatine app",
-  "version": "0.02535",
+  "version": "0.02539",
   "description": "Messaging from browser to main app",
   "devtools_page": "devtools.html",
   "permissions": ["activeTab", "storage", "contextMenus", "tabs"],

data/lib/locatine/for_search/data_generate.rb

@@ -5,53 +5,36 @@ module Locatine
     module DataGenerate
       private
 
-      def real_text_of(element)
-        element.text == element.inner_html ? element.text : ''
-      end
-
       def mesure(element)
         xy = element.location
         wh = element.size
         return xy.x, xy.y, wh.width, wh.height
       end
 
-      def get_dynamic_tag(element, vars)
-        tag = element.tag_name
-        tag = "\#{tag}" if vars[:tag] == tag
+      def get_dynamic_tag(tag, vars)
+        tag = "\#{tag}" if vars[:tag].to_s.casecmp(tag).zero?
         push_hash('tag', tag, 'tag')
       end
 
-      def get_dynamic_text(element, vars)
-        attrs = []
-        real_text_of(element).split(/['" ]/).each do |word|
+      def text_array(text)
+        text.to_s.tr("\n", ' ').split(/['" ]/)
+      end
+
+      def get_dynamic_text(text, vars)
+        attrs = text_array(text).map do |word|
           final = if !vars[:text].to_s.strip.empty?
                     word.gsub(vars[:text].to_s, "\#{text}")
                   else
                     word
                   end
-          attrs.push push_hash('text', final, 'text') unless final.empty?
+          push_hash('text', final, 'text') unless final.empty?
         end
-        attrs
-      end
-
-      def process_dimension(name, value, vars)
-        s_name = name.to_s
-        value = value.to_s.gsub(vars[name], "\#{#{s_name}}") if vars[name]
-        value
+        attrs.compact
       end
 
-      def processed_dimensions(element, vars)
-        x, y, width, height = mesure(element)
-        x = process_dimension(:x, x, vars)
-        y = process_dimension(:y, y, vars)
-        width = process_dimension(:width, width, vars)
-        height = process_dimension(:height, height, vars)
-        return x, y, width, height
-      end
-
-      def get_dimensions(element, vars)
+      def get_dimensions(element)
         resolution = window_size
-        x, y, w, h = processed_dimensions(element, vars)
+        x, y, w, h = mesure(element)
         push_hash(resolution, "#{x}*#{y}*#{w}*#{h}", 'dimensions')
       end
 
@@ -79,22 +62,6 @@ module Locatine
         end
         attrs
       end
-
-      ##
-      # Collecting attributes of the element
-      def get_attributes(element)
-        attributes = element.attributes
-        array = []
-        attributes.each_pair do |name, value|
-          next if name.to_s == 'locatineclass' # Should never happen
-
-          value.split(/['" ]/).reject(&:empty?).uniq.each do |part|
-            array.push('name' => name.to_s, 'type' => 'attribute',
-                       'value' => part)
-          end
-        end
-        array
-      end
     end
   end
 end

data/lib/locatine/for_search/data_logic.rb

@@ -5,27 +5,49 @@ module Locatine
     module DataLogic
       private
 
-      def get_dynamic_attributes(element, vars)
+      def get_dynamic_attributes(data, vars)
         attrs = []
-        get_attributes(element).each do |hash|
-          value = vars[hash['name'].to_sym]
-          hash['value'].gsub!(value, "\#{#{hash['name']}}") if value
-          attrs.push hash
+        data.each do |hash|
+          hash.each_pair do |key, full_value|
+            full_value.split(' ').each do |value|
+              next if key == 'locatineclass'
+
+              attrs.push some_attribute(value, key, vars)
+            end
+          end
         end
         attrs
       end
 
+      def some_attribute(value, key, vars)
+        replace = vars[key.to_sym]
+        push_hash(key,
+                  replace ? value.gsub(replace, "\#{#{key}}") : value,
+                  'attribute')
+      end
+
+      def get_element_raw(element)
+        element = element.to_subtype.wd.wd if element.tag_name == 'iframe'
+        script = File.read("#{HOME}/large_scripts/element.js")
+        engine.execute_script(script, element)
+      end
+
       ##
       # Generating array of hashes representing data of the element
       def get_element_info(element, vars, depth)
-        attrs = get_dynamic_attributes(element, vars)
-        attrs.push get_dynamic_tag(element, vars)
-        attrs += get_dynamic_text(element, vars)
-        attrs += get_dynamic_css(element, vars) if depth.to_i.zero? && visual?
-        attrs.push get_dimensions(element, vars) if depth.to_i.zero? && visual?
+        data = get_element_raw(element)
+        attrs = get_dynamic_attributes(data['attrs'], vars)
+        attrs.push get_dynamic_tag(data['tag'], vars)
+        attrs += get_dynamic_text(data['text'], vars)
+        attrs += get_dynamic_css(element, vars) if looking?(depth)
+        attrs.push get_dimensions(element) if looking?(depth)
         attrs
       end
 
+      def looking?(depth)
+        depth.to_i.zero? && visual?
+      end
+
       ##
       # Generating data for group of elements
       def generate_data(result, vars)

data/lib/locatine/for_search/defaults.rb

@@ -4,20 +4,14 @@ module Locatine
     # Default settings for search are living here
     module Defaults
       private
+
       def default_init_config
-        { json: './Locatine_files/default.json',
-          depth: 3,
-          browser: nil,
-          learn: ENV['LEARN'].nil? ? false : true,
-          stability_limit: 10,
-          scope: 'Default',
-          tolerance: 67,
-          visual_search: false,
-          no_fail: false,
-          trusted: [],
-          untrusted: [],
-          autolearn: nil
-        }
+        { json: './Locatine_files/default.json', depth: 3,
+          browser: nil, learn: ENV['LEARN'].nil? ? false : true,
+          stability_limit: 10, scope: 'Default',
+          tolerance: 67, visual_search: false,
+          no_fail: false, trusted: [],
+          untrusted: [], autolearn: nil }
       end
 
       def import_browser(browser)
@@ -38,7 +32,7 @@ module Locatine
 
       def import_config(config)
         config.each_pair do |key, value|
-          self.instance_variable_set("@#{key.to_s}", value)
+          instance_variable_set("@#{key}", value)
         end
       end
     end

data/lib/locatine/for_search/dialog_logic.rb

@@ -20,6 +20,7 @@ module Locatine
 
       def what_was_selected(element, attributes, vars)
         tag, index = tag_index
+        # TODO: ELEMENT COULD BE ALREADY LOST HERE. WE HAVE BUG AROUND THAT CODE
         send_to_app('locatineconfirmed', 'ok')
         mass_highlight_turn(element, false) if element
         element, attributes = working_on_selected(tag, index, vars, attributes)

data/lib/locatine/for_search/element_selection.rb

@@ -54,7 +54,7 @@ module Locatine
       def working_on_selected(tag, index, vars, attributes)
         send_working(tag, index)
         element, new_attributes = selected_element(tag, index, vars, attributes)
-        warn_dropping(tag, index) unless element
+        warn_dropping(tag, index) unless element[0].locate.located?
 
         warn_type(tag) if @type && !element
 

data/lib/locatine/for_search/find_by_guess.rb

@@ -8,57 +8,60 @@ module Locatine
     module FindByGuess
       private
 
-      def main_guess(name)
+      def all_similar(name, page, vars)
         all = []
-        name.split(' ').each do |part|
-          all += guess_by_part(part)
+        array = generate_hash_array(name)
+        array.each do |hash|
+          all += catch(page, hash, vars, 0)
         end
         all
       end
 
-      def guess_by_part(part)
-        all = []
-        tag_xpath = "//#{part}#{not_magic_div}"
-        text_xpath = "//*[contains(text(),'#{part}')]#{not_magic_div}"
-        attr_xpath = "//*[@*[contains(., '#{part}')]]#{not_magic_div}"
-        all += find_by_locator(xpath: tag_xpath).to_a
-        all += find_by_locator(xpath: text_xpath).to_a
-        all += find_by_locator(xpath: attr_xpath).to_a
-        all
+      def all_suggested(all, name, scope)
+        if all.empty?
+          send_no_guess(name, scope)
+          return nil
+        end
+        suggested = most_common_of(all).map do |element|
+          engine.elements(tag_name: element['tag'])[element['index'].to_i]
+        end
+        send_no_guess(name, scope) if suggested.length > 1
+        suggested
       end
 
-      def full_guess(all, vars, name)
-        max = all.count(all.max_by { |i| all.count(i) })
-        if max >= name.split(' ').length
-          guess = (all.select { |i| all.count(i) == max }).uniq
-          guess_data = generate_data(guess, vars)
-          found_by_data = find_by_data(guess_data, vars)
-        end
-        return found_by_data, guess_data.to_h
+      def main_guess(name, scope, page, vars)
+        all = all_similar(name, page, vars)
+        all_suggested(all, name, scope)
       end
 
-      def check_guess(all, vars, name, scope)
-        guess, guess_data = full_guess(all, vars, name)
-        if guess.nil? || (engine.elements.length / guess.length <= 4)
-          send_no_guess(name, scope)
-          guess = nil
-          guess_data = {}
-        else
-          send_has_guess(guess.length, name, scope)
+      def guessing(name, scope, page, vars)
+        suggested = main_guess(name, scope, page, vars)
+        suggest, attributes = final_of_all(suggested, vars) if suggested
+        return suggest, attributes
+      end
+
+      def find_by_guess(scope, name, vars, iteration = 0)
+        html = take_html
+        page = take_dom
+        suggest, attributes = guessing(name, scope, page, vars)
+        if html != take_html && iteration < 5
+          return find_by_guess(scope, name, vars, iteration + 1)
         end
-        return guess, guess_data
+
+        warn_highly_unstable if iteration == 5
+        send_has_guess(name, scope) if suggest
+        return suggest, attributes.to_h
       end
 
-      def find_by_guess(scope, name, vars)
-        @cold_time = 0
-        all = main_guess(name)
-        if all.empty?
-          send_no_guess(name, scope)
-        else
-          guess, guess_data = check_guess(all, vars, name, scope)
+      def generate_hash_array(name)
+        array = []
+        name.split(' ').each do |part|
+          array.push push_hash(part, '', 'attribute')
+          array.push push_hash('', part, 'attribute')
+          array.push push_hash('text', part, 'text')
+          array.push push_hash('tag', part, 'tag')
         end
-        @cold_time = nil
-        return guess, guess_data.to_h
+        array
       end
     end
   end

data/lib/locatine/for_search/find_by_locator.rb

@@ -49,36 +49,6 @@ module Locatine
         correct_method_detected(results)
       end
 
-      ##
-      # Getting elements by tag
-      def find_by_tag(hash, vars, depth = 0)
-        correction = '//*' if depth.to_i > 0
-        xpath = "//*[self::#{process_string(hash['value'], vars)}]"
-        find_by_locator(xpath: "#{xpath}#{correction}#{not_magic_div}")
-      end
-
-      ##
-      # Getting elements by text
-      def find_by_text(hash, vars, depth = 0)
-        correction = '//*' if depth.to_i > 0
-        value = process_string(hash['value'], vars)
-        xpath = "//*[contains(text(), '#{value}')]"
-        find_by_locator(xpath: "#{xpath}#{correction}#{not_magic_div}")
-      end
-
-      ##
-      # Getting elements by attribute
-      def find_by_attribute(hash, vars, depth = 0)
-        correction = '//*' if depth.to_i > 0
-        full_part = '//*[@*'
-        hash['name'].split('_').each do |part|
-          full_part += "[contains(name(), '#{part}')]"
-        end
-        value = process_string(hash['value'], vars)
-        xpath = full_part + "[contains(., '#{value}')]]"
-        find_by_locator(xpath: "#{xpath}#{correction}#{not_magic_div}")
-      end
-
       ##
       # Getting all the elements via stored information
       def find_by_data(data, vars)

data/lib/locatine/for_search/find_by_magic.rb

@@ -7,13 +7,34 @@ module Locatine
 
       ##
       # Getting all the elements via black magic
-      def find_by_magic(name, scope, data, vars)
+      def find_by_magic(name, scope, data, vars, iteration = 0)
+        html = take_html
+        page = take_dom
+        suggested = magic_elements(name, scope, data, vars, page)
+        warn_unstable if page_changed?(page, html)
+        if html != take_html && iteration < 5
+          return find_by_magic(name, scope, data, vars, iteration + 1)
+        end
+
+        warn_highly_unstable if iteration == 5
+        suggest_by_all(suggested, data, vars, name, scope)
+      end
+
+      def page_changed?(page, html)
+        html != take_html || page != take_dom
+      end
+
+      ##
+      # We are taking every element that look at least a bit similar to one we
+      # are looking for
+      def magic_elements(name, scope, data, vars, page)
         warn_element_lost(name, scope)
-        @cold_time = 0
-        all = all_options(data, vars)
-        @cold_time = nil
+        all = select_from_page(page, data, vars)
         raise_not_found(name, scope) if all.empty? && !@current_no_f
-        suggest_by_all(all, data, vars, name, scope)
+        suggested = most_common_of(all).map do |element|
+          engine.elements(tag_name: element['tag'])[element['index'].to_i]
+        end
+        suggested
       end
 
       def similar_enough(data, attributes)
@@ -23,16 +44,14 @@ module Locatine
         sameness >= 100 - @current_t
       end
 
-      def best_of_all(all, vars)
-        max = all.count(all.max_by { |i| all.count(i) })
-        suggest = (all.select { |i| all.count(i) == max }).uniq unless max.zero?
-        attributes = generate_data(suggest, vars) unless suggest.nil?
+      def final_of_all(suggest, vars)
+        attributes = generate_data(suggest, vars) unless suggest.empty?
         return suggest, attributes
       end
 
       def suggest_by_all(all, data, vars, name, scope)
-        suggest, attributes = best_of_all(all, vars)
-        ok = similar_enough(data, attributes) unless suggest.nil?
+        suggest, attributes = final_of_all(all, vars)
+        ok = similar_enough(data, attributes) unless suggest.empty?
         raise_not_similar(name, scope) if !ok && !@current_no_f
         if ok
           warn_lost_found(name, scope)
@@ -41,76 +60,6 @@ module Locatine
         warn_not_found(name, scope)
         return nil, nil
       end
-
-      def all_options(data, vars)
-        all = []
-        data.each_pair do |depth, array|
-          get_trusted(array).each do |hash|
-            all += one_option_array(hash, vars, depth).to_a
-          end
-        end
-        all += full_find_by_css(data, vars) if visual?
-        all += find_by_dimensions(data, vars) if visual?
-        all
-      end
-
-      def min_max_by_size(middle, size)
-        min = middle - (size.to_i * (200 - @current_t)) / 200
-        max = middle + (size.to_i * (200 - @current_t)) / 200
-        return min, max
-      end
-
-      def middle(sizes)
-        x = sizes[0].to_i + (sizes[2].to_i / 2)
-        y = sizes[1].to_i + (sizes[3].to_i / 2)
-        return x, y
-      end
-
-      def dimension_search_field(sizes)
-        x, y = middle(sizes)
-        x_min, x_max = min_max_by_size(x, sizes[2])
-        y_min, y_max = min_max_by_size(y, sizes[3])
-        return x_min, x_max, y_min, y_max
-      end
-
-      def retrieve_mesures(data)
-        size = window_size
-        dimensions = data['0'].map do |i|
-          i if (i['type'] == 'dimensions') && (i['name'] == size)
-        end
-        dimensions.compact
-      end
-
-      def sizez_from_dimensions(dimensions, vars)
-        result = []
-        dimensions.first['value'].split('*').each do |value|
-          result.push(process_string(value, vars))
-        end
-        result
-      end
-
-      def find_by_dimensions(data, vars)
-        dimensions = retrieve_mesures(data)
-        if !dimensions.empty?
-          sizes = sizez_from_dimensions(dimensions, vars)
-          xmi, xma, ymi, yma = dimension_search_field(sizes)
-          script = File.read("#{HOME}/large_scripts/dimensions.js")
-          engine.execute_script(script, xmi, xma, ymi, yma).compact
-        else
-          []
-        end
-      end
-
-      def one_option_array(hash, vars, depth)
-        case hash['type']
-        when 'tag'
-          find_by_tag(hash, vars, depth)
-        when 'text'
-          find_by_text(hash, vars, depth)
-        when 'attribute'
-          find_by_attribute(hash, vars, depth)
-        end
-      end
     end
   end
 end

data/lib/locatine/for_search/find_logic.rb

@@ -51,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,6 +16,11 @@ module Locatine
         (@iframe || @browser)
       end
 
+      def take_html
+        engine.locate
+        engine.html
+      end
+
       def time
         t = Time.now
         "#{t.year}.#{t.month}.#{t.day}  #{t.hour.to_s.rjust(2, '0')}:"\
@@ -90,6 +95,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/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/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

@@ -18,7 +18,7 @@ module Locatine
         max = (array.max_by { |i| i['stability'].to_i }) if array
         return max['stability'] if max
 
-        return 0
+        0
       end
 
       def generate_xpath(data, vars)
@@ -41,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,31 @@
+
+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

@@ -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];

data/lib/locatine/search.rb

@@ -10,11 +10,11 @@ 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/find_by_css'
 require 'locatine/for_search/name_helper'
 require 'locatine/for_search/dialog_logic'
 require 'locatine/for_search/find_by_magic'
@@ -36,11 +36,11 @@ module Locatine
     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::FindByCss
     include Locatine::ForSearch::NameHelper
     include Locatine::ForSearch::FindByMagic
     include Locatine::ForSearch::DialogLogic

data/lib/locatine/version.rb

@@ -1,6 +1,6 @@
 module Locatine
   # constants here...
-  VERSION = '0.02535'.freeze
+  VERSION = '0.02539'.freeze
   NAME = 'locatine'.freeze
   HOME = if File.readable?("#{Dir.pwd}/lib/#{Locatine::NAME}")
            "#{Dir.pwd}/lib/#{Locatine::NAME}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: locatine
 version: !ruby/object:Gem::Version
-  version: '0.02535'
+  version: '0.02539'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -142,7 +142,6 @@ files:
 - lib/locatine/for_search/dialog_logic.rb
 - lib/locatine/for_search/element_selection.rb
 - lib/locatine/for_search/file_work.rb
-- lib/locatine/for_search/find_by_css.rb
 - lib/locatine/for_search/find_by_guess.rb
 - lib/locatine/for_search/find_by_locator.rb
 - lib/locatine/for_search/find_by_magic.rb
@@ -152,11 +151,14 @@ files:
 - lib/locatine/for_search/listening.rb
 - lib/locatine/for_search/merge.rb
 - lib/locatine/for_search/name_helper.rb
+- lib/locatine/for_search/page_work.rb
 - lib/locatine/for_search/public.rb
 - lib/locatine/for_search/saying.rb
 - lib/locatine/for_search/xpath_generator.rb
 - lib/locatine/large_scripts/css.js
 - lib/locatine/large_scripts/dimensions.js
+- lib/locatine/large_scripts/element.js
+- lib/locatine/large_scripts/page.js
 - lib/locatine/scope.rb
 - lib/locatine/search.rb
 - lib/locatine/version.rb

data/lib/locatine/for_search/find_by_css.rb

@@ -1,47 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Looking for elements by css values
-    module FindByCss
-      private
-
-      def css_array_by_data(data, vars)
-        q_css = []
-        get_trusted(data['0']).each do |hash|
-          if hash['type'] == 'css'
-            value = process_string(hash['value'], vars) if vars[hash['name']]
-            q_css.push("#{hash['name']}: #{value || hash['value']}")
-          end
-        end
-        q_css
-      end
-
-      def return_caught_elements(caught)
-        all = []
-        caught.each do |i|
-          @help_hash[i[0]] ||= engine.elements(tag_name: i[0].downcase).to_a
-          elm = @help_hash[i[0]][i[1].to_i]
-          all.push(elm) if elm
-        end
-        all
-      end
-
-      def select_elements_from_raws_by_css(q_css, raws)
-        all = []
-        @help_hash = {}
-        q_css.each do |item|
-          caught = (raws.select { |i| i[2].include?(item) })
-          all += return_caught_elements(caught)
-        end
-        all
-      end
-
-      def full_find_by_css(data, vars)
-        q_css = css_array_by_data(data, vars)
-        script = File.read("#{HOME}/large_scripts/css.js")
-        raws = engine.execute_script(script)
-        select_elements_from_raws_by_css(q_css, raws)
-      end
-    end
-  end
-end