locatine 0.02637 → 0.02651

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/daemon.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'sinatra/base'
 require 'json'
-require 'locatine/daemon_helpers'
+require 'locatine/session'
+require 'locatine/daemon_helpers/methods'
 
 module Locatine
   #
@@ -8,86 +11,67 @@ module Locatine
   #
   # 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
-    end
-
-    post '/geckodriver' do
-      Webdrivers::Geckodriver.required_version = params['version']
-      { version: Webdrivers::Geckodriver.required_version }.to_json
+    post '/locatine/session/*' do
+      session = request.path_info.split('/').last
+      result = settings.sessions[session].configure(params)
+      { result: result }.to_json
     end
 
-    get '/geckodriver' do
-      { path: Webdrivers::Geckodriver.update }.to_json
+    # selenium calls
+    post '/wd/hub/session/*/element' do
+      content_type settings.headers['Content-Type']
+      results = settings.sessions[session_id].find(params, element_id)
+      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
+    post '/wd/hub/session/*/elements' do
+      content_type settings.headers['Content-Type']
+      results = settings.sessions[session_id].find(params, element_id)
+      status 200
+      answer = results.empty? ? [] : results.map(&:answer)
+      { value: answer }.to_json
     end
 
-    get '/iedriver' do
-      { path: Webdrivers::IEdriver.update }.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 '/connect' do
-      steal
-      { result: true }.to_json
+    delete '/wd/hub/session/*' do
+      settings.sessions[session_id] = nil
+      call_process('delete')
     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
-    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,85 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Locatine
+  module DaemonHelpers
+    #
+    # Methods that are used by daemon
+    module Methods
+      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
+    end
+  end
+end

data/lib/locatine/element.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Locatine
+  #
+  # Locatine single element
+  class Element
+    attr_accessor :answer
+
+    def initialize(session, element_code)
+      @session = session
+      @answer = element_code
+    end
+
+    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
+
+    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/results.rb

