marta 0.26150

data/lib/marta/simple_element_finder.rb

@@ -0,0 +1,84 @@
+require 'marta/x_path'
+
+module Marta
+
+  # Marta uses simple algorithm for element location when possible
+  # Or when method has _exact ending
+  module SimpleElementFinder
+
+    private
+
+    #
+    # That class is about simle element location strategy
+    #
+    # @note It is believed that no user will use it
+    # The main idea is not to find an element but to find an xpath that leads
+    # to a valid element.
+    class BasicFinder
+
+      include XPath
+
+      def initialize(meth, engine, requestor)
+        @requestor = requestor
+        @meth = meth
+        @xpath = xpath_by_meth
+        @engine = engine
+      end
+
+      # Maybe our element is defined as a collection?
+      def collection?
+        @meth['options']['collection']
+      end
+
+      # Maybe our element has user provided xpath?
+      def forced_xpath?
+        !@meth['options']['xpath'].nil?
+      end
+
+      # Getting an xpath
+      def xpath_by_meth
+        if forced_xpath?
+          @meth['options']['xpath']
+        else
+          XPathFactory.new(@meth, @requestor).generate_xpath
+        end
+      end
+
+      # element prefinding
+      def prefind
+        @engine.element(xpath: @xpath)
+      end
+
+      # collection prefinding
+      def prefind_collection
+        @engine.elements(xpath: @xpath)
+      end
+
+      # Transforming an element to a subtype
+      def subtype_of(element)
+        element = @engine.element(xpath: @xpath).to_subtype
+        #https://github.com/watir/watir/issues/537
+        if element.class == Watir::IFrame
+          element = @engine.iframe(xpath: @xpath)
+        end
+        element
+      end
+
+      # Main logic. We are returning a prefinded collection
+      # or subtyped prefind
+      def find
+        if collection?
+          prefind_collection
+        else
+          subtype_of prefind
+        end
+      end
+    end
+
+    # We can simply find something
+    def marta_simple_finder(meth)
+      finder = BasicFinder.new(meth, engine, self)
+      finder.find
+    end
+  end
+end

data/lib/marta/user_values_prework.rb

@@ -0,0 +1,26 @@
+module Marta
+
+  # Marta can parse strings like "hello #{value}"
+  module UserValuePrework
+
+    private
+
+    # Marta can parse strings like "hello #{value}"
+    def process_string(str='', requestor = self)
+      position1 = 0
+      # Not pretty. When you will see it again rewrite it
+      while (position1 != nil) and (str != nil) do
+        position1, position2 = str.index("\#{@"), str.index("}")
+        if position1 != nil
+          first_part = str[0, position1]
+          var_part = str[position1 + 2..position2 - 1]
+          last_part = str[position2 + 1..-1]
+          str = first_part +
+                requestor.instance_variable_get(var_part).to_s +
+                last_part
+        end
+      end
+      str.nil? ? '' : str
+    end
+  end
+end

data/lib/marta/version.rb

@@ -0,0 +1,4 @@
+module Marta
+  VERSION = "0.26150"
+  NAME = "marta"
+end

data/lib/marta/x_path.rb

@@ -0,0 +1,170 @@
+require 'marta/user_values_prework'
+
+module Marta
+
+  # That module is about creating xpaths for element searching
+  module XPath
+
+    private
+
+    #
+    # Here we are crating xpath including arrays of xpaths with one-two-...-x
+    # parts that are not known
+    #
+    # @note It is believed that no user will use it
+    # All xpaths for Marta are constructed out of three parts:
+    # granny, pappy, and self. Where self is a xpath for DOM element itself,
+    # pappy is for father element, granny is for grandfather.
+    # For example //DIV/SPAN/INPUT: //DIV = granny, /SPAN = pappy,
+    # /INPUT = self.
+    #
+    # We are generating special arrays of hashes at first for each part.
+    # And then we are constructing final xpaths
+    class XPathFactory
+
+      include UserValuePrework
+
+      attr_accessor :granny, :pappy
+      def initialize(meth, requestor)
+        @meth = meth
+        @granny = @pappy = true
+        @requestor = requestor
+      end
+
+      # Getting a part (by data or empty=any)
+      def get_xpaths(todo, what)
+        if todo
+          form_array_hash(@meth['options'][what], @meth[what])
+        else
+          [make_hash("//", "//"), make_hash("*", "*")]
+        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)
+          end
+          work_array = (work_array + temp_array).uniq
+        end
+        work_array
+      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|
+          xpath = String.new
+          variant.each do |part|
+            xpath = xpath + part[:full]
+          end
+          result_array.push process_string(xpath, @requestor)
+        end
+        result_array
+      end
+
+      # Special method to get the single xpath only. Without unknowns
+      def generate_xpath
+        generate_xpaths(0).join
+      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])
+            else
+              temp_array.push make_hash(item2[:full],item2[:empty])
+            end
+          end
+          result_array = result_array.push temp_array
+        end
+        result_array
+      end
+
+      # Creating a small part of array hash for tag
+      def form_array_hash_for_tag(tag)
+        result_array = Array.new
+        result_array.push make_hash("/", "//")
+        result_array.push make_hash(tag, "*")
+        result_array
+      end
+
+      # Creating an array hash
+      def form_array_hash(tag, attrs)
+        result_array = form_array_hash_for_tag(tag)
+        attrs.each_pair do |attribute, value|
+          if attribute.include?('class')
+            result_array = result_array +
+                                   form_array_hash_for_class(attribute, value)
+          else
+            result_array.push form_hash_for_attribute(attribute, value)
+          end
+        end
+        result_array
+      end
+
+      # Creating a small part of array hash for attribute
+      def form_hash_for_attribute(attribute, value)
+        result_array = Array.new
+        if attribute == 'retrieved_by_marta_text'
+          make_hash("[contains(text(),'#{value}')]", "")
+        else
+          make_hash("[@#{attribute}='#{value}']", "")
+        end
+      end
+
+      # Creating a small part of array hash for attribute contains 'class'
+      def form_array_hash_for_class(attribute, value)
+        result_array = Array.new
+        value.each do |value_part|
+          if value_part.gsub(' ','') != ''
+            result_array.push make_hash("[contains(@#{attribute},"\
+                                        "'#{value_part}')]", "")
+          end
+        end
+        result_array
+      end
+
+      # Creating the smallest possible part of array hash
+      def make_hash(full, empty)
+        {full: "#{full}", empty: "#{empty}"}
+      end
+    end
+  end
+end

