locatine 0.02247 → 0.02542

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

@@ -0,0 +1,40 @@
+module Locatine
+  module ForSearch
+    ##
+    # 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 }
+      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 import_file(json)
+        @json = json
+        @folder = File.dirname(@json)
+        @name = File.basename(@json)
+        @data = read_create
+      end
+
+      def import_config(config)
+        config.each_pair do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    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)
@@ -52,18 +53,40 @@ module Locatine
         return els, attrs
       end
 
+      # get_from_app('locatineconfirmed') 'selected' or 'declined' or 'true'
+      # or 'abort' or 'new' or anything else (ok or false)
       def listening(els, attrs, vars, name, scope)
-        until %w[true abort].include?(get_from_app('locatineconfirmed'))
-          sleep(0.1)
-          els, attrs = user_selection(els, attrs, vars, name, scope)
+        sleep(0.1)
+        result = hearing
+        els, attrs = understanding(els, attrs, vars, name, scope, result)
+        if (!result[:done] || !els) && !result[:abort]
+          return listening(els, attrs, vars, name, scope)
         end
-        result = get_from_app('locatineconfirmed')
-        return els, attrs if els && result != 'abort'
 
-        els, attrs = decline(els, name, scope)
-        return els, attrs if result == 'abort'
+        return els, attrs
+      end
+
+      def understanding(els, attrs, vars, name, scope, result)
+        if result[:selected]
+          els, attrs = user_selection(els, attrs, vars, name, scope)
+        else
+          start_listening(scope, name) if result[:new]
+          els, attrs = decline(els, name, scope) if result[:declined]
+        end
+        return els, attrs
+      end
 
-        listening(els, attrs, vars, name, scope)
+      def hearing
+        answer = {}
+        result = get_from_app('locatineconfirmed')
+        answer[:selected] = ((result == 'selected') || (result == 'true'))
+        answer[:new] = result == 'new'
+        answer[:done] = result == 'true'
+        answer[:abort] = result == 'abort'
+        answer[:declined] = ((result == 'new') ||
+                             (result == 'declined') ||
+                             (result == 'abort'))
+        answer
       end
 
       ##

data/lib/locatine/for_search/element_selection.rb

@@ -19,7 +19,7 @@ module Locatine
         return element, attrs
       end
 
-      def negative_needed(element, vars, old_depth)
+      def negative_need(element, vars, old_depth)
         @depth = old_depth
         warn_no_negatives
         generate_data([element], vars).to_h
@@ -27,10 +27,10 @@ module Locatine
 
       def complex_attrs(element, vars, old_depth = @depth)
         attrs = get_family_info(element, vars).to_h
-        return negative_needed(element, vars, old_depth) if attrs.length < @depth
+        return negative_need(element, vars, old_depth) if attrs.length < @depth
 
         if find_by_data(attrs, vars).length > 1
-          @depth +=1
+          @depth += 1
           return complex_attrs(element, vars, old_depth)
         end
         @depth = old_depth
@@ -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/file_work.rb

@@ -17,13 +17,6 @@ module Locatine
         hash.merge(JSON.parse(File.read(@json))['data'])
       end
 
-      def import_file(json)
-        @json = json
-        @folder = File.dirname(@json)
-        @name = File.basename(@json)
-        @data = read_create
-      end
-
       def create_json_file
         f = File.new(@json, 'w')
         f.puts '{"data" : {}}'
@@ -43,11 +36,18 @@ module Locatine
         final
       end
 
-      def stability_bump(to_add, hash)
+      def stability_value(name, max, init = 0)
+        result = @trust_now.include?(name) ? max.to_s : (init.to_i + 1).to_s
+        result = '0' if @untrust_now.include?(name)
+        result
+      end
+
+      def stability_bump(to_add, hash, max)
         if to_add.empty? # new ones
-          hash['stability'] = '1'
+          hash['stability'] = stability_value(hash['name'], max)
         elsif to_add[0]['stability'].to_i < @stability_limit # old ones
-          to_add[0]['stability'] = (to_add[0]['stability'].to_i + 1).to_s
+          to_add[0]['stability'] = stability_value(to_add[0]['name'],
+                                                   max, to_add[0]['stability'])
         end
         to_add.empty? ? [hash] : to_add
       end

data/lib/locatine/for_search/find_by_guess.rb

@@ -8,57 +8,59 @@ 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
+        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