locatine 0.02007 → 0.02247

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d489c3b40e3742d4a0133a1280587c338879b7c
-  data.tar.gz: 3347799276e7b897802781ce57cfc1d480c61b77
+  metadata.gz: 023773fde5af096ee6f8b04948dbeadcee35f3d2
+  data.tar.gz: 2071bcae7bf758afc1196a82f04f74690931f9c0
 SHA512:
-  metadata.gz: 794115b0c100ed8724bce73059ec80c8b39e2d91022ce4a0710838e976faba02be568096477c6b3482a0b591d0cdda90e7a09c3ad15b41b0323286ebd271ea24
-  data.tar.gz: 457935ca593e60dd278cfd18c8aad043f366c7fb8f79197139ddcea79d1cd196b78f2063e7e8f9be0455693568d6a787a7b9ada4e1aa28ce320de739194bdb63
+  metadata.gz: c3c8e5959c2fd4b850608ee0d998357c32ce9af253e6726c3077f6eafeeef4625a85fa0e5c70f10564d14c1d46756efe61a9823f4e68f2ac37dd5000d008d1bb
+  data.tar.gz: 99f44eb1de8f7158f8b108edc971c2682322fc2fb60db7e2729da318a73729e21f1dece359616bdfd14e9703a8277b6372c968cac73725fd82e930a85d61fa80

data/README.md

@@ -16,7 +16,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02007** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
+Version of Locatine is **0.02247** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
 
 ## Installation
 
@@ -95,7 +95,8 @@ Locatine::Search.new(json: "./Locatine_files/default.json",
                      stability_limit: 1000,
                      scope: "Default",
                      tolerance: 33,
-                     visual_search: false)
+                     visual_search: false,
+                     no_fail: false)
 ```
 
 ### json
@@ -142,6 +143,10 @@ Position and size for element will be stored for the current resolution only. St
 
 Be careful! Set true only if appearance of your page is pretty stable.
 
+### no_fail
+
+When element is lost and no_fail is true you will get nil for single element and [] for collection. If no_fail is false (which is default) and locatine cannot find something you will face an error.
+
 ## Changing options on fly
 
 You can get or set these values on fly. Like:
@@ -164,7 +169,8 @@ s.find(name: "some name",
        iframe: nil,
        return_locator: false,
        collection: false,
-       tolerance: nil)
+       tolerance: nil,
+       no_fail: nil)
 ```
 ### name
 
@@ -174,26 +180,6 @@ should be always provided. Name of element to look for. Must be uniq one per sco
 
 group of elements. Must be uniq per file. This is to help to store elements with same names from different pages in one file
 
-### exact
-
-unless it is true locatine will always try to find lost element using all the power it has. Use exact: true if you want element to be lost in case of any significant change. If it is impossible to find element when exact: true locatine will return nil.
-
-Be carefull: exact is working only when element is stable (has at least one parameter persistent for stability_limit times == well known by locatine). If element is not stable yet locatine will search for it anyway and maybe it will find something. So if you want to ensure that element does not exist you should use locator and exact at the same time. You may also set zero tolerance. Check it:
-
-```ruby
-# Will return nil if there is no element id = 'not welcome'
-s.find(name: "unexpected element", locator:{id: "not welcome"}, exact: true)
-
-# Will return nil if well known element "unexpected element" is not present
-# Will try to find and return at least something if "unexpected element" is not stable (well known)
-# If there is nothing similar to "unexpected element" returns nil
-s.find(name: "unexpected something", exact: true)
-
-# Will return element only if the same element is present
-# Changing of any attribute which is trusted by locatine will produce nil
-s.find(name: "unexpected something", exact: true, tolerance: 0)
-```
-
 ### locator
 
 you may provide your own locator to use. Same syntax as in Watir:
