web_minion 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf7a988efff88355bcdc557cdf6824061e883bbd
-  data.tar.gz: 43361685a55294c9d4c21f13d5bd273b749fe5e7
+  metadata.gz: 477c3b18a2d94887c6d2e3ad2fa1c59b6d4dfd74
+  data.tar.gz: eb231e8060d78d0e59ce36c97cabba543af1a4f1
 SHA512:
-  metadata.gz: fdb3412034e560b84953577ecf12f11962c41f402d442df73a81016bf73beee5f133b395f0cdadc85631f93223364d8165b0e2a86737bba9dc63d8096ff0a2f1
-  data.tar.gz: acfee494e048cd9f65f05ddffc5b381f4a8af92bb6ba9b8163d5daf353a09710323bc20dadfb5e5edd212984d092c7c6b6a7d0b4f7883c5a04d9f1f59b34640c
+  metadata.gz: a74a18184389fe2ead049b7ece8629d952d8f61ffa73d40e40be1d30b8433a0205930278afed97df5edda13e472bd6cfed533b0f2151df8dc6b376c41b4880b7
+  data.tar.gz: 7df05983de55cc6d37ac372b520f4136ed521e20fd801ac5aec40d9809e7c71b0a2718577c7f3edd8c86e0af5359efa064bf83e6bffa716f468697741bfce821

data/.gitignore

@@ -1,3 +1,9 @@
+*.DS_Store
+cl_tester.rb
+completer.hist
+cl_testing_html.html
+*.swo
+*.swp
 /.bundle/
 /.yardoc
 /Gemfile.lock

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 rvm:
   - 2.3.1
   - 2.2.5
-  - 2.1.9
-  - 2.0.0
-  - 1.9.3-p551
   - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -1,6 +1,9 @@
 source "https://rubygems.org"
 
 gem "mechanize"
+gem "capybara"
+gem "poltergeist"
+gem "selenium-webdriver"
 
 group :development do
   gem "pry"

data/README.md

