marta 0.26150

data/lib/marta/dialogs.rb

@@ -0,0 +1,124 @@
+require 'marta/simple_element_finder'
+require 'marta/x_path'
+require 'marta/lightning'
+require 'marta/injector'
+require 'marta/public_methods'
+module Marta
+
+  #
+  # All many-steps dialogs should be here
+  #
+  # There is at least one situation when getting info from user is not so simple
+  # We need dialogs for cases like that. Now there is only dialog about method
+  module Dialogs
+
+    private
+
+    #
+    # Dialog operator class
+    #
+    # @note It is believed that no user will use it
+    class MethodSpeaker
+
+      include XPath, Lightning, Injector, PublicMethods
+
+      def initialize(class_name, method_name, data, requestor)
+        @class_name = class_name
+        @method_name = method_name
+        @data = data
+        @title = class_name+  '.' + method_name.to_s
+        @requestor = requestor
+      end
+
+      # Standart question
+      def ask(what, title = 'Some title', data = Hash.new)
+        inject(what, title, data)
+      end
+
+      # Main method. All the dialog logic is here
+      def dialog
+        while !finished? do
+          @attrs = ask_for_elements
+          @mass = get_elements_by_attrs
+          @styles = mass_highlight_turn @mass
+          @result = ask_confirmation
+          mass_highlight_turn(@mass, false, @styles)
+        end
+        if @result == '1'
+          standart_meth_merge
+        else
+          xpath_meth_merge
+        end
+      end
+
+      # Asking: "What are you looking for?"
+      def ask_for_elements
+        ask 'element', @title, @data['meths'][@method_name]
+      end
+
+      # Creating data to save when it is a basically defined element
+      def standart_meth_merge
+        temp = temp_hash
+        temp['meths'][@method_name] = @attrs
+        @data['meths'].merge!(temp['meths'])
+        @data
+      end
+
+      # Creating data to save when user suggests a custom xpath
+      def xpath_meth_merge
+        temp = temp_hash
+        temp['meths'][@method_name]['options'] = @result
+        @data['meths'].merge!(temp['meths'])
+        @data
+      end
+
+      # Finding out what was selected
+      def get_elements_by_attrs
+        xpath = XPathFactory.new(@attrs, @requestor).generate_xpath
+        engine.elements(xpath: xpath)
+      end
+
+      # Asking: "Are you sure?"
+      def ask_confirmation
+        ask 'element-confirm', @title, @mass.length.to_s
+      end
+
+      # Asking: "Provide your xpath"
+      def ask_xpath
+        ask 'custom-xpath', @title
+      end
+
+      #
+      # Is dialog finished?
+      #
+      # JS returning '1' when it's done. That is not good
+      # and should be rewrited as soon as possible
+      def finished?
+        if @result == '1'
+          true
+        elsif @result == '3'
+          @result = ask_xpath
+          (@result != '2') ? true : false
+        else
+          false
+        end
+      end
+
+      # Forming of an empty hash for storing element info
+      def temp_hash
+        temp, temp['meths'], temp['meths'][@method_name],
+        temp['meths'][@method_name]['options'] = Hash.new, Hash.new, Hash.new,
+        Hash.new
+        temp
+      end
+    end
+
+    # Method definition process
+    def user_method_dialogs(my_class_name, method_name, data)
+      dialog_master = MethodSpeaker.new(my_class_name, method_name, data, self)
+      data = dialog_master.dialog
+      file_write(my_class_name.to_s, data)
+      data
+    end
+  end
+end

data/lib/marta/injector.rb

