locatine 0.02327 → 0.02432

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a584853859a41d1442f3037bef100dec0bb1d09e
-  data.tar.gz: 298cabc4969b4e454bb3d6bd9f5f2b5d091ff53c
+  metadata.gz: 2938862d7ec4f9e5db28711a7f40764d1911ea73
+  data.tar.gz: e6a0775a26dd2d7bd5516a8b0b198a6f4d4f7097
 SHA512:
-  metadata.gz: 4a317d9efb1aab542d551d90272ee912edb9b7ee36df13ad74292d1ac377848995d19a786104a5db89480f636bf14d77c3b3f1271d4b408732729d8f0498baa8
-  data.tar.gz: 99dbade69774c044b519d78e5c3ec3b0ba7469eb803e9cff80eee1fa3549bd566460ffaaf2c3c95e7a7817bd83c6dd2254101ef50666a76503a91a19a06b117f
+  metadata.gz: 131784b53b1c62a289587e7c7fc8faf44abce5d5121ecbd08aa6c58a2bfce1bdd05712d31aa9e2e3cafc3f76d4a390728c41a96da0635ad1b4ae44573737a858
+  data.tar.gz: 0c80e987bb31e5991dc917849b4069d727f6f4902688e975a03c9248f6823e827b59545f0ed59e49b78dcd400f501d097db064ee51a87a518a07532628173e29

data/README.md

@@ -16,7 +16,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02327** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
+Version of Locatine is **0.02432** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
 
 ## Installation
 
