marta 0.37396 → 0.41245

data/lib/marta/public_methods.rb

@@ -6,7 +6,6 @@ module Marta
 
     include OptionsAndPaths
 
-
     #
     # User can create pageobject class using SmartPage.new
     #
@@ -44,10 +43,12 @@ module Marta
       method_name = correct_name(name)
       exact_name = method_name.to_s + "_exact"
       data = user_method_dialogs(method_name)
-      define_singleton_method method_name.to_sym do |meth_content=@data['meths'][method_name]|
-        marta_magic_finder(meth_content)
+      define_singleton_method method_name.
+                         to_sym do |meth_content=@data['meths'][method_name]|
+        marta_magic_finder(meth_content, method_name)
       end
-      define_singleton_method exact_name.to_sym do |meth_content=@data['meths'][method_name]|
+      define_singleton_method exact_name.
+                         to_sym do |meth_content=@data['meths'][method_name]|
         marta_simple_finder(meth_content)
       end
       public_send name.to_sym

data/lib/marta/read_write.rb

@@ -1,9 +1,12 @@
 require 'marta/options_and_paths'
+require 'marta/element_information'
 module Marta
 
   # Marta has very simple read\write actions
   module ReadWrite
 
+    include ElementInformation
+
     private
 
     #
@@ -11,7 +14,7 @@ module Marta
     #
     # @note It is believed that no user will use it
     class ReaderWriter
-      include OptionsAndPaths
+      include OptionsAndPaths, ElementInformation
       # Marta is writing to jsons from time to time
       def self.file_write(name, data)
         file_name = File.join(SettingMaster.pageobjects_folder, name + '.json')
@@ -27,10 +30,56 @@ module Marta
         begin
           file = File.read(json)
           data = JSON.parse(file)
+          # If there are methods
+          if data['meths'] != {}
+            # If there are old methods
+            if !data['meths'].first[1]['options']['self'].nil? or !data['meths'].first[1]['options']['not_self'].nil?
+              data = treat_old_version(data)
+              File.open(json,"w") do |f|
+                f.write(JSON.pretty_generate(data))
+              end
+            end
+          end
+          return data
         rescue
           nil
         end
       end
+
+      def self.treat_old_version(data)
+        result, result['meths'] = Hash.new, Hash.new
+        result['vars'] = data['vars']
+        # Taking all methods one by one
+        data['meths'].each_pair do |method, method_content|
+          result['meths'][method] = ElementHelper.method_structure
+          result['meths'][method]['options']['collection'] = method_content['options'].to_h['collection']
+          ['self','pappy','granny'].each do |level|
+            if !method_content['options'].to_h[level].nil?
+              result['meths'][method]['positive'][level]['tag'] = [method_content['options'][level]] - ['*']
+            end
+            if !method_content[level].to_h['retrieved_by_marta_text'].nil?
+              result['meths'][method]['positive'][level]['text'] = [method_content[level]['retrieved_by_marta_text']]
+            end
+            method_content[level].to_h.each_pair do |name, value|
+              if name != "retrieved_by_marta_text"
+                result['meths'][method]['positive'][level]['attributes'][name] = value.class == String ? value.split(' ').uniq : value
+              end
+            end
+            if !method_content['options'].to_h["not_#{level}"].nil?
+              result['meths'][method]['negative'][level]['tag'] = [method_content['options']["not_#{level}"]] - ['*']
+            end
+            if !method_content["not_#{level}"].to_h['retrieved_by_marta_text'].nil?
+              result['meths'][method]['negative'][level]['text'] = [method_content["not_#{level}"]['retrieved_by_marta_text']]
+            end
+            method_content["not_#{level}"].to_h.each_pair do |name, value|
+              if name != "retrieved_by_marta_text"
+                result['meths'][method]['negative'][level]['attributes'][name] = value.class == String ? value.split(' ').uniq : value
+              end
+            end
+          end
+        end
+        result
+      end
     end
 
     def file_write(name, data)

data/lib/marta/server.rb

@@ -67,18 +67,6 @@ module Marta
       end
     end
 
-    #
-    # Test servlet. For example
-    #
-    # @note It is believed that no user will use it
-    class TestServlet < WEBrick::HTTPServlet::AbstractServlet
-      def do_GET (request, response)
-        response.status = 200
-        response.content_type = "text/html"
-        response.body = File.read(gem_libdir + "/data/test.html")
-      end
-    end
-
     #
     # Server control and logic is in the class.
     #
