locatine 0.02651 → 0.03118

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 346a046dc0581334a4266d04cd1e67aa901173fee6b1d283ee9a5f2f6b65c847
-  data.tar.gz: 4844bdbc771b339065af81425be655928d9212c55d15aab78639d777c7a17c53
+  metadata.gz: b992087a77664cfe04949ab6bb1f343edb0c03801bcc118ac21631c4455463f3
+  data.tar.gz: b0d586f4c4de1c38a84eee4d1f9e434a3d8136d4ae25e83367dc573a5ec67c76
 SHA512:
-  metadata.gz: 29615368e78617aace0075da63b77f4870ecd10e377ad561b0211d5907d37a4954c2f7fd8e625e1a7f98c9ecb1733ef36605a5d8ad75a5e284f53b2e22039cd6
-  data.tar.gz: 6091dda3b44a530b3d5ddc5bca2c2cd871dab961a6e2768253d214292c9d196d5feae0e3a76b03aa6c45e3cfbba0c5e2159d338ec6bbe69ff422565e1e96202a
+  metadata.gz: 59ae3ed8e6aa6ac27be09e3bcaeda8e4ce7968db40e8393efd0fe47aeb25be5770181c718555ed304a1938133e7c198b788e82adbf557acb1e451aa650d90d6e
+  data.tar.gz: b56c011bb15c36a1e42dd342f2cc0f09f21ad65835d3cdf457e20b915b18faaeb381bf3c9328b705e6b4a6ec613ebc17712e0cfead1de2e094905509bb50fbe8

data/README.md

@@ -14,11 +14,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02651**. 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.03118**.
 
 ## Installation
 
@@ -80,7 +76,7 @@ driver = Selenium::WebDriver.
 
 This way is recommended because of the simplicity.
 
-Another way is to set options after the session was created by making [POST request to '/locatine/session/%session_id%'](https://github.com/sseleznevqa/locatine#post-to-wd-hub-session_id)
+Another way is to set options after the session was created by making [POST request to '/locatine/session/%session_id%'](https://github.com/sseleznevqa/locatine#post-to-wdhubsession)
 
 ## Settings to pass
 
@@ -329,7 +325,7 @@ For more information about locators read about [locator strategies](https://www.
 
 Locatine also provides its own locator strategy == 'locatine'. In order to use it you need to inject it to the code of selenium-webdriver implementation.
 
-See it's done for ruby [here](https://github.com/sseleznevqa/locatine/tree/master/spec/e2e_spec.rb#L6-L25)
+See it's done for ruby [here](https://github.com/sseleznevqa/locatine/tree/master/spec/e2e_spec.rb#L5-L11)
 
 When it's done you can use:
 
@@ -367,9 +363,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

@@ -1,5 +1,18 @@
 # frozen_string_literal: true
 
+require 'locatine/daemon_helpers/methods'
+require 'locatine/results_helpers/common'
+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'
 require 'locatine/daemon'
 require 'locatine/session'
+require 'locatine/element'
+require 'locatine/results'
+require 'locatine/error'

data/lib/locatine/daemon.rb

@@ -2,11 +2,9 @@
 
 require 'sinatra/base'
 require 'json'
-require 'locatine/session'
-require 'locatine/daemon_helpers/methods'
 
 module Locatine
-  #
+  ##
   # Locatine daemon based on sinatra
   #
   # run Locatine::Daemon.run!
@@ -40,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
@@ -47,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
 

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+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
+
+    def log(text)
+      puts "MESSAGE: #{Time.now}: ".magenta + text
+    end
+
+    def locatine_error(text)
+      puts "ERROR: #{Time.now}: ".red + text.red
+    end
+
+    def warn_locator
+      warn("Locator is broken. For #{name} by"\
+           " #{@locator['using']}>>>'#{@locator['value']}'")
+    end
+
+    def warn_guess
+      warn("Locatine is trying to guess what is #{@name}")
+    end
+
+    def log_start
+      log "#{Time.now}: Locatine is working on #{@name}"
+    end
+
+    def warn_magic
+      warn "Locatine cannot find element #{@name} by usual methods and "\
+           'starting to look for some element that is similar. Retrived '\
+           'element may be not the one that is desired from this point'
+    end
+
+    def warn_lost
+      warn "Locatine found nothing for #{@name}"
+    end
+
+    def warn_unstable_page
+      warn 'Locatine detected stale element error. It means some elements'\
+           ' found by locatine are not attached to DOM anymore.'\
+           ' Page is unstable. Starting searching process again'
+    end
+
+    def log_found
+      log "Locatine found something as #{@name}"
+      log "XPATH == #{generate_xpath(raw_info)}"
+    end
+
+    def raise_script_error(script, args, answer)
+      locatine_error 'Locatine faced an error while trying to perform '\
+        "js script.\n ---Script was: #{script}\n\n ---Arguments was: #{args}"\
+        "\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,36 +1,85 @@
 # frozen_string_literal: true
 
-require 'locatine/results_helpers/info_generator'
-require 'locatine/results_helpers/xpath_generator'
-require 'locatine/results_helpers/find_by_magic'
-require 'locatine/results_helpers/common'
-require 'locatine/results_helpers/logger'
-require 'locatine/results_helpers/guess'
-
 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
     include Locatine::ResultsHelpers::FindByMagic
     include Locatine::ResultsHelpers::Common
-    include Locatine::ResultsHelpers::Logger
+    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
 
-    attr_accessor :name, :config, :locator
+    private
 
-    def configure(session, locator, parent)
-      @session = session
-      @locator = locator.clone
-      read_locator
-      @parent = parent
+    def find_routine
+      timer
+      classic_find
+      guess if name_only?
+      return if first.class == Locatine::Error || empty?
+
+      log_found if name_only?
     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
@@ -40,9 +89,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
@@ -72,16 +127,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
@@ -91,35 +136,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

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,22 +1,23 @@
 # frozen_string_literal: true
 
-require 'locatine/results'
-require 'locatine/element'
-require 'locatine/results_helpers/logger'
-
 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::ResultsHelpers::Logger
+    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
@@ -27,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)
@@ -35,30 +41,19 @@ module Locatine
       params
     end
 
-    def read
-      dir = File.dirname(@json)
-      FileUtils.mkdir_p(dir) unless File.directory?(dir)
-      unless File.exist?(@json)
-        File.open(@json, 'w') do |f|
-          f.write('{"elements" : {}}')
-        end
-      end
-      @elements = JSON.parse(File.read(@json))['elements']
-    end
-
-    def write
-      File.open(@json, 'w') do |f|
-        f.write(JSON.pretty_generate('elements' => @elements))
-      end
-    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)
-      results = Results.new
-      results.configure(self, params, parent)
-      answer = results.find
-      @elements[results.name] = results.info unless answer.empty?
-      write unless answer.empty?
-      answer
+      find_routine(params, parent)
     rescue RuntimeError => e
       raise e.message unless e.message == 'stale element reference'
 
@@ -66,29 +61,45 @@ module Locatine
       find(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 }
-      value = JSON.parse(api_request('/execute/sync', 'Post',
-                                     { script: script, args: args }
-                                             .to_json).body)['value']
+      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
-      execute_script(File.read("#{HOME}/scripts/page.js"))
-    end
-
-    def call_uri(path)
-      URI::HTTP.build(
-        host: @parsed_selenium.host,
-        port: @parsed_selenium.port,
-        path: "/wd/hub/session/#{@session}#{path}"
-      )
+      # 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)
@@ -98,5 +109,47 @@ module Locatine
       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)
