gondola 1.1.1 → 1.1.3

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "sauce", ">=0.17.5"
+gem "parallel", ">=0.5.2"
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/Gemfile.lock

@@ -0,0 +1,50 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    childprocess (0.1.7)
+      ffi (~> 0.6.3)
+    cmdparse (2.0.3)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    git (1.2.5)
+    highline (1.6.1)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.5.1)
+    json_pure (1.5.1)
+    mime-types (1.16)
+    net-ssh (2.1.3)
+    net-ssh-gateway (1.0.1)
+      net-ssh (>= 1.99.1)
+    parallel (0.5.2)
+    rake (0.8.7)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    rubyzip (0.9.4)
+    sauce (0.17.6)
+      childprocess (>= 0.1.6)
+      cmdparse (>= 2.0.2)
+      highline (>= 1.5.0)
+      json (>= 1.2.0)
+      net-ssh
+      net-ssh-gateway
+      rest-client
+      selenium-webdriver (>= 0.1.2)
+    selenium-webdriver (0.1.3)
+      childprocess (~> 0.1.5)
+      ffi (~> 0.6.3)
+      json_pure
+      rubyzip
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  parallel (>= 0.5.2)
+  sauce (>= 0.17.5)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Agora Games
+
+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.rdoc

@@ -0,0 +1,19 @@
+= gondola
+
+WORK IN PROGRESS
+
+== Contributing to gondola
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Agora Games. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'bundler'
+require './lib/gondola/version'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "gondola"
+  gem.homepage = "http://github.com/perrym5/gondola"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby command line utility and library for integrating the Selenium IDE more tightly with Sauce Labs' Ondemand services}
+  gem.description = %Q{
+    Gondola is Ruby command line utility and as well as a library  which helps
+    for integrate the Selenium IDE more tightly with Sauce Labs' Ondemand services and
+    provide greater ease for those who would like to use both tools but do not have
+    enough technical knowledge
+  }
+  gem.email = "mperry@agoragames.com"
+  gem.authors = ["Matthew Perry"]
+  gem.version = Gondola::Version::STRING
+  # Dependencies in GemFile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gondola #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/gondola

@@ -1,71 +1,68 @@
 #!/usr/bin/env ruby
 
-# Gondola v2
-# FILE: gondola
-# AUTHOR: Matthew Perry
-# DESCRIPTION:
-#   Main executable file which will dish out projects in parallel
-#   after converting them as needed
+# Gondola - gondola
+# Main executable file which will dish out projects in parallel
+# after converting them as needed
 
 require 'rubygems'
 require 'yaml'
 require 'cmdparse'
 
-lib_dir = File.expand_path( File.join( File.dirname( __FILE__ ), '..', 'lib/' ) )
-$LOAD_PATH.unshift( lib_dir ) unless $LOAD_PATH.include?( lib_dir )
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
 
 require 'gondola'
 
 # Command parsing stuff
-cmd = CmdParse::CommandParser.new( true, true )
+cmd = CmdParse::CommandParser.new(true, true)
 cmd.program_name = "gondola"
-cmd.program_version = "Gondola v1.1.0"
-cmd.add_command( CmdParse::HelpCommand.new )
-cmd.add_command( CmdParse::VersionCommand.new )
+cmd.program_version = Gondola::Version::STRING
+cmd.add_command(CmdParse::HelpCommand.new)
+cmd.add_command(CmdParse::VersionCommand.new)
 
 # Run command
 class RunCommand < CmdParse::Command
-    def initialize
-        super( 'run', false )
-        @opts = {}
-        self.short_desc = "Run an entire test suite or one test case"
-        # User supplied options for running a suite
-        self.options = CmdParse::OptionParserWrapper.new do |opt|
-            opt.on( '-s', '--super_parallel', 'Execute all test cases at once' ) do |sp|
-                @opts[:super_parallel] = true
-            end
-            opt.on( '-r', '--recursive', 'Execute all sub suites' ) do |r|
-                @opts[:recursive] = true
-            end
-            opt.on( '-l', '--legacy', 'Allow legacy Gondola suites' ) do |l|
-                @opts[:legacy] = true
-            end
-        end
+  def initialize
+    super('run', false)
+    @opts = {}
+    self.short_desc = "Run an entire test suite or one test case"
+    # User supplied options for running a suite
+    self.options = CmdParse::OptionParserWrapper.new do |opt|
+      opt.on('-s', '--super_parallel', 'Execute all test cases at once') do |sp|
+        @opts[:super_parallel] = true
+      end
+      opt.on('-r', '--recursive', 'Execute all sub suites') do |r|
+        @opts[:recursive] = true
+      end
+      opt.on('-l', '--legacy', 'Allow legacy Gondola suites') do |l|
+        @opts[:legacy] = true
+      end
     end