@@ -112,7 +100,6 @@ module Marta
                    AccessLog: WEBrick::Log.new(File.open(File::NULL, 'w')))
         the_server.mount "/dialog", DialogServlet
         the_server.mount "/welcome", WelcomeServlet
-        the_server.mount "/test", TestServlet
         the_server.mount_proc('/q') {|req, resp| the_server.shutdown;  exit;}
         the_server.start
       end
@@ -140,11 +127,6 @@ module Marta
         false
       end
 
-      # There is a possibility to get the port of the server outside
-      def current_port
-        @port
-      end
-
       # We are killing the server sometimes
       def server_kill
         # So nasty. But WEBrick knows what to do.

data/lib/marta/simple_element_finder.rb

@@ -72,25 +72,6 @@ module Marta
           subtype_of prefind
         end
       end
-
-      # Sometimes we need to find out what is hidden
-      def find_invisibles
-        result = Array.new
-        all = @engine.elements
-        all.each do |element|
-          if element.exists? and !element.visible?
-            result.push element
-          else
-            x, y = element.wd.location.x + 1, element.wd.location.y + 1
-            element_on_point = @engine.
-                 execute_script "return document.elementFromPoint(#{x}, #{y})"
-            if element_on_point != element
-              result.push element
-            end
-          end
-        end
-        return result
-      end
     end
 
     # We can simply find something

data/lib/marta/version.rb

@@ -1,4 +1,4 @@
 module Marta
-  VERSION = "0.37396"
+  VERSION = "0.41245"
   NAME = "marta"
 end

data/lib/marta/x_path.rb

@@ -31,181 +31,196 @@ module Marta
         @requestor = requestor
       end
 
-      # Getting a part (by data or empty=any)
-      def get_xpaths(todo, what)
-        if todo
-          result = form_array_hash(@meth['options'][what], @meth[what])
-          result = result + form_array_hash(@meth['options']['not_' + what],
-                                              @meth['not_' + what], true)
-          result
-        else
-          [make_hash("//", "//"), make_hash("*", "*")]
+      # We are trying to understand here how much work should we do in order
+      # to generate all possible xpaths variants.
+      #
+      # depth is suggested amount of unstable xpath parts
+      # limit is the maximum amount of xpaths that we want to generate
+      # If we can try all the combinations of xpaths with considering
+      # depth elements unstable withou reaching the limit of tries,
+      # method will return that depth and precreated array_of_hashes
+      # If limit will be reached on creation of all xpaths, method
+      # is returning last acceptable depth and array_of_hashes
+      def analyze(depth, limit)
+        hashes = array_of_hashes
+        count = 1
+        real_depth = 0
+        variativity = 0
+        hashes.each do |hash|
+          variativity += (hash[:empty] - hash[:full]).count
         end
-      end
-
-      # Creating the granny part of xpath
-      def create_granny
-        # We are suggesting that granny is not a very first element
-        result = get_xpaths(@granny, 'granny')
-        result[0] = make_hash("//", "//")
-        result
-      end
-
-      # Creating the pappy part of xpath
-      def create_pappy
-        get_xpaths(@pappy, 'pappy')
-      end
-
-      # Creating self part of xpath
-      def create_self
-        get_xpaths(true, 'self')
-      end
-
-      # Full array of hashes to transform into xpath
-      def create_xpath
-        result_array = Array.new
-        result_array = create_granny + create_pappy + create_self
-      end
-
-      # Creating hash arrays from base array
-      def form_variants(depth)
-        work_array = [create_xpath]
         depth.times do
-          temp_array = Array.new
-          work_array.each do |one_array|
-            temp_array = temp_array + form_xpaths_from_array(one_array)
+          count = count * variativity
+          if count < limit
+            real_depth += 1
           end
-          work_array = (work_array + temp_array).uniq
         end
-        work_array
+        return real_depth, hashes
       end
 
-      #
-      # Creating an array of xpaths
-      #
-      # When depth is 1 we will create out of xpath = //DIV/SPAN/INPUT
-      # variants = //*/SPAN/INPUT, //DIV//SPAN/INPUT, //DIV/*/INPUT,
-      # //DIV/SPAN//INPUT, //DIV/SPAN/* and //DIV/SPAN/INPUT as well
-      def generate_xpaths(depth)
-        result_array = Array.new
-        form_variants(depth).each do |variant|
-          xpaths = [""]
-          variant.each do |part|
-            xpaths = tree_push(xpaths, part[:full])
+      # Generating not more than limit random xpaths variants considering
+      # that depth parts of xpath are unstable
+      def monte_carlo(hashes, depth, limit)
+        xpaths = Array.new
+        while xpaths.count < limit do
+          mask = Array.new hashes.count, :full
+          depth.times do
+            mask[rand(mask.count)] = :empty
           end