@@ -1,11 +1,13 @@
 # WebMinion
 - [![Build](http://img.shields.io/travis-ci/jibeinc/web_minion.svg?style=flat-square)](https://travis-ci.org/jibeinc/web_minion)
 - [![Quality](http://img.shields.io/codeclimate/github/jibeinc/web_minion.svg?style=flat-square)](https://codeclimate.com/github/jibeinc/web_minion)
-- [![Coveralls](https://img.shields.io/coveralls/jibeinc/web_minion.svg?style=flat-square)](https://img.shields.io/coveralls/jibeinc/web_minion.svg)
+- [![Coveralls](https://img.shields.io/coveralls/jibeinc/web_minion.svg?style=flat-square)](https://coveralls.io/github/jibeinc/web_minion)
 - [![Issues](http://img.shields.io/github/issues/jibeinc/web_minion.svg?style=flat-square)](http://github.com/jibeinc/web_minion/issues)
 - [![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](http://opensource.org/licenses/MIT)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/web_minion`. To experiment with that code, run `bin/console` for an interactive prompt.
+WebMinion is a metadata-driven browser automation library. Instead of writing a custom bot with lots of code, you can write a JSON configuration and give it to WebMinion to run instead. You can use webdrivers like Mechanize, Capybara/Selenium (TODO) and Capybara/PhantomJS (TODO).
+
+*NOTE* The public API is currently unstable and subject to change.
 
 ## Installation
 
@@ -25,12 +27,19 @@ Or install it yourself as:
 
 ## Usage
 
+```ruby
+web_minion = WebMinion::Flow.build_via_json(File.read("./test/test_json/test_json_one.json"))
+web_minion.perform
+```
+
 ### Sample Flow
 
 Here's a sample login flow:
 
     {
-      "config": {},
+      "config": {
+        driver: "mechanize",
+        },
       "flow": {
         "name": "Login Flow",
         "actions": [
@@ -86,6 +95,15 @@ Here's a sample login flow:
       }
     }
 
+
+
+### WebMinion Drivers
+By default, WebMinion will load it's Mechanize drivers. If you want to use
+Capybara, you will need to do the following:
+
+`require "web_minion/drivers/capybara"`
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/web_minion

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+# Usage: bin/web_minion test/test_json/capybara_flow.json
+require "bundler/setup"
+require "web_minion"
+require "web_minion/drivers/capybara"
+require "pry"
+Capybara.register_driver :poltergeist do |app|
+  options = {
+    js_errors: false,
+    timeout: 120,
+    debug: false,
+    phantomjs_options: ["--load-images=no", "--disk-cache=false"],
+    inspector: false,
+  }
+  Capybara::Poltergeist::Driver.new(app, options)
+end
+
+web_minion = WebMinion::Flow.build_via_json(File.read(ARGV[0]))
+result = web_minion.perform
+puts result[:history].status
+puts result[:saved_vars].to_json if result[:saved_vars]

data/lib/web_minion.rb

@@ -1,6 +1,9 @@
-require "web_minion/bots/bot"
-require "web_minion/bots/mechanize_bot"
+require "web_minion/drivers/mechanize"
 require "web_minion/step"
 require "web_minion/action"
 require "web_minion/flow"
 require "web_minion/histories/history"
+module WebMinion
+  class MultipleOptionsFoundError < StandardError; end
+  class NoInputFound < StandardError; end
+end

data/lib/web_minion/action.rb

@@ -16,8 +16,16 @@ module WebMinion
       send("steps=", fields[:steps])
     end
 
-    def self.build_from_hash(fields = {})
-      steps = fields["steps"].map { |step| Step.new(step) }
+    def self.build_from_hash(fields = {}, vars = {})
+      steps = fields["steps"].map do |step|
+        begin
+          Step.new(step.merge("vars" => vars))
+        rescue NoValueForVariableError => e
+          (step["skippable"] && (step["is_validator"].nil? || !step["is_validator"])) ? nil : raise(e, "Current step is missing variable. (step: #{step['name']})")
+        end
+      end
+      steps = steps.reject(&:nil?)
+
       starting = (fields["starting"] || "false") == "false" ? false : true
       new(name: fields["name"], steps: steps, key: fields["key"],
           starting: starting, on_success: fields["on_success"],
@@ -50,16 +58,16 @@ module WebMinion
     end
 
     # Again, boilerplate for initial setup
-    def perform(bot)
+    def perform(bot, saved_values)
       element = nil
       status = @steps.map do |step|
         if step.validator?
-          step.perform(bot, element)
+          step.perform(bot, element, saved_values)
         else
           if step.retain?
-            step.perform(bot, element)
+            step.perform(bot, element, saved_values)
           else
-            element = step.perform(bot, element)
+            element = step.perform(bot, element, saved_values)
           end
           nil
         end

data/lib/web_minion/bots/bot.rb

@@ -7,8 +7,12 @@ module WebMinion
       @config = config
     end
 
-    def execute_step(method, target, value = nil, element = nil)
-      method(method).call(target, value, element)
+    def execute_step(method, target, value = nil, element = nil, values_hash = {})
+      if method == :save_value
+        method(method).call(target, value, element, values_hash)
+      else
+        method(method).call(target, value, element)
+      end
     end
   end
 end

data/lib/web_minion/bots/capybara_bot.rb

@@ -0,0 +1,315 @@
+require "capybara"
+require "web_minion/bots/bot"
+require "forwardable"
+
+module WebMinion
+  class CapybaraBot < WebMinion::Bot
+    extend Forwardable
+    attr_reader :bot
+    delegate [:body] => :@bot
+
+    # Initializes a CapybaraBot
+    #
+    # @param config [Hash] the configuration for the CapybaraBot
+    # @option options [Symbol] :driver The Capybara Driver to use.
+    # @return [CapybaraBot]
+    def initialize(config = {})
+      super(config)
+      @driver = config.fetch("driver").to_sym
+
+      if block_given?
+        yield
+      else
+        Capybara.register_driver @driver do |app|
+          Capybara::Selenium::Driver.new(app, browser:  @driver)
+        end unless Capybara.drivers.include?(@driver)
+      end
+
+      @bot = Capybara::Session.new(@driver)
+      @bot.driver.resize(config["dimensions"]["width"], config["dimensions"]["height"]) if config["dimensions"]
+    end
+
+    def page
+      @bot.html
+    end
+
+    # Goes to the provided url
+    #
+    # @param target [String] the target (URL) of the site to visit.
+    # @param _value [String] the value (unused)
+    # @param _element [Capybara::Node::Element] the element (unused)
+    # @return [nil]
+    def go(target, _value, _element)
+      @bot.visit(target)
+    end
+
+    # Clicks the provided target.
+    #
+    # @param target [String] the target (css or xpath) to be clicked
+    # @param _value [String] the value (unused)
+    # @param _element [Capybara::Node::Element] the element (unused)
+    # @return [nil]
+    def click(target, _value, _element)
+      @bot.click_link_or_button(target)
+    end
+
+    # Clicks the button in the provided form
+    #
+    # @param target [String] the target (css or xpath) to be clicked
+    # @param _value [String] the value (unused)
+    # @param element [Capybara::Node::Element] the element (form) containing the target
+    # @return [nil]
+    def click_button_in_form(target, _value, element)
+      element.find(target).click
+    end
+
+    # Sets the file to be uploaded
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [nil]
+    def set_file_upload(target, value, element)
+      if target.is_a?(String) && %w(first last).include?(target)
+        file_upload = element.find_all(:css, "input[type='file']").send(target)
+      elsif target.is_a?(String)
+        target_type = %r{^//} =~ target ? :xpath : :css
+        file_upload = element.find(target_type, target, match: :first)
+      elsif target.is_a?(Hash)
+        key, input_name = target.first
+        locator = "input[#{key}='#{input_name}']"
+        file_upload = element.find(:css, locator, match: :first)
+      end
+
+      raise Errno::ENOENT unless File.exist?(File.absolute_path(value))
+
+      file_upload.set(File.absolute_path(value))
+    end
+
+    # Saves the current page.
+    #
+    # @param _target [String] the target (unused)
+    # @param value [String] the value, i.e. the filename
+    # @param _element [Capybara::Node::Element] the element (unused)
+    # @return [String]
+    # Examples:
+    #
+    #    bot.save_html(nil, "/tmp/myfile-%{timestamp}.html")
+    #    # => "/tmp/myfile-%{timestamp}.html"
+    def save_page_html(_target, value, _element)
+      filename = value % { timestamp: Time.now.strftime("%Y-%m-%d_%H-%M-%S") }
+      @bot.save_page(filename)
+    end
+
+    # Saves a value to a given hash
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Hash]
+    def save_value(target, value, _element, val_hash)
+      target_type = %r{^/} =~ target ? :xpath : :css
+      elements = @bot.find_all(target_type, target)
+      return val_hash if elements.empty?
+
+      val_hash[value.to_sym] = if elements.size == 1
+                                 Nokogiri::XML(elements.first["outerHTML"]).children.first
+                               else
+                                 val_hash[value.to_sym] = elements.map { |e| Nokogiri::XML(e["outerHTML"]).children.first }
+                               end
+
+      val_hash
+    end
+
+    ## FORM METHODS ##
+    # Must have an element passed to them (except get form)
+
+    # Gets a form element
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Capybara::Node::Element]
+    def get_form(target, _value, _element)
+      if target.is_a?(Hash)
+        type, target = target.first
+        return @bot.find(type, target)
+      elsif target.is_a?(String)
+        index = %w(first last).index(target)
+        return @bot.find(target) if index < 0
+      end
+
+      index = target if index < 0
+
+      @bot.find_all("form")[index]
+    end
+
+    # Finds the form field for a given element.
+    #
+    # @param target [String] the target (name) of the field
+    # @param _value [String] the value (unused)
+    # @param element [Capybara::Node::Element] the element containing the field
+    # @return [Capybara::Node::Element]
+    def get_field(target, _value, element)
+      # raise no element passed in? Invalid element?
+      element.find_field(target)
+    end
+
+    # Fills in a input element
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Capybara::Node::Element]
+    def fill_in_input(target, value, element)
+      key, input_name = target.first
+      input = element.find("input[#{key}='#{input_name}']")
+      raise(NoInputFound, "For target: #{target}") unless input
+      input.set value
+
+      element
+    end
+
+    # Submit a form
+    #
+    # @param _target [String] the target (unused)
+    # @param _value [String] the value (unused)
+    # @param element [Capybara::Node::Element] the element
+    # @return [nil]
+    def submit(_target, _value, element)
+      element.find('input[type="submit"]').click
+    rescue Capybara::ElementNotFound
+      element.click
+    end
+
+    # Selects the options from a <select> input.Clicks/
+    #
+    # @param target [String] the target, the label or value for the Select Box
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Capybara::Node::Element]
+    def select_field(target, _value, element)
+      # NOTE: Capybara selects from the option's label, i.e. the text, not the
+      #       option value. If it can't find the matching text, it raises a
+      #       Capybara::ElementNotFound error. In this situation, we should find
+      #       that select option manually.
+      #
+      #       <select>
+      #         <option value="1">Hello</option>
+      #         <option value="2">Hi</option>
+      #       </select>
+      #
+      #       These two commands are equivalent
+      #
+      #       1. element.select("Hello")
+      #       2. element.find("option[value='1']").select_option
+      if target.is_a?(Hash)
+        key, value = target.first
+        element.find("option[#{key}='#{value}']").select_option
+      else
+        element.select(target)
+      end
+    rescue Capybara::ElementNotFound
+      element.find("option[value='#{target}']").select_option
+    rescue Capybara::Ambiguous
+      raise(MultipleOptionsFoundError, "For target: #{target}")
+    end
+
+    # Checks a checkbox
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [nil]
+    def select_checkbox(target, _value, element)
+      if target.is_a?(Array)
+        target.each do |tar|
+          key, value = tar.first
+          element.find(:css, "input[#{key}='#{value}']").set(true)
+        end
+      else
+        begin
+          element.check(target)
+        rescue Capybara::ElementNotFound
+          element.find(:css, target).set(true)
+        end
+      end
+    end
+
+    # Select a radio button
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Capybara::Node::Element]
+    def select_radio_button(target, value, element)
+      if target.is_a?(Array)
+        return target.map { |tar| select_radio_button(tar, value, element) }
+      elsif target.is_a?(Hash)
+        key, value = target.first
+        radio = element.find(:css, "input[#{key}='#{value}']")
+        radio.set(true)
+      else
+        begin
+          element.choose(target)
+        rescue Capybara::ElementNotFound
+          radio = element.find(:css, target)
+          radio.set(true)
+        end
+      end
+
+      radio || element.find(target)
+    end
+
+    # Selects the first radio button
+    #
+    # @param target [String] the target
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Capybara::Node::Element]
+    def select_first_radio_button(_target, _value, element)
+      radio = element.find(:css, "input[type='radio']", match: :first)
+      radio.set(true)
+
+      radio
+    end
+
+    ## VALIDATION METHODS ##
+
+    # Tests if the value provided equals the current URL.
+    #
+    # @param _target [String] the target (unused)
+    # @param value [String] the value
+    # @param _element [Capybara::Node::Element] the element (unused)
+    # @return [Boolean]
+    def url_equals(_target, value, _element)
+      !!(@bot.current_url == value)
+    end
+
+    # Tests if the body includes the value or values provided.
+    #
+    # @param target [String] the target
+    # @param value [String, Regexp, Array[String, Regexp]] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Boolean]
+    def body_includes(target, value, element)
+      if value.is_a?(Array)
+        # FIXME: this should probably return true if all the values exist.
+        val_check_arr = value.map { |v| body_includes(target, v, element) }
+        val_check_arr.uniq.include?(true)
+      else
+        !!(body.index(value) && body.index(value) > 0)
+      end
+    end
+
+    # Tests if the value provided equals the value of the element
+    #
+    # @param _target [String] the target (unused)
+    # @param value [String] the value
+    # @param element [Capybara::Node::Element] the element
+    # @return [Boolean]
+    def value_equals(_target, value, element)
+      !!(element && (element.value == value))
+    end
+  end
+end

data/lib/web_minion/bots/elements/file_upload_element.rb

@@ -0,0 +1,40 @@
+require 'web_minion/bots/elements/file_upload_element'
+
+class FileUploadElement < MechanizeElement
+  def initialize(bot, target, value, element)
+    super(bot, target, value, element)
+  end
+
+  def set_file
+    case @target_type
+    when :index
+      index_set
+    when :string_path
+      string_set
+    when :first_last
+      first_last_set
+    else
+      raise(InvalidTargetType, "#{@target_type} is not valid!")
+    end
+  end
+
+  private
+
+  def index_set
+    @element.file_uploads[@target].file_name = @value
+  end
+
+  def string_set
+    @element.file_upload_with(@target).file_name = @value
+  end
+
+  def first_last_set
+    if @target == "first"
+      @element.file_uploads.first.file_name = @value
+    elsif @target == "last"
+      @element.file_uploads.last.file_name = @value
+    else
+      raise(InvalidTargetType, "#{@target} is not first or last!")
+    end
+  end
+end

data/lib/web_minion/bots/elements/form_element.rb

@@ -0,0 +1,40 @@
+require "web_minion/bots/elements/mechanize_element"
+
+class FormElement < MechanizeElement
+  def initialize(bot, target, value = nil, element = nil)
+    super(bot, target, value, element)
+  end
+
+  def get
+    case @target_type
+    when :index
+      index_get
+    when :string_path
+      string_get
+    when :first_last
+      first_last_get
+    else
+      raise(InvalidTargetType, "#{@target_type} is not valid!")
+    end
+  end
+
+  private
+
+  def first_last_get
+    if @target == "first"
+      @bot.page.forms.first
+    elsif @target == "last"
+      @bot.page.forms.last
+    else
+      raise(InvalidTargetType, "#{@target} is not first or last!")
+    end
+  end
+
+  def index_get
+    @bot.page.forms[@target]
+  end
+
+  def string_get
+    @bot.page.form_with(@target)
+  end
+end

data/lib/web_minion/bots/elements/mechanize_element.rb

@@ -0,0 +1,27 @@
+class MechanizeElement
+  class InvalidTargetType < StandardError; end
+
+  attr_reader :bot, :target, :value, :element, :target_type
+
+  def initialize(bot, target, value = nil, element = nil)
+    @bot = bot
+    @target = target
+    @target_type = determine_target_type(target)
+    @value = value
+    @element = element
+  end
+
+  private
+
+  def determine_target_type(target)
+    if target.is_a? Integer
+      return :index
+    else
+      if %w(first last).include?(target)
+        return :first_last
+      end
+
+      :string_path
+    end
+  end
+end

data/lib/web_minion/bots/mechanize_bot.rb

@@ -1,9 +1,9 @@
 require "mechanize"
 require "web_minion/bots/bot"
+require "web_minion/bots/elements/form_element"
+require "web_minion/bots/elements/file_upload_element"
 
-class MultipleOptionsFoundError < StandardError; end
-class NoInputFound < StandardError; end
-# Mechanize driven bot. More efficient, but can"t handle any dynamic js-driven
+# Mechanize driven bot. More efficient, but can't handle any dynamic js-driven
 # pages
 module WebMinion
   class MechanizeBot < WebMinion::Bot
@@ -33,19 +33,39 @@ module WebMinion
       element.button_with(target).click
     end
 
+    def set_file_upload(target, value, element)
+      FileUploadElement.new(@bot, target, value, element).set_file
+    end
+
+    # ability to save dynamic dates in the filename with string "INSERT_DATE"
+    # so a value of "myfilename-INSERT_DATE.html" will look like this:
+    # "myfilename-2016-09-19_18-51-40.html"
+    # if you want multiple steps saving at the same time without overwriting,
+    # rename save_html step in your json (i.e. 'save_html_confirmation' etc)
     def save_page_html(_target, value, _element)
+      if value.include?("INSERT_DATE")
+        time = Time.now.strftime('%Y-%m-%d_%H-%M-%S').to_s
+        value = value.split("INSERT_DATE").insert(1, time).join
+      end
       write_html_file(value)
     end
 
-    ## FORM METHODS ##
-    # Must have an element passed to them (except get form)
+    def save_value(target, value, _element, val_hash)
+      element = @bot.page.search(target)
 
-    def get_form_in_index(target, _value, _element)
-      @bot.page.forms[target]
+      if val_hash[value.to_sym]
+        val_hash[value.to_sym] << element if element
+      else
+        val_hash[value.to_sym] = element if element
+      end
+
+      val_hash
     end
 
+    ## FORM METHODS ##
+    # Must have an element passed to them (except get form)
     def get_form(target, _value, _element)
-      @bot.page.form_with(target)
+      FormElement.new(@bot, target, nil, nil).get
     end
 
     def get_field(target, _value, element)
@@ -71,7 +91,11 @@ module WebMinion
     end
 
     def select_checkbox(target, _value, element)
-      element.checkbox_with(target).check
+      if target.is_a?(Array)
+        target.each { |tar| select_checkbox(tar, nil, element) }
+      else
+        element.checkbox_with(target).check
+      end
     end
 
     def select_radio_button(target, _value, element)
@@ -93,7 +117,15 @@ module WebMinion
     end
 
     def body_includes(_target, value, _element)
-      !!(body.index(value) && body.index(value) > 0)
+      if value.is_a?(Array)
+        val_check_arr = []
+        value.each do |val|
+          val_check_arr << !!(body.index(val) && body.index(val) > 0)
+        end
+        val_check_arr.uniq.include?(true)
+      else
+        !!(body.index(value) && body.index(value) > 0)
+      end
     end
 
     def value_equals(_target, value, element)

data/lib/web_minion/drivers/capybara.rb

@@ -0,0 +1,2 @@
+require "capybara/poltergeist" if $LOAD_PATH.select { |p| p.include? "poltergeist" }
+require "web_minion/bots/capybara_bot"

data/lib/web_minion/drivers/mechanize.rb

@@ -0,0 +1 @@
+require "web_minion/bots/mechanize_bot"

data/lib/web_minion/flow.rb

@@ -13,25 +13,32 @@ module WebMinion
     class NoStartingActionError < StandardError; end
     class CyclicalFlowError < StandardError; end
 
-    attr_accessor :actions, :bot, :history
-    attr_writer :name
-    attr_reader :curr_action, :starting_action
+    attr_accessor :actions, :bot, :history, :name, :vars
+    attr_reader :curr_action, :starting_action, :saved_values
 
-    def initialize(actions, bot, name = "")
+    def initialize(actions, bot, vars = {}, name = "")
       @actions = actions
       @bot = bot
       @name = name
+      @vars = vars
       @history = nil
+      @saved_values = {}
     end
 
-    def self.build_via_json(rule_json)
+    def self.build_via_json(rule_json, vars = {})
       ruleset = JSON.parse(rule_json)
-      bot = MechanizeBot.new(ruleset["config"])
-      build_from_hash(ruleset["flow"].merge(bot: bot))
+      driver = ruleset["config"]["driver"] || "mechanize"
+      bot = if driver == "mechanize"
+              MechanizeBot.new(ruleset["config"])
+            else
+              CapybaraBot.new(ruleset["config"])
+            end
+      build_from_hash(ruleset["flow"].merge(bot: bot, vars: vars))
     end
 
     def self.build_from_hash(fields = {})
       flow = new([], nil, nil)
+      flow.vars = fields[:vars] if fields[:vars]
       fields.each_pair do |k, v|
         flow.send("#{k}=", v)
       end
@@ -41,7 +48,7 @@ module WebMinion
     def actions=(actions)
       @actions = {}
       actions.each do |act|
-        action = Action.build_from_hash(act)
+        action = Action.build_from_hash(act, @vars)
         @actions[action.key] = action
         @starting_action = action if action.starting_action?
       end
@@ -56,23 +63,30 @@ module WebMinion
 
     def perform
       @history = FlowHistory.new
-      status = execute_action(@starting_action)
+      status = execute_action(@starting_action, @saved_values)
       @history.end_time = Time.now
       @history.status = status
-      @history
+      results
     end
 
     private
 
-    def execute_action(action)
+    def results
+      {
+        history: @history,
+        saved_values: @saved_values
+      }
+    end
+
+    def execute_action(action, saved_values = {})
       @curr_action = action
       @history.action_history << ActionHistory.new(action.name, action.key)
-      status = action.perform(@bot)
+      status = action.perform(@bot, saved_values)
       update_action_history(status)
       if status
-        action.ending_action? ? true : execute_action(action.on_success)
+        action.ending_action? ? true : execute_action(action.on_success, saved_values)
       else
-        action.on_failure ? execute_action(action.on_failure) : false
+        action.on_failure ? execute_action(action.on_failure, saved_values) : false
       end
     end
 

data/lib/web_minion/histories/history.rb

@@ -2,6 +2,10 @@ module WebMinion
   # Histories are used to log the events as the bot performs its flows, steps,
   # and actions
   class History
+    class InvalidStatus < StandardError; end
+
+    VALID_STATUSES = %w(Successful Unsuccessful Skipped).freeze
+
     attr_reader :runtime, :status, :start_time, :end_time
 
     def initialize(start_time = nil)
@@ -10,12 +14,27 @@ module WebMinion
     end
 
     def status=(status)
-      @status = status ? "Successful" : "Unsuccessful"
+      @status = parse_status(status)
     end
 
     def end_time=(end_time)
       @end_time = end_time
       @runtime = @end_time - @start_time if @start_time && @end_time
     end
+
+    private
+
+    def parse_status(status)
+      if [TrueClass, FalseClass].include? status.class
+        status ? "Successful" : "Unsuccessful"
+      elsif [String, Symbol].include? status.class
+        unless VALID_STATUSES.include? status.capitalize
+          raise(InvalidStatus, "#{status} is not a valid!")
+        end
+        status.to_s.capitalize
+      else
+        raise(InvalidStatus, "#{status} must be a boolean, string, or symbol.")
+      end
+    end
   end
 end

data/lib/web_minion/step.rb

@@ -1,45 +1,63 @@
 module WebMinion
   class InvalidMethodError < StandardError; end
-
+  class NoValueForVariableError < StandardError; end
   # A Step represents the individual operation that the bot will perform. This
   # often includes grabbing an element from the DOM tree, or performing some
   # operation on an element that has already been found.
   class Step
-    attr_accessor :name, :target, :method, :value, :is_validator, :retain_element
-
-    VALID_METHODS = [
-      :go,
-      :select,
-      :click,
-      :click_button_in_form,
-      :get_form,
-      :get_form_in_index,
-      :get_field,
-      :select_field,
-      :select_radio_button,
-      :select_first_radio_button,
-      :select_checkbox,
-      :submit,
-      :fill_in_input,
-      :url_equals,
-      :value_equals,
-      :body_includes,
-      :save_page_html
-    ].freeze
+    attr_accessor :name, :target, :method, :value, :is_validator, :retain_element, :skippable
+    attr_reader :saved_values, :vars
+
+    VALID_METHODS = {
+      select: [
+        :field,
+        :radio_button,
+        :first_radio_button,
+        :checkbox
+      ],
+      main_methods: [
+        :set_file_upload,
+        :get_field,
+        :get_form,
+        :go,
+        :select,
+        :click,
+        :click_button_in_form,
+        :submit,
+        :fill_in_input,
+        :url_equals,
+        :value_equals,
+        :body_includes,
+        :save_page_html,
+        :save_value
+      ]
+    }.freeze
 
     def initialize(fields = {})
       fields.each_pair do |k, v|
-        send("#{k}=", v)
+        if valid_method?(k.to_sym)
+          send("method=", k)
+          @target = v
+        else
+          send("#{k}=", v)
+        end
       end
+
+      replace_all_variables
+    end
+
+    def vars=(vars)
+      @vars = Hash[vars.collect{ |k, v| [k.to_s, v] }]
     end
 
-    def perform(bot, element = nil)
-      bot.execute_step(@method, @target, @value, element)
+    def perform(bot, element = nil, saved_values)
+      bot.execute_step(@method, @target, @value, element, saved_values)
     end
 
     def method=(method)
       raise(InvalidMethodError, "Method: #{method} is not valid") unless valid_method?(method.to_sym)
-      @method = method.to_sym
+      split = method.to_s.split("/").map(&:to_sym)
+      @method = split.count > 1 ? "#{split[0]}_#{split[1]}".to_sym : method.to_sym
     end
 
     def retain?
@@ -51,7 +69,42 @@ module WebMinion
     end
 
     def valid_method?(method)
-      VALID_METHODS.include?(method)
+      split = method.to_s.split("/").map(&:to_sym)
+      if split.count > 1
+        return true if VALID_METHODS[split[0]].include?(split[1])
+      end
+      VALID_METHODS[:main_methods].include?(method)
+    end
+
+    private
+
+    def replace_all_variables
+      %w(value target).each do |field|
+        next if send(field).nil?
+        send("#{field}=", replace_variable(send(field)))
+      end
+    end
+
+    def replace_variable(var)
+      if var.is_a?(Hash)
+        return handle_hash_replacement(var)
+      else
+        return var unless var.is_a?(String)
+        # This will handle email addresses
+        return var if var.match(/\w+@\D+\.\D+/)
+        if replace_var = var.match(/@(\D+)/)
+          raise(NoValueForVariableError, "no variable to use found for #{replace_var}") unless @vars[replace_var[1]]
+          var = @vars[replace_var[1]]
+        end
+      end
+      var
+    end
+
+    def handle_hash_replacement(hash)
+      hash.each_pair do |k, v|
+        hash[k] = replace_variable(v)
+      end
+      hash
     end
   end
 end

data/lib/web_minion/version.rb

@@ -1,3 +1,3 @@
 module WebMinion
-  VERSION = "0.1.0".freeze
+  VERSION = "0.3.0".freeze
 end

data/web_minion.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "bin"
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = "web_minion" 
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: web_minion
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Parrish
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2016-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,8 +56,7 @@ description: A metadata-driven browser automation.
 email:
 - m.andrewparrish@gmail.com
 executables:
-- console
-- setup
+- web_minion
 extensions: []
 extra_rdoc_files: []
 files:
@@ -71,12 +70,18 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/jibe_ruleset_bot/version.rb
+- bin/web_minion
 - lib/web_minion.rb
 - lib/web_minion/action.rb
 - lib/web_minion/bots/bot.rb
+- lib/web_minion/bots/capybara_bot.rb
+- lib/web_minion/bots/elements/file_upload_element.rb
+- lib/web_minion/bots/elements/form_element.rb
+- lib/web_minion/bots/elements/mechanize_element.rb
 - lib/web_minion/bots/mechanize_bot.rb
 - lib/web_minion/cycle_checker.rb
+- lib/web_minion/drivers/capybara.rb
+- lib/web_minion/drivers/mechanize.rb
 - lib/web_minion/flow.rb
 - lib/web_minion/histories/action_history.rb
 - lib/web_minion/histories/flow_history.rb

data/lib/jibe_ruleset_bot/version.rb

@@ -1,3 +0,0 @@
-module WebMinion
-  VERSION = "0.1.0".freeze
-end