@@ -263,6 +249,14 @@ if true array of elements will be returned. If false only the one element (the f
 
 You can state custom tolerance for the element.
 
+### exact
+
+It is disabling attempts to find element by advanced algorithms. If locator is provided find method will use only locator. If there is no locator only the basic search will be performed.
+
+### no_fail
+
+no_fail option that will work for that search only.
+
 ## Scope
 
 If you want to define a whole bunch of elements at once you can do:
@@ -302,7 +296,8 @@ search.get_scope(name: "Name of scope").all
 # => {"element name": {
 #      elements: Array of Watir::Element,
 #      locator: valid xpath locator
-#      }...
+#      },
+#     "next element name":...
 #    }
 ```
 
@@ -343,3 +338,12 @@ s.collect("group of elements") # Will return an array
 # or
 s.collect(name: "group of elements")
 ```
+
+Also:
+
+```ruby
+s.exact_collection(name: "something") == s.collect(exact: true, name: "something")
+s.exact(name: "something") == s.find(name: "something", exact: true)
+s.check(name: "something") == s.find(name: "something", tolerance: 0)
+s.check_collection(name: "something") == s.collect(name: "something", tolerance: 0)
+```

data/lib/locatine/app/manifest.json

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

data/lib/locatine/for_search/dialog_logic.rb

@@ -18,50 +18,6 @@ module Locatine
         return element, attributes
       end
 
-      def add_selected_attributes(new_attributes, attributes)
-        if get_from_app('locatinecollection') == 'true'
-          get_commons(new_attributes, attributes.to_h)
-        else
-          new_attributes
-        end
-      end
-
-      def selected_element_attributes(tag, index, vars)
-        generate_data([engine.elements(tag_name: tag)[index]], vars).to_h
-      end
-
-      def selected_element(tag, index, vars, attributes)
-        new_attributes = selected_element_attributes(tag, index, vars)
-        new_attributes = add_selected_attributes(new_attributes, attributes)
-        element = find_by_data(new_attributes, vars)
-        return element, new_attributes
-      end
-
-      def working_on_selected(tag, index, vars, attributes)
-        send_working(tag, index)
-        element, new_attributes = selected_element(tag, index, vars, attributes)
-        warn_dropping(tag, index) unless element
-
-        warn_type(tag) if @type && !element
-
-        return_selected(element, attributes, new_attributes, vars)
-      end
-
-      def return_old_selection(attrs, vars)
-        return find_by_data(attrs, vars).to_a, attrs.to_h if attrs.to_h != {}
-
-        return nil, {}
-      end
-
-      def return_selected(element, attributes, new_attributes, vars)
-        if !element && new_attributes.to_h != {}
-          send_lost
-          return return_old_selection(attributes, vars)
-
-        end
-        return element, new_attributes
-      end
-
       def what_was_selected(element, attributes, vars)
         tag, index = tag_index
         send_to_app('locatineconfirmed', 'ok')

data/lib/locatine/for_search/element_selection.rb

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

data/lib/locatine/for_search/file_work.rb

@@ -35,6 +35,7 @@ module Locatine
       # Setting stability
       def set_stability(first, second)
         second = first if second.to_h == {}
+        first = second.merge first
         final = Hash.new { |hash, key| hash[key] = [] }
         first.each_pair do |depth, array|
           final[depth] = same_entries(array, second, depth, true).uniq
@@ -54,6 +55,7 @@ module Locatine
       ##
       # Saving json
       def store(attributes, scope, name)
+        @data[scope][name] = {} if @learn
         @data[scope][name] = set_stability(attributes, @data[scope][name])
         to_write = { 'data' => @data }
         File.open(@json, 'w') do |f|

data/lib/locatine/for_search/find_by_magic.rb

@@ -7,13 +7,13 @@ module Locatine
 
       ##
       # Getting all the elements via black magic
-      def find_by_magic(name, scope, data, vars, exact)
+      def find_by_magic(name, scope, data, vars)
         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)
+        raise_not_found(name, scope) if all.empty? && !@current_no_f
+        suggest_by_all(all, data, vars, name, scope)
       end
 
       def similar_enough(data, attributes)
@@ -30,11 +30,10 @@ module Locatine
         return suggest, attributes
       end
 
-      def suggest_by_all(all, data, vars, name, scope, exact)
+      def suggest_by_all(all, data, vars, name, scope)
         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
+        raise_not_similar(name, scope) if !ok && !@current_no_f
         if ok
           warn_lost_found(name, scope)
           return suggest, attributes

data/lib/locatine/for_search/find_logic.rb

@@ -11,20 +11,12 @@ module Locatine
         name
       end
 
-      def stable?(attributes)
-        s = []
-        attributes.each_pair do |_depth, array|
-          s.push array.max_by { |i| i['stability'].to_i }['stability'].to_i
-        end
-        s.max >= @stability_limit
-      end
-
       def data_search(name, scope, vars, exact)
         result = find_by_data(@data[scope][name], vars)
         attributes = generate_data(result, vars) if result
-        if !result && (!exact || !stable?(@data[scope][name]))
+        if !result && !exact
           result, attributes = find_by_magic(name, scope,
-                                             @data[scope][name], vars, exact)
+                                             @data[scope][name], vars)
         end
         return result, attributes
       end