-          result_array += xpaths
+          final_array = Array.new
+          hashes.each_with_index do |hash, index|
+            final_array.push(hash[mask[index]].sample)
+          end
+          xpaths.push final_array.join
+          xpaths
         end
-        result_array
+        xpaths
       end
 
-      # Sometimes we need to double number of variants since there
-      # are more than one option to try
-      def tree_push(main, what)
+      # We are generating masks like [:empty,:full,:full,:empty]
+      # They are used for more understandable logic of looping xpaths variants
+      # In fact they are lists with all the combinations of
+      # switches :full\:empty. Where the length of switches is the same as
+      # length of xpath parts. And amount of :empty switches is depth
+      def get_masks(masks, depth)
         result = Array.new
-        what.each do |part|
-          main.each do |host_item|
-            result.push(process_string(host_item + part, @requestor))
+        masks.each do |mask|
+          result.push mask
+          for i in 0..mask.count-1
+            result.push(mask.map { |e| e.dup })
+            result.last[i] = :empty
           end
         end
-        result
-      end
-
-      # Special method to get the single xpath only. Without unknowns
-      def generate_xpath
-        generate_xpaths(0).join
+        if depth-1 == 0
+          result
+        else
+          get_masks(result, depth-1)
+        end
       end
 
-      # Getting array of hashes from the raw data
-      def form_xpaths_from_array(array)
-        result_array = Array.new
-        array.each_with_index do |item, index|
-          temp_array = Array.new
-          array.each_with_index do |item2, index2|
-            if index == index2
-              temp_array.push make_hash(item2[:empty],item2[:empty])
+      # We are forming xpath strings by masks and hashes with data
+      def xpaths_by_mask(mask, hashes)
+        xpaths = Array.new
+        final_array = [[]]
+        hashes.each_with_index do |hash, index|
+          hash[mask[index]].each_with_index do |hash_value, empty_index|
+            if empty_index == 0
+              final_array.each do |final_array_item|
+                final_array_item.push(hash_value)
+              end
             else
-              temp_array.push make_hash(item2[:full],item2[:empty])
+              alternative_final_array = []
+              final_array.each do |final_array_item|
+                alternative_final_array.push final_array_item.dup
+              end
+              alternative_final_array.each do |a_final_array_item|
+                a_final_array_item[-1] = hash_value
+              end
+              final_array = final_array + alternative_final_array
             end
           end
-          result_array = result_array.push temp_array
         end
-        result_array
+        final_array.each do |final_array_item|
+          xpaths.push final_array_item.join
+        end
+        xpaths
+      end
+
+      # Full logic of xpath generating
+      # We are understanding can we find all the possible xpath variations
+      # We are creating all possible masks (arrays of switches) one by one
+      # If we know that we cannot find all variants we are generating some
+      # by more random algorithm
+      def generate_xpaths(depth, limit = 100000)
+        xpaths = Array.new
+        real_depth, hashes = analyze(depth, limit)
+        masks = get_masks([Array.new(hashes.count, :full)], real_depth)
+        masks.each do |mask|
+          xpaths = xpaths + xpaths_by_mask(mask, hashes)
+        end
+        if real_depth != depth
+          xpaths = xpaths + monte_carlo(hashes, depth, limit)
+        end
+        xpaths.uniq.map {|xpath| process_string(xpath, @requestor)}
       end
 
-      # Creating a small part of array hash for tag
-      def form_array_hash_for_tag(tag, negative)
-        result_array = Array.new
-        if negative
-          if !tag.nil? and tag != ""
-            result_array.push make_hash("[not(self::#{tag})]", "")
-          end
-        else
-          result_array.push make_hash("/", "//")
-          result_array.push make_hash(tag, "*")
+      # We can generate straight xpath by all known data
+      def generate_xpath
+        result = ''
+        array_of_hashes.each do |hash|
+          result = result + hash[:full][0]
         end
-        result_array
+        process_string result, @requestor
       end
 
