locatine 0.02637 → 0.03050

data/bin/locatine-daemon.rb

@@ -1,7 +1,9 @@
 #!Locatine-daemon...
+# frozen_string_literal: true
+
 require 'locatine'
-args = Hash[ ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/) ]
-args = args.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+args = Hash[ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/)]
+args = args.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v; }
 args.each_pair do |key, value|
   Locatine::Daemon.set key, value
 end

data/lib/locatine.rb

@@ -1,4 +1,18 @@
-require 'locatine/search'
-require 'locatine/scope'
+# 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

@@ -1,93 +1,79 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 require 'json'
-require 'locatine/daemon_helpers'
 
 module Locatine
-  #
+  ##
   # Locatine daemon based on sinatra
   #
   # run Locatine::Daemon.run!
   class Daemon < Sinatra::Base
-    include Locatine::DaemonHelpers
-    configure do
-      set :search, nil
-    end
+    include Locatine::DaemonHelpers::Methods
 
-    get '/app' do
-      { app: File.join(Locatine::HOME, 'app').to_s }.to_json
+    configure do
+      set :sessions, {}
+      set :selenium, ENV['SELENIUM'] || 'http://localhost:4444'
+      set :headers, 'Content-Type' => 'application/json'
+      set :port, 7733
     end
 
+    # own calls
     get '/' do
-      redirect 'https://github.com/sseleznevqa/locatine#using-as-a-daemon'
+      redirect 'https://github.com/sseleznevqa/locatine'
     end
 
-    get '/stop' do
+    get '/locatine/stop' do
       Locatine::Daemon.quit!
       { result: 'dead' }.to_json
     end
 
-    post '/chromedriver' do
-      Webdrivers::Chromedriver.required_version = params['version']
-      { version: Webdrivers::Chromedriver.required_version }.to_json
-    end
-
-    get '/chromedriver' do
-      { path: Webdrivers::Chromedriver.update }.to_json
+    post '/locatine/session/*' do
+      session = request.path_info.split('/').last
+      result = settings.sessions[session].configure(params)
+      { result: result }.to_json
     end
 
-    post '/geckodriver' do
-      Webdrivers::Geckodriver.required_version = params['version']
-      { version: Webdrivers::Geckodriver.required_version }.to_json
-    end
+    # selenium calls
+    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
 
-    get '/geckodriver' do
-      { path: Webdrivers::Geckodriver.update }.to_json
+      status 200
+      results.empty? ? raise_not_found : { value: results.first.answer }.to_json
     end
 
-    post 'iedriver' do
-      Webdrivers::IEdriver.required_version = params['version']
-      { version: Webdrivers::IEdriver.required_version }.to_json
-    end
+    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
 
-    get '/iedriver' do
-      { path: Webdrivers::IEdriver.update }.to_json
+      status 200
+      answer = results.empty? ? [] : results.map(&:answer)
+      { value: answer }.to_json
     end
 
-    post '/connect' do
-      steal
-      { result: true }.to_json
+    post '/wd/hub/session' do
+      result = call_process('post')
+      the_session = JSON.parse(result)['value']['sessionId']
+      caps = params['desiredCapabilities']
+      locatine_caps = caps['locatine'] if caps
+      settings.sessions[the_session] = Locatine::Session
+                                       .new(selenium, the_session)
+      settings.sessions[the_session].configure(locatine_caps)
+      result
     end
 
-    post '/lctr' do
-      data = Hash[params.map { |k, v| [k.to_sym, v] }]
-      data.each { |k, v| data[k] = false if v == 'false' }
-      search.lctr(data).to_json
+    delete '/wd/hub/session/*' do
+      settings.sessions[session_id] = nil
+      call_process('delete')
     end
 
-    post '/set' do
-      hash = params
-      search.json = hash['json'] if hash['json']
-      warn 'You cannot set browser like this. Use /connect' if hash['browser']
-      params.each_pair do |key, value|
-        unless (key == 'browser') || (key == 'json')
-          value = false if value == 'false'
-          search.instance_variable_set("@#{key}", value)
-        end
+    %w[get post put patch delete].each do |verb|
+      send(verb, '/wd/hub/*') do
+        call_process(verb)
       end