@@ -38,7 +30,7 @@ module Locatine
 
       def full_search(name, scope, vars, locator, exact)
         result, attributes = search_steps(name, scope, vars, locator, exact)
-        raise_not_found(name, scope) if !result && !exact
+        raise_not_found(name, scope) if !result && !@current_no_f
         store(attributes, scope, name) if result
         return result, attributes
       end
@@ -69,11 +61,13 @@ module Locatine
       #
       # +collection+ nil, true or false
       def to_subtype(result, collection)
+        result = result.to_a
+        to_return = result.map(&:to_subtype)
         case collection
         when true
-          result
+          to_return
         when false
-          result.first.to_subtype
+          to_return.first
         end
       end
     end

data/lib/locatine/for_search/helpers.rb

@@ -26,10 +26,11 @@ module Locatine
         @iframe = @browser.iframe(@iframe.selector) if @iframe && @iframe.stale?
       end
 
-      def set_env_for_search(look_in, iframe, tolerance)
+      def set_env_for_search(look_in, iframe, tolerance, no_fail)
         @type = look_in
         @iframe = iframe
         @current_t = tolerance || @tolerance
+        @current_no_f = no_fail || @no_fail
       end
 
       def not_magic_div

data/lib/locatine/for_search/highlight.rb

@@ -27,7 +27,7 @@ module Locatine
       ##
       # We can highlight\unhighlight tons of elements at once
       def mass_highlight_turn(mass, turn_on = true)
-        warn_much_highlight if turn_on && mass.length > 50
+        warn_much_highlight(mass.length) if turn_on && mass.length > 50
         mass[0..49].each do |element|
           if turn_on
             highlight element

data/lib/locatine/for_search/merge.rb

@@ -16,7 +16,8 @@ module Locatine
       def same_entries(array, second, depth, stability_up = false)
         result = []
         array.each do |hash|
-          to_add = select_same(second[depth], hash)
+          item = second[depth]
+          to_add = item.nil? ? [] : select_same(second[depth], hash)
           to_add = stability_bump(to_add, hash) if stability_up
           result += to_add
         end

data/lib/locatine/for_search/public.rb

@@ -35,7 +35,8 @@ module Locatine
                      stability_limit: 1000,
                      scope: 'Default',
                      tolerance: 67,
-                     visual_search: false)
+                     visual_search: false,
+                     no_fail: false)
         import_browser browser
         import_file(json)
         @depth = depth
@@ -44,6 +45,7 @@ module Locatine
         @scope = scope
         @tolerance = tolerance
         @visual_search = visual_search
+        @no_fail = no_fail
       end
 
       ##
@@ -88,14 +90,16 @@ module Locatine
                iframe: nil,
                return_locator: false,
                collection: false,
-               tolerance: nil)
+               tolerance: nil,
+               no_fail: nil)
         name = set_name(simple_name, name)
-        set_env_for_search(look_in, iframe, tolerance)
+        set_env_for_search(look_in, iframe, tolerance, no_fail)
         scope ||= @scope.nil? ? 'Default' : @scope
         result, attributes = full_search(name, scope, vars, locator, exact)
         return { xpath: generate_xpath(attributes, vars) } if result &&
                                                               return_locator
-        return to_subtype(result, collection) if result && !return_locator
+
+        to_subtype(result, collection)
       end
 
       ##
@@ -133,6 +137,30 @@ module Locatine
         answer.define(vars) if @learn
         answer
       end
+
+      ##
+      # Find alias with zero tolerance option enforced
+      def check(*args)
+        enforce({ tolerance: 0 }, *args)
+      end
+
+      ##
+      # Collection alias with zero tolerance option enforced
+      def check_collection(*args)
+        enforce({ tolerance: 0, collection: true }, *args)
+      end
+
+      ##
+      # Collection alias with exact option on
+      def exact_collection(*args)
+        enforce({ exact: true, collection: true }, *args)
+      end
+
+      ##
+      # Find alias with exact option on
+      def exact(*args)
+        enforce({ exact: true }, *args)
+      end
     end
   end
 end

data/lib/locatine/for_search/saying.rb

@@ -91,10 +91,25 @@ module Locatine
         push_title "#{length} #{verb(length)} selected as #{name} in #{scope}."\
         " But it was already defined #{found.length} times."
         example = found.sample