data/lib/marta.rb

@@ -0,0 +1,62 @@
+require "marta/version"
+require 'marta/public_methods'
+require 'marta/options_and_paths'
+require 'marta/read_write'
+require 'marta/user_values_prework'
+require 'marta/dialogs'
+require 'marta/classes_creation'
+require 'marta/lightning'
+require 'marta/injector'
+require 'marta/json_2_class'
+require 'marta/black_magic'
+require 'marta/simple_element_finder'
+require 'marta/x_path'
+require "watir"
+require 'fileutils'
+require 'json'
+
+#
+# Marta class is providing three simple methods.
+#
+# const_missing is hijacked. And in a learn mode marta will treat any unknown
+# constant as an unknown pageobject and will try to ask about using browser
+module Marta
+
+  include OptionsAndPaths, ReadWrite, Json2Class
+
+  class SmartPage
+    include BlackMagic, XPath, SimpleElementFinder, ClassesCreation,
+            PublicMethods, Dialogs, Injector, Lightning, OptionsAndPaths,
+            Json2Class, ReadWrite, UserValuePrework
+  end
+
+  # That is how Marta connected to the world
+
+  # We will ask user about completely new class
+  def Object.const_missing(const, *args, &block)
+    if !SettingMaster.learn_status
+      raise NameError, "#{const} is not defined."
+    else
+      data, data['vars'], data['meths'] = Hash.new, Hash.new, Hash.new
+      SmartPageCreator.json_2_class(ReaderWriter.file_write(const.to_s, data))
+    end
+  end
+
+  # Marta is returning an engine (it should be a browser instance)
+  # Watir::Browser.new(:chrome) by default
+  def engine
+    SettingMaster.engine
+  end
+
+  # dance_with is for creating settings to be used later.
+  # Settings can be changed at any time by calling dance with.
+  # Read more in the README
+  def dance_with(browser: nil, folder: nil, learn: nil, tolerancy: nil)
+    SettingMaster.set_engine browser
+    SettingMaster.set_folder folder
+    SettingMaster.set_learn learn
+    SmartPageCreator.create_all
+    SettingMaster.set_tolerancy tolerancy
+    engine
+  end
+end

data/marta.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'marta/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = Marta::NAME
+  spec.version       = Marta::VERSION
+  spec.authors       = ["Sergei Seleznev"]
+  spec.email         = ["s_seleznev_qa@hotmail.com"]
+
+  spec.summary       = "That will be an another one watir-webdriver wrap"
+  spec.description   = "It's nothing to describe now."
+  spec.homepage      = "https://github.com/sseleznevqa/marta"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } + Dir.glob("lib/marta/data/*")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "watir"
+  #spec.add_dependency "fileutils"
+  spec.add_dependency "json"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: marta
+version: !ruby/object:Gem::Version
+  version: '0.26150'
+platform: ruby
+authors:
+- Sergei Seleznev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: watir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It's nothing to describe now.
+email:
+- s_seleznev_qa@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example_project/p_object/test_page.rb
+- example_project/spec/p_object/pageobjects/MartaTestPage.json
+- example_project/spec/spec_helper.rb
+- example_project/spec/watir_test_page_spec.rb
+- example_project/tests_with_learning.sh
+- example_project/tests_without_learning.sh
+- lib/marta.rb
+- lib/marta/black_magic.rb
+- lib/marta/classes_creation.rb
+- lib/marta/data/custom-xpath.html
+- lib/marta/data/custom-xpath.js
+- lib/marta/data/element-confirm.html
+- lib/marta/data/element-confirm.js
+- lib/marta/data/element.html
+- lib/marta/data/element.js
+- lib/marta/data/for_test.html
+- lib/marta/data/for_test.js
+- lib/marta/data/page.html
+- lib/marta/data/page.js
+- lib/marta/data/style.css
+- lib/marta/dialogs.rb
+- lib/marta/injector.rb
+- lib/marta/json_2_class.rb
+- lib/marta/lightning.rb
+- lib/marta/options_and_paths.rb
+- lib/marta/public_methods.rb
+- lib/marta/read_write.rb
+- lib/marta/simple_element_finder.rb
+- lib/marta/user_values_prework.rb
+- lib/marta/version.rb
+- lib/marta/x_path.rb
+- marta.gemspec
+homepage: https://github.com/sseleznevqa/marta
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: That will be an another one watir-webdriver wrap
+test_files: []