locatine 0.02653 → 0.03143

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d99cd5d5712f3b8c2e5ee842d747cabe50389989ae74ee3cfa2e7c7c053459bb
-  data.tar.gz: 5887791f4997688df39acfab6d5bb9e15827e77b970643a9e6fd63afa9947e57
+  metadata.gz: 38cf69f2ca475f5755477d3bf3ea25581edf0a4a1a57b6491e70f4b97073541b
+  data.tar.gz: 22eeccf122ed564e802047874710fb85f234d4ba52c03a89b8b3ad8e20d0a2cd
 SHA512:
-  metadata.gz: fbd537352c05d38f9b4a2f8ebaee26c1e83d787071593caaa1a72bce8be60c41b36c2d869923d633bfb3851e26497b63f453c15e69fac4725986d8207cea03a7
-  data.tar.gz: 11f6d7403fb9eed905255a1c4d1eee477a2ea220d867d0a4d7ce09a9a0b50b081daf59f21cb92dbffcbe4dd4e31ca76ef01e3234e66353ee203a1007b8cc4685
+  metadata.gz: e637591dbc8f53827fd59747dc45675674350f0ed03985b22524b8f9b0b0b705ba60006e5575ee37b2e0c0c51fa8109bf459381fcc11fd96d51120bf2c31da40
+  data.tar.gz: 2b1461b445491aa49a94a725431e2a4cec9d41bbc5d46e6c6570792297f21987e887c930f17285f65e3782bc4fcc4cef9f4490fd6ee62f0e9b6c85f177f82355

data/README.md

@@ -14,11 +14,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02653**. This is the 1st version since redesign. Next 5-15 versions will be about bug fixing and minor tweaks.
-
-## Attention
-
-This version of Locatine is not compatible to previous.
+Version of Locatine is **0.03143**.
 
 ## Installation
 
@@ -52,14 +48,16 @@ driver.quit
 4. Run the locatine daemon
 
 ```
-    $ SELENIUM=http://localhost:4444 locatine-daemon.rb --port=7733
+    $ locatine-daemon.rb --port=7733 --selenium="http://localhost:4444"
 ```
 
-5. SELENIUM - is for url where selenium hub is started, port is the port for your code to connect. 4444 and 7733 are defaults.
+5. *--selenium* - is for url where selenium hub is started, *--port* is the port for your code to connect. 4444 and 7733 are defaults.
 6. Run your code
 7. Data of element will be stored to ./default.json file.
 8. Now if id of your element is changed on the page Locatine will show a warning and gonna try to retrieve it.