+      unless File.exist?(@json)
+        File.open(@json, 'w') do |f|
+          f.write('{"elements" : {}}')
+        end
+      end
+      @elements = JSON.parse(File.read(@json))['elements']
+    end
+
+    def write
+      File.open(@json, 'w') do |f|
+        f.write(JSON.pretty_generate('elements' => @elements))
+      end
+    end
+
+    def find_routine(params, parent)
+      results = Results.new
+      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)
+      URI::HTTP.build(
+        host: @parsed_selenium.host,
+        port: @parsed_selenium.port,
+        path: "/wd/hub/session/#{@session}#{path}"
+      )
+    end
   end
 end

data/lib/locatine/version.rb

@@ -2,7 +2,7 @@
 
 module Locatine
   # constants here...
-  VERSION = '0.02651'
+  VERSION = '0.03118'
   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.02651'
+  version: '0.03118'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-01 00:00:00.000000000 Z
+date: 2020-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,12 +141,15 @@ 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
-- lib/locatine/results_helpers/logger.rb
 - lib/locatine/results_helpers/xpath_generator.rb
 - lib/locatine/scripts/element.js
 - lib/locatine/scripts/page.js

data/lib/locatine/results_helpers/logger.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'colorize'
-
-module Locatine
-  module ResultsHelpers
-    #
-    # Methods for sending lines to STDOUT
-    module Logger
-      def warn(text)
-        puts "WARNING: #{Time.now}: ".yellow + text
-      end
-
-      def log(text)
-        puts "MESSAGE: #{Time.now}: ".magenta + text
-      end
-
-      def locatine_error(text)
-        puts "ERROR: #{Time.now}: ".red + text.red
-      end
-
-      def warn_locator
-        warn("Locator is broken. For #{name} by"\
-             " #{@locator['using']}>>>'#{locator['value']}'")
-      end
-
-      def warn_guess
-        warn("Locatine is trying to guess what is #{@name}")
-      end
-
-      def log_start
-        log "#{Time.now}: Locatine is working on #{@name}"
-      end
-
-      def warn_magic
-        warn "Locatine cannot find element #{@name} by usual methods and "\
-             'starting to look for some element that is similar. Retrived '\
-             'element may be not the one that is desired from this point'
-      end
-
-      def warn_lost
-        warn "Locatine found nothing for #{@name}"
-      end
-
-      def warn_unstable_page
-        warn 'Locatine detected stale element error. It means some elements'\
-             ' found by locatine are not attached to DOM anymore.'\
-             ' Page is unstable. Starting searching process again'
-      end
-
-      def log_found
-        log "Locatine found something as #{@name}"
-        log "XPATH == #{generate_xpath(raw_info)}"
-      end
-
-      def raise_script_error(script, args, answer)
-        locatine_error 'Locatine faced an error while trying to perform '\
-          "js script.\n ---Script was: #{script}\n\n ---Arguments was: #{args}"\
-          "\n\n ---Answer was: #{answer}"
-        raise answer['error']
-      end
-    end
-  end
-end