@@ -0,0 +1,101 @@
+module Marta
+
+  #
+  # This module can add Marta's stuff to the page.
+  #
+  # Marta is inserting tons of stuff to the pages!
+  # Those insertions are the only way for her to perform dialog with user
+  module Injector
+
+    private
+
+    #
+    # We are injecting things to the page using the Syringe.
+    #
+    # @note It is believed that no user will use it
+    class Syringe
+
+      def initialize(engine, marta_what, title = 'Something important',
+                     old_data = Hash.new, folder = gem_libdir)
+        @what = marta_what
+        @title = title
+        @data = old_data
+        @engine = engine
+        @folder = folder
+      end
+
+      # "first" or "last".
+      def get_where(first)
+        first ? "first" : "last"
+      end
+
+      # Inserting to the page
+      def insert_to_page(tag, inner, first = true)
+        where = get_where(first)
+        script = <<-JS
+        var newMartaObject = document.createElement('#{tag}');
+        newMartaObject.setAttribute('martaclass','marta_#{tag}');
+        newMartaObject.innerHTML   = '#{inner}';
+        document.body.insertBefore(newMartaObject,document.body.#{where}Child);
+        JS
+         @engine.execute_script script.gsub("\n",'')
+      end
+
+      # Taking a correct js file to inject
+      def js
+        File.read(@folder + "/data/#{@what}.js").gsub("\n",'')
+      end
+
+      # Taking a correct html file to inject
+      def html
+        File.read(@folder + "/data/#{@what}.html").gsub("\n",'')
+      end
+
+      # Taking a correct css file to inject
+      def style
+        File.read(@folder + "/data/style.css").gsub("\n",'')
+      end
+
+      # Injecting everything to the page
+      def files_to_page
+        insert_to_page('div', html)
+        insert_to_page('script', js, false)
+        insert_to_page('style', style, false)
+      end
+
+      # It is never used without get_result.
+      # But it can be used to show some message for user
+      def actual_injection
+        files_to_page
+        @data ||= Hash.new
+        insert_to_page('script', "var marta_what = \"#{@title}\"", false)
+        insert_to_page('script', "var old_marta_Data = #{@data}".gsub('=>',':'),
+                       false)
+        @engine.execute_script("marta_add_data();")
+      end
+
+      # Retrieving result if js var = marta_confirm_mark is true
+      # we are returning js var = marta_result. So custom js should always
+      # return both.
+      def get_result
+        result = false
+        while result != true
+          # When Marta can't get a result she is reinjecting her stuff
+          begin
+            result = @engine.execute_script("return marta_confirm_mark")
+          rescue
+            actual_injection
+          end
+        end
+        @engine.execute_script("return marta_result")
+      end
+    end
+
+    # That's how Marta is injecting and retrieving result
+    def inject(what, title = 'Something important', data = Hash.new)
+      syringe = Syringe.new(engine, what, title, data, gem_libdir)
+      syringe.actual_injection
+      syringe.get_result
+    end
+  end
+end

data/lib/marta/json_2_class.rb

@@ -0,0 +1,145 @@
+require 'marta/options_and_paths'
+require 'marta/read_write'
+module Marta
+
+  #
+  # Here Marta is reading json files and precreating pageobject classes
+  # which were defined previously
+  #
+  # Main trick of the Marta is parsing jsons files to classes.
+  # For example valid Foo.json file in a valid folder will turn into Foo class.
+  # Class content differs when Marta is set to learning mode and when it's not.
+  # Class will have methods = watir elements
+  # and vars = user defined vars with default values.
+  # Class will not accept any arguments for generated methods.
+  # The class will have default initialize method, engine method.
+  #
+  # Also the class can has method_edit method. In theory it can be called like
+  # Foo.method_edit('new_method_name').
+  # It should define new method even if learn mode is disabled.
+  # But I am never using such construction :)
+  # In learn mode any unknown method will cause dialog that will ask user about
+  # what element should be used.
+  #
+  # Also for each method foo method foo_exact will be created and vice versa.
+  # Method wich ends with exact will use strict element searching scheme.
+  module Json2Class
+
+    private
+
+    #
+    # To create a special class we are using a special class
+    #
+    # @note It is believed that no user will use it
+    class SmartPageCreator
+
+      include OptionsAndPaths, ReadWrite
+
+      #
+      # Main class creation method. SmartPage method is only working with
+      # a proper initialization.
+      #
+      # By default SmartPage has no initialization which is making it almost
+      # useles while not constructed like that. It will be fixed.
+      def self.create(class_name, data, edit)
+        c = Class.new(SmartPage) do
+          define_method :initialize do |my_data=data, my_class_name=class_name,
+                                        will_edit=edit|
+            @data = my_data
+            @class_name = class_name
+            @edit_mark = will_edit
+            build_content my_data
+            if will_edit
+              page_edit my_class_name, my_data
+            end
+            # We need optimization here very much!
+            build_content my_data
+          end
+        end
+        # We are vanishing previous version of class
+        if Kernel.constants.include?(class_name.to_sym)
+          Kernel.send(:remove_const, class_name.to_sym)
+        end
+        # We are declaring our class
+        Kernel.const_set class_name, c
+      end
+
+      # We are parsing file into a class
+      def self.json_2_class(json, edit_enabled = true)
+        data = ReaderWriter.file_2_hash(json)
+        if !data.nil?
+          class_name = File.basename(json, ".*")
+          edit_mark = SettingMaster.learn_status and edit_enabled
+          create class_name, data, edit_mark
+        end
+      end
+
+      # Marta is parsing all the files in pageobject folder into classes
+      def self.create_all
+        if File.directory?(SettingMaster.pageobjects_folder)
+          Dir["#{SettingMaster.pageobjects_folder}/*.json"].each do |file_name|
+            json_2_class(file_name, true) #true here
+          end
+        else
+          FileUtils::mkdir_p SettingMaster.pageobjects_folder
+        end
+      end
+    end
+
+    def read_folder
+      SmartPageCreator.create_all
+    end
+
+    def json_2_class(json, edit_enabled = true)
+      SmartPageCreator.json_2_class(json, edit_enabled)
+    end
+
+    def build_content(data)
+      build_methods(data['meths'])
+      build_vars(data['vars'])
+    end
+
+    def build_methods(methods)
+      methods.each_pair do |method_name, content|
+        build_method method_name, content
+      end
+    end
+
+    def build_vars(vars)
+      vars.each do |var_name, default_value|
+        build_var var_name, default_value
+      end
+    end
+
+    def build_method(name, content)
+      define_singleton_method name.to_sym do
+        learn_status ? method_edit(name) : marta_magic_finder(content)
+      end
+      exact = name + '_exact'
+      define_singleton_method exact.to_sym do
+        learn_status ? method_edit(exact) : marta_simple_finder(content)
+      end
+    end
+
+    def build_var(name, content)
+      if !self.methods.include?(name.to_sym) and (@data['meths'][name] == nil)
+        self.singleton_class.send(:attr_accessor, name.to_sym)
+        instance_variable_set("@#{name}", process_string(content))
+      else
+        if !@data['meths'][name].nil?
+          warn "Marta will not create '#{name}' variable for #{self.class}"\
+          " since it is already in use by method"
+        end
+      end
+    end
+
+    def correct_name(name)
+      if name.to_s.end_with? "_exact"
+        method_name = name.to_s[0..-7]
+      else
+        method_name = name.to_s
+      end
+      method_name
+    end
+  end
+end

data/lib/marta/lightning.rb

@@ -0,0 +1,36 @@
+module Marta
+
+  # Marta can highlight or unhighlight elements when her styles are injected.
+  module Lightning
+
+    private
+
+    # We can highlight an element
+    def highlight(element)
+      orig_style = element.attribute_value("style")
+      engine.execute_script("arguments[0].setAttribute(arguments[1],"\
+                            " arguments[2])", element, "style",
+                            "animation: marta_found 6s infinite;")
+      orig_style
+    end
+
+    # We can unhighlight an element
+    def unhighlight(element, style)
+      engine.execute_script("arguments[0].setAttribute(arguments[1],"\
+                            " arguments[2])", element, "style", style)
+    end
+
+    # We can highlight\unhighlight tons of elements at once
+    def mass_highlight_turn(mass, turn_on = true, styles = nil)
+      result = Array.new
+      mass.each_with_index do |element, i|
+        if turn_on
+          result[i] = highlight(element)
+        else
+          unhighlight(element, styles[i])
+        end
+      end
+      result
+    end
+  end
+end

data/lib/marta/options_and_paths.rb

@@ -0,0 +1,140 @@
+module Marta
+
+  #
+  # Marta can store and return settings which may differ for each thread
+  #
+  # Settings for Marta.
+  # Most of them could be changed in action using dance_with.
+  # Most of them are thread dependant.
+  module OptionsAndPaths
+
+    #
+    # We are storing vars in a special class
+    #
+    # @note It is believed that no user will use it
+    class SettingMaster
+      @@folder = Hash.new
+      @@tolerancy = Hash.new
+      @@learn = Hash.new
+      @@engine = Hash.new
+
+      # Getting uniq id for process thread
+      def self.thread_id
+        Thread.current.object_id
+      end
+
+      # Checking default learn option status
+      def self.learn_option
+        ENV['LEARN'].nil? ? false : true
+      end
+
+      # Marta knows does she learn or not.
+      def self.learn_status
+        if @@learn[thread_id].nil?
+          learn_option
+        else
+          @@learn[thread_id]
+        end
+      end
+
+      # Marta knows where are her saved generated pageobjects
+      def self.pageobjects_folder
+        @@folder[thread_id]
+      end
+
+      # Marta knows how hard she should search for elements
+      def self.tolerancy_value
+        @@tolerancy[thread_id]
+      end
+
+      # engine (analog of browser) is a setting too
+      def self.engine
+        @@engine[thread_id]
+      end
+
+      # Marta is changing parameters by the same scheme.
+      def self.parameter_set(what, value, default)
+        what[thread_id] = !value.nil? ? value : what[thread_id]
+        what[thread_id] = what[thread_id].nil? ? default : what[thread_id]
+        what
+      end
+
+      # Marta locates iframes sometimes
+      def self.iframe_locate
+        if !engine.nil?
+          if engine.class == Watir::IFrame
+            engine.locate
+          end
+        end
+      end
+
+      # Marta is switching to iframes sometimes
+      def self.iframe_switch_to
+        if !engine.nil?
+          if engine.class == Watir::IFrame
+            engine.switch_to!
+          end
+        end
+      end
+
+      # Marta is setting engine by pretty comlex rules
+      def self.set_engine(value)
+        iframe_locate
+        @@engine = parameter_set(@@engine, value, nil)
+        iframe_switch_to
+        if engine.nil?
+          @@engine = parameter_set(@@engine, value, Watir::Browser.new(:chrome))
+        end
+      end
+
+      # Marta uses simple rules to set the folder
+      def self.set_folder(value)
+        @@folder = parameter_set(@@folder, value, 'Marta_s_pageobjects')
+      end
+
+      # Marta uses simple rules to set the laearn mode
+      def self.set_learn(value)
+        @@learn = parameter_set(@@learn, value, learn_option)
+      end
+
+      # Marta uses simple rules to set the tolerancy value
+      def self.set_tolerancy(value)
+        @@tolerancy = parameter_set(@@tolerancy, value, 1024)
+      end
+    end
+
+    private
+
+    # Defining the place for files to inject to browser
+    def gem_libdir
+      t = ["#{File.dirname(File.expand_path($0))}/../lib/#{Marta::NAME}",
+           "#{Gem.dir}/gems/#{Marta::NAME}-#{Marta::VERSION}/lib/#{Marta::NAME}"]
+      t.each {|i| return i if File.readable?(i) }
+    end
+
+    # Marta knows does she learn or not.
+    def learn_status
+      SettingMaster.learn_status
+    end
+
+    # Marta knows where are her saved generated pageobjects
+    def pageobjects_folder
+      SettingMaster.pageobjects_folder
+    end
+
+    # Marta knows how hard she should search for elements
+    def tolerancy_value
+      SettingMaster.tolerancy_value
+    end
+
+    # Marta is accepting parameters and rereading pageobjects on any change
+    def dance_with(browser: nil, folder: nil, learn: nil, tolerancy: nil)
+      SettingMaster.set_engine browser
+      SettingMaster.set_folder folder
+      SettingMaster.set_learn learn
+      read_folder
+      SettingMaster.set_tolerancy tolerancy
+      engine
+    end
+  end
+end

data/lib/marta/public_methods.rb

@@ -0,0 +1,51 @@
+require 'marta/options_and_paths'
+module Marta
+
+  # Methods that user can use out of the box in SmartPage
+  module PublicMethods
+
+    include OptionsAndPaths
+
+    # User can define a method for example in a middle of a debug session
+    def method_edit(name)
+      method_name = correct_name(name)
+      exact_name = method_name.to_s + "_exact"
+      data = user_method_dialogs(@class_name, method_name, @data)
+      define_singleton_method method_name.to_sym do |meth_content=@data['meths'][method_name]|
+        marta_magic_finder(meth_content)
+      end
+      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
+    end
+
+    # User can get engine (normally browser instance or iframe element)
+    def engine
+      SettingMaster.engine
+    end
+
+    # If page has url variable it can be opened like Page.new.open_page
+    def open_page(url = nil)
+      if url != nil
+        engine.goto url
+      else
+        if @url == nil
+          raise ArgumentError, "You should set url to use open_page"
+        end
+        engine.goto @url
+      end
+    end
+
+    alias_method :default_method_missing, :method_missing
+
+    # method missing hijacking It should be used only for SmartPage
+    def method_missing(method_name, *args, &block)
+      if learn_status
+        method_edit(method_name)# , *args, &block)
+      else
+        default_method_missing(method_name, *args, &block)
+      end
+    end
+  end
+end

data/lib/marta/read_write.rb

@@ -0,0 +1,44 @@
+require 'marta/options_and_paths'
+module Marta
+
+  # Marta has very simple read\write actions
+  module ReadWrite
+
+    private
+
+    #
+    # Sometimes marta reads files. Sometimes writes
+    #
+    # @note It is believed that no user will use it
+    class ReaderWriter
+      include OptionsAndPaths
+      # Marta is writing to jsons from time to time
+      def self.file_write(name, data)
+        file_name = File.join(SettingMaster.pageobjects_folder, name + '.json')
+        File.open(file_name,"w") do |f|
+          f.write(data.to_json)
+        end
+        file_name
+      end
+
+      # Marta reads file to hash if it is a valid json
+      # If it is not a json file Marta will treat it like nothing
+      def self.file_2_hash(json)
+        begin
+          file = File.read(json)
+          data = JSON.parse(file)
+        rescue
+          nil
+        end
+      end
+    end
+
+    def file_write(name, data)
+      ReaderWriter.file_write(name, data)
+    end
+
+    def file_2_hash(json)
+      ReaderWriter.file_2_hash(json)
+    end
+  end
+end