@@ -361,3 +361,131 @@ s.exact(name: "something") == s.find(name: "something", exact: true)
 s.check(name: "something") == s.find(name: "something", tolerance: 0)
 s.check_collection(name: "something") == s.collect(name: "something", tolerance: 0)
 ```
+
+## Using as a daemon
+
+Locatine daemon is a web server based on sinatra. You can run it from your code like:
+
+```ruby
+require 'locatine'
+Locatine::Daemon.set :port, 7733 #Your port goes here
+Locatine::Daemon.run!
+```
+
+Also you can do it with terminal:
+
+```bash
+locatine-daemon.rb -port=7733
+```
+
+You can see a python3 example in the [example](https://github.com/sseleznevqa/locatine/tree/master/example) folder. Main idea is
+
+1. Run daemon
+2. Ask daemon for the app path
+3. Run your browser with the app as extension
+4. Turn on the learn
+5. Provide data to the daemon for connect (browser name, session_id, connect url, proxy)
+6. Use API calls to teach daemon how to find elements
+7. After that you can start browser without the app
+8. Provide data for connect
+9. Now you can ask daemon to find your element via API call. And it will answer with a valid xpath you can use.
+
+### API
+
+#### GET call to /app
+
+returns path to locatine application in order to start chrome with it.
+
+Example of response:
+
+```
+{"app": "/some/path/to/app"}
+```
+
+#### GET call to /stop
+
+stops Locatine daemon.
+
+Returns:
+
+```
+{"result": "dead"}
+```
+
+#### POST call to /connect
+
+allows Locatine Daemon to connect existing browser instance
+
+POST data:
+
+```
+{'browser': 'chrome', 'session_id': session_id, 'url': 'http://whatever_is_browser_ip:port_opened_by_browser_for_selenium', 'proxy': 'optionally' }
+```
+
+Answer:
+
+```
+{"result": "true"}
+```
+
+#### POST call to /set
+
+is to control options of locatine search. Sending to set data ==
+
+```
+{"learn": "true"}
+```
+
+Answer:
+
+```
+{"result": "true"}
+```
+
+is the same as
+
+```ruby
+search.learn = true
+```
+
+#### POST call to /lctr
+
+is to find and return locator of an element found by locatine
+
+POST data just the same as for find or lctr method. It's like:
+
+```
+{"name": "some name", "scope": "Default", "exact": "false" ...}
+```
+
+Answer:
+
+```
+{"xpath": "//YOUR[@xpath='goes here']"}
+```
+
+### GET /chromedriver || /geckodriver || /iedriver
+
+returns path to the binary retrieved by locatine (using webdrivers gem)
+
+Answer:
+
+```
+{"path": "path/to/the/binary"}
+```
+
+### POST call to /chromedriver || /geckodriver || /iedriver
+
+is to force locatine to use your webdriver (for example for using old version of browser)
+
+POST data:
+
+```
+{"version": "2.46"}
+```
+
+Answer:
+
+```
+{"version": "2.46"}
+```

data/bin/locatine-daemon.rb

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

data/lib/locatine/app/manifest.json

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

data/lib/locatine/daemon.rb

@@ -0,0 +1,93 @@
+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
+
+    get '/app' do
+      { app: File.join(Locatine::HOME, 'app').to_s }.to_json
+    end
+
+    get '/' do
+      redirect 'https://github.com/sseleznevqa/locatine#using-as-a-daemon'
+    end
+
+    get '/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
+    end
+
+    get '/geckodriver' do
+      { path: Webdrivers::Geckodriver.update }.to_json
+    end
+
+    post 'iedriver' do
+      Webdrivers::IEdriver.required_version = params['version']
+      { version: Webdrivers::IEdriver.required_version }.to_json
+    end
+
+    get '/iedriver' do
+      { path: Webdrivers::IEdriver.update }.to_json
+    end
+
+    post '/connect' do
+      steal
+      { result: true }.to_json
+    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
+      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.rb

@@ -0,0 +1,52 @@
+module Locatine
+  #
+  # Usefull things daemon can do
+  module DaemonHelpers
+    private
+
+    def steal
+      cast_ghost_browser
+      disguise_session
+      disguise_server_url
+      disguise_http
+      disguise_proxy unless params['proxy'].to_s.empty?
+    end
+
+    def bridge
+      search.browser.wd.send(:bridge)
+    end
+
+    def b_http
+      bridge.send(:http)
+    end
+
+    def disguise_session
+      bridge.instance_variable_set('@session_id', params['session_id'])
+    end
+
+    def disguise_server_url
+      uri = URI.parse(params['url'])
+      b_http.instance_variable_set('@server_url', uri)
+    end
+
+    def disguise_http
+      b_http.instance_variable_set('@http', make_net)
+    end
+
+    def disguise_proxy
+      b_http.instance_variable_set('@proxy', params['proxy'])
+    end
+
+    def make_net
+      parsed = URI.parse(params['url'])
+      path = parsed.path == '/' ? '' : parsed.path
+      Net::HTTP.new("#{parsed.host}#{path}", parsed.port)
+    end
+
+    def cast_ghost_browser
+      search.browser = Watir::Browser.new(params['browser'].to_sym)
+      search.browser.quit
+      search.browser.instance_variable_set('@closed', false)
+    end
+  end
+end

data/lib/locatine/for_search/defaults.rb

@@ -0,0 +1,45 @@
+module Locatine
+  module ForSearch
+    ##
+    # Default settings for search are living here
+    module Defaults
+      private
+      def default_init_config
+        { json: './Locatine_files/default.json',
+          depth: 3,
+          browser: nil,
+          learn: ENV['LEARN'].nil? ? false : true,
+          stability_limit: 1000,
+          scope: 'Default',
+          tolerance: 67,
+          visual_search: false,
+          no_fail: false,
+          trusted: [],
+          untrusted: []
+        }
+      end
+
+      def import_browser(browser)
+        selenium = browser.class.superclass == Selenium::WebDriver::Driver
+        b = right_browser unless browser
+        b = browser if browser.class == Watir::Browser
+        b = Watir::Browser.new(browser) if selenium
+        @browser = b
+        @default_styles = default_styles.to_a
+      end
+
+      def import_file(json)
+        @json = json
+        @folder = File.dirname(@json)
+        @name = File.basename(@json)
+        @data = read_create
+      end
+
+      def import_config(config)
+        config.each_pair do |key, value|
+          self.instance_variable_set("@#{key.to_s}", value)
+        end
+      end
+    end
+  end
+end

data/lib/locatine/for_search/file_work.rb

@@ -17,13 +17,6 @@ module Locatine
         hash.merge(JSON.parse(File.read(@json))['data'])
       end
 
-      def import_file(json)
-        @json = json
-        @folder = File.dirname(@json)
-        @name = File.basename(@json)
-        @data = read_create
-      end
-
       def create_json_file
         f = File.new(@json, 'w')
         f.puts '{"data" : {}}'

data/lib/locatine/for_search/helpers.rb

@@ -64,15 +64,6 @@ module Locatine
         Watir::Browser.new(:chrome, switches: ["--load-extension=#{HOME}/app"])
       end
 
-      def import_browser(browser)
-        selenium = browser.class.superclass == Selenium::WebDriver::Driver
-        b = right_browser unless browser
-        b = browser if browser.class == Watir::Browser
-        b = Watir::Browser.new(browser) if selenium
-        @browser = b
-        @default_styles = default_styles.to_a
-      end
-
       def css_text_to_hash(text)
         almost_hash = []
         array = text[0..-2].split('; ')

data/lib/locatine/for_search/public.rb

@@ -28,28 +28,21 @@ module Locatine
       # to the lost one. Default is 67 which means that if less than 33% of
       # metrics of alternative elements are the same as of the lost element
       # will not be returned
-      def initialize(json: './Locatine_files/default.json',
-                     depth: 3,
-                     browser: nil,
-                     learn: ENV['LEARN'].nil? ? false : true,
-                     stability_limit: 1000,
-                     scope: 'Default',
-                     tolerance: 67,
-                     visual_search: false,
-                     no_fail: false,
-                     trusted: [],
-                     untrusted: [])
-        import_browser browser
-        import_file(json)
-        @depth = depth
-        @learn = learn
-        @stability_limit = stability_limit
-        @scope = scope
-        @tolerance = tolerance
-        @visual_search = visual_search
-        @no_fail = no_fail
-        @trusted = trusted
-        @untrusted = untrusted
+      #
+      # +visual_search+ locatine will use position and style if true
+      #
+      # +no_fail+ if true locatine is not producing errors on element loss.
+      #
+      # +trusted+ array of names of attributes and element params to use
+      # in search always.
+      #
+      # +untrusted+ array of names of attributes and element params to use
+      # in search never.
+      def initialize(config = {})
+        init_config = default_init_config.merge(config)
+        import_browser init_config.delete :browser
+        import_file init_config.delete :json
+        import_config init_config
       end
 
       ##
@@ -84,6 +77,14 @@ module Locatine
       #
       # +tolerance+ It is possible to set a custom tolerance for every find. See
       # examples in README
+      #
+      # +no_fail+ if true locatine is not producing errors on element loss.
+      #
+      # +trusted+ array of names of attributes and element params to use
+      # in search always.
+      #
+      # +untrusted+ array of names of attributes and element params to use
+      # in search never.
       def find(simple_name = nil,
                name: nil,
                scope: nil,

data/lib/locatine/for_search/xpath_generator.rb

@@ -15,7 +15,7 @@ module Locatine
       end
 
       def max_stability(array)
-        max = (array.max_by { |i| i['stability'].to_i })
+        max = (array.max_by { |i| i['stability'].to_i }) if array
         return max['stability'] if max
 
         return 0

data/lib/locatine/search.rb

@@ -8,6 +8,7 @@ require 'locatine/for_search/merge'
 require 'locatine/for_search/public'
 require 'locatine/for_search/saying'
 require 'locatine/for_search/helpers'
+require 'locatine/for_search/defaults'
 require 'locatine/for_search/file_work'
 require 'locatine/for_search/listening'
 require 'locatine/for_search/highlight'
@@ -33,6 +34,7 @@ module Locatine
     include Locatine::ForSearch::Public
     include Locatine::ForSearch::Saying
     include Locatine::ForSearch::Helpers
+    include Locatine::ForSearch::Defaults
     include Locatine::ForSearch::FileWork
     include Locatine::ForSearch::DataLogic
     include Locatine::ForSearch::Listening

data/lib/locatine/version.rb

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

data/lib/locatine.rb

@@ -1,3 +1,4 @@
 require 'locatine/search'
 require 'locatine/scope'
 require 'locatine/version'
+require 'locatine/daemon'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: locatine
 version: !ruby/object:Gem::Version
-  version: '0.02327'
+  version: '0.02432'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-13 00:00:00.000000000 Z
+date: 2019-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,27 +100,43 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.5
 description: The main goal to write locators never
 email: s_seleznev_qa@hotmail.com
-executables: []
+executables:
+- locatine-daemon.rb
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- bin/locatine-daemon.rb
 - lib/locatine.rb
 - lib/locatine/app/background.js
 - lib/locatine/app/content.css
@@ -131,9 +147,12 @@ files:
 - lib/locatine/app/popup.css
 - lib/locatine/app/popup.html
 - lib/locatine/app/popup.js
+- lib/locatine/daemon.rb
+- lib/locatine/daemon_helpers.rb
 - lib/locatine/for_search.rb
 - lib/locatine/for_search/data_generate.rb
 - lib/locatine/for_search/data_logic.rb
+- lib/locatine/for_search/defaults.rb
 - lib/locatine/for_search/dialog_logic.rb
 - lib/locatine/for_search/element_selection.rb
 - lib/locatine/for_search/file_work.rb