@@ -0,0 +1,125 @@
+# 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
+  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::ResultsHelpers::Guess
+
+    attr_accessor :name, :config, :locator
+
+    def configure(session, locator, parent)
+      @session = session
+      @locator = locator.clone
+      read_locator
+      @parent = parent
+    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|
+        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 classic_find
+      first_attempt
+      locating = @locator['value'].empty? || tolerance.positive?
+      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 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
+    end
+
+    def not_found
+      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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Some common methods without much logic
+    module Common
+      def timer
+        @time ||= Time.now
+        timeout > Time.now - @time
+      end
+
+      def name_only?
+        @locator['value'].empty? && !known && @name
+      end
+
+      def known
+        @session.elements[@name]
+      end
+
+      def unknown_no_text(item, hash)
+        ((item['type'] == '*') && (hash['type'] != 'text')) ||
+          ((item['type'] != 'text') && (hash['type'] == '*'))
+      end
+
+      def same_name_type(item, hash)
+        (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
+
+      def trusted
+        @config['trusted'] || @session.trusted
+      end
+
+      def untrusted
+        @config['untrusted'] || @session.untrusted
+      end
+
+      def tolerance
+        @config['tolerance'] || @session.tolerance
+      end
+
+      def timeout
+        @config['timeout'] || @session.timeout
+      end
+
+      def the_depth
+        @config['depth'] || @session.depth
+      end
+
+      def thread_out
+        Thread.current['out']
+      end
+    end
+  end
+end

data/lib/locatine/results_helpers/find_by_magic.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Methods for active looking for element
+    module FindByMagic
+      def magic_thread
+        Thread.new do
+          while empty?
+            magic_find
+            clear unless similar?
+          end
+        end
+      end
+
+      def classic_thread
+        Thread.new do
+          while empty?
+            sleep 0.5
+            classic_find
+          end
+        end
+      end
+
+      def find_by_magic
+        warn_magic
+        classic = classic_thread
+        magic = magic_thread
+        sleep 0.1 while timer && !similar?
+        classic.kill
+        magic.kill
+        normalize_indexes(magic['out']) if empty? && (magic['out'].to_h != {})
+        self
+      end
+
+      def magic_routine(data)
+        Thread.current['out'] = {}
+        page = @session.page
+        data.each_pair do |depth, array|
+          get_trusted(array).each do |hash|
+            @temp = []
+            catch(page, hash, depth)
+            temp_results_push
+          end
+        end
+      end
+
+      def temp_results_push
+        @temp.uniq.each do |index|
+          thread_out[index] ||= 0
+          thread_out[index] += 1
+        end
+      end
+
+      def magic_find(data = known)
+        magic_routine(data)
+        normalize_indexes
+      end
+
+      def normalize_indexes(indexes = Thread.current['out'])
+        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] }
+        answers.each do |item|
+          push Locatine::Element.new(@session, item)
+        end
+      end
+
+      def max_indexes(indexes)
+        max = 0
+        array = []
+        indexes.each_pair do |index, count|
+          next if count < max
+
+          array.push(index)
+          next if count == max
+
+          array = [index]
+          max = count
+        end
+        array
+      end
+
+      def catch(page, hash, depth)
+        page.each do |element|
+          caught = (element['data'].select do |item|
+                      info_hash_eq(item, hash)
+                    end).first
+          kids([element], depth) if caught
+          catch(element['children'], hash, depth)
+        end
+      end
+
+      def kids(array, depth)
+        array.each do |element|
+          @temp.push element['index']
+          if !element['children'].empty? && depth.to_i.positive?
+            kids(element['children'], depth)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/locatine/results_helpers/guess.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Trying to guess element here
+    module Guess
+      def guess
+        warn_guess
+        @config['tolerance'] = 100
+        magic = Thread.new do
+          magic_find(guess_data)
+        end
+        sleep 0.1 while timer && !similar?
+        magic.kill
+        normalize_indexes(magic['out']) if empty? && (magic['out'].to_h != {})
+      end
+
+      def main_guess_data
+        answer = { '0' => [] }
+        parts = @name.split(/[\s\'\\]/)
+        parts.each do |item|
+          next if item.to_s.empty?
+
+          answer['0'].push('type' => '*',
+                           'name' => '*',
+                           'value' => item)
+        end
+        answer
+      end
+
+      def guess_data
+        answer = main_guess_data
+        # We expecting tag at the last position.
+        last = @name.split(/[\s\'\\]/).last.to_s
+        unless last.empty?
+          answer['0'].push('type' => 'tag',
+                           'name' => 'tag',
+                           'value' => last)
+        end
+        answer
+      end
+    end
+  end
+end

data/lib/locatine/results_helpers/info_generator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Locatine
+  module ResultsHelpers
+    #
+    # Methods for gathering element info
+    module InfoGenerator
+      def info
+        stability_bump(raw_info)
+      end
+
+      def raw_info
+        result = {}
+        i = 0
+        while i <= the_depth
+          all = parents(i)
+          data = all.map(&:info)
+          result[i.to_s] = common_info(data) unless data.empty?
+          i += 1
+        end
+        result
+      end
+
+      def parents(depth)
+        all = clone
+        depth.times do
+          all.map!(&:parent)
+          all.compact!
+        end
+        all
+      end
+
+      def catching_old_equal(hash, depth)
+        if known && known[depth]
+          old = known[depth].clone
+          catched = (old.select { |item| info_hash_eq(item, hash) }).first
+        end
+        catched ||= hash
+        catched
+      end
+
+      def hash_stability_bump(catched, max)
+        new_stability = catched['stability'].to_i + 1
+        max += 1 if max < stability
+        catched['stability'] = new_stability if new_stability <= stability
+        catched['stability'] = max if trusted.include?(catched['name'])
+        catched['stability'] = 0 if untrusted.include?(catched['name'])
+        catched
+      end
+
+      def stability_bump(data)
+        result = {}
+        data.each_pair do |depth, info_array|
+          result[depth] = []
+          max = max_stability(known.to_h[depth])
+          info_array.each do |hash|
+            catched = catching_old_equal(hash, depth)
+            result[depth].push hash_stability_bump(catched, max)
+          end
+        end
+        result
+      end
+
+      def common_info(elements_data)
+        merged = elements_data.first
+        elements_data.each do |element_data|
+          merged = info_sum(merged, element_data)
+        end
+        merged
+      end
+
+      def info_sum(one, two)
+        (one.map do |hash|
+           (two.select { |item| info_hash_eq(item, hash) }).first
+         end).compact
+      end
+    end
+  end
+end