locatine 0.0092

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44a26e49cfff1bf0841fd588c9556fa0fbb1b394
+  data.tar.gz: 8f5b147ce47421e947be9ccdc2191da0fa746621
+SHA512:
+  metadata.gz: 3d151d506c89a6990640d34515519121a1b5b0da0c5d4797d3751b2b486ce7cb094ec90a7adab71c5580a2f2dbcd88c8f169c0c078f75c0c35bcc05589db9fbc
+  data.tar.gz: 3f6251ba3eed8756ca023d47a43b57953210463670430320cf46d06e762113796b2bc8f12d51f58d89f5d2c873e7de602787f5cfb4913d6d39f74d422755eea4

data/lib/locatine/app/background.js

@@ -0,0 +1,9 @@
+chrome.browserAction.onClicked.addListener(
+  function(tab) {
+    console.log("WAS here");
+    chrome.windows.create( {'url': 'popup.html',
+                            'type': 'popup',
+                            'width': 800,
+                            'height': 600});
+
+  });

data/lib/locatine/app/content.css

@@ -0,0 +1,40 @@
+@keyframes locatine_found {
+  0%   {border: 4px dashed #6495ED;}
+  20%  {border: 4px dashed #FF7F50;}
+  40%  {border: 4px dashed #8FBC8F;}
+  60% {border: 4px dashed #FFA500;}
+  80% {border: 4px dashed #DDA0DD;}
+  100% {border: 4px dashed #6495ED;}
+}
+
+div[locatinestyle=true] {
+  position:fixed;
+  padding:0;
+  margin:0;
+  top:0;
+  left:0;
+  opacity: 0;
+  background: black;
+  height: 100%;
+  width: 100%;
+  pointer-events: visible;
+  display: block;
+  z-index: 2147483646;
+}
+
+div[locatinestyle=false] {
+  height: 0%;
+  width: 0%;
+}
+
+div[locatinestyle=blocked] {
+  height: 0%;
+  width: 0%;
+}
+
+[locatineclass=foundbylocatine]
+  {animation: locatine_found 6s infinite;
+   -webkit-appearance: none;
+   -moz-appearance: none;
+   appearance: none;
+}

data/lib/locatine/app/content.js

@@ -0,0 +1,94 @@
+async function set_value(name, value){
+  let temp = {};
+  temp[name] = value;
+  await chrome.storage.sync.set(temp, function() {});
+};
+
+async function get_value(name) {
+  let x = await new Promise((resolve, reject) => chrome.storage.sync.get([name], resolve));
+  return x[name];
+};
+
+document.addEventListener("locatine_send", async function(e) {
+  await set_value(e.detail.varname, e.detail.varvalue);
+});
+
+async function refreshData(){
+  if (!document.getElementById("locatine_magic_div")){
+    const options = {
+      "locatineclass": "locatine_smthing",
+      "id":"locatine_magic_div",
+      "locatinestyle": await get_value('magic_div') || "false",
+      "locatinetitle": "ok",
+      "locatinehint": "ok"
+    };
+    locatine_create_element(document.body, "div", options, "");
+  } else {
+    const magicDiv = document.getElementById("locatine_magic_div");
+    if (magicDiv.getAttribute("locatinestyle") === "set_true") {
+      await set_value('magic_div', true);
+      magicDiv.setAttribute("locatinestyle", "true");
+    };
+    if (magicDiv.getAttribute("locatinetitle") != "ok") {
+      await set_value('locatine_title', magicDiv.getAttribute("locatinetitle"));
+      await set_value('locatine_hint', magicDiv.getAttribute("locatinehint"));
+      magicDiv.setAttribute("locatinetitle", "ok");
+    }
+    let status = await get_value('magic_div');
+    if (magicDiv.getAttribute("locatinestyle") != "set_true"){
+      magicDiv.setAttribute("locatinestyle", status);
+    }
+    magicDiv.setAttribute("locatinecollection", await get_value("locatine_collection"))
+    if (magicDiv.getAttribute("locatineconfirmed") === "ok") {
+      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);
+  };
+  const magic_cover = document.getElementById('locatine_magic_div');
+  magic_cover.onclick = function(e) {locatine_magic_click(e)};
+};
+
+function getSelected(value){
+  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);
+};
+
+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);
+  document.getElementById("locatine_magic_div").setAttribute("TAG", tagName);
+  document.getElementById("locatine_magic_div").setAttribute("INDEX", index);
+};
+
+function locatine_create_element(dom, tag, attrs, inner) {
+  const element = document.createElement(tag);
+  dom.appendChild(element);
+  for (var key in attrs) {
+    element.setAttribute(key, attrs[key])
+  };
+  element.innerHTML = inner;
+  return element;
+};
+
+//set_value('magic_div','off');
+
+setInterval(async function(){
+  if (document.getElementById("locatine_magic_div")) {
+    if (document.getElementById("locatine_magic_div").getAttribute("locatinestyle") != "blocked") {
+      await refreshData()
+    }
+  } else {
+    await refreshData()
+  }
+}, 100);

data/lib/locatine/app/devtools.html

@@ -0,0 +1 @@
+<script src="devtools.js"></script>

data/lib/locatine/app/devtools.js

@@ -0,0 +1,3 @@
+setInterval(function(){
+  chrome.devtools.inspectedWindow.eval("getSelected($0)", { useContentScriptContext: true });
+}, 100);

data/lib/locatine/app/manifest.json

@@ -0,0 +1,20 @@
+{
+  "name": "Locatine app",
+  "version": "0.0092",
+  "description": "Messaging from browser to main app",
+  "devtools_page": "devtools.html",
+  "permissions": ["activeTab", "storage", "contextMenus", "tabs"],
+  "background": {
+    "scripts": ["background.js"],
+    "persistent": true
+  },
+  "content_scripts": [{
+       "matches": ["<all_urls>"],
+       "all_frames": true,
+       "js":      ["content.js"],
+       "css":     ["content.css"]
+   }],
+   "browser_action": {
+      "default_title": "Locatine"},
+  "manifest_version": 2
+}

data/lib/locatine/app/popup.css

@@ -0,0 +1,41 @@
+.button {
+  border: none;
+  height: 30px;
+  width: 100%;
+  color: white;
+  padding: 5px 32px;
+  text-align: center;
+  text-decoration: none;
+  display: inline-block;
+  font-size: 16px;
+}
+
+.green {
+  background-color: #4CAF50
+}
+
+.red {
+  background-color: #AF4C50
+}
+
+.blue {
+  background-color: #4C50AF
+}
+
+.header {
+  padding: 10px 5px 10px 5px;
+  text-align: center;
+  color: black;
+  font-size: 25px;
+}
+
+.hint {
+  padding: 10px 5px 10px 5px;
+  text-align: center;
+  background-color: #EFFA93;
+  box-shadow: 5px 5px 5px;
+}
+
+.block {
+  padding: 30px 5px 30px 5px;
+}

data/lib/locatine/app/popup.html

@@ -0,0 +1,17 @@
+
+<html>
+  <head>
+    <link rel="stylesheet" href="popup.css">
+  </head>
+  <body>
+    <h2 class="header" id="mainTitle">Right now you are defining nothing. So no button will work</h2>
+    <h3 class="hint" id="hint">But you can click it anyway :)</h3>
+    <div class="block">
+      <input class="blue button" id="watchSwitch" type="button" value="Do not watch"/>
+      <input class="blue button" id="mode" type="button" value="Adding mode is enabled"/>
+      <input class="red button" id="clearMark" type="button" value="Clear selection"/>
+      <input class="green button" id="confirm" type="button" value="Confirm selection"/>
+    </div>
+    <script src="popup.js"></script>
+  </body>
+</html>

data/lib/locatine/app/popup.js

@@ -0,0 +1,50 @@
+async function get_value(name) {
+  let x = await new Promise((resolve, reject) => chrome.storage.sync.get([name], resolve));
+  return x[name];
+};
+
+async function set_value(name, value){
+  let temp = {};
+  temp[name] = value;
+  await chrome.storage.sync.set(temp, function() {});
+};
+
+async function correct_buttons() {
+  if (await get_value("magic_div") === true) {
+    document.getElementById("watchSwitch").setAttribute("value", "Locatine is waiting for click");
+  } else {
+    document.getElementById("watchSwitch").setAttribute("value", "Locatine is not waiting now");
+  };
+  if (await get_value("locatine_collection") === true) {
+    document.getElementById("mode").setAttribute("value", "You are in collection mode")
+  } else {
+    document.getElementById("mode").setAttribute("value", "You are in single selection mode")
+  };
+  document.getElementById("mainTitle").innerText = await get_value("locatine_title");
+  document.getElementById("hint").innerText = await get_value("locatine_hint");
+}
+
+async function watch() {
+  await set_value("magic_div", !(await get_value("magic_div")));
+}
+
+function clear() {
+  set_value("locatine_confirm", "declined");
+}
+
+function confirm() {
+  set_value("locatine_confirm", true);
+}
+
+async function mode() {
+  await set_value("locatine_collection", !(await get_value("locatine_collection")));
+}
+
+document.getElementById("watchSwitch").onclick = function() {watch()};
+document.getElementById("clearMark").onclick = function() {clear()};
+document.getElementById("confirm").onclick = function() {confirm()};
+document.getElementById("mode").onclick = function() {mode()};
+
+setInterval(function(){
+  correct_buttons();
+}, 100);

data/lib/locatine/search.rb

@@ -0,0 +1,601 @@
+require "watir"
+require "json"
+require "fileutils"
+require "chromedriver-helper"
+
+module Locatine
+
+  ##
+  # Search is the main class of the Locatine
+  #
+  # Locatine can search.
+  class Search
+
+    attr_accessor :data, :depth, :browser, :learn, :json, :stability_limit, :scope
+
+    ##
+    # Creates a new instance of Search
+    #
+    # Params:
+    # +json+ is the name of file to store//read data. Default => "./Locatine_files/default.json"
+    #
+    # +depth+ is the value that shows how many data will be stored for element.
+    #
+    # +browser+ is the instance of Watir::Browser. Unless provided it gonna be created with locatine-app onboard.
+    #
+    # +learn+ shows will locatine ask for assistance from user or will fail on error. learn is true when LEARN parameter is set in environment.
+    #
+    # +stability_limit+ shows max times attribute should be present to consider it trusted.
+    #
+    # +scope+ will be used in search (if not provided) defaulkt is "Default"
+    def initialize(json: "./Locatine_files/default.json",
+                   depth: 3,
+                   browser: nil,
+                   learn: ENV['LEARN'].nil? ? false : true,
+                   stability_limit: 10,
+                   scope: "Default")
+      if !browser
+        @browser = Watir::Browser.new(:chrome, switches: ["--load-extension=#{HOME}/app"])
+      else
+        @browser = browser
+      end
+      @json = json
+      @folder = File.dirname(@json)
+      @name = File.basename(@json)
+      @depth = depth
+      @data = read_create
+      @learn = learn
+      @stability_limit = stability_limit
+      @scope = scope
+    end
+
+    ##
+    # Looking for the element
+    #
+    # Params:
+    #
+    # +scope+ is a parameter that is used to get information about the element from @data. Default is "Default"
+    #
+    # +name+ is a parameter that is used to get information about the element from @data. Must not be nil.
+    #
+    # +exact+ if true locatine will be forced to use only basic search. Default is false
+    #
+    # +locator+ if not empty it is used for the first attempt to find the element. Default is {}
+    #
+    # +vars+ hash of variables that will be used for dynamic attributes. See readme for example
+    #
+    # +look_in+ only elements of that kind will be used. Use Watir::Browser methods returning collections (:text_fields, :links, :divs, etc.)
+    #
+    # +iframe+ if provided locatine will look for elements inside of it
+    def find(simple_name = nil,
+             name: nil,
+             scope: nil,
+             exact: false,
+             locator: {},
+             vars: {},
+             look_in: nil,
+             iframe: nil,
+             return_locator: false,
+             collection: false)
+      name ||= simple_name
+      raise ArgumentError, ":name should be provided" if !name
+      @type = look_in
+      @iframe = iframe
+      scope = @scope if scope.nil?
+      scope = "Default" if scope.nil?
+      result = find_by_locator(locator) if locator != {}
+      if !result
+        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
+      end
+      result, attributes = ask(scope, name, result, vars) if @learn
+      raise RuntimeError, "Nothing was found for #{scope} #{name}" if !result && !exact
+      if result
+        attributes = generate_data(result, vars) if !attributes
+        store(attributes, scope, name)
+        return return_locator ? {xpath: generate_xpath(attributes, vars)} : to_subtype(result, collection)
+      else
+        return nil
+      end
+    end
+
+    ##
+    # Find alias with return_locator option enforced
+    def lctr(*args)
+      if args.last.class == Hash
+        args.last[:return_locator] = true
+      else
+        args.push({return_locator: true})
+      end
+      find(args)
+    end
+
+    ##
+    # Find alias with collection option enforced
+    def collect(*args)
+      enforce(:collection, true, *args)
+    end
+
+    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
+      unless File.directory?(@folder)
+        FileUtils.mkdir_p(@folder)
+      end
+      if File.exists?(@json)
+        hash = Hash.new { |hash, key| hash[key] = Hash.new { |hash, key| hash[key] = {}}}
+        return hash.merge(JSON.parse(File.read(@json))["data"])
+      else
+        f = File.new(@json, "w")
+        f.puts '{"data" : {}}'
+        f.close
+        return Hash.new { |hash, key| hash[key] = Hash.new { |hash, key| hash[key] = {}}}
+      end
+    end
+
+    def enforce(what, value, *args)
+      if args.last.class == Hash
+        args.last[what] = value
+        find(*args)
+      else
+        temp = Hash.new
+        temp[what] = value
+        args.push(temp)
+        find(*args)
+      end
+    end
+
+    def engine
+      return (@iframe || @browser)
+    end
+
+    def collection?(the_class)
+      case the_class.superclass.to_s
+      when "Object"
+        return nil
+      when "Watir::Element"
+        return false
+      when "Watir::ElementCollection"
+        return true
+      else
+        return 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
+        @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.)"
+      when true
+        begin
+          results[0].wait_until(timeout: @cold_time) { |el| el.present? }
+          return results
+        rescue
+          return nil
+        end
+      when false
+        begin
+          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.)"
+          results.wait_until(timeout: @cold_time) { |el| el.present? }
+          the_class = results.class
+          results = engine.elements(locator).to_a.select{|item| item.to_subtype.class == the_class}
+          return results
+        rescue
+          return nil
+        end
+      end
+    end
+
+    def get_trusted(array)
+      if array.length > 0
+        max_stability = (array.max_by {|i| i["stability"].to_i})["stability"].to_i
+        return (array.select {|i| i["stability"].to_i == max_stability}).uniq
+      else
+        return []
+      end
+    end
+
+    def generate_xpath(data, vars)
+      xpath = ''
+      data.each_pair do |depth, array|
+        trusted = get_trusted(array)
+        trusted.each do |hash|
+          case hash["type"]
+          when "tag"
+            xpath = "[self::#{process_string(hash["value"], vars)}]" + xpath
+          when "text"
+            xpath = "[contains(text(), '#{process_string(hash["value"], vars)}')]" + xpath
+          when "attribute"
+            full_part = "[@*"
+            hash["name"].split("_").each do |part|
+              full_part = full_part + "[contains(name(), '#{part}')]"
+            end
+            xpath = full_part + "[contains(., '#{process_string(hash["value"], vars)}')]]" + xpath
+          end
+        end
+        xpath = '/*' + xpath
+      end
+      xpath = '/' + xpath
+      return xpath
+    end
+
+    ##
+    # Getting all the elements via stored information
+    def find_by_data(data, vars)
+      find_by_locator({xpath: generate_xpath(data, vars)})
+    end
+
+    ##
+    # Getting all the elements via black magic
+    def find_by_magic(name, scope, data, vars)
+      warn "Cannot locate #{name} in #{scope} with usual ways. Trying to use magic"
+      all = []
+      timeout = @cold_time
+      @cold_time = 0
+      data.each_pair do |depth, array|
+        trusted = get_trusted(array)
+        trusted.each do |hash|
+          case hash["type"]
+          when "tag"
+            all = all + find_by_tag(hash, vars, depth).to_a
+          when "text"
+            all = all + find_by_text(hash, vars, depth).to_a
+          when "attribute"
+            all = all + find_by_attribute(hash, vars, depth).to_a
+          end
+        end
+      end
+      @cold_time = timeout
+      raise RuntimeError, "Locatine is unable to find element #{name} in #{scope}" if all.length == 0
+      # Something esoteric here :)
+      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
+
+    ##
+    # 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 = full_part + "[contains(name(), '#{part}')]"
+      end
+      xpath = full_part + "[., '#{process_string(hash["value"], vars)}')]]"
+      find_by_locator(xpath: "#{full_part}[contains(., '#{process_string(hash["value"], vars)}')]]#{correction}")
+    end
+
+    ##
+    # Getting elements by tag
+    def find_by_tag(hash, vars, depth = 0)
+      correction = "/*" * depth.to_i
+      find_by_locator(xpath: "//*[self::#{process_string(hash["value"], vars)}')]#{correction}")
+    end
+
+    ##
+    # Getting elements by text
+    def find_by_text(hash, vars, depth = 0)
+      correction = "/*" * depth.to_i
+      find_by_locator(xpath: "//*[contains(text(), '#{process_string(hash["value"], vars)}')]#{correction}")
+    end
+
+    ##
+    # Setting attribute of locatine div (way to communicate)
+    def send_to_app(what, value, b = engine)
+      fix_iframe
+      b.wd.execute_script(%Q[if (document.getElementById('locatine_magic_div')) {
+                                  return document.getElementById('locatine_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(%Q[if (document.getElementById('locatine_magic_div')) {
+                                  return document.getElementById('locatine_magic_div').getAttribute("#{what}")}])
+      fix_iframe
+      return result
+    end
+
+    def fix_iframe
+      if @iframe
+        @iframe = @browser.iframe(@iframe.selector)
+      end
+    end
+
+    def set_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 find_by_guess(scope, name, vars)
+      all = []
+      timeout = @cold_time
+      @cold_time = 0
+      name.split(" ").each do |part|
+        all = all + find_by_locator({tag_name: part}).to_a
+        all = all + find_by_locator({xpath: "//*[contains(text(),'#{part}')]"}).to_a
+        all = all + find_by_locator({xpath: "//*[@*[contains(., '#{part}')]]"}).to_a
+      end
+      if all.length>0
+        max = all.count(all.max_by {|i| all.count(i)})
+        guess = (all.select {|i| all.count(i) == max}).uniq
+        guess_data = generate_data(guess, vars)
+        by_data = find_by_data(guess_data, vars)
+        if by_data.nil? || (engine.elements.length/find_by_data(guess_data, vars).length <=4)
+          set_title "Locatine has no good guess for #{name} in #{scope}. Try to change the name. Or just define it."
+          guess = nil
+          guess_data = {}
+        end
+      else
+        set_title "Locatine has no guess for #{name} in #{scope}. Try to change the name. Or just define it."
+      end
+      @cold_time = timeout
+      return guess, guess_data.to_h
+    end
+
+    ##
+    # request send and waiting for an answer
+    def ask(scope, name, result, vars)
+      start_listening(scope, name)
+      element, attributes, finished, old_tag, old_index, old_element = result, {}, false, nil, nil, nil
+      if !element.nil?
+        attributes = generate_data(element, vars)
+      else
+        set_title("Locatine is trying to guess what is #{name} in #{scope}.")
+        element, attributes = find_by_guess(scope, name, vars) if name.length >= 5
+      end
+      while !finished do
+        sleep 0.1
+        tag = get_from_app("tag")
+        tag = tag.downcase if !tag.nil?
+        index = get_from_app("index").to_i
+        if (!tag.to_s.strip.empty?) && ((tag != old_tag) or (old_index != index))
+          element = [engine.elements({tag_name: tag})[index]]
+          new_attributes = generate_data(element, vars)
+          if get_from_app("locatinecollection") == "true"
+            attributes = get_commons(new_attributes, attributes)
+            element = find_by_data(attributes, vars)
+          else
+            attributes = new_attributes
+          end
+        end
+        if old_element != element
+          mass_highlight_turn(old_element, false) if old_element
+          mass_highlight_turn(element) if element
+          if element.nil?
+            set_title "Nothing is selected as #{name} in #{scope}"
+          else
+            set_title "#{element.length} elements were selected as #{name} in #{scope}. If it is correct - confirm the selection."
+          end
+        end
+        old_element, old_tag, old_index = element, tag, index
+        case get_from_app("locatineconfirmed")
+        when "true"
+          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")
+          finished = true
+        when "declined"
+          send_to_app("locatineconfirmed", "ok")
+          element, old_tag, old_index, tag, index, attributes = nil, nil, nil, nil, nil, {}
+        end
+      end
+      mass_highlight_turn(element, false)
+      send_to_app("locatinestyle", "ok", @browser) if @iframe
+      sleep 0.5
+      return element, attributes
+    end
+
+    ##
+    # We can highlight an element
+    def highlight(element)
+      if !element.stale? && element.exists?
+        begin
+          engine.execute_script("arguments[0].setAttribute"\
+                            "('locatineclass','foundbylocatine')", element)
+        rescue
+          warn " something was found as #{element.selector} but we cannot highlight it"
+        end
+      end
+    end
+
+    ##
+    # We can unhighlight an element
+    def unhighlight(element)
+      if !element.stale? && element.exists?
+        begin
+          engine.execute_script("arguments[0].removeAttribute('locatineclass')",
+                              element)
+        rescue
+          # watir is not allowing to play with attributes of some strange elements
+        end
+      end
+    end
+
+    ##
+    # We can highlight\unhighlight tons of elements at once
+    def mass_highlight_turn(mass, turn_on = true)
+      mass.each do |element|
+        if turn_on
+          highlight element
+        else
+          unhighlight element
+        end
+      end
+    end
+
+    ##
+    # Generating array of hashes representing data of the element
+    def get_element_info(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
+      txt = (element.text == element.inner_html) ? element.text : ''
+      tag = element.tag_name
+      if vars[:tag] == tag
+        tag = "\#{tag}"
+      end
+      attrs.push({"name" => "tag", "value" => tag, "type" => "tag"})
+      txt.split(" ").each do |word|
+        if !vars[:text].to_s.strip.empty?
+          final_word = word.gsub(vars[:text].to_s, "\#{text}")
+        else
+          final_word = word
+        end
+        attrs.push({"name" => "text", "value" => final_word, "type" => "text"})
+      end
+      return attrs
+    end
+
+    ##
+    # Merging data of two elements (new data is to find both)
+    def get_commons(first, second)
+      second = first if second == {}
+      final = Hash.new { |hash, key| hash[key] = [] }
+      first.each_pair do |depth, array|
+        array.each do |hash|
+          to_add = second[depth].select {|item| (item["name"] == hash["name"]) and (item["value"] == hash["value"]) and item["type"] == hash["type"]}
+          final[depth] = final[depth] + to_add
+        end
+      end
+      final
+    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|
+        array.each do |hash|
+          to_add = second[depth].select {|item| (item["name"] == hash["name"]) and (item["value"] == hash["value"]) and item["type"] == hash["type"]}
+          if to_add.length > 0 # old ones
+            to_add[0]["stability"] = (to_add[0]["stability"].to_i + 1).to_s if (to_add[0]["stability"].to_i < @stability_limit)
+            final[depth] = final[depth] + to_add
+          else # new ones
+            hash["stability"] = "1"
+            final[depth] = final[depth].push hash
+          end
+        end
+        final[depth].uniq!
+      end
+      final
+    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
+      return 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 = current_depth+1
+        element = element.parent
+        # Sometimes watir is not returning a valid parent that's why:
+        current_depth = @depth if !element.parent.exists?
+      end
+      return attributes
+    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
+
+    ##
+    # Collecting attributes of the element
+    def get_attributes(element)
+      attributes = element.attributes
+      array = Array.new
+      attributes.each_pair do |name, value|
+        if (name.to_s != "locatineclass")
+          value.split(" ").uniq.each do |part|
+            array.push({"name" => name.to_s, "type" => "attribute", "value" => part})
+          end
+        end
+      end
+      return array
+    end
+
+    ##
+    # Replacing dynamic entries with values
+    def process_string(str, vars)
+      str ||= ""
+      n = nil
+      while str != n
+        str = n if !n.nil?
+        thevar = str.match(/\#{[^\#{]*}/).to_s
+        if thevar != ""
+          value = vars[thevar.match(/(\w.*)}/)[1].to_sym]
+          raise ArgumentError, ":#{thevar.match(/(\w.*)}/)[1]} must be provided in vars since element was defined with it" if !value
+          n = str.gsub(thevar, value)
+        else
+          n = str
+        end
+      end
+      str
+    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
+        return result
+      when false
+        return result.first.to_subtype
+      end
+    end
+  end
+
+end

data/lib/locatine/version.rb

@@ -0,0 +1,6 @@
+module Locatine
+  # constants here...
+  VERSION = "0.0092"
+  NAME = "locatine"
+  HOME = File.readable?("#{Dir.pwd}/lib/#{Locatine::NAME}")? "#{Dir.pwd}/lib/#{Locatine::NAME}" : "#{Gem.dir}/gems/#{Locatine::NAME}-#{Locatine::VERSION}/lib/#{Locatine::NAME}"
+end

data/lib/locatine.rb

@@ -0,0 +1,2 @@
+require "locatine/search"
+require "locatine/version"

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: locatine
+version: !ruby/object:Gem::Version
+  version: '0.0092'
+platform: ruby
+authors:
+- Sergei Seleznev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: watir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.16'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: chromedriver-helper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: The main goal to write locators never
+email: s_seleznev_qa@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/locatine.rb
+- lib/locatine/app/background.js
+- lib/locatine/app/content.css
+- lib/locatine/app/content.js
+- lib/locatine/app/devtools.html
+- lib/locatine/app/devtools.js
+- lib/locatine/app/manifest.json
+- lib/locatine/app/popup.css
+- lib/locatine/app/popup.html
+- lib/locatine/app/popup.js
+- lib/locatine/search.rb
+- lib/locatine/version.rb
+homepage: https://github.com/sseleznevqa/locatine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Element locating tool based on watir
+test_files: []