locatine 0.00695 → 0.01084

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 243bb8f7b9d129d5e150c06fedde26e259b6ab3b
-  data.tar.gz: 12bbfbb7c9a0e02b17354b925a824f1a933434f5
+  metadata.gz: 38885391980f7e8d2b0cef65643f998edf5074cf
+  data.tar.gz: f321d064c113b65f024d8d22bd52bfd0ab6a56d8
 SHA512:
-  metadata.gz: bf8572d806425b259429a81b2e4461f295396e3af8bf69c1f2eda4d638f959f78b636a9a44001c812d1079ea86d51b32079b26c924f283ae78c700e2245f9ba9
-  data.tar.gz: 5d317c2c22853ed9a74ace1e01cdfd1dfc3c4665df1d98b5f946f74fe2e39116a81b0394ffa219ea52a7776ff377f134552e82f7d3684af855542ebc621b6396
+  metadata.gz: 110afe53c901b20d93cdc7c34c2846e82c5b361d96068e368a42ad907278bb124eed0fdc53bc993a77f87afae72b744a03bd41e7e7156679a62604a6a76a115b
+  data.tar.gz: 02105771e43ba72453ebbb238be198408037c11fd90e2169f0e79f44d96efc49a1c4bed2c08dcf8e5068e34c08c2725bb015343475074b9a48707e9a52937764

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.01084",
+  "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

@@ -67,7 +67,16 @@ module Locatine
     # +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)
+    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
@@ -85,22 +94,26 @@ module Locatine
         end
       end
       result, attributes = ask(scope, name, result, vars) if @learn
-      raise RuntimeError, "Nothing was found for #{scope} #{name}" if !result
-      attributes = generate_data(result, vars) if !attributes
-      @type = nil
-      store(attributes, scope, name)
-      return return_locator ? {xpath: generate_xpath(attributes, vars)} : to_subtype(result)
+      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)
+      enforce(:return_locator, true, *args)
+    end
+
+    ##
+    # Find alias with collection option enforced
+    def collect(*args)
+      enforce(:collection, true, *args)
     end
 
     private
@@ -124,6 +137,18 @@ module Locatine
       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
@@ -180,7 +205,7 @@ module Locatine
     end
 
     def generate_xpath(data, vars)
-      xpath = ''
+      xpath = "[not(@id = 'locatine_magic_div')]"
       data.each_pair do |depth, array|
         trusted = get_trusted(array)
         trusted.each do |hash|
@@ -247,21 +272,21 @@ module Locatine
         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}")
+      find_by_locator(xpath: "#{full_part}[contains(., '#{process_string(hash["value"], vars)}')]]#{correction}[not(@id = 'locatine_magic_div')]")
     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}")
+      find_by_locator(xpath: "//*[self::#{process_string(hash["value"], vars)}')]#{correction}[not(@id = 'locatine_magic_div')]")
     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}")
+      find_by_locator(xpath: "//*[contains(text(), '#{process_string(hash["value"], vars)}')]#{correction}[not(@id = 'locatine_magic_div')]")
     end
 
     ##
@@ -308,16 +333,16 @@ module Locatine
       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
+        all = all + find_by_locator({xpath: "//#{part}[not(@id = 'locatine_magic_div')]"}).to_a
+        all = all + find_by_locator({xpath: "//*[contains(text(),'#{part}')][not(@id = 'locatine_magic_div')]"}).to_a
+        all = all + find_by_locator({xpath: "//*[@*[contains(., '#{part}')]][not(@id = 'locatine_magic_div')]"}).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)
+        if by_data.nil? || (engine.elements.length/by_data.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 = {}
@@ -336,9 +361,9 @@ module Locatine
       element, attributes, finished, old_tag, old_index, old_element = result, {}, false, nil, nil, nil
       if !element.nil?
         attributes = generate_data(element, vars)
-      else
+      elsif name.length >= 5
         set_title("Locatine is trying to guess what is #{name} in #{scope}.")
-        element, attributes = find_by_guess(scope, name, vars) if name.length >= 5
+        element, attributes = find_by_guess(scope, name, vars)
       end
       while !finished do
         sleep 0.1
@@ -556,11 +581,14 @@ module Locatine
     #
     # Params:
     # +result+ must be Watir::HTMLElementCollection or Array
-    def to_subtype(result)
-      if result.size == 1
-        return result[0].to_subtype
-      else
+    #
+    # +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

data/lib/locatine/version.rb

@@ -1,6 +1,6 @@
 module Locatine
   # constants here...
-  VERSION = "0.00695"
+  VERSION = "0.01084"
   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

@@ -1 +1,2 @@
-Dir.glob("./lib/locatine/*.rb").each {|it| require it}
+require "locatine/search"
+require "locatine/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: locatine
 version: !ruby/object:Gem::Version
-  version: '0.00695'
+  version: '0.01084'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,6 +115,15 @@ 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