locatine 0.02542 → 0.02878

data/lib/locatine/for_search/highlight.rb

@@ -1,41 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Locatine can highlight elements
-    module Highlight
-      private
-
-      ##
-      # We can highlight an element
-      def highlight(element)
-        script = "arguments[0].setAttribute('locatineclass','foundbylocatine')"
-        engine.execute_script(script, element)
-      rescue StandardError
-        warn_cannot_highlight(element.selector)
-      end
-
-      ##
-      # We can unhighlight an element
-      def unhighlight(element)
-        script = "arguments[0].removeAttribute('locatineclass')"
-        engine.execute_script(script, element)
-      rescue StandardError
-        false
-        # watir is not allowing to play with attributes of some elements
-      end
-
-      ##
-      # We can highlight\unhighlight tons of elements at once
-      def mass_highlight_turn(mass, turn_on = true)
-        warn_much_highlight(mass.length) if turn_on && mass.length > 50
-        mass[0..49].each do |element|
-          if turn_on
-            highlight element
-          else
-            unhighlight element
-          end
-        end
-      end
-    end
-  end
-end

data/lib/locatine/for_search/listening.rb

@@ -1,48 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Simple actions about communicating with chrome extension (and user)
-    module Listening
-      private
-
-      ##
-      # Getting attribute of locatine div (way to communicate)
-      def get_from_app(what)
-        fix_iframe
-        result = engine.wd.execute_script(
-          %[if (document.getElementById('locatine_magic_div')) {
-             const magic_div = document.getElementById('locatine_magic_div');
-             return magic_div.getAttribute("#{what}")}]
-        )
-        fix_iframe
-        result
-      end
-
-      ##
-      # Sending request to locatine app
-      def start_listening(scope, name)
-        send_to_app('locatinestyle', 'blocked', @browser) if @iframe
-        send_to_app('locatinestyle', 'set_true')
-        send_to_app('locatineconfirmed', 'ok')
-        send_selecting(name, scope)
-        sleep 0.5
-      end
-
-      def tag_index
-        tag = get_from_app('tag')
-        tag = tag.downcase unless tag.nil?
-        index = get_from_app('index').to_i
-        return tag, index
-      end
-
-      def response_action(element)
-        send_to_app('locatineconfirmed', 'ok')
-        send_has_response
-        mass_highlight_turn(element, false) if element
-        send_to_app('locatinestyle', 'set_false')
-        send_to_app('locatinestyle', 'ok', @browser) if @iframe
-        sleep 1
-      end
-    end
-  end
-end

data/lib/locatine/for_search/merge.rb

@@ -1,40 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Getting commons of two piles of elements data. To find all similar to them
-    module Merge
-      private
-
-      def select_same(where, hash)
-        where.select do |item|
-          (item['name'] == hash['name']) &&
-            (item['value'] == hash['value']) &&
-            (item['type'] == hash['type'])
-        end
-      end
-
-      def same_entries(array, second, depth, stability_up = false)
-        result = []
-        array.each do |hash|
-          item = second[depth]
-          to_add = item.nil? ? [] : select_same(second[depth], hash)
-          max = max_stability(second[depth]).to_i + 1
-          to_add = stability_bump(to_add, hash, max) if stability_up
-          result += to_add
-        end
-        result
-      end
-
-      ##
-      # Merging data of two elements (new data is to find both)
-      def get_commons(first, second)
-        second = first if second == {}
-        final = Hash.new { |hash, key| hash[key] = [] }
-        first.each_pair do |depth, array|
-          final[depth] = same_entries(array, second, depth)
-        end
-        final
-      end
-    end
-  end
-end

data/lib/locatine/for_search/name_helper.rb

@@ -1,51 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # We have a module that helps name elements
-    module NameHelper
-      private
-
-      def good_name(main, vars)
-        good = %w[name title id role text]
-        tmp = main.select { |i| good.any? { |k| i['name'].include?(k) } }
-        words = (tmp.map { |i| process_string(i['value'], vars) }).uniq
-        words.sample
-      end
-
-      def so_so_name(main, vars)
-        all = main.select { |i| i['type'] == 'attribute' }
-        words = all.map { |i| process_string(i['value'], vars) }
-        words.sample
-      end
-
-      def some_name(main, vars)
-        result = good_name(main, vars)
-        result = so_so_name(main, vars) if result.nil?
-        result = "undescribed #{generate_word}" if result.nil?
-        result
-      end
-
-      def suggest_name(name, attrs, vars)
-        if name.to_s.empty?
-          tag = attrs['0'].select { |i| i['type'] == 'tag' }
-          tag = process_string(tag[0]['value'], vars)
-          name = "#{some_name(attrs['0'], vars)} #{tag}"
-        end
-        suggest = name
-        send_to_app('locatine_name', suggest)
-        send_to_app('locatine_name_mark', 'true')
-        suggest
-      end
-
-      def generate_word(pairs = 3)
-        ss = 'qwrtpsdfghjklzxcvbnm'.split('')
-        sa = 'eyuioa'.split('')
-        str = ''
-        pairs.times do
-          str += ss.sample + sa.sample
-        end
-        str
-      end
-    end
-  end
-end

