metallize 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c73d9917bd4adae0a41a4ed1c2a152af4861deb
+  data.tar.gz: c782498d465db2481a33683a749782b9f9e95996
+SHA512:
+  metadata.gz: 0891c321113a414dfe07fe7d3d3ecaf97e2723d78246e539a28d08d45f2e4bed556634d89c8233f985e4141412c08c28d85f0b51716fdc2dd2770af1db9bd5d7
+  data.tar.gz: 4045961d464c82d642eb303dc46a7fc3bea3b75a777c3f34874c970b28c444297a491e223d8a7c6a1c712ec16a8d2ebf2039b414918e40c6d79c9a3495cb84fd

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/*

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in metallize.gemspec
+gemspec
+
+gem 'selenium-webdriver'
+gem 'rspec'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sam Treweek
+
+MIT License
+
+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,29 @@
+# Metallize
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'metallize'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metallize
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/metallize/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/metallize.rb

@@ -0,0 +1,47 @@
+require 'metallize/version'
+require 'selenium-webdriver'
+require 'pp'
+
+require 'metallize/page'
+require 'metallize/element_matcher'
+
+require 'metallize/form'
+require 'metallize/form/field'
+require 'metallize/form/button'
+require 'metallize/form/hidden'
+require 'metallize/form/submit'
+require 'metallize/form/text'
+require 'metallize/form/multi_select_list'
+require 'metallize/form/select_list'
+require 'metallize/form/option'
+
+require 'metallize/page'
+require 'metallize/page/link'
+
+class Metallize
+
+  attr_reader :driver
+
+  def initialize(browser)
+    @driver = Selenium::WebDriver.for browser
+  end
+
+  def get(uri)
+    driver.get(uri)
+    Page.new(driver)
+  end
+
+  def quit
+    driver.quit
+  end
+
+  alias :close :quit
+
+  def method_missing(sym)
+    driver.send sym
+  end
+
+  def self.inspect
+    'Metallize; Mechanize API using Selenium-WebDriver'
+  end
+end

data/lib/metallize/element_matcher.rb

@@ -0,0 +1,65 @@
+module Metallize::ElementMatcher
+
+  def elements_with singular, plural = "#{singular}s"
+    class_eval <<-CODE
+      def #{plural}_with criteria = {}
+        selector = method = nil
+        if String === criteria then
+          criteria = {:name => criteria}
+        else
+          criteria = criteria.each_with_object({}) { |(k, v), h|
+            case k = k.to_sym
+            when :id
+              h[:dom_id] = v
+            when :class
+              h[:dom_class] = v
+            when :search, :xpath, :css
+              if v
+                selector = v
+                method = k
+              end
+            else
+              h[k] = v
+            end
+          }
+        end
+
+        f = select_#{plural}(selector, method).find_all do |thing|
+          criteria.all? do |k,v|
+            v === thing.send(k)
+          end
+        end
+        yield f if block_given?
+        f
+      end
+
+      def #{singular}_with criteria = {}
+        f = #{plural}_with(criteria).first
+        yield f if block_given?
+        f
+      end
+
+      def #{singular}_with! criteria = {}
+        f = #{singular}_with(criteria)
+        raise Mechanize::ElementNotFoundError.new(self, :#{singular}, criteria) if f.nil?
+        yield f if block_given?
+        f
+      end
+
+      def select_#{plural} selector, method = :search
+        if selector.nil? then
+          #{plural}
+        else
+          nodes = __send__(method, selector)
+          #{plural}.find_all do |element|
+            nodes.include?(element.node)
+          end
+        end
+      end
+
+      alias :#{singular} :#{singular}_with
+    CODE
+  end
+
+end
+

data/lib/metallize/form.rb

@@ -0,0 +1,284 @@
+require_relative 'element_matcher'
+
+class Metallize::Form
+
+  extend Metallize::ElementMatcher
+
+    attr_accessor :method, :action, :name
+
+    attr_reader :fields, :buttons, :file_uploads, :radiobuttons, :checkboxes
+
+    # Content-Type for form data (i.e. application/x-www-form-urlencoded)
+    attr_accessor :enctype
+
+    # Character encoding of form data (i.e. UTF-8)
+    attr_accessor :encoding
+
+    # When true, character encoding errors will never be never raised on form
+    # submission.  Default is false
+    attr_accessor :ignore_encoding_error
+
+    alias :elements :fields
+
+    attr_reader :form_node
+    attr_reader :page
+
+    attr_accessor :method, :action
+
+    attr_reader :fields, :buttons
+
+    alias :elements :fields
+
+    def initialize(driver, form)
+      @driver = driver
+      @form   = form
+      @method = (@form.attribute('method') || 'GET').upcase
+      @action = @form.attribute('action')
+      parse
+    end
+
+    def name
+      @form.attribute('name')
+    end
+
+    def parse
+      @fields       = []
+      @buttons      = []
+
+      form_node = @driver.find_elements(:tag_name, 'input')
+      form_node.each do |node|
+        type = (node.attribute('type') || 'text').downcase
+        name = node.attribute('name')
+        next if name.nil? && !%w[submit button image].include?(type)
+        case type
+          when 'submit'
+            @buttons << Submit.new(node)
+          when 'button'
+            @buttons << Button.new(node)
+          when 'hidden'
+            @fields << Hidden.new(node, node.attribute('value') || '')
+          when 'text'
+            @fields << Text.new(node, node.attribute('value') || '')
+          else
+            @fields << Field.new(node, node.attribute('value') || '')
+        end
+
+        form_node = @driver.find_elements(:tag_name, 'select')
+        form_node.each do |node|
+          next unless node['name']
+          @fields << SelectList.new(node)
+        end
+
+        form_node = @driver.find_elements(:tag_name, 'button')
+        form_node.each do |node|
+          @buttons << Button.new(node)
+        end
+      end
+
+      def has_value?(value)
+        fields.find { |f| f.value == value }
+      end
+
+      # Returns all field names (keys) for this form
+      def keys
+        fields.map { |f| f.name }
+      end
+
+      # Returns all field values for this form
+      def values
+        fields.map { |f| f.value }
+      end
+
+      # Returns all buttons of type Submit
+      def submits
+        @submits ||= buttons.select { |f| f.class == Submit }
+      end
+
+      # Returns all buttons of type Reset
+      def resets
+        @resets ||= buttons.select { |f| f.class == Reset }
+      end
+
+      # Returns all fields of type Text
+      def texts
+        @texts ||= fields.select { |f| f.class == Text }
+      end
+
+      # Returns all fields of type Hidden
+      def hiddens
+        @hiddens ||= fields.select { |f| f.class == Hidden }
+      end
+
+      # Returns all fields of type Textarea
+      def textareas
+        @textareas ||= fields.select { |f| f.class == Textarea }
+      end
+
+      # Returns all fields of type Keygen
+      def keygens
+        @keygens ||= fields.select { |f| f.class == Keygen }
+      end
+
+      # Returns whether or not the form contains a Submit button named +button_name+
+      def submit_button?(button_name)
+        submits.find { |f| f.name == button_name }
+      end
+
+      # Returns whether or not the form contains a Reset button named +button_name+
+      def reset_button?(button_name)
+        resets.find { |f| f.name == button_name }
+      end
+
+      # Returns whether or not the form contains a Text field named +field_name+
+      def text_field?(field_name)
+        texts.find { |f| f.name == field_name }
+      end
+
+      # Returns whether or not the form contains a Hidden field named +field_name+
+      def hidden_field?(field_name)
+        hiddens.find { |f| f.name == field_name }
+      end
+
+      # Returns whether or not the form contains a Textarea named +field_name+
+      def textarea_field?(field_name)
+        textareas.find { |f| f.name == field_name }
+      end
+
+      # This method is a shortcut to get form's DOM id.
+      # Common usage:
+      #   page.form_with(:dom_id => "foorm")
+      # Note that you can also use +:id+ to get to this method:
+      #   page.form_with(:id => "foorm")
+      def dom_id
+        form_node['id']
+      end
+
+      # This method is a shortcut to get form's DOM class.
+      # Common usage:
+      #   page.form_with(:dom_class => "foorm")
+      # Note that you can also use +:class+ to get to this method:
+      #   page.form_with(:class => "foorm")
+      def dom_class
+        form_node['class']
+      end
+
+      # Add a field with +field_name+ and +value+
+      def add_field!(field_name, value = nil)
+        fields << Field.new({'name' => field_name}, value)
+      end
+
+      ##
+      # This method sets multiple fields on the form.  It takes a list of +fields+
+      # which are name, value pairs.
+      #
+      # If there is more than one field found with the same name, this method will
+      # set the first one found.  If you want to set the value of a duplicate
+      # field, use a value which is a Hash with the key as the index in to the
+      # form.  The index is zero based.
+      #
+      # For example, to set the second field named 'foo', you could do the
+      # following:
+      #
+      #   form.set_fields :foo => { 1 => 'bar' }
+      def set_fields fields = {}
+        fields.each do |name, v|
+          case v
+            when Hash
+              v.each do |index, value|
+                self.fields_with(:name => name.to_s)[index].value = value
+              end
+            else
+              value = nil
+              index = 0
+
+              [v].flatten.each do |val|
+                index = val.to_i if value
+                value = val unless value
+              end
+
+              self.fields_with(:name => name.to_s)[index].value = value
+          end
+        end
+      end
+
+      # Fetch the value of the first input field with the name passed in. Example:
+      #  puts form['name']
+      def [](field_name)
+        f = field(field_name)
+        f && f.value
+      end
+
+      # Set the value of the first input field with the name passed in. Example:
+      #  form['name'] = 'Aaron'
+      def []=(field_name, value)
+        f = field(field_name)
+        if f
+          f.value = value
+        else
+          add_field!(field_name, value)
+        end
+      end
+
+    end
+
+    def pretty_print(q) # :nodoc:
+      q.object_group(self) {
+        q.breakable; q.group(1, '{name', '}') { q.breakable; q.pp name }
+        q.breakable; q.group(1, '{method', '}') { q.breakable; q.pp method }
+        q.breakable; q.group(1, '{action', '}') { q.breakable; q.pp action }
+        q.breakable; q.group(1, '{fields', '}') {
+          fields.each do |field|
+            q.breakable
+            q.pp field
+          end
+        }
+        # q.breakable; q.group(1, '{radiobuttons', '}') {
+        #   radiobuttons.each { |b| q.breakable; q.pp b }
+        # }
+        # q.breakable; q.group(1, '{checkboxes', '}') {
+        #   checkboxes.each { |b| q.breakable; q.pp b }
+        # }
+        # q.breakable; q.group(1, '{file_uploads', '}') {
+        #   file_uploads.each { |b| q.breakable; q.pp b }
+        # }
+        q.breakable; q.group(1, '{buttons', '}') {
+          buttons.each { |b| q.breakable; q.pp b }
+        }
+      }
+    end
+
+    elements_with :field
+
+    def submit
+      # 1. Loop through the non hidden fields and if they're active and displayed enter the value
+      @fields.each do |field|
+        unless field.kind_of?(Metallize::Form::Hidden)
+
+          element = @driver.find_element(name: field.name)
+          if element.displayed? and !field.value.empty?
+            element.send_keys field.value
+          end
+
+        end
+      end
+
+      # 2. Submit Form
+      @buttons.first.node.click
+
+      wait_for_page(@driver)
+
+      # 4. Return new Page
+      Metallize::Page.new(@driver)
+
+    end
+
+    def wait_for_page(driver)
+      # 3. Wait for the Page State to Return
+      wait = Selenium::WebDriver::Wait.new(:timeout => 10)
+      wait.until {
+        driver.execute_script("return document.readyState;") == "complete"
+      }
+    end
+
+
+  end

data/lib/metallize/form/button.rb

@@ -0,0 +1,2 @@
+class Metallize::Form::Button < Metallize::Form::Field
+end

data/lib/metallize/form/field.rb

@@ -0,0 +1,19 @@
+class Metallize::Form::Field
+
+  attr_accessor :name, :value, :node, :type
+
+  def initialize(node, value = node.attribute('value'))
+    @node  = node
+    @name  = node.attribute('name')
+    @type  = node.attribute('type')
+    @value = value
+  end
+
+  def inspect # :nodoc:
+    "[%s:0x%x type: %s name: %s value: %s]" % [
+        self.class.name.sub(/Metallize::Form::/, '').downcase,
+        object_id, type, name, value
+    ]
+  end
+
+end

data/lib/metallize/form/hidden.rb

@@ -0,0 +1,2 @@
+class Metallize::Form::Hidden < Metallize::Form::Field
+end

data/lib/metallize/form/multi_select_list.rb

@@ -0,0 +1,53 @@
+class Metallize::Form::MultiSelectList < Metallize::Form::Field
+
+  extend Metallize::ElementMatcher
+
+  attr_accessor :options
+
+  def initialize node
+    value    = []
+    @options = []
+
+    # parse
+    node.find_elements(:tag_name, 'option').each do |n|
+      @options << Metallize::Form::Option.new(n, self)
+    end
+
+    super node, value
+
+  end
+
+  elements_with :option
+
+  # Select no options
+  def select_none
+    @value = []
+    options.each { |o| o.untick }
+  end
+
+  def value=(values)
+    select_none
+    [values].flatten.each do |value|
+      option = options.find { |o| o.value == value }
+      if option.nil?
+        @value.push(value)
+      else
+        option.node.click
+      end
+    end
+  end
+
+  # Get a list of all selected options
+  def selected_options
+    @options.find_all { |o| o.selected? }
+  end
+
+  def value
+    value = []
+    value.concat @value
+    value.concat selected_options.map { |o| o.value }
+    value.first
+  end
+
+end
+

data/lib/metallize/form/option.rb

@@ -0,0 +1,48 @@
+class Metallize::Form::Option
+
+  attr_reader :value, :selected, :text, :select_list, :node
+
+  alias :selected? :selected
+
+  def has_attribute?(node, attr)
+    if node.attribute(attr)
+      true
+    else
+      false
+    end
+  end
+
+  def initialize(node, select_list)
+    @node        = node
+    @text        = node.attribute('innerText')
+    @value       = node.attribute('value') || node.attribute('innerText')
+    @selected    = has_attribute? node, 'selected'
+    @select_list = select_list # The select list this option belongs to
+  end
+
+
+  # Select this option
+  def select
+    unselect_peers
+    @selected = true
+    # option = Selenium::WebDriver::Support::Select.new(node)
+    # option
+  end
+
+  # Unselect this option
+  def unselect
+    @selected = false
+  end
+
+  alias :tick   :select
+  alias :untick :unselect
+
+
+  private
+  def unselect_peers
+    # return unless Mechanize::Form::SelectList === @select_list
+
+    @select_list.select_none
+  end
+
+end

data/lib/metallize/form/select_list.rb

@@ -0,0 +1,7 @@
+class Metallize::Form::SelectList < Metallize::Form::MultiSelectList
+
+  def initialize node
+    super
+  end
+
+end

data/lib/metallize/form/submit.rb

@@ -0,0 +1,2 @@
+class Metallize::Form::Submit < Metallize::Form::Field
+end

data/lib/metallize/form/text.rb

@@ -0,0 +1,2 @@
+class Metallize::Form::Text < Metallize::Form::Field
+end

data/lib/metallize/page.rb

@@ -0,0 +1,62 @@
+require_relative 'element_matcher'
+
+class Metallize::Page
+
+  extend Metallize::ElementMatcher
+
+  attr_reader :driver
+
+  def initialize(driver)
+    @driver = driver
+  end
+
+  def title
+    driver.title
+  end
+
+  def uri
+    driver.current_url
+  end
+
+  def links
+    links = driver.find_elements(:tag_name, 'a')
+    links.map {|link| Link.new(driver, link)}
+  end
+
+  def forms
+    forms = driver.find_elements(:tag_name, 'form')
+    forms.map {|form| Metallize::Form.new(driver, form)}
+  end
+
+  def pretty_print(q)
+    q.object_group(self) {
+      q.breakable
+      q.group(1, '{url', '}') {q.breakable; q.pp uri }
+      q.breakable
+      # q.group(1, '{meta_refresh', '}') {
+      #   meta_refresh.each { |link| q.breakable; q.pp link }
+      # }
+      # q.breakable
+      q.group(1, '{title', '}') { q.breakable; q.pp title }
+      q.breakable
+      # q.group(1, '{iframes', '}') {
+      #   iframes.each { |link| q.breakable; q.pp link }
+      # }
+      # q.breakable
+      # q.group(1, '{frames', '}') {
+      #   frames.each { |link| q.breakable; q.pp link }
+      # }
+      # q.breakable
+      q.group(1, '{links', '}') {
+        links.each { |link| q.breakable; q.pp link }
+      }
+      # q.breakable
+      q.group(1, '{forms', '}') {
+        forms.each { |form| q.breakable; q.pp form }
+      }
+    }
+  end
+
+  elements_with :link
+
+end

data/lib/metallize/page/link.rb

@@ -0,0 +1,39 @@
+class Metallize::Page::Link
+
+  attr_reader :driver, :link
+
+  def initialize(driver, link)
+    @driver = driver
+    @link   = link
+  end
+
+  def text
+    link.text
+  end
+
+  def href
+    link_attribute = link.attribute('href')
+    URI(link_attribute).path
+  end
+
+  def click
+    link.click
+
+    # 1. Wait for the Page State to Return
+    wait = Selenium::WebDriver::Wait.new(:timeout => 10)
+    wait.until {
+      driver.execute_script("return document.readyState;") == "complete"
+    }
+
+    # 2. Return new Page
+    Metallize::Page.new(driver)
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.object_group(self) {
+      q.breakable; q.pp text
+      q.breakable; q.pp href
+    }
+  end
+
+end

data/lib/metallize/version.rb

@@ -0,0 +1,3 @@
+class Metallize
+  VERSION = "0.0.1"
+end

data/metallize.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metallize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "metallize"
+  spec.version       = Metallize::VERSION
+  spec.authors       = ["Sam Treweek"]
+  spec.email         = ["samtreweek@uksa.eu"]
+  spec.summary       = %q{Mechanize plus Selenium}
+  spec.description   = %q{Mechanize API with Selenium-WebDriver Library}
+  spec.homepage      = "http://uksa.eu"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency 'rake', '~> 0'
+end

data/test/htdocs/select.html

@@ -0,0 +1,11 @@
+<form action="/numbers" method="POST" name="post_numbers" id="post_numbers">
+    <select id="numbers" name="numbers" class="numbers" required="">
+        <option id="number_select_1" value="1">1</option>
+        <option id="number_select_2" value="2">2</option>
+        <option id="number_select_3" value="3">3</option>
+        <option id="number_select_4" value="4" selected="">4</option>
+        <option id="number_select_5" value="5">5</option>
+        <option id="number_select_7" value="7">7</option>
+    </select>
+    <input type="submit" class="btn-submit" id="submit" value="Submit">
+</form>

data/test/spec/select_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe '#HTML Element Select' do
+
+  before(:each) do
+    file = File.join(File.dirname(__FILE__),"../","htdocs/select.html")
+    @page = @metz.get "file://#{file}"
+    @form = @page.forms.first
+  end
+
+  it 'should return list of Options' do
+    options_value =  @form.field_with(name: 'numbers').options
+    expect(options_value.count).to eq 6
+  end
+
+  it 'should return a list of Option Values' do
+    options_value = @form.field_with(name: 'numbers').options.map(&:value)
+    expect(options_value.count).to eq 6
+  end
+
+  it 'should return current value of option' do
+    option_value = @form.field_with(name: 'numbers').value
+    expect(option_value).to eq "4"
+  end
+
+  it 'should change when a new value is selected' do
+    @form.field_with(name: 'numbers').value = '3'
+    page = @page.forms.first
+    option_value = page.field_with(name: 'numbers').value
+    expect(option_value).to eq '3'
+  end
+
+  it 'should return the selected option' do
+    option_value = @form.field_with(name: 'numbers').selected_options
+    expect(option_value.first.selected).to eq true
+  end
+
+  it 'should inspect the option' do
+    inspect = @form.field_with(name: 'numbers').inspect
+    expect(inspect).to include('value: 4')
+  end
+
+end

data/test/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'metallize'
+require 'rubygems'
+require 'webrick'
+
+include WEBrick
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:all) do
+    browser = [:chrome, :firefox].sample
+    puts "Used Browser: #{browser}"
+    @metz = Metallize.new(browser)
+  end
+
+  config.after(:all) do
+    @metz.quit
+  end
+
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: metallize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sam Treweek
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDeDCCAmCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBBMRMwEQYDVQQDDApzYW10
+  cmV3ZWVrMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZFgNj
+  b20wHhcNMTMxMDEzMjAxMjE5WhcNMTQxMDEzMjAxMjE5WjBBMRMwEQYDVQQDDApz
+  YW10cmV3ZWVrMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDt5a6qQLOOsPv7
+  cdGaWtu8g622mMvgLpP5DPDc3D6BMOib9wwSXhZJJBcddtO+QN52lRb0tBR8klBE
+  uqAbBkv2UuBCKu2cKFldCVMQ5KKwTxj25My8cG3UVX60o7uT7HmWOmsGXqojGw9f
+  DFdBzURwFwI5ZtKl3sblwl25AH4qmn+DbENMgrvlYDDGs+JRBGBeMU6fN30C0PvP
+  YVUAdt3GAOG4KxPvA/8e5FMwohiAV6OfVjdIz7XV3c95omrZtafVVj8jQsaPOCO4
+  YsBd9zrZAqglVp2yo5fEzAozKS6B6FE5n+wpBR9dhjXMhfCmKKuGPjD9zvnnaE6Y
+  KnCyK0j9AgMBAAGjezB5MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBSoLCC1wDQu43FFE55O778Ox77OmjAfBgNVHREEGDAWgRRzYW10cmV3ZWVrQGdt
+  YWlsLmNvbTAfBgNVHRIEGDAWgRRzYW10cmV3ZWVrQGdtYWlsLmNvbTANBgkqhkiG
+  9w0BAQUFAAOCAQEAJ3swCy1wmG6tQ9oer7PpxUhZzXPYZ8JBMFaZWbkirFeoI9Yn
+  c4qh0FyHnaM2pqde0pqOfbKxESUHSLtb8x2vhwpTvvsjRRixdMpIBP/Vtxp6p9Oa
+  Ayq5ITS201gMgktPhDO8MkaSpaxMXSCcMQSWuJmdY4uDv+mAY2ansK6mpwYLLi60
+  ovWjYMUykCDhWQH8l8SsWRkIKcVlnjgs73ZAKCSlehzPWCFBmMgpAZeMNFHw3a5k
+  qzoH/QN65IPJvffqtIusKUZBsHUKy9n60vrCEgK4ZTj+VZAjvxmPRB5UYDeP6xeh
+  SC+V9I2l+qX545yXG4raXDZqTyh9bsMrlE+5+A==
+  -----END CERTIFICATE-----
+date: 2015-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+description: Mechanize API with Selenium-WebDriver Library
+email:
+- samtreweek@uksa.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/metallize.rb
+- lib/metallize/element_matcher.rb
+- lib/metallize/form.rb
+- lib/metallize/form/button.rb
+- lib/metallize/form/field.rb
+- lib/metallize/form/hidden.rb
+- lib/metallize/form/multi_select_list.rb
+- lib/metallize/form/option.rb
+- lib/metallize/form/select_list.rb
+- lib/metallize/form/submit.rb
+- lib/metallize/form/text.rb
+- lib/metallize/page.rb
+- lib/metallize/page/link.rb
+- lib/metallize/version.rb
+- metallize.gemspec
+- test/htdocs/select.html
+- test/spec/select_spec.rb
+- test/spec/spec_helper.rb
+homepage: http://uksa.eu
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Mechanize plus Selenium
+test_files:
+- test/htdocs/select.html
+- test/spec/select_spec.rb
+- test/spec/spec_helper.rb