locatine 0.01084 → 0.01100

data/lib/locatine/helpers.rb

@@ -0,0 +1,43 @@
+module Locatine
+  ##
+  # Different methods to make life easier
+  module Helpers
+    private
+
+    def enforce(what, value, *args)
+      if args.last.class == Hash
+        args.last[what] = value
+      else
+        temp = {}
+        temp[what] = value
+        args.push(temp)
+      end
+      find(*args)
+    end
+
+    def engine
+      (@iframe || @browser)
+    end
+
+    def not_magic_div
+      "[not(@id = 'locatine_magic_div')]"
+    end
+
+    def right_browser
+      Watir::Browser.new(:chrome, switches: ["--load-extension=#{HOME}/app"])
+    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]
+      unless value
+        raise ArgumentError, ":#{thevar} must be "\
+          'provided in vars since element was defined with it'
+      end
+      process_string(str.gsub('#{' + thevar + '}', value.to_s), vars)
+    end
+  end
+end

data/lib/locatine/highlight.rb

@@ -0,0 +1,41 @@
+module Locatine
+  ##
+  # Locatine can highlight elements
+  module Highlight
+    private
+
+    ##
+    # We can highlight an element
+    def highlight(element)
+      script = "arguments[0].setAttribute('locatineclass','foundbylocatine')"
+      ok = !element.stale? && element.exists?
+      engine.execute_script(script, element) if ok
+    rescue StandardError
+      warn " something was found as #{element.selector} but we cannot "\
+           'highlight it'
+    end
+
+    ##
+    # We can unhighlight an element
+    def unhighlight(element)
+      script = "arguments[0].removeAttribute('locatineclass')"
+      ok = !element.stale? && element.exists?
+      engine.execute_script(script, element) if ok
+    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)
+      mass.each do |element|
+        if turn_on
+          highlight element
+        else
+          unhighlight element
+        end
+      end
+    end
+  end
+end

data/lib/locatine/merge.rb

@@ -0,0 +1,36 @@
+module Locatine
+  ##
+  # 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|
+        to_add = select_same(second[depth], hash)
+        to_add = stability_bump(to_add, hash) 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

data/lib/locatine/public.rb

@@ -0,0 +1,103 @@
+module Locatine
+  ##
+  # 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+ is the value that 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 to
+    # consider it trusted.
+    #
+    # +scope+ will be used in search (if not provided) defaulkt is "Default"
+    def initialize(json: './Locatine_files/default.json',
+                   depth: 3,
+                   browser: nil,
+                   learn: ENV['LEARN'].nil? ? false : true,
+                   stability_limit: 10,
+                   scope: 'Default')
+      browser ||= right_browser
+      @browser = browser
+      @json = json
+      @folder = File.dirname(@json)
+      @name = File.basename(@json)
+      @depth = depth
+      @data = read_create
+      @learn = learn
+      @stability_limit = stability_limit
+      @scope = scope
+    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
+    def find(simple_name = nil,
+             name: nil,
+             scope: nil,
+             exact: false,
+             locator: {},
+             vars: {},
+             look_in: nil,
+             iframe: nil,
+             return_locator: false,
+             collection: false)
+      name = set_name(simple_name, name)
+      @type = look_in
+      @iframe = iframe
+      scope ||= @scope.nil? ? 'Default' : @scope
+      result, attributes = full_search(name, scope, vars, locator, exact)
+      return { xpath: generate_xpath(attributes, vars) } if result &&
+                                                            return_locator
+      return to_subtype(result, collection) if result && !return_locator
+    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
+  end
+end