-      # Creating an array hash
-      def form_array_hash(tag, attrs, negative = false)
-        result_array = form_array_hash_for_tag(tag, negative)
-        if !attrs.nil?
-          attrs.each_pair do |attribute, value|
-            if attribute.include?('class')
-              result_array = result_array +
-                        form_array_hash_for_class(attribute, value, negative)
-            else
-              if !value.nil? and value != ""
-                result_array.push form_hash_for_attribute(attribute,
-                                                          value,
-                                                          negative)
-              end
+      # We are parsing positive part of element data to array of hashes
+      def positive_part_of_array_of_hashes(what)
+        result = Array.new
+        result.push make_hash(@meth['positive'][what]['tag'] != [] ? @meth['positive'][what]['tag'][0] : '*', '*')
+        if (@meth['positive'][what]['text'] != []) and (@meth['positive'][what]['text'] != [''])
+          result.push make_hash("[contains(text(),'#{@meth['positive'][what]['text'][0]}')]")
+        end
+        @meth['positive'][what]['attributes'].each_pair do |attribute, values|
+          if (values != []) and (values != ['']) and !values.nil?
+            values.each do |value|
+              result.push make_hash("[contains(@#{attribute},'#{value}')]",
+                                    ["[@*[contains(.,'#{value}')]]", ""])
             end
           end
         end
-        result_array
+        result
       end
 
-      # Creating a small part of array hash for attribute
-      def form_hash_for_attribute(attribute, value, negative)
-        not_start, not_end = get_nots_frames(negative)
-        if (attribute == 'retrieved_by_marta_text')
-          make_hash("[#{not_start}contains(text(),'#{value}')#{not_end}]", [""])
-        else
-          make_hash("[#{not_start}@#{attribute}='#{value}'#{not_end}]", ["",
-                     "[#{not_start}@*='#{value}'#{not_end}]"])
+      # We are parsing negative part of element data to array of hashes
+      def negative_part_of_array_of_hashes(what)
+        result = Array.new
+        @meth['negative'][what]['tag'].each do |not_tag|
+          result.push make_hash("[not(self::#{not_tag})]", '')
         end
-      end
-
-      def get_nots_frames (negative)
-        return negative ? ["not(", ")"] : ["", ""]
-      end
-
-      # Creating a small part of array hash for attribute contains 'class'
-      def form_array_hash_for_class(attribute, value, negative)
-        result_array = Array.new
-        not_start, not_end = get_nots_frames(negative)
-        value.each do |value_part|
-          if value_part.gsub(' ','') != ''
-            result_array.
-              push make_hash("[#{not_start}contains(@#{attribute},"\
-                             "'#{value_part}')#{not_end}]", ["",
-                             "[#{not_start}@*[contains"\
-                             "(.,'#{value_part}')]#{not_end}]"])
+        @meth['negative'][what]['text'].each do |not_text|
+          result.push make_hash("[not(contains(text(),'#{not_text}'))]", '')
+        end
+        @meth['negative'][what]['attributes'].each_pair do |attribute, values|
+          if (values != []) and (values != ['']) and !values.nil?
+            values.each do |value|
+              result.push make_hash("[not(contains(@#{attribute},'#{value}'))]")
+            end
           end
         end
-        result_array
+        result
       end
 
-      # Creating the smallest possible part of array hash
-      def make_hash(full, empty)
-        if empty.class != Array
-          empty = [empty]
+      # We are parsing stored element data (tag, text and attributes)
+      # into the array of hashes
+      #
+      # Output looks like:
+      # [{full:["//"],empty["//"]},
+      # {full:["H1"],empty["*"]},
+      # {full:["[@id='x']"],empty["", "[@*[contains(.,'x')]]"]}]
+      def array_of_hashes
+        result = Array.new
+        result.push make_hash('//', '//')
+        if @granny
+          result = result +
+                   positive_part_of_array_of_hashes('granny') +
+                   negative_part_of_array_of_hashes('granny')
+          result.push make_hash('/', '//')
         end
-        if full.class != Array
-          full = [full]
+        if @pappy
+          result = result +
+                   positive_part_of_array_of_hashes('pappy') +
+                   negative_part_of_array_of_hashes('pappy')
+          result.push make_hash('/', '//')
         end
-        {full: full, empty: empty}
+        result = result +
+                 positive_part_of_array_of_hashes('self') +
+                 negative_part_of_array_of_hashes('self')
+        result
+      end
+
+      # Creating the smallest possible part of array hash
+      def make_hash(full, empty = '')
+        {full: [full], empty: empty.class != Array ? [empty] : empty}
       end
     end
   end