locatine 0.01659 → 0.01811

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9be6c3fbe4cec2f39899f6874683c8653b12d756
-  data.tar.gz: 1c00862aa6032251a4f7a14f4a80a02e68d1be3e
+  metadata.gz: 291cbcc01b2a41fb79a851461f620ab5e3089d9d
+  data.tar.gz: e8f0125d9caafe79dabf0834cdbd4e50737e5e42
 SHA512:
-  metadata.gz: bc1289f818358b5a05789676cff4384f24ca3494cfafbbed95a64e04cf0a172b841490f267f93d7ba6db8e9ea72e4081c96d4b1bda184d6da02ce067d55b46fd
-  data.tar.gz: 12d72cb6cb38cac62e74c9c7ee38eaec0586cf93ab1997e70e8d0cf4608fe95aa05baf53a32c694f0d367aafd3925a1fc43a9635d3df24b87dd19bfc3c4d615f
+  metadata.gz: a1766f658d20d1fe90fb1a854ea493a23835961847578ec246820b36dc7aea3c55d304efdc99261de6badd13514c518e9dc6e4348ee1a57c151b8a82d7618221
+  data.tar.gz: 44ab3200dbe3290012e7ffc43f3a68d2729d44ef8b94bb5cf9e71fb13836df26b04e0b163e6e598bede348e5d6404fe2e4dbd9346a9e9b364d425e0e5e476246

data/lib/locatine/app/manifest.json

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

data/lib/locatine/for_search/data_generate.rb

@@ -0,0 +1,100 @@
+module Locatine
+  module ForSearch
+    ##
+    # Collecting data of element and making it dynamic
+    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
+        push_hash('tag', tag, 'tag')
+      end
+
+      def get_dynamic_text(element, vars)
+        attrs = []
+        real_text_of(element).split(/['" ]/).each 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?
+        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
+      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)
+        resolution = window_size
+        x, y, w, h = processed_dimensions(element, vars)
+        push_hash(resolution, "#{x}*#{y}*#{w}*#{h}", 'dimensions')
+      end
+
+      def hash_by_style(style, value, vars)
+        value.gsub!(vars[style.to_sym], "\#{#{style}}") if vars[style.to_sym]
+        push_hash(style, value, 'css')
+      end
+
+      def get_raw_css(element)
+        test_script = 'return typeof(arguments[0])'
+        ok = engine.execute_script(test_script, element) == 'object'
+        script = 'return getComputedStyle(arguments[0]).cssText'
+        return engine.execute_script(script, element) if ok
+      end
+
+      def get_dynamic_css(element, vars)
+        attrs = []
+        raw = get_raw_css(element)
+        if raw
+          styles = css_text_to_hash(get_raw_css(element))
+          (styles.to_a - @default_styles).to_h.each_pair do |style, value|
+            hash = hash_by_style(style, value, vars)
+            attrs.push(hash) if hash
+          end
+        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

@@ -0,0 +1,54 @@
+module Locatine
+  module ForSearch
+    ##
+    # Logic of collecting data of the element
+    module DataLogic
+      private
+
+      def get_dynamic_attributes(element, 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
+        end
+        attrs
+      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?
+        attrs
+      end
+
+      ##
+      # Generating data for group of elements
+      def generate_data(result, vars)
+        family = {}
+        result.each do |item|
+          family = get_commons(get_family_info(item, vars), family)
+        end
+        family
+      end
+
+      ##
+      # Getting element\\parents information
+      def get_family_info(element, vars)
+        i = 0
+        attributes = {}
+        while i != @depth
+          attributes[i.to_s] = get_element_info(element, vars, i)
+          i += 1
+          element = element.parent
+          i = @depth unless element.exists?
+        end
+        attributes
+      end
+    end
+  end
+end

data/lib/locatine/for_search/dialog_logic.rb

@@ -0,0 +1,118 @@
+module Locatine
+  module ForSearch
+    ##
+    # Logic of recieving element selected by user
+    module DialogLogic
+      private
+
+      def suggest_element(element, vars, name, scope)
+        attributes = {}
+        if !element.nil?
+          attributes = generate_data(element, vars)
+          send_found(name, scope, element.length)
+        elsif name.length >= 5
+          send_guessing(name, scope)
+          element, attributes = find_by_guess(scope, name, vars)
+        end
+        mass_highlight_turn(element) if element
+        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, attrss.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, name, scope)
+        tag, index = tag_index
+        send_to_app('locatineconfirmed', 'ok')
+        mass_highlight_turn(element, false) if element
+        element, attributes = working_on_selected(tag, index, vars, attributes)
+        if element
+          mass_highlight_turn(element)
+          send_selected(element.length, name, scope)
+        end
+        return element, attributes
+      end
+
+      def decline(element, name, scope)
+        mass_highlight_turn(element, false) if element
+        send_to_app('locatineconfirmed', 'ok')
+        send_clear(name, scope)
+        return nil, {}
+      end
+
+      def user_selection(els, attrs, vars, name, scope)
+        case get_from_app('locatineconfirmed')
+        when 'selected'
+          els, attrs = what_was_selected(els, attrs, vars, name, scope)
+        when 'declined'
+          els, attrs = decline(els, name, scope)
+        end
+        return els, attrs
+      end
+
+      def listening(els, attrs, vars, name, scope)
+        until get_from_app('locatineconfirmed') == 'true'
+          sleep(0.1)
+          els, attrs = user_selection(els, attrs, vars, name, scope)
+        end
+        return els, attrs if els
+
+        decline(els, name, scope)
+        listening(els, attrs, vars, name, scope)
+      end
+
+      ##
+      # request send and waiting for an answer
+      def ask(scope, name, element, vars)
+        start_listening(scope, name)
+        element, attributes = suggest_element(element, vars, name, scope)
+        @cold_time = 0
+        element, attributes = listening(element, attributes, vars, name, scope)
+        @cold_time = nil
+        response_action(element)
+        return element, attributes
+      end
+    end
+  end
+end

data/lib/locatine/for_search/file_work.rb

@@ -0,0 +1,65 @@
+module Locatine
+  module ForSearch
+    ##
+    # Methods about creating, reading and writing files
+    module FileWork
+      private
+
+      ##
+      # Reading data from provided file which is set on init of the class
+      # instance
+      #
+      # If there is no dir or\and file they will be created
+      def read_create
+        FileUtils.mkdir_p(@folder) unless File.directory?(@folder)
+        hash = Hash.new { |h, k| h[k] = Hash.new { |hi, ki| hi[ki] = {} } }
+        create_json_file unless File.exist?(@json)
+        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" : {}}'
+        f.close
+        send_info "#{@json} is created"
+      end
+
+      ##
+      # Setting stability
+      def set_stability(first, second)
+        second = first if second.to_h == {}
+        final = Hash.new { |hash, key| hash[key] = [] }
+        first.each_pair do |depth, array|
+          final[depth] = same_entries(array, second, depth, true).uniq
+        end
+        final
+      end
+
+      def stability_bump(to_add, hash)
+        if to_add.empty? # new ones
+          hash['stability'] = '1'
+        elsif to_add[0]['stability'].to_i < @stability_limit # old ones
+          to_add[0]['stability'] = (to_add[0]['stability'].to_i + 1).to_s
+        end
+        to_add.empty? ? [hash] : to_add
+      end
+
+      ##
+      # Saving json
+      def store(attributes, scope, name)
+        @data[scope][name] = set_stability(attributes, @data[scope][name])
+        to_write = { 'data' => @data }
+        File.open(@json, 'w') do |f|
+          f.write(JSON.pretty_generate(to_write))
+        end
+      end
+    end
+  end
+end

data/lib/locatine/for_search/find_by_css.rb

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

data/lib/locatine/for_search/find_by_guess.rb

@@ -0,0 +1,65 @@
+module Locatine
+  module ForSearch
+    ##
+    # If html code is good and name is related to the code, Locatine can guess
+    # it
+    #
+    # Methods for finding element by name only
+    module FindByGuess
+      private
+
+      def main_guess(name)
+        all = []
+        name.split(' ').each do |part|
+          all += guess_by_part(part)
+        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
+      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
+      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)
+        end
+        return guess, guess_data
+      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)
+        end
+        @cold_time = nil
+        return guess, guess_data.to_h
+      end
+    end
+  end
+end

