marta 0.26150

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23b20fe634d3cc98a3adbb3997269c9687256b23
+  data.tar.gz: d9644a0f8c01d32f4d25c9f67e1b30482a24ec98
+SHA512:
+  metadata.gz: 1ba5036b4d3350b73cc4004e39af27c9af90dd67ad89f9efac0e9937f54bcccba7463dc0156aa2ab7bced7702c08f823498edeb895d8c67b7a6cd7f28715b89a
+  data.tar.gz: 2eb03fb937126b707e5290a765dc50314701301548389d5b8baf982316e5b542e694f719cbf38fbd21acb45dc691e276520df30e0ce847f4ee9fda4bd36dc65b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.DS_Store
+.DS_Store
+.DS_Store?

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at seleznev@webzilla.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in marta.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Segey Seleznev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,299 @@
+# Marta
+
+Marta is a pretty new way to write selenium tests for WEB applications using Watir. Main idea is very similar to cucumber. In Cucumber you are writing test and then defining a code behind it. In Marta you are writing code and then defining classes/pageobjects and methods/elements behind it thru your browser window.
+
+Also Marta is providing a little more stability when locating elements on the page.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'marta'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install marta
+
+## Usage
+
+1. Be sure that you have [Chromedriver](https://sites.google.com/a/chromium.org/chromedriver/) installed as well as [Chrome browser](https://www.google.com/chrome/browser/desktop/). It should work with any browser but it's definitely working in Chrome :)
+2. Write the code
+```ruby
+require 'marta'
+include Marta
+dance_with
+your_page = Your_Page.new
+your_page.open_page
+your_page.your_element.click
+```
+3. Run it in terminal with parameter LEARN=1 approximately like:
+
+    $ LEARN=1 ruby path_to_your_test.rb
+
+4. Take a look at the browser window: Marta will ask you to define Your_Page class. You can add variables for the class there.
+5. Add *url* variable with the url of desired page as a default value.
+6. Confirm.
+7. Then page will be opened and you will be asked about your_element.
+8. Just click the element and confirm the selection (twice)
+9. Now you can run the test without LEARN parameter and it will work.
+
+**So you are `writing code in pageobject pattern` style.**
+
+**Where each `class is` meant to be a `pageobject`.**
+
+**Where each `method` except reserved (method_edit, engine, open_page, new, class, etc.) `can be a class variable or` should represent `an element at the page`.**
+
+**At first `run` (with `learning mode enabled`) you are `defining Pages and elements` via web interface.**
+
+**After that you can `run your code without learning` and it should pass.**
+
+**`Stability` of the scheme `is ensured by` Marta's `ability to find elements` even `if` some `attributes were changed`.**
+
+## FAQ
+**Q: What if some attributes of elements will be changed?**
+
+*A: First of all at the defining stage you can exclude dynamic attributes. Also Marta has special Black Magic algorithm that will try to find the most similar element anyway.*
+
+*NOTE: Exclude attributes with empty values as well. In later versions Marta will filter them out automatically.*
+
+**Q: What if I can locate element only by dynamic attributes like account_id?**
+
+*A: For example you have a pack of html elements with only one attribute that differs: account_id_attribute. First at the stage of page defining create a class variable account_id = "123". After that you can dynamically change it in your code like*
+```ruby
+your_page.account_id = "456"
+```
+*And when defining an element you can use it in value field of account_id_attribute like #{@account_id}. See couple examples in example_project (Ruby checkbox, item1 and 2 radio buttons)*
+
+**Q: I want to use firefox. How could I?**
+
+*A: dance_with is accepting parameter :browser like*
+```ruby
+dance_with browser: Watir::Browser.new(:firefox)
+```
+
+**Q: How Marta stores data?**
+
+*A: Marta creates a json files in the default folder with name = Marta_s_pageobjects'. You can force Marta to use other folder like*
+```ruby
+dance_with folder: 'path/to/your/folder'
+```
+
+**Q: I want to turn learning mode on\off in the code. How?**
+
+*A:*
+```ruby
+dance_with learn: true or false
+```
+*Note: it may not work inside of the previously defined class. In that case use:*
+```ruby
+your_page.method_edit('newelementname')
+```
+
+**Q: Sometimes Marta is looking for lost element for too long. What can I do about it?**
+
+*A: You can set tolerancy parameter. Larger = longer*
+```ruby
+dance_with tolerancy: 1024# is the default value
+```
+*That logic will be changed to more understandable soon. I hope.*
+
+**Q: How can I get Watir browser instance if I want for example execute_script or find element without Marta?**
+
+*A: Like that*
+```ruby
+engine.execute_script('your script')
+#or
+your_page.engine.execute_script('your script')
+#and
+engine.element(id: 'will_be_located_without_Marta')
+```
+
+**Q: How can I find a collection of elements?**
+
+*A: When defining an element you can set a collection checkbox at the top of the dialog. In that case Marta will return Watir::ElementCollection.*
+
+**Q: How can I find not just an element but a Watir::Radio for example?**
+
+*A: Marta automatically performs to_subtype for every element. So if your element is a radio button you will be able to use specific methods.*
+```ruby
+your_page.element_that_supposed_to_be_radio.set?
+```
+*ATTENTION. Until [Watir issue 537](https://github.com/watir/watir/issues/537) is not fixed it may work wrong. Sometimes.*
+
+**Q: And what about elements under iframes?**
+
+*A: First of all DO NOT USE switch_to! - it will not work. Please use:*
+```ruby
+dance_with browser: your_page.iframe_element
+```
+*After that Marta will look for elements inside iframe only. To switch back use:*
+```ruby
+dance_with browser: engine.browser
+```
+*Fixing switch_to! is planned. And as always you can:*
+```ruby
+your_page.iframe_element.text_field(id: 'ifield')
+```
+
+**Q: Marta is finding similar elements when she cannot find the element. But what if I need to check presence of the element and I am not interested in a similar one?**
+
+*A: To prevent Marta from searching similar elements use methods with _exact at the end. Like.*
+```ruby
+your_page.important_element_exact.present?
+#Once defined it can be called without exact as well
+your_page.important_element.click
+```
+
+**Q: Is there any other way to strictly define an element?**
+
+*A: You can click 'Set custom xpath' at element defining stage and set own xpath. In that case only that xpath will be used to find element. It is planned to add possibility to set custom css, id, name, etc.*
+
+**Q: Why Watir? I want to use pure Selenium Webdriver or Capybara or something!**
+
+*A: I like Watir. And I have no plans so far to implement something else.*
+
+**Q: And what about Cucumber? Will it work with Marta?**
+
+*A: I don't know. I am not a Cucumber fan and I have giant doubts that Marta and Cucumber will work together well. But you can try. Also I am thinking about it.*
+
+**Q: Ok. With what WILL it work?**
+
+*A: It should work with rspec and parallel_rspec. See example_project for example*
+
+**Q: How can I design more object oriented and DRY tests using Marta**
+
+*A: Create wrapping classes. Like*
+```ruby
+class Google_page < Marta_google_page
+  def search(what)
+    search_field.set what
+    search_button.click
+  end
+end
+g_page = Google_page.new
+g_page.open_page
+g_page.search "I am in love with selenium."
+```
+*You will define with Marta Marta_google_page class(do not forget to set an url!) and methods: search_field and search_button.*
+
+**Q: What about an example?**
+
+*A: It is placed in example_project folder. All elements are defined already (except one that is not in use by default). For a tour do*
+
+    $ cd example_project
+    $ ./tests_with_learning.sh
+
+*Take a look at elements defining (especially when variables like #{i1} are used). Try to redefine elements. And see what attributes are used what are not. Also take a look at the ruby code. There are some comments.*
+
+**Q: What else?**
+
+*A: Nothing. Marta is under development. Her version is 0.26150 only. And I am not a professional developer. But I am training her on new tricks.*
+
+## Internal Design
+
+**That is not a real code. That is just an idea of internal structure. Feel free to criticize it**
+
+```ruby
+# Main module
+module Marta
+
+  # Helper module
+  module OptionsAndPaths
+
+    # Helper class. If it will be used for Marta module it has singleton
+    # methods.
+    class SettingMaster
+      @@options = nil
+
+      # Class can have different options for different threads
+      def self.opts option
+        @@options[Thread.current.object_id]
+      end
+    end
+  end
+
+  # Includes public methods for SmartPage
+  module PublicMethods
+
+    # Some methods that can be called almost always even from SmartPage like
+    def open_page page
+      # Marta opens page
+    end
+
+    # SmartPage hijacks method_missing as well in a learn mode
+    def method_missing
+      # We are doing things in a learn mode here
+    end
+  end
+
+  # Injecting messages to the browser page
+  module Injector
+
+    private
+
+    def inject something
+      # Marta injecting dialogs to the page
+    end
+  end
+
+  # Marta has a lot of modules...
+  # module Something
+  #   private
+  #   Marta has many other private methods...
+  # end
+
+  # Marta hijacks const_missing for her learn mode
+  # In the real world that stuff is in Json2Class module
+  def const_missing
+    if learn_mode
+      c = class.new(SmartPage) do
+        # We are creating new class here
+        # adding of some public methods that can be used
+        # adding custom variables
+        if learn_mode
+          def initialize *args
+            # Showing user dialogs in browser
+          end
+          def method_missing *args
+            # We can create methods dynamically
+            # We will ask user about method\element in browser instance
+          end
+        end
+      end
+    else
+      # We are showing error
+    end
+  end
+
+  # Generated Pageobject classes will inherit from SmartPage
+  class SmartPage
+    include OptionsAndPaths, PublicMethods, Injector#, Something, and others
+  end
+
+  # If module is included we can call some methods.
+  def dance_with option
+    SettingMaster.opts = option
+    # And other useful things here
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/marta. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "marta"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example_project/p_object/test_page.rb

@@ -0,0 +1,31 @@
+# TestPage class will wrap MartaTestPage class generated by Marta
+# Methods that are not defined here will be taken from class generated by Marta
+class MyTestPage < MartaTestPage
+  def form_fill(name: 'somebody', story: 'nostory', watir_radio: true,
+                language: 'Ruby', browser: 'Chrome', how_happy: '1',
+                item1: '5', item2: '3')
+    # name_field is MartaTestPage.name_field.
+    # Marta will ask about it in learning mode
+    name_field.set name
+    story_area.set story
+    # selenium radio button was never defined.
+    # So selenium.set will cause an error... But in learn mode you can define it
+    # Or you can:
+    # self.method_edit('selenium')
+    watir_radio ? watir.set : selenium.set
+    # These values was alredy set to some values at page\class defining stage
+    @lang = language
+    @happy = how_happy
+    @i1 = item1
+    @i2 = item2
+    dropbox.select browser
+    # language_checkbox, how_happy_element, item1_element and item2_element are
+    # defined as dependant of related variables. For example if @lang == 'Java'
+    # language_checkbox will be an element <input... value='Java'>
+    language_checkbox.set
+    how_happy_element.set
+    item1_element.set
+    item2_element.set
+    send_button.click
+  end
+end

data/example_project/spec/p_object/pageobjects/MartaTestPage.json

@@ -0,0 +1 @@
+{"vars":{"happy":"1","i1":"1","i2":"2","lang":"Java","url":"http://bit.ly/watir-example"},"meths":{"name_field":{"granny":{"class":["ss-item","ss-item-required","ss-text"],"dir":"auto"},"options":{"collection":false,"granny":"DIV","pappy":"DIV","self":"INPUT"},"pappy":{"class":["ss-form-entry"]},"self":{"aria-label":"What is your name? A text field ","aria-required":"true","class":["ss-q-short"],"dir":"auto","id":"entry_1000000","name":"entry.1000000","type":"text"}},"story_area":{"granny":{"class":["ss-item","","ss-paragraph-text"],"dir":"auto"},"options":{"collection":false,"granny":"DIV","pappy":"DIV","self":"TEXTAREA"},"pappy":{"class":["ss-form-entry"]},"self":{"aria-label":"What is your story? A text box ","class":["ss-q-long"],"cols":"0","dir":"auto","id":"entry_1000001","name":"entry.1000001","rows":"8"}},"watir":{"granny":{},"options":{"collection":false,"granny":"LABEL","pappy":"SPAN","self":"INPUT"},"pappy":{"class":["ss-choice-item-control","goog-inline-block"]},"self":{"aria-label":"Watir","class":["ss-q-radio"],"id":"group_1000002_1","name":"entry.1000002","role":"radio","type":"radio","value":"Watir"}},"language_checkbox":{"granny":{},"options":{"collection":false,"granny":"LABEL","pappy":"SPAN","self":"INPUT"},"pappy":{"class":["ss-choice-item-control","goog-inline-block"]},"self":{"class":["ss-q-checkbox"],"id":"group_1000003_1","name":"entry.1000003","role":"checkbox","type":"checkbox","value":"#{@lang}"}},"dropbox":{"granny":{"class":["ss-item","ss-select"],"dir":"auto"},"options":{"collection":false,"granny":"DIV","pappy":"DIV","self":"SELECT"},"pappy":{"class":["ss-form-entry"]},"self":{"aria-label":"What browser do you use? Drop down box ","class":[],"id":"entry_1000004","name":"entry.1000004"}},"how_happy_element":{"granny":{"class":["ss-scalerow"]},"options":{"collection":false,"granny":"TD","pappy":"DIV","self":"INPUT"},"pappy":{"class":["ss-scalerow-fieldcell"]},"self":{"aria-label":"#{@happy}","class":["ss-q-radio"],"id":"group_1000005_1","name":"entry.1000005","role":"radio","type":"radio","value":"#{@happy}"}},"item1_element":{"granny":{"class":["ss-grid-button-label"]},"options":{"collection":false,"granny":"LABEL","pappy":"DIV","self":"INPUT"},"pappy":{"class":["ss-grid-button-wrapper","ss-grid-cell"]},"self":{"aria-label":"#{@i1}","class":["ss-q-radio"],"id":"group_1000006_#{@i1}","name":"entry.1000006","role":"radio","type":"radio","value":"#{@i1}"}},"item2_element":{"granny":{"class":["ss-grid-button-label"]},"options":{"collection":false,"granny":"LABEL","pappy":"DIV","self":"INPUT"},"pappy":{"class":["ss-grid-button-wrapper","ss-grid-cell"]},"self":{"aria-label":"#{@i2}","class":["ss-q-radio"],"id":"group_1000007_#{@i2}","name":"entry.1000007","role":"radio","type":"radio","value":"#{@i2}"}},"send_button":{"granny":{},"options":{"collection":false,"granny":"TR","pappy":"TD","self":"INPUT"},"pappy":{"class":["ss-form-entry","goog-inline-block"],"dir":"ltr","id":"navigation-buttons"},"self":{"class":["jfk-button","jfk-button-action"],"id":"ss-submit","name":"submit","type":"submit"}},"confirmation_message":{"granny":{"class":["ss-container"]},"options":{"collection":false,"granny":"DIV","pappy":"DIV","self":"H1"},"pappy":{"class":["ss-resp-card"]},"self":{"class":["ss-confirmation"],"retrieved_by_marta_text":"Watir Example"}}}}

data/example_project/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.expand_path('../../p_object', __FILE__)
+require 'marta'
+require 'rspec'
+include Marta
+RSpec.configure do |config|
+  config.before do |example|
+    folder = "./spec/p_object/pageobjects"
+    dance_with(folder: folder)
+    require 'test_page'
+  end
+end

data/example_project/spec/watir_test_page_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "We will do some dummy things like" do
+  before(:each) do
+    @page = MyTestPage.new
+    @page.open_page
+  end
+  it "touching every single element at the test page" do
+    @page.form_fill
+    expect(@page.confirmation_message_exact.present?).to be true
+  end
+end

data/example_project/tests_with_learning.sh

@@ -0,0 +1 @@
+LEARN=1 rspec ./spec/

data/example_project/tests_without_learning.sh

@@ -0,0 +1 @@
+rspec ./spec/

data/lib/marta/black_magic.rb

@@ -0,0 +1,147 @@
+require 'marta/x_path'
+require 'marta/simple_element_finder'
+
+module Marta
+
+  #
+  # Black magic is responsible for lost element searching
+  #
+  # When it is impossible to find element as is we have a special algorithm.
+  # It is suggesting that one part of xpath (tag or attribute) is wrong.
+  # So it is checking all the possible combination of xpath with excluding of each
+  # xpath part one by one.
+  # When there is no success it is trying without two parts
+  # It repeats everything until it finds something or number of variants is
+  # becoming larger than tolerancy value
+  module BlackMagic
+
+    include XPath, SimpleElementFinder
+
+    private
+
+    #
+    # Element searching class.
+    #
+    # @note It is believed that no user will use it
+    class MagicFinder < BasicFinder
+
+      def initialize(meth, engine, tolerancy, requestor)
+        @tolerancy = tolerancy
+        super(meth, engine, requestor)
+      end
+
+      # We can prefind an element and wait for it.
+      def prefind_with_waiting
+        begin
+          prefind.wait_until_present(timeout: 10)
+        rescue
+          # found nothing
+          prefind
+        end
+      end
+
+      # Main method. It finds an element
+      def find
+        if !forced_xpath?
+          element = prefind_with_waiting
+          warn_and_search element
+        end
+        super
+      end
+
+      # Marta is producing warning when element was not found normally
+      def warn_and_search(element)
+        if !element.exists?
+          warn "Element #{@xpath} was not found. And Marta uses a black"\
+               " magic to find it. Redefine it as soon as possible"
+          actual_searching(element)
+        end
+      end
+
+      # Marta can form special xpath guess for element finding attempt
+      def form_complex_xpath(unknowns, granny=true, pappy=true)
+        xpath_factory = XPathFactory.new(@meth, @requestor)
+        xpath_factory.granny = granny
+        xpath_factory.pappy = pappy
+        if xpath_factory.create_xpath.count <= unknowns
+          raise "Marta did her best. But she found nothing"
+        else
+          xpath_factory.generate_xpaths(unknowns)
+        end
+      end
+
+      # We should manage granny, pappy and i values for additional steps
+      def granny_pappy_manage(granny, pappy)
+        if !(granny or pappy)
+          raise "Marta did her best. But she found nothing"
+        end
+        if (granny and pappy) or (granny and !pappy)
+          granny = false
+        else
+          granny, pappy = true, false
+        end
+        return granny, pappy
+      end
+
+      # We are  forming arrays of candidates
+      def candidates_arrays_creation(array_of_xpaths)
+        array_of_elements, array_of_els_xpaths = Array.new, Array.new
+        something = nil
+        array_of_xpaths.each do |xpath|
+          something = @engine.element(xpath: xpath)
+          if something.exists?
+            array_of_elements.push something
+            array_of_els_xpaths.push xpath
+          end
+        end
+        return array_of_elements, array_of_els_xpaths
+      end
+
+      # Selecting the most common element in the array.
+      def get_search_result(result, array_of_elements, array_of_els_xpaths)
+        something = result
+        if array_of_elements.size > 0
+          result = array_of_elements.group_by(&:itself).
+                   values.max_by(&:size).first
+        else
+          result = nil
+        end
+        if result != nil
+          @xpath = array_of_els_xpaths[array_of_elements.index(result)]
+        else
+          result = something
+        end
+        return result
+      end
+
+      # The core of Black Magic Algorithm
+      def actual_searching(result)
+        granny, pappy, i = true, true, 1
+        while !result.exists?
+          array_of_xpaths = form_complex_xpath(i, granny, pappy)
+          if array_of_xpaths.count >= @tolerancy
+            # One more step.
+            # We will try to exclude grandparent element data at first.
+            # Then we will try to exclude parent.
+            # Finally we will try to exclude all the parents.
+            # If they are already excluded and Marta is out of tolerancy...
+            granny, pappy, i = granny_pappy_manage(granny, pappy) + [1]
+            array_of_xpaths = form_complex_xpath(i, granny, pappy)
+          end
+          array_of_elements,
+            array_of_els_xpaths = candidates_arrays_creation(array_of_xpaths)
+          i += 1
+          result =
+              get_search_result(result, array_of_elements, array_of_els_xpaths)
+        end
+        return result
+      end
+    end
+
+    # Marta can find something when data is incorrect (by Black magick)
+    def marta_magic_finder(meth)
+      finder = MagicFinder.new(meth, engine, tolerancy_value, self)
+      finder.find
+    end
+  end
+end