locatine 0.02058 → 0.02539

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 839233263a07aac6fda720392d0dbd920a5a9660
-  data.tar.gz: b60a4fdc5d93b96abb65b49c128302eb73d5a9b6
+  metadata.gz: 63c1d452b58e6881483141749a4cd5fc572a1a34
+  data.tar.gz: 5436ddbbd222888ab16ef121750e871be2d0b330
 SHA512:
-  metadata.gz: f6279a2237def4ac7799e8a1ed6f3d293251d92ad7e2a62e13fd98ac22b05c2d4bccaabd4be19cf9de97f27a28a98916d784236af6240109ccb61323481dd7be
-  data.tar.gz: f1f87a3f394b2091d0391e53e3844067e6c929d51dfc68e2d526a0dd44dd588ce293752044e9c27602997f3d9b2d43c27e1fb657683387761079fae9b81d5f65
+  metadata.gz: 875b40b1ebc3294dc60868c4f029a3eb2c37b984509002c30fadecad20d7e26f0df207eab8ed3466cc7021777d9a89baa6a0a6c4ba7dc655bea1109b573031cb
+  data.tar.gz: 9c36756f4c0388acf60d1009ed79ebed732b2401daa387930a3f61c8c97b745f2c1bc0bdeeced30e300543d88b09459c7bdf0f7320ef4630dbd47e83c9b58550

data/README.md

@@ -16,7 +16,7 @@ That's it.
 
 ## Stage of development:
 
-Version of Locatine is **0.02058** 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.02539** only. It means so far this is an alfa. You can use it in a real project if you are a risky person.
 
 ## Installation
 
@@ -96,7 +96,10 @@ Locatine::Search.new(json: "./Locatine_files/default.json",
                      scope: "Default",
                      tolerance: 33,
                      visual_search: false,
-                     no_fail: false)
+                     no_fail: false,
+                     trusted: [],
+                     untrusted: [],
+                     autolearn: nil)
 ```
 
 ### json
@@ -147,6 +150,24 @@ Be careful! Set true only if appearance of your page is pretty stable.
 
 When element is lost and no_fail is true you will get nil for single element and [] for collection. If no_fail is false (which is default) and locatine cannot find something you will face an error.
 
+### trusted/untrusted
+
+If you are sure that some attribute (or something) is not good(generated by random, not uniq, etc.) you can forbid to use it in search. You can write attribute name, "text", "tag", or css attribute name (if you are using visual_search)
+
+On the other hand you can force locatine to always trust something with trusted.
+
+### autolearn
+
+Determines wether Locatine will study elements by default or not.
+
+If true Locatine will always check element for changes even if it is found properly (to catch for example adding of a new attribute). This is slow.
+
+If false Locatine will study element only in case when it is lost.
+
+If not stated Locatine will use false until it is not facing any lost element. After the first lost element it will be studying everything (true).
+
+Notice that if autolearn is false Locatine is not bumping the stability values of attributes for elements which were found normally.
+
 ## Changing options on fly
 
 You can get or set these values on fly. Like:
@@ -170,7 +191,9 @@ s.find(name: "some name",
        return_locator: false,
        collection: false,
        tolerance: nil,
-       no_fail: nil)
+       no_fail: nil,
+       trusted: [],
+       untrusted: [])
 ```
 ### name
 
@@ -219,7 +242,7 @@ vars = {tag: random_tag} # The tag
 vars = {attribute_name: random_attr} # If attribute is dynamic (use name of the attribute)
 # And two lines work with visual_search == true only
 vars = {css_option: random_value} # If your css is dynamic
-vars = {x: random_x} # x, y, width, height for element size and position
+vars = {x: random_x} # x, y for element position
 ```
 
 And if you do not like it you can do:
@@ -257,6 +280,10 @@ It is disabling attempts to find element by advanced algorithms. If locator is p
 
 no_fail option that will work for that search only.
 
+### trusted//untrusted
+
+You can set trusted elements just for search
+
 ## Scope
 
 If you want to define a whole bunch of elements at once you can do:
@@ -347,3 +374,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.rb

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

data/lib/locatine/app/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "Locatine app",
-  "version": "0.02058",
+  "version": "0.02539",
   "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/data_generate.rb

@@ -5,53 +5,36 @@ module Locatine
     module DataGenerate
       private
 
-      def real_text_of(element)
-        element.text == element.inner_html ? element.text : ''
-      end
-
       def mesure(element)
         xy = element.location
         wh = element.size
         return xy.x, xy.y, wh.width, wh.height
       end
 
-      def get_dynamic_tag(element, vars)
-        tag = element.tag_name
-        tag = "\#{tag}" if vars[:tag] == tag
+      def get_dynamic_tag(tag, vars)
+        tag = "\#{tag}" if vars[:tag].to_s.casecmp(tag).zero?
         push_hash('tag', tag, 'tag')
       end
 
-      def get_dynamic_text(element, vars)
-        attrs = []
-        real_text_of(element).split(/['" ]/).each do |word|
+      def text_array(text)
+        text.to_s.tr("\n", ' ').split(/['" ]/)
+      end
+
+      def get_dynamic_text(text, vars)
+        attrs = text_array(text).map do |word|
           final = if !vars[:text].to_s.strip.empty?
                     word.gsub(vars[:text].to_s, "\#{text}")
                   else
                     word
                   end
-          attrs.push push_hash('text', final, 'text') unless final.empty?
+          push_hash('text', final, 'text') unless final.empty?
         end
-        attrs
-      end
-
-      def process_dimension(name, value, vars)
-        s_name = name.to_s
-        value = value.to_s.gsub(vars[name], "\#{#{s_name}}") if vars[name]
-        value
+        attrs.compact
       end
 
-      def processed_dimensions(element, vars)
-        x, y, width, height = mesure(element)
-        x = process_dimension(:x, x, vars)
-        y = process_dimension(:y, y, vars)
-        width = process_dimension(:width, width, vars)
-        height = process_dimension(:height, height, vars)
-        return x, y, width, height
-      end
-
-      def get_dimensions(element, vars)
+      def get_dimensions(element)
         resolution = window_size
-        x, y, w, h = processed_dimensions(element, vars)
+        x, y, w, h = mesure(element)
         push_hash(resolution, "#{x}*#{y}*#{w}*#{h}", 'dimensions')
       end
 
@@ -79,22 +62,6 @@ module Locatine
         end
         attrs
       end
-
-      ##
-      # Collecting attributes of the element
-      def get_attributes(element)
-        attributes = element.attributes
-        array = []
-        attributes.each_pair do |name, value|
-          next if name.to_s == 'locatineclass' # Should never happen
-
-          value.split(/['" ]/).reject(&:empty?).uniq.each do |part|
-            array.push('name' => name.to_s, 'type' => 'attribute',
-                       'value' => part)
-          end
-        end
-        array
-      end
     end
   end
 end