+  end
 
-    # Proper usage format
-    def usage
-        "Usage: #{commandparser.program_name} run [options] [tests]"
+  # Proper usage format
+  def usage
+    "Usage: #{commandparser.program_name} run [options] [tests]"
+  end
+
+  # Function that is executed when a user issues a run command
+  def execute(args)
+    if args.length < 1
+      puts run.usage
+      exit 1
     end
-    
-    # Function that is executed when a user issues a run command
-    def execute( args )
-        if args.length < 1
-            puts run.usage
-            exit 1
-        end
-        test = args[0]
-        # Can either provide directory or file
-        if File.exists?( test )
-            runner = Gondola::TestRunner.new
-            runner.addTest( test )
-            runner.run( @opts )
-        else
-            puts "Could not find file \"#{test}\""
-        end
+    test = args[0]
+    # Can either provide directory or file
+    if File.exists?(test)
+      runner = Gondola::TestRunner.new
+      runner.add_test(test)
+      runner.run(@opts)
+    else
+      puts "Could not find file \"#{test}\""
     end
+  end
 end
-cmd.add_command( RunCommand.new )
+cmd.add_command(RunCommand.new)
 
 cmd.parse
-exit( 0 )
+exit(0)

data/gondola.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gondola}
+  s.version = "1.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matthew Perry"]
+  s.date = %q{2011-03-09}
+  s.default_executable = %q{gondola}
+  s.description = %q{
+    Gondola is Ruby command line utility and as well as a library  which helps
+    for integrate the Selenium IDE more tightly with Sauce Labs' Ondemand services and
+    provide greater ease for those who would like to use both tools but do not have
+    enough technical knowledge
+  }
+  s.email = %q{mperry@agoragames.com}
+  s.executables = ["gondola"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "bin/gondola",
+    "examples/config.yml",
+    "examples/gondola_agora_fail.html",
+    "examples/gondola_agora_pass.html",
+    "gondola.gemspec",
+    "lib/gondola.rb",
+    "lib/gondola/converter.rb",
+    "lib/gondola/tester.rb",
+    "lib/gondola/testrunner.rb",
+    "lib/gondola/version.rb",
+    "test/helper.rb",
+    "test/test_gondola.rb"
+  ]
+  s.homepage = %q{http://github.com/perrym5/gondola}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.0}
+  s.summary = %q{Ruby command line utility and library for integrating the Selenium IDE more tightly with Sauce Labs' Ondemand services}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_gondola.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sauce>, [">= 0.17.5"])
+      s.add_runtime_dependency(%q<parallel>, [">= 0.5.2"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<sauce>, [">= 0.17.5"])
+      s.add_dependency(%q<parallel>, [">= 0.5.2"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<sauce>, [">= 0.17.5"])
+    s.add_dependency(%q<parallel>, [">= 0.5.2"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+

data/lib/gondola.rb

@@ -2,5 +2,6 @@ require 'rubygems'
 require 'gondola/converter'
 require 'gondola/tester'
 require 'gondola/testrunner'
+require 'gondola/version'
 require 'sauce'
 require 'parallel'

data/lib/gondola/converter.rb

@@ -1,216 +1,213 @@
-# Gondola v2
-# FILE: converter.rb
-# AUTHOR: Matthew Perry
-# DESCRIPTION:
+# Gondola - converter.rb:
 #   Function definition for turning Selenium HTML into
 #   webdriver ruby code
 
 module Gondola
-    class Converter
-        # Constructor that opens an HTML file
-        def initialize( filename, sel="@sel" )
-            File.open( filename, "r" ) do |f|
-                @html = f.read
+  class Converter
+    # Constructor that opens an HTML file
+    def initialize(filename, sel="@sel")
+      File.open(filename, "r") do |f|
+        @html = f.read
+      end
+      @s_obj = sel
+      ruby()
+    end
+
+    # Function: name
+    # Returns the name of this test case
+    def name
+      unless @name
+        @name = /<title>(.*)<\/title>/.match(@html)[1]
+      end
+      @name
+    end
+
+    # Function: ruby
+    # This function parses the selenium
+    # HTML file and sends commands to the
+    # html_to_ruby helper function
+    def ruby
+      unless @ruby
+        @ruby = ""
+        # Get body of commands from flattened html
+        cmd_body = /<tbody>(.*)<\/tbody>/.match(@html.split("\n").join(''))[1]
+
+        # Define some patterns for the individual commands
+        block_rxp = Regexp.new(/<tr>(.*?)<\/tr>/)
+        cmd_rxp = Regexp.new(/<td>(.*?)<\/td>\s*<td>(.*?)<\/td>\s*<td>(.*?)<\/td>/)
+
+        # Loop over all commands
+        cmd_body.scan(block_rxp ) do |cmd_block|
+          cmd_block[0].scan(cmd_rxp ) do |cmd|
+            # Need to make sure arguements are represented
+            # correctly
+            if cmd[1] =~ /\$\{(.*)\}/
+              cmd[1] = $1
+            elsif cmd[1] != ""
+              cmd[1] = cmd[1].inspect
             end
-            @sObject = sel
-            ruby()
+            if cmd[2] =~ /\$\{(.*)\}/
+              cmd[2] = $1
+            elsif cmd[2] != ""
+              cmd[2] = cmd[2].inspect
+            end
+            # Append commands to a result string
+            args = [ cmd[1], cmd[2] ]
+            @ruby << html_to_ruby(cmd[0], args)
+            @ruby << "\ncmd_inc\n"
+          end
+        end         
+      end  
+      @ruby
+    end
+
+    private
+    # Function: html_to_ruby
+    #   cmd - the name of the command
+    #   args - array of arguements to cmd
+    # This function turns a command that has been
+    # extracted from a selenium HTML file into
+    # one that can be used by the ruby-driver for
+    # selenium
+    def html_to_ruby(cmd, args)
+      # Select over various command types
+      case cmd
+        # Assert command
+      when /^(assert|verify)(.*)$/ then
+        # Check to see if this is a negated assertion
+        tester = $1
+        string = $2
+        if $1 =~ /(.*)Not(.*)$/
+          string = $1 + $2
+          tester = tester + "_not"
         end
 
-        # Function: name
-        # Returns the name of this test case
-        def name
-            unless @name
-                @name = /<title>(.*)<\/title>/.match( @html )[1]
-            end
-            @name
+        # Check the semantics of the command
+        if semantic_is?(string)
+          retval = "#{tester} #{@s_obj}.is_#{underscore(string)}"
+          if args[0] != ""
+            retval += "(#{args[0]}"
+          end
+          if args[1] != ""
+            retval += ", #{args[1]}"
+          end
+          retval += ")"
+        else
+          var = args[0]
+          extra = ''
+          if args[1] != ""
+            var = args[1]
+            extra = "(#{args[0]})"
+          end
+          retval = "#{tester}_eq #{var}, #{@s_obj}.get_#{underscore(string)}" + extra
         end
 
-        # Function: ruby
-        # This function parses the selenium
-        # HTML file and sends commands to the
-        # htmltoruby helper function
-        def ruby
-            unless @ruby
-                @ruby = ""
-                # Get body of commands from flattened html
-                cmdBody = /<tbody>(.*)<\/tbody>/.match( @html.split("\n").join('') )[1]
-
-                # Define some patterns for the individual commands
-                blockRxp = Regexp.new( /<tr>(.*?)<\/tr>/ )
-                cmdRxp = Regexp.new( /<td>(.*?)<\/td>\s*<td>(.*?)<\/td>\s*<td>(.*?)<\/td>/ )
-
-                # Loop over all commands
-                cmdBody.scan( blockRxp  ) do |cmdBlock|
-                    cmdBlock[0].scan( cmdRxp  ) do |cmd|
-                        # Need to make sure arguements are represented
-                        # correctly
-                        if cmd[1] =~ /\$\{(.*)\}/
-                            cmd[1] = $1
-                        elsif cmd[1] != ""
-                            cmd[1] = cmd[1].inspect
-                        end
-                        if cmd[2] =~ /\$\{(.*)\}/
-                            cmd[2] = $1
-                        elsif cmd[2] != ""
-                            cmd[2] = cmd[2].inspect
-                        end
-                        # Append commands to a result string
-                        args = [ cmd[1], cmd[2] ]
-                        @ruby << htmltoruby( cmd[0], args )
-                        @ruby << "\ncmdInc\n"
-                    end
-                end         
-            end  
-            @ruby
+        # All commands return arrays that need to be joined
+        if string =~ /^All/
+          retval += ".join(\",\")"
         end
+        return retval
 
-        private
-        # Function: htmltoruby
-        #   cmd - the name of the command
-        #   args - array of arguements to cmd
-        # This function turns a command that has been
-        # extracted from a selenium HTML file into
-        # one that can be used by the ruby-driver for
-        # selenium
-        def htmltoruby( cmd, args )
-            # Select over various command types
-            case cmd
-                # Assert command
-                when /^(assert|verify)(.*)$/ then
-                    # Check to see if this is a negated assertion
-                    tester = $1
-                    string = $2
-                    if $1 =~ /(.*)Not(.*)$/
-                        string = $1 + $2
-                        tester = tester + "Not"
-                    end
-    
-                    # Check the symantics of the command
-                    if commandIs( string )
-                        retval = "#{tester} #{@sObject}.is_#{underscore(string)}"
-                        if args[0] != ""
-                            retval += "(#{args[0]}"
-                        end
-                        if args[1] != ""
-                            retval += ", #{args[1]}"
-                        end
-                        retval += ")"
-                    else
-                        var = args[0]
-                        extra = ''
-                        if args[1] != ""
-                            var = args[1]
-                            extra = "(#{args[0]})"
-                        end
-                        retval = "#{tester}Eq #{var}, #{@sObject}.get_#{underscore(string)}" + extra
-                    end
-
-                    # All commands return arrays that need to be joined
-                    if string =~ /^All/
-                        retval += ".join(\",\")"
-                    end
-                    return retval
-
-                # Wait For command
-                when /^waitFor(.*)$/ then
-                    # Special case
-                    if $1 == "PageToLoad"
-                       return "#{@sObject}.wait_for_page_to_load \"30000\""
-                    end
-                    # The expression that is checked against depends on whether
-                    # or not the command uses the "is" or the "get" symantic
-                    if commandIs( $1 )
-                        expression = "#{@sObject}.is_#{underscore($1)}(#{args[0]}"
-                        if args[1] != ""
-                            expression += ", #{args[1]}"
-                        end
-                        expression += ")"
-                    else
-                        expression = "#{args[1]} == #{@sObject}.get_#{underscore($1)}(#{args[1]})"
-                    end
-                    # The waitFor commands loop until something is satisfied
-                    return "assert !60.times{ break if(#{expression} rescue false); sleep 1 }"
-
-                # AndWait command POSTFIX
-                when /^(.*)AndWait$/ then
-                    # A command with a postfix of AndWait simply adds
-                    # a second command which waits a certain time
-                    firstPart = htmltoruby( $1, args )
-                    secondPart = "\n#{@sObject}.wait_for_page_to_load \"30000\""
-                    return firstPart + secondPart
-
-                # store command
-                when /^store(.*)$/ then
-                    string = $1
-                    # Store by itself doesnt use any selenium functions
-                    # its the same as a regular assignment
-                    if $1 == ""
-                        # Arguements have quotes by default
-                        # they need to be stripped for LHS assignments
-                        args[1] = args[1].match( /"(.*)"/ )[1]
-                        return "#{args[1]} = #{args[0]}"
-                    end
-
-                    # Otherwise, a store command takes the result of the
-                    # cmd and stores it somewhere
-                    var = args[0]
-                    extra = ""
-                    if args[1] != ""
-                        var = args[1]
-                        extra = "( #{args[0]} )"
-                    end
-                    # Arguements have quotes by default
-                    # they need to be stripped for LHS assignments
-                    var = var.match( /"(.*)"/ )[1]
-                    if commandIs( string )
-                        return "#{var} = #{@sObject}.is_#{underscore(string)}" + extra
-                    else 
-                        return "#{var} = #{@sObject}.get_#{underscore(string)}" + extra
-                    end
-
-                # Pause is directly translated
-                when /^pause$/ then
-                    convert = args[0].to_f * 0.001
-                    return "sleep #{convert}"
-
-                # Default case
-                else
-                    # Most commands just need to be converted to
-                    # underscore_case and have their arguements
-                    # appeneded
-                    cmdNew = underscore( cmd )
-                    add = ""
-                    if args[1] != ""
-                        add = ", #{args[1]}"
-                    end
-                    return "#{@sObject}.#{cmdNew} #{args[0]}" + add
-            end
+        # Wait For command
+      when /^waitFor(.*)$/ then
+        # Special case
+        if $1 == "PageToLoad"
+          return "#{@s_obj}.wait_for_page_to_load \"30000\""
+        end
+        # The expression that is checked against depends on whether
+        # or not the command uses the "is" or the "get" semantic
+        if semantic_is?($1)
+          expression = "#{@s_obj}.is_#{underscore($1)}(#{args[0]}"
+          if args[1] != ""
+            expression += ", #{args[1]}"
+          end
+          expression += ")"
+        else
+          expression = "#{args[1]} == #{@s_obj}.get_#{underscore($1)}(#{args[1]})"
         end
+        # The waitFor commands loop until something is satisfied
+        return "assert !60.times{ break if(#{expression} rescue false); sleep 1 }"
 
-        # Function to turn CamelCase into underscore_case
-        def underscore( str )
-            str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+        # AndWait command POSTFIX
+      when /^(.*)AndWait$/ then
+        # A command with a postfix of AndWait simply adds
+        # a second command which waits a certain time
+        firstPart = html_to_ruby($1, args)
+        secondPart = "\n#{@s_obj}.wait_for_page_to_load \"30000\""
+        return firstPart + secondPart
+
+        # store command
+      when /^store(.*)$/ then
+        string = $1
+        # Store by itself doesnt use any selenium functions
+        # its the same as a regular assignment
+        if $1 == ""
+          # Arguements have quotes by default
+          # they need to be stripped for LHS assignments
+          args[1] = args[1].match(/"(.*)"/)[1]
+          return "#{args[1]} = #{args[0]}"
         end
-        
-        # Function to weed out 11 special functions that
-        # use an "is" symantic
-        def commandIs( str )
-            case str
-                when /Present$/
-                    return true
-                when /Checked$/
-                    return true
-                when /Editable$/
-                    return true
-                when /Ordered$/
-                    return true
-                when /Selected$/
-                    return true
-                when /Visible$/
-                    return true
-                else
-                    return false
-            end
+
+        # Otherwise, a store command takes the result of the
+        # cmd and stores it somewhere
+        var = args[0]
+        extra = ""
+        if args[1] != ""
+          var = args[1]
+          extra = "(#{args[0]})"
         end
+        # Arguements have quotes by default
+        # they need to be stripped for LHS assignments
+        var = var.match(/"(.*)"/)[1]
+        if semantic_is?(string)
+          return "#{var} = #{@s_obj}.is_#{underscore(string)}" + extra
+        else 
+          return "#{var} = #{@s_obj}.get_#{underscore(string)}" + extra
+        end
+
+        # Pause is directly translated
+      when /^pause$/ then
+        convert = args[0].to_f * 0.001
+        return "sleep #{convert}"
+
+        # Default case
+      else
+        # Most commands just need to be converted to
+        # underscore_case and have their arguements
+        # appeneded
+        cmd_new = underscore(cmd)
+        add = ""
+        if args[1] != ""
+          add = ", #{args[1]}"
+        end
+        return "#{@s_obj}.#{cmd_new} #{args[0]}" + add
+      end
+    end
+
+    # Function to turn CamelCase into underscore_case
+    def underscore(str)
+      str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+    end
+
+    # Function to weed out 11 special functions that
+    # use an "is" semantic
+    def semantic_is?(str)
+      case str
+      when /Present$/
+        return true
+      when /Checked$/
+        return true
+      when /Editable$/
+        return true
+      when /Ordered$/
+        return true
+      when /Selected$/
+        return true
+      when /Visible$/
+        return true
+      else
+        return false
+      end
     end
+  end
 end