+        same = found.select { |i| (i[:name] == name) && (i[:scope] == scope) }
+        if same.empty?
+          send_same_entry_example(example)
+        else
+          send_fully_similar
+        end
+      end
+
+      def send_same_entry_example(example)
         send_to_app('locatinehint', "For example like #{example[:name]} in"\
         " #{example[:scope]}")
       end
 
+      def send_fully_similar
+        send_to_app('locatinehint', 'And it was defined with the same name'\
+        ' and in the same scope. So saving your selection will cause'\
+        ' deleting of all previously stored data about the element')
+      end
+
       def warn_dropping(tag, index)
         send_warn('For some reason locatine cannot proceed with'\
           " //#{tag}[#{index}] element. You've selected. Maybe element was"\
@@ -131,7 +146,19 @@ module Locatine
       end
 
       def warn_not_found(name, scope)
-        "Locatine cannot find element #{name} in #{scope}"
+        send_warn "Locatine cannot find element #{name} in #{scope}"
+      end
+
+      def warn_totally_same(how_deep)
+        send_warn('There are more than one elements with totally similar'\
+          " attributes. Custom depth for element is set to #{how_deep}.")
+      end
+
+      def warn_no_negatives
+        send_warn 'The only way to find the selected element is to use'\
+        " negative expression like //*[not(@id='something')]. Locatine does"\
+        ' not support it. So you must to provide for element a custom locator.'\
+        ' Or find it as a part of collection and than return it by index'
       end
 
       def raise_not_found(name, scope)

data/lib/locatine/scope.rb

@@ -42,7 +42,7 @@ module Locatine
       success = []
       result = find_all(vars, true)
       result.each_pair do |name, hash|
-        success.push name if hash[:elements].nil?
+        success.push name if hash[:elements].empty?
       end
       raise "Check of #{@scope} failed! Lost: #{success}" unless success.empty?
 
@@ -58,7 +58,9 @@ module Locatine
     def find_one(name, hash, vars, strict)
       locator = { xpath: @search.send(:generate_xpath, hash, vars) } if strict
       elements = @search.collect(scope: @scope, name: name,
-                                 locator: locator, exact: strict)
+                                 locator: locator,
+                                 exact: strict,
+                                 no_fail: strict)
       locator = { xpath: @search.send(:generate_xpath, hash, vars) }
       { elements: elements, locator: locator }
     end

data/lib/locatine/search.rb

@@ -1,7 +1,7 @@
 require 'watir'
 require 'json'
 require 'fileutils'
-require 'chromedriver-helper'
+require 'webdrivers'
 
 # Internal requires
 require 'locatine/for_search/merge'
@@ -21,6 +21,7 @@ require 'locatine/for_search/find_by_guess'
 require 'locatine/for_search/data_generate'
 require 'locatine/for_search/xpath_generator'
 require 'locatine/for_search/find_by_locator'
+require 'locatine/for_search/element_selection'
 
 module Locatine
   ##
@@ -45,6 +46,7 @@ module Locatine
     include Locatine::ForSearch::DataGenerate
     include Locatine::ForSearch::FindByLocator
     include Locatine::ForSearch::XpathGenerator
+    include Locatine::ForSearch::ElementSelection
 
     attr_accessor :data,
                   :depth,
@@ -52,7 +54,8 @@ module Locatine
                   :stability_limit,
                   :scope,
                   :tolerance,
-                  :visual_search
+                  :visual_search,
+                  :no_fail
     attr_reader   :json,
                   :browser
   end

data/lib/locatine/version.rb

@@ -1,6 +1,6 @@
 module Locatine
   # constants here...
-  VERSION = '0.02007'.freeze
+  VERSION = '0.02247'.freeze
   NAME = 'locatine'.freeze
   HOME = if File.readable?("#{Dir.pwd}/lib/#{Locatine::NAME}")
            "#{Dir.pwd}/lib/#{Locatine::NAME}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: locatine
 version: !ruby/object:Gem::Version
-  version: '0.02007'
+  version: '0.02247'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2019-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,19 +95,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: chromedriver-helper
+  name: webdrivers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
 description: The main goal to write locators never
 email: s_seleznev_qa@hotmail.com
 executables: []
@@ -129,6 +135,7 @@ files:
 - lib/locatine/for_search/data_generate.rb
 - lib/locatine/for_search/data_logic.rb
 - lib/locatine/for_search/dialog_logic.rb
+- lib/locatine/for_search/element_selection.rb
 - lib/locatine/for_search/file_work.rb
 - lib/locatine/for_search/find_by_css.rb
 - lib/locatine/for_search/find_by_guess.rb