data/lib/locatine/for_search/find_by_locator.rb

@@ -0,0 +1,87 @@
+module Locatine
+  module ForSearch
+    ##
+    # Methods related to the most simple search by ready locator.
+    module FindByLocator
+      private
+
+      def collection?(the_class)
+        case the_class.superclass.to_s
+        when 'Watir::Element'
+          false
+        when 'Watir::ElementCollection'
+          true
+        else
+          collection?(the_class.superclass)
+        end
+      end
+
+      ##
+      # Getting all the elements matching a locator
+      def find_by_locator(locator)
+        method = @type.nil? ? :elements : @type
+        results = engine.send(method, locator)
+        return correct_method_detected(results) if collection?(results.class)
+
+        acceptable_method_detected(results, method, locator)
+      end
+
+      def correct_method_detected(results)
+        all = []
+        begin
+          results[0].wait_until(timeout: @cold_time, &:present?)
+        rescue StandardError
+          nil
+        end
+        results.each { |item| all.push item if item.present? }
+        return all unless all.empty?
+        return nil if all.empty?
+      end
+
+      def acceptable_method_detected(results, method, locator)
+        warn_acceptable_type(method)
+        the_class = results.class
+        results = engine.elements(locator)
+                        .to_a
+                        .select { |item| item.to_subtype.class == the_class }
+        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)
+        find_by_locator(xpath: generate_xpath(data, vars))
+      end
+    end
+  end
+end

data/lib/locatine/for_search/find_by_magic.rb

@@ -0,0 +1,117 @@
+module Locatine
+  module ForSearch
+    ##
+    # Logic for finding lost element
+    module FindByMagic
+      private
+
+      ##
+      # Getting all the elements via black magic
+      def find_by_magic(name, scope, data, vars, exact)
+        warn_element_lost(name, scope)
+        @cold_time = 0
+        all = all_options(data, vars)
+        @cold_time = nil
+        raise_not_found(name, scope) if all.empty? && !exact
+        suggest_by_all(all, data, vars, name, scope, exact)
+      end
+
+      def similar_enough(data, attributes)
+        same = same_entries(data['0'], attributes, '0').length
+        all = data['0'].length
+        sameness = (same * 100) / all
+        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?
+        return suggest, attributes
+      end
+
+      def suggest_by_all(all, data, vars, name, scope, exact)
+        suggest, attributes = best_of_all(all, vars)
+        ok = similar_enough(data, attributes) unless suggest.nil?
+        spawn = !ok && !exact
+        raise_not_similar(name, scope) if spawn
+        if ok
+          warn_lost_found(name, scope)
+          return suggest, attributes
+        end
+        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