locatine 0.02058 → 0.02539

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

@@ -18,52 +18,9 @@ module Locatine
         return element, attributes
       end
 
-      def add_selected_attributes(new_attributes, attributes)
-        if get_from_app('locatinecollection') == 'true'
-          get_commons(new_attributes, attributes.to_h)
-        else
-          new_attributes
-        end
-      end
-
-      def selected_element_attributes(tag, index, vars)
-        generate_data([engine.elements(tag_name: tag)[index]], vars).to_h
-      end
-
-      def selected_element(tag, index, vars, attributes)
-        new_attributes = selected_element_attributes(tag, index, vars)
-        new_attributes = add_selected_attributes(new_attributes, attributes)
-        element = find_by_data(new_attributes, vars)
-        return element, new_attributes
-      end
-
-      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_type(tag) if @type && !element
-
-        return_selected(element, attributes, new_attributes, vars)
-      end
-
-      def return_old_selection(attrs, vars)
-        return find_by_data(attrs, vars).to_a, attrs.to_h if attrs.to_h != {}
-
-        return nil, {}
-      end
-
-      def return_selected(element, attributes, new_attributes, vars)
-        if !element && new_attributes.to_h != {}
-          send_lost
-          return return_old_selection(attributes, vars)
-
-        end
-        return element, new_attributes
-      end
-
       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

@@ -0,0 +1,80 @@
+module Locatine
+  module ForSearch
+    ##
+    # Cooking element data for dialog
+    module ElementSelection
+      private
+
+      def add_selected_attributes(new_attributes, attributes)
+        if get_from_app('locatinecollection') == 'true'
+          get_commons(new_attributes, attributes.to_h)
+        else
+          new_attributes
+        end
+      end
+
+      def simple_attrs(tag, index, vars)
+        element = engine.elements(tag_name: tag)[index]
+        attrs = generate_data([element], vars).to_h
+        return element, attrs
+      end
+
+      def negative_need(element, vars, old_depth)
+        @depth = old_depth
+        warn_no_negatives
+        generate_data([element], vars).to_h
+      end
+
+      def complex_attrs(element, vars, old_depth = @depth)
+        attrs = get_family_info(element, vars).to_h
+        return negative_need(element, vars, old_depth) if attrs.length < @depth
+
+        if find_by_data(attrs, vars).length > 1
+          @depth += 1
+          return complex_attrs(element, vars, old_depth)
+        end
+        @depth = old_depth
+        attrs
+      end
+
+      def selected_element_attributes(tag, index, vars)
+        element, attrs = simple_attrs(tag, index, vars)
+        length = find_by_data(attrs, vars).to_a.length
+        attrs = complex_attrs(element, vars) if length > 1
+        attrs
+      end
+
+      def selected_element(tag, index, vars, attributes)
+        new_attributes = selected_element_attributes(tag, index, vars)
+        new_attributes = add_selected_attributes(new_attributes, attributes)
+        element = find_by_data(new_attributes, vars)
+        return element, new_attributes
+      end
+
+      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[0].locate.located?
+
+        warn_type(tag) if @type && !element
+
+        return_selected(element, attributes, new_attributes, vars)
+      end
+
+      def return_old_selection(attrs, vars)
+        return find_by_data(attrs, vars).to_a, attrs.to_h if attrs.to_h != {}
+
+        return nil, {}
+      end
+
+      def return_selected(element, attributes, new_attributes, vars)
+        if !element && new_attributes.to_h != {}
+          send_lost
+          return return_old_selection(attributes, vars)
+
+        end
+        return element, new_attributes
+      end
+    end
+  end
+end

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" : {}}'
@@ -35,6 +28,7 @@ module Locatine
       # Setting stability
       def set_stability(first, second)
         second = first if second.to_h == {}
+        first = second.merge first
         final = Hash.new { |hash, key| hash[key] = [] }
         first.each_pair do |depth, array|
           final[depth] = same_entries(array, second, depth, true).uniq
@@ -42,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,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