locatine 0.01084 → 0.01100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38885391980f7e8d2b0cef65643f998edf5074cf
-  data.tar.gz: f321d064c113b65f024d8d22bd52bfd0ab6a56d8
+  metadata.gz: 8ca422d8fbe87acacb5b19639d98c509fbdb04a2
+  data.tar.gz: b81058cdc3aa26f76a5521312de44f11f5b299bd
 SHA512:
-  metadata.gz: 110afe53c901b20d93cdc7c34c2846e82c5b361d96068e368a42ad907278bb124eed0fdc53bc993a77f87afae72b744a03bd41e7e7156679a62604a6a76a115b
-  data.tar.gz: 02105771e43ba72453ebbb238be198408037c11fd90e2169f0e79f44d96efc49a1c4bed2c08dcf8e5068e34c08c2725bb015343475074b9a48707e9a52937764
+  metadata.gz: f3435a0ae9f55f95e2419d47f37e066c9af65c4cc630b222229a5057aec35060a4a3d24504a5bb1eed21bee6c2c59611b692eb14dec12a945648da1f75bb8fd0
+  data.tar.gz: 96236870dffc079e8fa474b8fab27d5276c57ddbb1655ff0b8edf598a7eea1e45476e8cfb41b27e6feb16fc992c0f66bca6f80a84afdfe45df623ae75f9b9cc2

data/lib/locatine/app/background.js

@@ -3,7 +3,7 @@ chrome.browserAction.onClicked.addListener(
     console.log("WAS here");
     chrome.windows.create( {'url': 'popup.html',
                             'type': 'popup',
-                            'width': 800,
-                            'height': 600});
+                            'width': 640,
+                            'height': 480});
 
   });

data/lib/locatine/app/content.js

@@ -29,6 +29,10 @@ async function refreshData(){
       await set_value('magic_div', true);
       magicDiv.setAttribute("locatinestyle", "true");
     };