data/lib/locatine/for_search/page_work.rb

@@ -1,126 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Methods about getting full information about opened page>
-    # And methods for stalkibg around the page in oreder to find something.
-    module PageWork
-      private
-
-      def matcher
-        { 'tag' => ->(data) { take_by_tag(*data) },
-          'text' => ->(data) { take_by_text(*data) },
-          'attribute' => ->(data) { take_by_attribute(*data) },
-          'css' => ->(data) { take_by_css(*data) } }
-      end
-
-      def take_dom
-        script = File.read("#{HOME}/large_scripts/page.js")
-        engine.execute_script(script)
-      end
-
-      def select_from_page(page, data, vars)
-        all = [] # No result is a valid result too
-        data.each_pair do |depth, array|
-          get_trusted(array).each do |hash|
-            all += catch(page, hash, vars, depth)
-          end
-        end
-        all
-      end
-
-      def catch(page, hash, vars, depth)
-        all = []
-        hash['value'] = process_string(hash['value'], vars)
-        page.each do |element|
-          all += take_match(element, depth, hash, vars)
-          all += catch(element['children'], hash, vars, depth)
-        end
-        all.uniq
-      end
-
-      def take_match(element, depth, hash, vars)
-        if hash['type'] == 'dimensions'
-          return take_by_dimensions(hash, element, depth, vars)
-        end
-
-        matcher.fetch(hash['type']).call([hash, element, depth])
-      end
-
-      def take_by_tag(hash, elt, depth)
-        return kids([elt], depth) if elt['tag'].downcase.include?(hash['value'])
-
-        []
-      end
-
-      def take_by_text(hash, elt, depth)
-        return kids([elt], depth) if elt['text'].include?(hash['value'])
-
-        []
-      end
-
-      def take_attribute_check(hash, elt)
-        if !hash['name'].to_s.empty? && !hash['value'].to_s.empty?
-          return elt['attrs'][hash['name']].to_s
-        end
-
-        elt['attrs'].to_s
-      end
-
-      def take_by_attribute(hash, elt, depth)
-        str = hash['value'].to_s.empty? ? hash['name'].to_s : hash['value'].to_s
-        ok = take_attribute_check(hash, elt).include?(str)
-        return kids([elt], depth) if ok
-
-        []
-      end
-
-      def dimensions_for_search(hash, vars)
-        values = hash['value'].split('*').map(&:to_i)
-        values[0] = vars[:x].to_i if vars[:x]
-        values[1] = vars[:y].to_i if vars[:y]
-        values
-      end
-
-      def dimensions_from_page(elt)
-        [elt['coordinates']['top'].to_i, elt['coordinates']['bottom'].to_i,
-         elt['coordinates']['left'].to_i, elt['coordinates']['right'].to_i]
-      end
-
-      def take_by_dimensions(hash, elt, depth, vars)
-        return [] if !visual? || hash['name'] != window_size
-
-        return kids([elt], depth) if in_recatngle?(hash, elt, vars)
-
-        []
-      end
-
-      def in_recatngle?(hash, elt, vars)
-        cleft, ctop, cwidth, cheight = dimensions_for_search(hash, vars)
-        top, bottom, left, right = dimensions_from_page(elt)
-        (cleft >= left) && (cleft + cwidth <= right) &&
-          (ctop >= top) && (ctop + cheight <= bottom)
-      end
-
-      def take_by_css(hash, elt, depth)
-        return [] unless visual?
-
-        string = "#{hash['name']}: #{hash['value']}"
-        return kids([elt], depth) if elt['style'].include?(string)
-
-        []
-      end
-
-      # If depth != 0 we should return all children subchildren.
-      def kids(array, depth)
-        answer = []
-        return array if depth.to_i.zero?
-
-        array.each do |one|
-          answer += one['children']
-          answer += kids(one['children'], depth)
-        end
-        answer
-      end
-    end
-  end
-end

