locatine 0.02637 → 0.03050

data/lib/locatine/for_search/find_by_locator.rb

@@ -1,59 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Methods related to the most simple search by ready locator.
-    module FindByLocator
-      private
-
-      def collection?(the_class)
-        case the_class.superclass.to_s
-        when 'Watir::Element'
-          false
-        when 'Watir::ElementCollection'
-          true
-        else
-          collection?(the_class.superclass)
-        end
-      end
-
-      ##
-      # Getting all the elements matching a locator
-      def find_by_locator(locator)
-        method = @type.nil? ? :elements : @type
-        begin
-          engine.element(locator).wait_until(timeout: @cold_time, &:exists?)
-        rescue StandardError
-          return nil
-        end
-        results = engine.send(method, locator)
-        return correct_method_detected(results) if collection?(results.class)
-
-        acceptable_method_detected(results, method, locator)
-      end
-
-      def correct_method_detected(results)
-        return nil if results.empty?
-
-        all = results.reject(&:stale?)
-        return all unless all.empty?
-
-        nil
-      end
-
-      def acceptable_method_detected(results, method, locator)
-        warn_acceptable_type(method)
-        the_class = results.class
-        results = engine.elements(locator)
-                        .to_a
-                        .select { |item| item.to_subtype.class == the_class }
-        correct_method_detected(results)
-      end
-
-      ##
-      # Getting all the elements via stored information
-      def find_by_data(data, vars)
-        find_by_locator(xpath: generate_xpath(data, vars))
-      end
-    end
-  end
-end

data/lib/locatine/for_search/find_by_magic.rb

@@ -1,65 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Logic for finding lost element
-    module FindByMagic
-      private
-
-      ##
-      # Getting all the elements via black magic
-      def find_by_magic(name, scope, data, vars, iteration = 0)
-        html = take_html
-        page = take_dom
-        suggested = magic_elements(name, scope, data, vars, page)
-        warn_unstable if page_changed?(page, html)
-        if html != take_html && iteration < 5
-          return find_by_magic(name, scope, data, vars, iteration + 1)
-        end
-
-        warn_highly_unstable if iteration == 5
-        suggest_by_all(suggested, data, vars, name, scope)
-      end
-
-      def page_changed?(page, html)
-        html != take_html || page != take_dom
-      end
-
-      ##
-      # We are taking every element that look at least a bit similar to one we
-      # are looking for
-      def magic_elements(name, scope, data, vars, page)
-        warn_element_lost(name, scope, data, vars)
-        all = select_from_page(page, data, vars)
-        raise_not_found(name, scope) if all.empty? && !@current_no_f
-        suggested = most_common_of(all).map do |element|
-          engine.elements(tag_name: element['tag'])[element['index'].to_i]
-        end
-        suggested
-      end
-
-      def similar_enough(data, attributes)
-        same = same_entries(data['0'], attributes, '0').length
-        all = data['0'].length
-        sameness = (same * 100) / all
-        sameness >= 100 - @current_t
-      end
-
-      def final_of_all(suggest, vars)
-        attributes = generate_data(suggest, vars) unless suggest.empty?
-        return suggest, attributes
-      end
-
-      def suggest_by_all(all, data, vars, name, scope)
-        suggest, attributes = final_of_all(all, vars)
-        ok = similar_enough(data, attributes) unless suggest.empty?
-        raise_not_similar(name, scope) if !ok && !@current_no_f
-        if ok
-          warn_lost_found(name, scope, attributes, vars)
-          return suggest, attributes
-        end
-        warn_not_found(name, scope)
-        return nil, nil
-      end
-    end
-  end
-end

data/lib/locatine/for_search/find_logic.rb