-      { result: true }.to_json
-    end
-
-    def search
-      return settings.search unless settings.search.nil?
-
-      settings.search = Locatine::Search.new
-      settings.search.browser.quit
-      settings.search
-    end
-
-    def params
-      request.body.rewind
-      JSON.parse request.body.read
     end
   end
 end

data/lib/locatine/daemon_helpers/methods.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Locatine
+  module DaemonHelpers
+    #
+    # 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,
+                                            settings.headers.merge(new_headers))
+        req.body = body.read
+        Net::HTTP.new(uri.hostname, uri.port).start { |http| http.request(req) }
+      end
+
+      def make_uri(path, query_string)
+        parsed = URI.parse selenium
+        URI::HTTP.build(
+          host: parsed.host,
+          port: parsed.port,
+          path: path,
+          query: query_string
+        )
+      end
+
+      def all_headers(response)
+        header_list = {}
+        response.header.each_capitalized do |k, v|
+          header_list[k] = v unless k == 'Transfer-Encoding'
+        end
+        header_list
+      end
+
+      def incomming_headers(request)
+        request.env.map do |header, value|
+          if header.start_with?('HTTP_')
+            [header[5..-1].split('_').map(&:capitalize).join('-'), value]
+          end
+        end .compact.to_h
+      end
+
+      def send_answer(response)
+        content_type settings.headers['Content-Type']
+        status response.code
+        headers all_headers(response)
+        response.body
+      end
+
+      def call_process(verb)
+        start_request = Thread.new do
+          api_request(verb.capitalize, request.path_info, request.query_string,
+                      request.body, incomming_headers(request))
+        end
+        send_answer(start_request.value)
+      end
+
+      def params
+        request.body.rewind
+        JSON.parse request.body.read
+      end
+
+      def selenium
+        settings.selenium
+      end
+
+      def raise_not_found
+        status 404
+        { value: { error: 'no such element',
+                   message: 'no such element: Unable to locate element',
+                   stacktrace: 'Locatine has no idea too' } }.to_json
+      end
+
+      def session_id
+        request.path_info.split('/')[4]
+      end
+
+      def element_id
+        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

@@ -0,0 +1,46 @@
+# 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
+    #
+    # +session+ is a Locatine::Session instance
+    # +element_code+ 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
+
+      info = File.read("#{HOME}/scripts/element.js")
+      @info = @session.execute_script(info, self)
+      @info
+    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

@@ -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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Locatine
+  ##
+  # 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::Logger
+    include Locatine::ResultsHelpers::Guess
+    include Locatine::ResultsHelpers::Comparing
+    include Locatine::ResultsHelpers::Config
+
+    attr_accessor :name
+
+    ##
+    # Method to find elements
+    #
+    # +session+ instance of Locatine::Session
+    # +locator+ 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 comment"}*/'}
+    # It can be a locatine locator
+    # {'using' => 'locatine', 'value' => '{"name": "magic comment"}'} or
+    # {'using' => 'locatine', 'value' => 'magic comment'
+    # +parent+ is the parent element to look for the nested ones.
+    def find(session, locator, parent)
+      configure(session, locator, parent)
+      timer
+      classic_find
+      guess if name_only?
+      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
+
+    def simple_find
+      path = @parent ? "/element/#{@parent}/elements" : '/elements'
+      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
+      #   {"value"=>
+      #  [{"element-6066-11e4-a52e-4f735466cecf"=>"c95a0580-4ac7-4c6d-..."},
+      #  {"element-6066-11e4-a52e-4f735466cecf"=>"f419f6cf-1a04-4bc8-b246-..."},
+      #  {"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?) && !@error
+      return unless locating
+
+      second_attempt
+      third_attempt if known
+      forth_attempt if known
+    end
+
+    def first_attempt
+      log_start
+      simple_find unless @locator['value'].empty?
+      warn_locator if !@locator['value'].empty? && empty?
+    end
+
+    def third_attempt
+      base = {}
+      base['0'] = known['0']
+      find_by_data(base) if empty?
+    end
+
+    def second_attempt
+      find_by_data if known && empty?
+    end
+
+    def forth_attempt
+      base = {}
+      base['0'] = known['0'].select { |item| trusted.include?(item['name']) }
+      find_by_data(base) if empty? && !trusted.empty? && !base['0'].empty?
+    end
+
+    def found
+      log_found
+      uniq
+    end
+
+    def not_found
+      warn_lost
+      []
+    end
+  end
+end