+    if (magicDiv.getAttribute("locatinestyle") === "set_false") {
+      await set_value('magic_div', false);
+      magicDiv.setAttribute("locatinestyle", "false");
+    };
     if (magicDiv.getAttribute("locatinetitle") != "ok") {
       await set_value('locatine_title', magicDiv.getAttribute("locatinetitle"));
       await set_value('locatine_hint', magicDiv.getAttribute("locatinehint"));
@@ -43,7 +47,6 @@ async function refreshData(){
       magicDiv.removeAttribute("tag");
       magicDiv.removeAttribute("index");
       await set_value("locatine_confirm", false);
-      await set_value('magic_div', false);
     }
     const confirmed = await get_value('locatine_confirm');
     magicDiv.setAttribute("locatineconfirmed", confirmed);
@@ -52,21 +55,27 @@ async function refreshData(){
   magic_cover.onclick = function(e) {locatine_magic_click(e)};
 };
 
-function getSelected(value){
+async function getSelected(value){
+  const magic_div = document.getElementById("locatine_magic_div");
   const tagName = value.tagName;
   const array = Array.prototype.slice.call( document.getElementsByTagName(tagName) );
   const index = array.indexOf(value);
-  document.getElementById("locatine_magic_div").setAttribute("tag", tagName);
-  document.getElementById("locatine_magic_div").setAttribute("index", index);
+  if (document.locatine_selected !=  value) {
+    document.locatine_selected = value;
+    await set_value("locatine_confirm", "selected");
+    magic_div.setAttribute("tag", tagName);
+    magic_div.setAttribute("index", index);
+  }
 };
 
-function locatine_magic_click(e) {
+async function locatine_magic_click(e) {
   document.getElementById("locatine_magic_div").setAttribute("locatinestyle", "blocked");
   const value = document.elementFromPoint(e.clientX, e.clientY);
   document.getElementById("locatine_magic_div").setAttribute("locatinestyle", "true");
   const tagName = value.tagName;
   const array = Array.prototype.slice.call( document.getElementsByTagName(tagName) );
   const index = array.indexOf(value);
+  await set_value("locatine_confirm", "selected");
   document.getElementById("locatine_magic_div").setAttribute("TAG", tagName);
   document.getElementById("locatine_magic_div").setAttribute("INDEX", index);
 };

data/lib/locatine/app/manifest.json

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

data/lib/locatine/data_generate.rb

@@ -0,0 +1,91 @@
+module Locatine
+  ##
+  # Generating locatine json info from element itself
+  module DataGenerate
+    private
+
+    def get_dynamic_attributes(element, vars)
+      attrs = []
+      get_attributes(element).each do |hash|
+        if vars[hash['name'].to_sym]
+          hash['value'].gsub!(vars[hash['name'].to_sym], "\#{#{hash['name']}}")
+        end
+        attrs.push hash
+      end
+      attrs
+    end
+
+    def get_dynamic_tag(element, vars)
+      tag = element.tag_name
+      tag = "\#{tag}" if vars[:tag] == tag
+      { 'name' => 'tag', 'value' => tag, 'type' => 'tag' }
+    end
+
+    def real_text_of(element)
+      element.text == element.inner_html ? element.text : ''
+    end
+
+    def get_dynamic_text(element, vars)
+      attrs = []
+      real_text_of(element).split(' ').each do |word|
+        final_word = if !vars[:text].to_s.strip.empty?
+                       word.gsub(vars[:text].to_s, "\#{text}")
+                     else
+                       word
+                     end
+        attrs.push('name' => 'text', 'value' => final_word, 'type' => 'text')
+      end
+      attrs
+    end
+
+    ##
+    # Generating array of hashes representing data of the element
+    def get_element_info(element, vars)
+      attrs = get_dynamic_attributes(element, vars)
+      attrs.push get_dynamic_tag(element, vars)
+      attrs += get_dynamic_text(element, vars)
+      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)
+      current_depth = 0
+      attributes = {}
+      while current_depth != @depth
+        attributes[current_depth.to_s] = get_element_info(element, vars)
+        current_depth += 1
+        element = element.parent
+        # Sometimes watir is not returning a valid parent that's why:
+        current_depth = @depth unless element.parent.exists?
+      end
+      attributes
+    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'
+
+        value.split(' ').uniq.each do |part|
+          array.push('name' => name.to_s, 'type' => 'attribute',
+                     'value' => part)
+        end
+      end
+      array
+    end
+  end
+end

data/lib/locatine/dialog_actions.rb

@@ -0,0 +1,71 @@
+module Locatine
+  ##
+  # Simple actions about communicating with chrome extension (and user)
+  module DialogActions
+    private
+
+    ##
+    # Setting attribute of locatine div (way to communicate)
+    def send_to_app(what, value, bro = engine)
+      fix_iframe
+      bro.wd.execute_script(
+        %[if (document.getElementById('locatine_magic_div')){
+          const magic_div = document.getElementById('locatine_magic_div');
+           return magic_div.setAttribute("#{what}", "#{value}")}]
+      )
+      fix_iframe
+    end
+
+    ##
+    # Getting attribute of locatine div (way to communicate)
+    def get_from_app(what)
+      fix_iframe
+      result = engine.wd.execute_script(
+        %[if (document.getElementById('locatine_magic_div')) {
+           const magic_div = document.getElementById('locatine_magic_div');
+           return magic_div.getAttribute("#{what}")}]
+      )
+      fix_iframe
+      result
+    end
+
+    def fix_iframe
+      @iframe = @browser.iframe(@iframe.selector) if @iframe
+    end
+
+    def push_title(text)
+      puts text
+      send_to_app('locatinetitle', text)
+    end
+
+    ##
+    # Sending request to locatine app
+    def start_listening(_scope, _name)
+      send_to_app('locatinestyle', 'blocked', @browser) if @iframe
+      send_to_app('locatinehint', 'Toggle single//collection mode button if '\
+        'you need. If you want to do some actions on the page toggle Locatine'\
+        ' waiting button. You also can select element on devtools -> Elements.'\
+        ' Do not forget to confirm your selection.')
+      send_to_app('locatinestyle', 'set_true')
+      sleep 0.5
+    end
+
+    def tag_index
+      tag = get_from_app('tag')
+      tag = tag.downcase unless tag.nil?
+      index = get_from_app('index').to_i
+      return tag, index
+    end
+
+    def response_action(element)
+      send_to_app('locatineconfirmed', 'ok')
+      send_to_app('locatinetitle', 'Right now you are defining nothing. '\
+                                   'So no button will work')
+      send_to_app('locatinehint', 'Place for a smart hint here')
+      mass_highlight_turn(element, false)
+      send_to_app('locatinestyle', 'set_false')
+      send_to_app('locatinestyle', 'ok', @browser) if @iframe
+      sleep 0.5
+    end
+  end
+end

data/lib/locatine/dialog_logic.rb

@@ -0,0 +1,94 @@
+module Locatine
+  ##
+  # 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)
+        push_title("#{element.length} elements found as #{name} in #{scope}.")
+      elsif name.length >= 5
+        push_title("Locatine is trying to guess what is #{name} in #{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)
+      push_title "You've selected //#{tag}[#{index}]. Wait while Locatine works"
+      element, new_attributes = selected_element(tag, index, vars, attributes)
+      warn 'Cannot proceed with selected. Dropping it.' unless element
+
+      warn "Maybe #{tag} can't be found as a #{@type}?" if @type && !element
+
+      return find_by_data(attributes, vars).to_a, attributes.to_h unless element
+
+      return element, new_attributes
+    end
+
+    def what_was_selected(element, attributes, vars, name, scope)
+      send_to_app('locatineconfirmed', 'ok')
+      tag, index = tag_index
+      mass_highlight_turn(element, false) if element
+      element, attributes = working_on_selected(tag, index, vars, attributes)
+      mass_highlight_turn(element) if element
+      push_title "#{element.length} elements were selected as #{name} in "\
+                  "#{scope}. If it is correct - confirm the selection."
+      return element, attributes
+    end
+
+    def decline(element, name, scope)
+      mass_highlight_turn(element, false) if element
+      send_to_app('locatineconfirmed', 'ok')
+      push_title "Nothing is selected as #{name} in #{scope}"
+      return nil, {}
+    end
+
+    def listening(els, attrs, vars, name, scope)
+      until get_from_app('locatineconfirmed') == 'true'
+        sleep(0.1)
+        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
+      end
+      return els, attrs
+    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

data/lib/locatine/file_work.rb

@@ -0,0 +1,54 @@
+module Locatine
+  ##
+  # 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 create_json_file
+      f = File.new(@json, 'w')
+      f.puts '{"data" : {}}'
+      f.close
+    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

data/lib/locatine/find_by_guess.rb

@@ -0,0 +1,62 @@
+module Locatine
+  ##
+  # 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)
+        push_title "Locatine has no good guess for #{name} in #{scope}."
+        guess = nil
+        guess_data = {}
+      else
+        push_title "#{guess.length} elements guessed as #{name} in #{scope}."
+      end
+      return guess, guess_data
+    end
+
+    def find_by_guess(scope, name, vars)
+      @cold_time = 0
+      all = main_guess(name)
+      if !all.empty?
+        guess, guess_data = check_guess(all, vars, name, scope)
+      else
+        push_title "Locatine has no guess for #{name} in #{scope}."
+      end
+      @cold_time = nil
+      return guess, guess_data.to_h
+    end
+  end
+end

data/lib/locatine/find_by_locator.rb

@@ -0,0 +1,98 @@
+module Locatine
+  ##
+  # Methods related to the most simple search by ready locator.
+  module FindByLocator
+    private
+
+    def collection?(the_class)
+      case the_class.superclass.to_s
+      when 'Object'
+        nil
+      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)
+      case collection?(results.class)
+      when nil
+        wrong_method_detected(method)
+      when true
+        return correct_method_detected(results)
+      when false
+        return acceptable_method_detected(results, method)
+      end
+    end
+
+    def wrong_method_detected(method)
+      @type = nil
+      raise ArgumentError, "#{method} is not good for :look_in property. Use"\
+      ' a method of Watir::Browser that returns a collection (like :divs,'\
+      ' :links, etc.)'
+    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 "#{method} works for :look_in. But it is better to use a method of"\
+      ' Watir::Browser that returns a collection (like :divs, :links, etc.)'
+      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 = '/*' * depth.to_i
+      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 = '/*' * depth.to_i
+      xpath = "//*[contains(text(), '#{process_string(hash['value'], vars)}')]"
+      find_by_locator(xpath: "#{xpath}#{correction}#{not_magic_div}")
+    end
+
+    ##
+    # Getting elements by attribute
+    def find_by_attribute(hash, vars, depth = 0)
+      correction = '/*' * depth.to_i
+      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

data/lib/locatine/find_by_magic.rb

@@ -0,0 +1,43 @@
+module Locatine
+  ##
+  # Logic for finding lost element
+  module FindByMagic
+    private
+
+    ##
+    # Getting all the elements via black magic
+    def find_by_magic(name, scope, data, vars)
+      warn "#{name} in #{scope} is lost. Looking for it."
+      @cold_time = 0
+      all = all_options(data, vars)
+      @cold_time = nil
+      raise "Unable to find element #{name} in #{scope}" if all.empty?
+
+      max = all.count(all.max_by { |i| all.count(i) })
+      suggestion = (all.select { |i| all.count(i) == max }).uniq
+      attributes = generate_data(suggestion, vars)
+      return suggestion, attributes
+    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)
+        end
+      end
+      all
+    end
+
+    def one_option_array(hash, vars, depth)
+      case hash['type']
+      when 'tag'
+        find_by_tag(hash, vars, depth).to_a
+      when 'text'
+        find_by_text(hash, vars, depth).to_a
+      when 'attribute'
+        find_by_attribute(hash, vars, depth).to_a
+      end
+    end
+  end
+end

data/lib/locatine/find_logic.rb

@@ -0,0 +1,61 @@
+module Locatine
+  ##
+  # Methods explaining find logic
+  module FindLogic
+    private
+
+    def set_name(simple_name, name)
+      name ||= simple_name
+      raise ArgumentError, ':name should be provided' unless name
+
+      name
+    end
+
+    def core_search(result, name, scope, vars, exact)
+      if @data[scope][name].to_h != {}
+        result = find_by_data(@data[scope][name], vars)
+        attributes = generate_data(result, vars) if result
+        if !result && !exact
+          result, attributes = find_by_magic(name, scope,
+                                             @data[scope][name], vars)
+        end
+      end
+      return result, attributes
+    end
+
+    def full_search(name, scope, vars, locator, exact)
+      result, attributes = locator_search(locator, vars)
+      unless result
+        result, attributes = core_search(result, name, scope,
+                                         vars, exact)
+      end
+      result, attributes = ask(scope, name, result, vars) if @learn
+      raise "Nothing was found for #{scope} #{name}" if !result && !exact
+
+      store(attributes, scope, name) if result
+      return result, attributes
+    end
+
+    def locator_search(locator, vars)
+      result = find_by_locator(locator) if locator != {}
+      attributes = generate_data(result, vars) if result
+      return result, attributes
+    end
+
+    ##
+    # Returning subtype of the only element of collection OR collection
+    #
+    # Params:
+    # +result+ must be Watir::HTMLElementCollection or Array
+    #
+    # +collection+ nil, true or false
+    def to_subtype(result, collection)
+      case collection
+      when true
+        result
+      when false
+        result.first.to_subtype
+      end
+    end
+  end
+end