@@ -1,79 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Methods explaining find logic
-    module FindLogic
-      private
-
-      def set_name(simple_name, name)
-        name ||= simple_name
-        raise_no_name unless name
-        name
-      end
-
-      def data_search(name, scope, vars, exact)
-        result = find_by_data(@data[scope][name], vars)
-        attributes = generate_data(result, vars) if result
-        if !result && !exact
-          @autolearn = true if @autolearn.nil?
-          @save = true
-          result, attributes = find_by_magic(name, scope,
-                                             @data[scope][name], vars)
-        end
-        return result, attributes
-      end
-
-      def core_search(name, scope, vars, exact)
-        if @data[scope][name].to_h != {}
-          result, attributes = data_search(name, scope, vars, exact)
-        end
-        return result, attributes
-      end
-
-      def full_search(name, scope, vars, locator, exact)
-        @save = @autolearn
-        result, attributes = search_steps(name, scope, vars, locator, exact)
-        raise_not_found(name, scope) if !result && !@current_no_f
-        store(attributes, scope, name) if result && (@save || @learn)
-        return result, attributes
-      end
-
-      def search_steps(name, scope, vars, locator, exact)
-        result, attributes = locator_search(locator, vars)
-        ok = result || ((locator != {}) && exact)
-        result, attributes = core_search(name, scope, vars, exact) unless ok
-        if @learn
-          answer = ask(scope, name, result, vars)
-          result = answer[:element]
-          attributes = answer[:attributes]
-        end
-        return result, attributes
-      end
-
-      def locator_search(locator, vars)
-        result = find_by_locator(locator) unless locator == {}
-        attributes = generate_data(result, vars) if result
-        warn_broken_locator(locator) if locator.to_h != {} && !result
-        return result, attributes
-      end
-
-      ##
-      # Returning subtype of the only element of collection OR collection
-      #
-      # Params:
-      # +result+ must be Watir::HTMLElementCollection or Array
-      #
-      # +collection+ nil, true or false
-      def to_subtype(result, collection)
-        result = result.to_a
-        to_return = result.map(&:to_subtype)
-        case collection
-        when true
-          to_return
-        when false
-          to_return.first
-        end
-      end
-    end
-  end
-end

data/lib/locatine/for_search/helpers.rb

@@ -1,106 +0,0 @@
-module Locatine
-  module ForSearch
-    ##
-    # Different methods to make life easier
-    module Helpers
-      private
-
-      def enforce(inject, *args)
-        inject = args.last.merge(inject) if args.last.class == Hash
-        ok = (args.first.class == String) && inject[:name].nil?
-        inject[:name] = args.first if ok
-        find(inject)
-      end
-
-      def engine
-        (@iframe || @browser)
-      end
-
-      def take_html
-        engine.locate
-        engine.html.gsub(/<div.*id="locatine_magic_div".*>/, '')
-      end
-
-      def time
-        t = Time.now
-        t.strftime('%F %T')
-      end
-
-      def fix_iframe
-        @iframe = @browser.iframe(@iframe.selector) if @iframe && @iframe.stale?
-      end
-
-      def set_env_for_search(look_in,
-                             iframe,
-                             tolerance,
-                             no_fail,
-                             trusted,
-                             untrusted)
-        @type = look_in
-        @iframe = iframe
-        @current_t = tolerance || @tolerance
-        @current_no_f = no_fail || @no_fail
-        @trust_now = trusted || @trusted
-        @untrust_now = untrusted || @untrusted
-      end
-
-      def not_magic_div
-        "[not(@id = 'locatine_magic_div')]"
-      end
-
-      def push_hash(name, value, type)
-        { 'name' => name,
-          'value' => value,
-          'type' => type }
-      end
-
-      def window_size
-        b_w = engine.execute_script('return window.innerWidth')
-        b_h = engine.execute_script('return window.innerHeight')
-        "#{b_w}x#{b_h}"
-      end
-
-      def visual?
-        @visual_search
-      end
-
-      def right_browser
-        Watir::Browser.new(:chrome, switches: ["--load-extension=#{HOME}/app"])
-      end
-
-      def css_text_to_hash(text)
-        almost_hash = []
-        array = text[0..-2].split('; ')
-        array.each do |item|
-          almost_hash.push item.split(': ')
-        end
-        almost_hash.to_h
-      end
-
-      def default_styles
-        css =
-          engine.execute_script("const dummy = document.createElement('dummy');
-                                 document.body.appendChild(dummy);
-                                 return getComputedStyle(dummy).cssText;")
-        css_text_to_hash(css)
-      end
-
-      def process_string(str, vars)
-        str = str.to_s
-        thevar = str.match(/\#{([^\#{]*)}/)[1] unless str.match(/\#{(.*)}/).nil?
-        return str unless thevar
-
-        value = vars[thevar.to_sym] || vars[thevar]
-        raise_no_var(thevar) unless value
-        process_string(str.gsub('#{' + thevar + '}', value.to_s), vars)
-      end
-
-      def most_common_of(all)
-        max = all.count(all.max_by { |i| all.count(i) })
-        return (all.select { |i| all.count(i) == max }).uniq unless max.zero?
-
-        []
-      end
-    end
-  end
-end

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', 'set_false', @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