-9. See [example](https://github.com/sseleznevqa/locatine/tree/master/examples) to see how it really works.
+9. See [examples](https://github.com/sseleznevqa/locatine/tree/master/examples) to see how it really works.
+
+**NOTE!** All examples in readme are ruby language examples. But any language can be successfully used. You can find Python example using the link above.
 
 ## Session
 
@@ -367,9 +365,7 @@ element = driver.find_element(css: "/*important input*/")
 
 Locatine will try to find it by those two words. If the id is really uniq it will return the desired element.
 
-Right now there is a Locatine Naming App that is in pending review status in the Chrome extension shop. This app is for creating good locatine locators.
-
-If you wanna try it before it is published - code is in the app folder of this repository.
+There is a [Locatine Name Helper chrome extension](https://chrome.google.com/webstore/detail/locatine-locator-helper/heeoaalghiamfjphdlieoblmodpcficg). This app is for creating good locatine locators (it is creating a pair - most uniq attribute value + tag for selected element, elements). Note that the app is an early draft. It's gonne be better with time.
 
 **NOTE! Locatine locators case insensitive.**
 

data/lib/locatine.rb

@@ -6,6 +6,8 @@ require 'locatine/results_helpers/find_by_magic'
 require 'locatine/results_helpers/guess'
 require 'locatine/results_helpers/info_generator'
 require 'locatine/results_helpers/xpath_generator'
+require 'locatine/results_helpers/comparing'
+require 'locatine/results_helpers/config'
 
 require 'locatine/logger'
 require 'locatine/version'
@@ -13,3 +15,4 @@ require 'locatine/daemon'
 require 'locatine/session'
 require 'locatine/element'
 require 'locatine/results'
+require 'locatine/error'

data/lib/locatine/daemon.rb

@@ -4,7 +4,7 @@ require 'sinatra/base'
 require 'json'
 
 module Locatine
-  #
+  ##
   # Locatine daemon based on sinatra
   #
   # run Locatine::Daemon.run!
@@ -13,7 +13,7 @@ module Locatine
 
     configure do
       set :sessions, {}
-      set :selenium, ENV['SELENIUM'] || 'http://localhost:4444'
+      set :selenium, 'http://localhost:4444'
       set :headers, 'Content-Type' => 'application/json'
       set :port, 7733
     end
@@ -38,6 +38,8 @@ module Locatine
     post '/wd/hub/session/*/element' do
       content_type settings.headers['Content-Type']
       results = settings.sessions[session_id].find(params, element_id)
+      return send_error(results.first) if results.first.class == Locatine::Error
+
       status 200
       results.empty? ? raise_not_found : { value: results.first.answer }.to_json
     end
@@ -45,6 +47,8 @@ module Locatine
     post '/wd/hub/session/*/elements' do
       content_type settings.headers['Content-Type']
       results = settings.sessions[session_id].find(params, element_id)
+      return send_error(results.first) if results.first.class == Locatine::Error
+
       status 200
       answer = results.empty? ? [] : results.map(&:answer)
       { value: answer }.to_json

data/lib/locatine/daemon_helpers/methods.rb

@@ -7,6 +7,8 @@ module Locatine
     #
     # Methods that are used by daemon
     module Methods
+      private
+
       def api_request(type, path, query_string, body, new_headers)
         uri = make_uri(path, query_string)
         req = Net::HTTP.const_get(type).new(uri,
@@ -80,6 +82,12 @@ module Locatine
         path_array = request.path_info.split('/')
         path_array.size >= 7 ? path_array[6] : nil
       end
+
+      def send_error(error)
+        status error.status
+
+        error.answer
+      end
     end
   end
 end

data/lib/locatine/element.rb

@@ -1,22 +1,42 @@
 # frozen_string_literal: true
 
 module Locatine
-  #
+  ##
   # Locatine single element
+  #
+  # It is used to store element info and to return parent.
+  # I am thinking about moving staleness check here.
   class Element
     attr_accessor :answer
 
+    ##
+    # Init method
+    #
+    # @param session [Locatine::Session instance]
+    # @param element_code [Hash] is an element hash returned by selenium,
+    #   it is shaped like:
+    #
+    #   +{"element-6066-11e4-a52e-4f735466cecf"=>"c95a0580-4ac7-4c6d-..."}+
     def initialize(session, element_code)
+      unless element_code
+        raise ArgumentError, 'Cannot init element with no element data'
+      end
+
       @session = session
       @answer = element_code
     end
 
+    ##
+    # Returning a parent element
     def parent
       parent = File.read("#{HOME}/scripts/parent.js")
       new_answer = @session.execute_script(parent, self)
       new_answer.nil? ? nil : Locatine::Element.new(@session, new_answer)
     end
 
+    ##
+    # Method to get the info about particular element or return it if it was
+    # gathered before
     def info
       return @info if @info
 
@@ -24,5 +44,16 @@ module Locatine
       @info = @session.execute_script(info, self)
       @info
     end
+
+    ##
+    # Method to get tag of the particular element or return it if it was
+    # gathered before
+    def tag_name
+      return @tag if @tag
+
+      script = 'return arguments[0].tagName'
+      @tag = @session.execute_script(script, self)
+      @tag
+    end
   end
 end

data/lib/locatine/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Locatine
+  ##
+  # Simple error
+  class Error
+    attr_accessor :answer, :status
+
+    def initialize(response)
+      @answer = response.body
+      @status = response.code
+    end
+  end
+end

data/lib/locatine/logger.rb

@@ -3,9 +3,13 @@
 require 'colorize'
 
 module Locatine
-  #
+  ##
   # Methods for sending lines to STDOUT
+  #
+  # Some of methods are specific and should be run in a correct class only!
   module Logger
+    private
+
     def warn(text)
       puts "WARNING: #{Time.now}: ".yellow + text
     end
@@ -20,7 +24,7 @@ module Locatine
 
     def warn_locator
       warn("Locator is broken. For #{name} by"\
-           " #{@locator['using']}>>>'#{locator['value']}'")
+           " #{@locator['using']}>>>'#{@locator['value']}'")
     end
 
     def warn_guess
@@ -58,5 +62,12 @@ module Locatine
         "\n\n ---Answer was: #{answer}"
       raise answer['error']
     end
+
+    def warn_error_detected(answer)
+      warn "selenium is returning an error with code #{answer.code} "\
+           'It will be returned to your code. It can be locatine internal '\
+           'bug, selenium problem (dead browser for example) or something '\
+           'in your code (invalid locator for example)'
+    end
   end
 end

data/lib/locatine/results.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 module Locatine
+  ##
+  # Locatine results container.
   #
-  # Locatine results container
+  # Results is a pretty strange concept. It is an array of returned elements
+  # which is extended by methods of finding and gathering elements.
   class Results < Array
     include Locatine::ResultsHelpers::InfoGenerator
     include Locatine::ResultsHelpers::XpathGenerator
@@ -10,20 +13,77 @@ module Locatine
     include Locatine::ResultsHelpers::Common
     include Locatine::Logger
     include Locatine::ResultsHelpers::Guess
+    include Locatine::ResultsHelpers::Comparing
+    include Locatine::ResultsHelpers::Config
+
+    attr_accessor :name
+
+    ##
+    # Method to find elements
+    #
+    # @param session [Locatine::Session]
+    # @param locator [Hash] can be a classic locator shaped for webdriver
+    #   protocol like:
+    #
+    #   +{'using => 'xpath', 'value' => '//div'}+ or
+    #   +{'using' => 'css selector', 'value' => 'div'}+
+    #
+    #   It also can be a locator with magic comment like:
+    #
+    #   +{'using' => 'css selector', 'value' => 'div/*magic comment*/'}+
+    #
+    #   It also can be a locator with incapsulated json
+    #
+    #   +{'using' => 'css selector', 'value' => 'div/*{"name": "magic "}*/'}+
+    #
+    #   It can be a locatine locator
+    #
+    #   +{'using' => 'locatine', 'value' => '{"name": "magic comment"}'}+ or
+    #   +{'using' => 'locatine', 'value' => 'magic comment'}+
+    # @param parent is the parent element to look for the nested ones.
+    # @return class instance populated by results or an empty array
+    def find(session, locator, parent)
+      configure(session, locator, parent)
+      find_routine
+      return self unless empty?
+
+      find_by_magic if known && tolerance.positive?
+      similar? ? found : not_found
+    end
+
+    ##
+    # Method to return information about elements found
+    #
+    # Information is returned combined with the previously known data and can
+    # be stored and used as is. It means that its returning not the data about
+    # one particular search. But the combined data of all previous searches
+    def info
+      stability_bump(raw_info)
+    end
+
+    private
 
-    attr_accessor :name, :config, :locator
+    def find_routine
+      timer
+      classic_find
+      guess if name_only?
+      return if first.class == Locatine::Error || empty?
+
+      check_guess if name_only?
+    end
 
-    def configure(session, locator, parent)
-      @session = session
-      @locator = locator.clone
-      read_locator
-      @parent = parent
+    def check_guess
+      map(&:tag_name).uniq.size == 1 ? log_found : clear
     end
 
     def simple_find
       path = @parent ? "/element/#{@parent}/elements" : '/elements'
-      selenium_found = @session.api_request(path, 'Post', @locator.to_json).body
-      JSON.parse(selenium_found)['value'].each do |item|
+      response = @session.api_request(path, 'Post', @locator.to_json)
+      found = JSON.parse(response.body)
+      error_present = (found['value'].class == Hash) && found['value']['error']
+      return error_routine(response) if error_present
+
+      found['value'].each do |item|
         push Locatine::Element.new(@session, item)
       end
       self
@@ -33,9 +93,15 @@ module Locatine
       #  {"element-6066-11e4
     end
 
+    def error_routine(answer)
+      @error = Locatine::Error.new(answer)
+      warn_error_detected(answer)
+      push @error
+    end
+
     def classic_find
       first_attempt
-      locating = @locator['value'].empty? || tolerance.positive?
+      locating = (@locator['value'].empty? || tolerance.positive?) && !@error
       return unless locating
 
       second_attempt
@@ -65,16 +131,6 @@ module Locatine
       find_by_data(base) if empty? && !trusted.empty? && !base['0'].empty?
     end
 
-    def find
-      timer
-      classic_find
-      guess if name_only?
-      return self unless empty?
-
-      find_by_magic if known && tolerance.positive?
-      similar? ? found : not_found
-    end
-
     def found
       log_found
       uniq
@@ -84,35 +140,5 @@ module Locatine
       warn_lost
       []
     end
-
-    def read_locator
-      case @locator['using']
-      when 'css selector'
-        # "button/*{json}*/"
-        read_locator_routine(%r{/\*(.*)\*/$})
-      when 'xpath'
-        # "//button['{json}']"
-        read_locator_routine(/\[\'(.*)\'\]$/)
-      when 'locatine'
-        read_locator_routine(/(.*)/)
-      end
-    end
-
-    def read_locator_routine(regexp)
-      matched = @locator['value'].match(regexp)
-      @config = matched ? config_provided(matched[1]) : {}
-      @locator['value'] = @locator['value'].gsub(matched[0], '') if matched
-      @locator = @config['locator'] if @config['locator']
-      @name = @config['name'] || @locator['value']
-    end
-
-    def config_provided(config)
-      JSON.parse(config)
-    rescue StandardError
-      result = {}
-      result['tolerance'] = 0 if config.start_with?('exactly')
-      result['name'] = config.gsub('exactly ', '')
-      result
-    end
   end
 end

data/lib/locatine/results_helpers/common.rb

@@ -2,9 +2,11 @@
 
 module Locatine
   module ResultsHelpers
-    #
+    ##
     # Some common methods without much logic
     module Common
+      private
+
       def timer
         @time ||= Time.now
         timeout > Time.now - @time
@@ -27,15 +29,6 @@ module Locatine
         (item['name'] == hash['name']) && (item['type'] == hash['type'])
       end
 
-      def info_hash_eq(item, hash)
-        # Return true
-        # If type is unknown (but not a text)
-        # Or when type and name are similar
-        (unknown_no_text(item, hash) || same_name_type(item, hash)) &&
-          # And at the same time values are (almost) the same
-          (item['value'].downcase == hash['value'].downcase)
-      end
-
       def stability
         @config['stability'] || @session.stability
       end

data/lib/locatine/results_helpers/comparing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Trying to compare elements here
+    module Comparing
+      private
+
+      def count_similarity
+        all = 0
+        same = 0
+        # Next is necessary for unknown reason (smthing thread related)
+        raw = raw_info['0']
+        get_trusted(known['0']).each do |hash|
+          caught = (raw.select { |item| info_hash_eq(item, hash) }).first
+          all += 1
+          same += 1 if caught
+        end
+        similar_enough(same, all)
+      end
+
+      def similar?
+        return false if empty?
+
+        return true if tolerance == 100
+
+        count_similarity
+      rescue RuntimeError => e
+        raise e.message unless e.message == 'stale element reference'
+
+        warn_unstable_page
+        false
+      end
+
+      def similar_enough(same, all)
+        sameness = (same * 100) / all
+        sameness >= 100 - tolerance
+      end
+
+      def info_hash_eq(item, hash)
+        # Return true
+        # If type is unknown (but not a text)
+        # Or when type and name are similar
+        (unknown_no_text(item, hash) || same_name_type(item, hash)) &&
+          # And at the same time values are (almost) the same
+          (item['value'].downcase == hash['value'].downcase)
+      end
+    end
+  end
+end

data/lib/locatine/results_helpers/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Trying to configure results here
+    module Config
+      private
+
+      def configure(session, locator, parent)
+        @session = session
+        @locator = locator.clone
+        read_locator
+        @parent = parent
+      end
+
+      def read_locator
+        case @locator['using']
+        when 'css selector'
+          # "button/*{json}*/"
+          read_locator_routine(%r{/\*(.*)\*/$})
+        when 'xpath'
+          # "//button['{json}']"
+          read_locator_routine(/\[\'(.*)\'\]$/)
+        when 'locatine'
+          read_locator_routine(/(.*)/)
+        end
+      end
+
+      def read_locator_routine(regexp)
+        matched = @locator['value'].match(regexp)
+        @config = matched ? config_provided(matched[1]) : {}
+        @locator['value'] = @locator['value'].gsub(matched[0], '') if matched
+        @locator = @config['locator'] if @config['locator']
+        @name = @config['name'] || @locator['value']
+      end
+
+      def config_provided(config)
+        JSON.parse(config)
+      rescue StandardError
+        result = {}
+        result['tolerance'] = 0 if config.start_with?('exactly')
+        result['name'] = config.gsub('exactly ', '')
+        result
+      end
+    end
+  end
+end

data/lib/locatine/results_helpers/find_by_magic.rb

@@ -2,9 +2,11 @@
 
 module Locatine
   module ResultsHelpers
-    #
+    ##
     # Methods for active looking for element
     module FindByMagic
+      private
+
       def magic_thread
         Thread.new do
           while empty?
@@ -17,8 +19,8 @@ module Locatine
       def classic_thread
         Thread.new do
           while empty?
-            sleep 0.5
             classic_find
+            sleep 1
           end
         end
       end
@@ -28,12 +30,17 @@ module Locatine
         classic = classic_thread
         magic = magic_thread
         sleep 0.1 while timer && !similar?
-        classic.kill
-        magic.kill
+        kill_join(classic)
+        kill_join(magic)
         normalize_indexes(magic['out']) if empty? && (magic['out'].to_h != {})
         self
       end
 
+      def kill_join(thread)
+        thread.kill
+        thread.join
+      end
+
       def magic_routine(data)
         Thread.current['out'] = {}
         page = @session.page
@@ -54,15 +61,25 @@ module Locatine
       end
 
       def magic_find(data = known)
+        @everything = all_elements
         magic_routine(data)
         normalize_indexes
       end
 
-      def normalize_indexes(indexes = Thread.current['out'])
+      def all_elements
         all = { 'using' => 'tag name', 'value' => '*' }
         list = @session.api_request('/elements', 'Post', all.to_json).body
-        list = JSON.parse(list)['value']
-        answers = max_indexes(indexes).map { |index| list[index.to_i] }
+        JSON.parse(list)['value']
+      end
+
+      def normalize_indexes(indexes = Thread.current['out'])
+        list = all_elements
+        warn_unstable_page if list != @everything
+        max_list = max_indexes(indexes)
+        old_answers = max_list.map { |index| @everything[index.to_i] }
+        answers = max_list.map { |index| list[index.to_i] }
+        return if old_answers != answers
+
         answers.each do |item|
           push Locatine::Element.new(@session, item)
         end

data/lib/locatine/results_helpers/guess.rb

@@ -2,9 +2,11 @@
 
 module Locatine
   module ResultsHelpers
-    #
+    ##
     # Trying to guess element here
     module Guess
+      private
+
       def guess
         warn_guess
         @config['tolerance'] = 100
@@ -40,32 +42,6 @@ module Locatine
         end
         answer
       end
-
-      def count_similarity
-        all = 0
-        same = 0
-        # Next is necessary for unknown reason (smthing thread related)
-        raw = raw_info['0']
-        get_trusted(known['0']).each do |hash|
-          caught = (raw.select { |item| info_hash_eq(item, hash) }).first
-          all += 1
-          same += 1 if caught
-        end
-        similar_enough(same, all)
-      end
-
-      def similar?
-        return false if empty?
-
-        return true if tolerance == 100
-
-        count_similarity
-      end
-
-      def similar_enough(same, all)
-        sameness = (same * 100) / all
-        sameness >= 100 - tolerance
-      end
     end
   end
 end

data/lib/locatine/results_helpers/info_generator.rb

@@ -2,12 +2,10 @@
 
 module Locatine
   module ResultsHelpers
-    #
+    ##
     # Methods for gathering element info
     module InfoGenerator
-      def info
-        stability_bump(raw_info)
-      end
+      private
 
       def raw_info
         result = {}

data/lib/locatine/results_helpers/xpath_generator.rb

@@ -5,6 +5,8 @@ module Locatine
     ##
     # Methods for generation xpath from stored data
     module XpathGenerator
+      private
+
       def find_by_data(base = known)
         xpath = generate_xpath(base)
         @locator = { 'using' => 'xpath', 'value' => xpath }

data/lib/locatine/scripts/page.js

@@ -50,4 +50,5 @@ function walk(target) {
 }
 const everything = Array.prototype.slice.call( document.getElementsByTagName("*") );
 let result = walk(document.body);
-return [result];
+// We need to incapsulate since chromedriver cannot return a giant object
+return JSON.stringify({"result": [result]});

data/lib/locatine/session.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
 module Locatine
+  ##
+  # Locatine Session class.
   #
-  # Locatine session operator finds and returns
+  # Each selenium session gets a locatine session. Locatine session knows
+  # selenium address and session_id so it is able to communicate with selenium.
+  # It has no complex logic, but acts like a bridge between daemon and selenium
+  # while element is searched
   class Session
     include Locatine::Logger
     attr_accessor :json, :depth, :trusted, :untrusted, :tolerance, :stability,
                   :elements, :timeout
 
-    def defaults
-      { json: "#{Dir.pwd}/locatine_files/default.json", depth: 3, trusted: [],
-        untrusted: [], tolerance: 50, stability: 10, timeout: 25 }
-    end
-
+    ##
+    # Init of the new session instance
+    #
+    # @param selenium [String] is a selenium address like +"https://host:port"+
+    # @param session [String] is a session id provided by selenium
     def initialize(selenium, session)
       @selenium = selenium
       @parsed_selenium = URI.parse @selenium
@@ -23,6 +28,11 @@ module Locatine
       configure defaults
     end
 
+    ##
+    # This method is to set settings
+    #
+    # @param params [Hash] is for settings like +{json: "some", depth: 0...}+
+    # @return params hash :)
     def configure(params)
       params.to_h.each_pair do |var, value|
         instance_variable_set("@#{var}", value)
@@ -31,6 +41,83 @@ module Locatine
       params
     end
 
+    ##
+    # Find method is for finding elements.
+    #
+    # That is the part that is replacing simple finding by selenium
+    # @param params [Hash] is for settings like +{json: "some", depth: 0...}+
+    # @param parent [String] is an element code of the element to look under.
+    #   It is counted
+    #   only for the most simple search. If element is lost parent will be
+    #   ignored
+    # @return populated instance of Locatine::Results or an empty array
+    #   or Locatine::Error
+    def find(params, parent = nil)
+      @start_time = Time.now
+      find_routine(params, parent)
+    rescue RuntimeError => e
+      raise e.message unless e.message == 'stale element reference'
+
+      warn_unstable_page
+      find_routine(params, parent)
+    end
+
+    ##
+    # Session can execute js scripts on a page
+    #
+    # @note This method will be not called when you are asking selenum via
+    #   locatine to execute a script. This method is for internal use only.
+    # @param script [String] some valid js code
+    # @param *args [Array] arguments to be passed to script.
+    def execute_script(script, *args)
+      args.map! { |item| item.class == Locatine::Element ? item.answer : item }
+      response = api_request('/execute/sync', 'Post',
+                             { script: script, args: args }.to_json).body
+      value = JSON.parse(response, max_nesting: false)['value']
+      error_present = (value.class == Hash) && value['error']
+      raise_script_error(script, args, value) if error_present
+
+      value
+    end
+
+    ##
+    # Returning information about the current page
+    def page
+      # We need duplicated JSON parse since standart
+      # chromedriver giving an error here if the page is too large
+      page = execute_script(File.read("#{HOME}/scripts/page.js"))
+      JSON.parse(page, max_nesting: false)['result']
+    end
+
+    ##
+    # This method is used to ask selenium about something.
+    #
+    # We are using it to ask for elements found by selenium or
+    # for script execution
+    # @param path [String] is a relative path to call on selenium like
+    #   +'/elements'+
+    # @param method [String] is an http method to perform ( +'Get'+, +'Post'+,
+    #   etc.)
+    # @param body [String] is for request data. Json here (selenium wants it)
+    #   or nil
+    # @return result of call whatever it is
+    def api_request(path, method, body)
+      uri = call_uri(path)
+      req = Net::HTTP.const_get(method)
+                     .new(uri,
+                          "Content-Type": 'application/json; charset=utf-8',
+                          "Cache-Control": 'no-cache')
+      req.body = body
+      Net::HTTP.new(uri.hostname, uri.port).start { |http| http.request(req) }
+    end
+
+    private
+
+    def defaults
+      { json: "#{Dir.pwd}/locatine_files/default.json", depth: 3, trusted: [],
+        untrusted: [], tolerance: 50, stability: 10, timeout: 25 }
+    end
+
     def read
       dir = File.dirname(@json)
       FileUtils.mkdir_p(dir) unless File.directory?(dir)
@@ -48,33 +135,21 @@ module Locatine
       end
     end
 
-    def find(params, parent = nil)
-      results = Results.new
-      results.configure(self, params, parent)
-      answer = results.find
-      @elements[results.name] = results.info unless answer.empty?
-      write unless answer.empty?
-      answer
-    rescue RuntimeError => e
-      raise e.message unless e.message == 'stale element reference'
-
-      warn_unstable_page
-      find(params, parent)
-    end
-
-    def execute_script(script, *args)
-      args.map! { |item| item.class == Locatine::Element ? item.answer : item }
-      value = JSON.parse(api_request('/execute/sync', 'Post',
-                                     { script: script, args: args }
-                                             .to_json).body)['value']
-      error_present = (value.class == Hash) && value['error']
-      raise_script_error(script, args, value) if error_present
-
-      value
+    def define_timeout(params)
+      params['timeout'] = params['timeout']
+                          .to_i - (Time.now - @start_time).round
+      params
     end
 
-    def page
-      execute_script(File.read("#{HOME}/scripts/page.js"))
+    def find_routine(params, parent)
+      results = Results.new
+      params = define_timeout(params)
+      answer = results.find(self, params, parent)
+      if !answer.empty? && answer.first.class != Locatine::Error
+        @elements[results.name] = results.info
+        write
+      end
+      answer
     end
 
     def call_uri(path)
@@ -84,15 +159,5 @@ module Locatine
         path: "/wd/hub/session/#{@session}#{path}"
       )
     end
-
-    def api_request(path, method, body)
-      uri = call_uri(path)
-      req = Net::HTTP.const_get(method)
-                     .new(uri,
-                          "Content-Type": 'application/json; charset=utf-8',
-                          "Cache-Control": 'no-cache')
-      req.body = body
-      Net::HTTP.new(uri.hostname, uri.port).start { |http| http.request(req) }
-    end
   end
 end

data/lib/locatine/version.rb

@@ -2,7 +2,7 @@
 
 module Locatine
   # constants here...
-  VERSION = '0.02653'
+  VERSION = '0.03143'
   NAME = 'locatine'
   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.02653'
+  version: '0.03143'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2020-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,7 +128,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
-description: The main goal to write locators never
+description: The main goal is to write locators (almost) never
 email: s_seleznev_qa@hotmail.com
 executables:
 - locatine-daemon.rb
@@ -141,9 +141,12 @@ files:
 - lib/locatine/daemon.rb
 - lib/locatine/daemon_helpers/methods.rb
 - lib/locatine/element.rb
+- lib/locatine/error.rb
 - lib/locatine/logger.rb
 - lib/locatine/results.rb
 - lib/locatine/results_helpers/common.rb
+- lib/locatine/results_helpers/comparing.rb
+- lib/locatine/results_helpers/config.rb
 - lib/locatine/results_helpers/find_by_magic.rb
 - lib/locatine/results_helpers/guess.rb
 - lib/locatine/results_helpers/info_generator.rb
@@ -175,5 +178,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Element locating tool based on watir
+summary: Element locating proxy for selenium
 test_files: []