data/lib/locatine/for_search/public.rb

@@ -1,179 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Public methods of the Search class
-    module Public
-      ##
-      # Creates a new instance of Search
-      #
-      # Params:
-      #
-      # +json+ is the name of file to store//read data. Default =>
-      # "./Locatine_files/default.json"
-      #
-      # +depth+ shows how many data will be stored for element.
-      #
-      # +browser+ is the instance of Watir::Browser. Unless provided it gonna
-      # be created with locatine-app onboard.
-      #
-      # +learn+ shows will locatine ask for assistance from user or will fail
-      # on error. learn is true when LEARN parameter is set in environment.
-      #
-      # +stability_limit+ shows max times attribute should be present and
-      # checked to consider it trusted.
-      #
-      # +scope+ will be used in search (if not provided) defaulkt is "Default"
-      #
-      # +tolerance+ Shows how similar must be an element found as alternative
-      # 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
-      #
-      # +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.
-      #
-      # +autolearn+ determines will locatine study an element or not. true means
-      # locatine will always study it (slow). false means it won't study it
-      # unless it was lost and found. If not stated locatine will turn set it
-      # true if at least one element was lost.
-      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
-
-      ##
-      # Looking for the element
-      #
-      # Params:
-      #
-      # +scope+ is a parameter that is used to get information about the
-      # element from @data. Default is "Default"
-      #
-      # +name+ is a parameter that is used to get information about the
-      # element from @data. Must not be nil.
-      #
-      # +exact+ if true locatine will be forced to use only basic search.
-      # Default is false
-      #
-      # +locator+ if not empty it is used for the first attempt to find the
-      # element. Default is {}
-      #
-      # +vars+ hash of variables that will be used for dynamic attributes.
-      # See readme for example
-      #
-      # +look_in+ only elements of that kind will be used. Use Watir::Browser
-      # methods returning collections (:text_fields, :links, :divs, etc.)
-      #
-      # +iframe+ if provided locatine will look for elements inside of it
-      #
-      # +return_locator+ is to return a valid locator of the result
-      #
-      # +collection+ when true an array will be returned. When false - a
-      # single element
-      #
-      # +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,
-               exact: false,
-               locator: {},
-               vars: {},
-               look_in: nil,
-               iframe: nil,
-               return_locator: false,
-               collection: false,
-               tolerance: nil,
-               no_fail: nil,
-               trusted: nil,
-               untrusted: nil)
-        name = set_name(simple_name, name)
-        set_env_for_search(look_in, iframe, tolerance,
-                           no_fail, trusted, untrusted)
-        scope ||= @scope.nil? ? 'Default' : @scope
-        result, attributes = full_search(name, scope, vars, locator, exact)
-        return { xpath: generate_xpath(attributes, vars) } if result &&
-                                                              return_locator
-
-        to_subtype(result, collection)
-      end
-
-      ##
-      # Find alias with return_locator option enforced
-      def lctr(*args)
-        enforce({ return_locator: true }, *args)
-      end
-
-      ##
-      # Find alias with collection option enforced
-      def collect(*args)
-        enforce({ collection: true }, *args)
-      end
-
-      def json=(value)
-        import_file(value)
-      end
-
-      def browser=(value)
-        import_browser(value)
-      end
-
-      ##
-      # Returns an instance of the Scope class. Starts define if learn == true
-      #
-      # Params:
-      #
-      # +name+ is a parameter that stores name of the scope.
-      # Default is "Default"
-      #
-      # +vars+ is a hash which will be used to generate dynamic attributes.
-      # See readme for explanation.
-      def get_scope(name: 'Default', vars: {})
-        answer = Scope.new(name, self)
-        answer.define(vars) if @learn
-        answer
-      end
-
-      ##
-      # Find alias with zero tolerance option enforced
-      def check(*args)
-        enforce({ tolerance: 0 }, *args)
-      end
-
-      ##
-      # Collection alias with zero tolerance option enforced
-      def check_collection(*args)
-        enforce({ tolerance: 0, collection: true }, *args)
-      end
-
-      ##
-      # Collection alias with exact option on
-      def exact_collection(*args)
-        enforce({ exact: true, collection: true }, *args)
-      end
-
-      ##
-      # Find alias with exact option on
-      def exact(*args)
-        enforce({ exact: true }, *args)
-      end
-    end
-  end
-end