steam 0.0.2

data/lib/steam/browser/html_unit/client.rb

@@ -0,0 +1,74 @@
+# Just hides the ugly Java'ish details of instantiating, configuring and using
+# a com.gargoylesoftware.htmlunit.WebClient (HtmlUnit's main browser object).
+
+module Steam
+  module Browser
+    class HtmlUnit
+      class Client
+        Java.load_from(Steam.config[:html_unit][:java_path])
+
+        Java.import 'com.gargoylesoftware.htmlunit.Version'
+        Java.import 'com.gargoylesoftware.htmlunit.WebClient'
+        Java.import 'com.gargoylesoftware.htmlunit.BrowserVersion'
+        Java.import 'com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController'
+        Java.import 'com.gargoylesoftware.htmlunit.FailingHttpStatusCodeException'
+
+        include Java::Com::Gargoylesoftware::Htmlunit
+
+        class SilencingListener
+          def notify(message, origin); end
+        end
+
+        def initialize(connection = nil, options = {})
+          options = Steam.config[:html_unit].merge(options)
+
+          @java = WebClient.new(BrowserVersion.send(options[:browser_version]))
+          @java.setCssEnabled(options[:css])
+          @java.setJavaScriptEnabled(options[:javascript])
+          @java.setPrintContentOnFailingStatusCode(options[:on_error_status] == :print)
+          @java.setThrowExceptionOnFailingStatusCode(options[:on_error_status] == :raise)
+          @java.setThrowExceptionOnScriptError(options[:on_script_error] == :raise)
+
+          self.log_level = options[:log_level]
+          unless options[:log_incorrectness]
+            listener = Rjb::bind(SilencingListener.new, 'com.gargoylesoftware.htmlunit.IncorrectnessListener')
+            @java.setIncorrectnessListener(listener)
+          end
+
+          if options[:resynchronize]
+            controller = NicelyResynchronizingAjaxController.new
+            @java.setAjaxController(controller)
+          end
+
+          if connection
+            connection = Rjb::bind(HtmlUnit::Connection.new(connection), 'com.gargoylesoftware.htmlunit.WebConnection')
+            @java.setWebConnection(connection)
+          end
+        end
+
+        def request(*args)
+          @java.getPage(*args) # TODO use WebRequestSettings
+        end
+
+        def wait_for_javascript(timeout)
+          waitForBackgroundJavaScript(timeout)
+          yield if block_given?
+        end
+
+        # FIXME setLevel throws "Fail: unknown method name `setLevel'". weird.
+        def log_level=(level)
+          [ 'com.gargoylesoftware.htmlunit',
+            'com.gargoylesoftware.htmlunit.html',
+            'com.gargoylesoftware.htmlunit.javascript',
+            'org.apache.commons.httpclient'
+          ].each { |classifier|
+            Java.logger(classifier).setLevel(Java.log_level(level)) }
+        end
+
+        def method_missing(method, *args)
+          @java.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/steam/browser/html_unit/connection.rb

@@ -0,0 +1,79 @@
+# For internal use in Browser::HtmlUnit to hook into HtmlUnit's request process.
+# Does not support the Rack interface because HtmlUnit doesn't. Not currently
+# used by Steam, but potentially useful to get HtmlUnit and the app running in
+# a single stack.
+#
+# Can be set to a com.gargoylesoftware.htmlunit.WebClient like this:
+#
+#   mock = Steam::Connection::Mock.new
+#   mock.mock :get, 'http://localhost:3000/', 'body!'
+#   connection = Steam::Browser::HtmlUnit::Connection.new(mock)
+#
+#   client = java::WebClient.new(Java::Com::Gargoylesoftware::Htmlunit::BrowserVersion.FIREFOX_3)
+#   client.setWebConnection(Rjb::bind(connection, 'com.gargoylesoftware.htmlunit.WebConnection'))
+
+require 'thread'
+require 'rack/utils'
+
+module Steam
+  module Browser
+    class HtmlUnit
+      class Connection
+        @@lock = Mutex.new
+
+        Java.import 'com.gargoylesoftware.htmlunit.Version'
+
+        include Java::Com::Gargoylesoftware::Htmlunit
+
+        Java.import('com.gargoylesoftware.htmlunit.MockWebConnection')
+        classifier = Version.getProductVersion == '2.6' ?
+          'org.apache.commons.httpclient.NameValuePair' :    # HtmlUnit 2.6
+          'com.gargoylesoftware.htmlunit.util.NameValuePair' # HtmlUnit 2.7
+        NameValuePair = Java.import(classifier, :NameValuePair)
+
+        attr_reader :connection, :java
+
+        def initialize(connection)
+          @connection = connection
+          @java = MockWebConnection.new
+        end
+
+        def getResponse(request)
+          # FIXME preserve original scheme, host + port
+          method = request.getHttpMethod.toString.dup
+          url    = request.getUrl.toString.dup
+
+          body   = request.getRequestBody
+          body   = body.toString.dup if body
+
+          params = request.getRequestParameters
+          params = Hash[*params.toArray.map { |e| [e.name, e.value] }.flatten]
+
+          input  = body ? body : Rack::Utils.build_nested_query(params)
+          env    = Request.env_for(url, :method => method, :input => input)
+
+          status, headers, response = connection.call(env)
+          response.body.close if response.body.respond_to?(:close)
+
+          set_response(request.getUrl, response)
+          java.getResponse(request)
+        rescue Exception => e
+          puts "#{e.class.name}: #{e.message}"
+          e.backtrace.each { |line| puts line }
+        end
+
+        def set_response(url, response)
+          body    = response.body.join
+          status  = response.status
+          message = Rack::Utils::HTTP_STATUS_CODES[status.to_i]
+          charset = Steam.config[:charset]
+          headers = response.header.map { |key, value| NameValuePair.new(key, value) }
+          headers = Java::Util::Arrays.asList(headers)
+          content_type = response.content_type
+
+          java.setResponse(url, body, status, message, content_type, charset, headers)
+        end
+      end
+    end
+  end
+end

data/lib/steam/browser/html_unit/drb.rb

@@ -0,0 +1,45 @@
+require 'drb'
+
+module Steam
+  module Browser
+    class HtmlUnit
+      class Drb
+        attr_reader :process, :connection, :options
+
+        def initialize(connection, options = {})
+          @connection, @options = connection, options
+          @process = Steam::Process.new
+
+          process.kill if options[:restart] && process.running?
+          options[:daemon] ? daemonize : start unless process.running?
+        end
+
+        def object
+          @object ||= DRbObject.new(nil, Steam.config[:drb_uri])
+        end
+
+        def daemonize
+          options[:keep_alive] = true unless options.key?(:keep_alive)
+          process.fork(options) { start }
+          sleep(1) # FIXME
+        end
+
+        def start
+          uri = Steam.config[:drb_uri]
+          DRb.start_service(uri, HtmlUnit.new(connection, options))
+          puts "HtmlUnit ready and listening at #{uri} [#{::Process.pid}]"
+          DRb.thread.join
+        end
+
+        def restart
+          process.kill if process.running?
+          daemonize
+        end
+
+        def method_missing(method, *args, &block)
+          object.send(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/steam/browser/html_unit/matchers.rb

@@ -0,0 +1,57 @@
+# module Steam
+#   module HtmlUnit
+#     module Matchers
+#       class HasContent #:nodoc:
+#         def initialize(content)
+#           @content = content
+#         end
+# 
+#         def matches?(target)
+#           @target = target
+#           !!@target.locate_element(@content)
+#         end
+# 
+#         def failure_message
+#           "expected the following element's content to #{content_message}:\n#{squeeze_space(@target.page.body)}"
+#         end
+# 
+#         def negative_failure_message
+#           "expected the following element's content to not #{content_message}:\n#{squeeze_space(@target.page.body)}"
+#         end
+# 
+#         def squeeze_space(inner_text)
+#           (inner_text || '').gsub(/^\s*$/, "").squeeze("\n")
+#         end
+# 
+#         def content_message
+#           case @content
+#           when String
+#             "include \"#{@content}\""
+#           when Regexp
+#             "match #{@content.inspect}"
+#           end
+#         end
+#       end
+# 
+#       # Matches the contents of an HTML document with
+#       # whatever string is supplied
+#       def contain(content)
+#         HasContent.new(content)
+#       end
+# 
+#       # Asserts that the body of the response contain
+#       # the supplied string or regexp
+#       def assert_contain(content)
+#         hc = HasContent.new(content)
+#         assert hc.matches?(response.body), hc.failure_message
+#       end
+# 
+#       # Asserts that the body of the response
+#       # does not contain the supplied string or regepx
+#       def assert_not_contain(content)
+#         hc = HasContent.new(content)
+#         assert !hc.matches?(response.body), hc.negative_failure_message
+#       end
+#     end
+#   end
+# end

data/lib/steam/browser/html_unit/page.rb

@@ -0,0 +1,51 @@
+# Wraps a dom.gargoylesoftware.htmlunit.html.HtmlPage (which is returned by
+# most browser actions such as click, drag, drop etc.) with a nicer interface.
+
+module Steam
+  module Browser
+    class HtmlUnit
+      class Page
+        attr_reader
+
+        def initialize(page)
+          @page = page
+        end
+
+        def url
+          @page.getWebResponse.getRequestSettings.getUrl.toString
+        end
+
+        def status
+          @page.getWebResponse.getStatusCode
+        end
+
+        def headers
+          @page.getWebResponse.getResponseHeaders.toArray.inject({}) do |headers, pair|
+            headers[pair.name] = pair.value
+            headers
+          end
+        end
+
+        def body
+          @page.asXml
+        end
+
+        def execute(javascript)
+          @page.executeJavaScript(javascript)
+        end
+
+        def sourceCode
+          @page.asXml
+        end
+
+        def to_a
+          [body, status, headers]
+        end
+
+        def method_missing(method, *args)
+          return @page.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/steam/browser/html_unit/web_response.rb

@@ -0,0 +1,116 @@
+# Mimicks the com.gargoylesoftware.htmlunit.WebRequestSettings api so it can be
+# returned by an object that mimicks com.gargoylesoftware.htmlunit.WebConnection
+# Not currently used in Steam, but useful for experimental stuff.
+
+module Steam
+  module Browser
+    class HtmlUnit
+      class WebResponse
+        Java.import 'java.net.Url'
+        Java.import 'java.io.ByteArrayInputStream'
+        Java.import 'com.gargoylesoftware.htmlunit.WebRequestSettings'
+
+        include Java::Com::Gargoylesoftware::Htmlunit
+
+        classifier = Version.getProductVersion == '2.6' ?
+          'org.apache.commons.httpclient.NameValuePair' :    # HtmlUnit 2.6
+          'com.gargoylesoftware.htmlunit.util.NameValuePair' # HtmlUnit 2.7
+        NameValuePair = Java.import(classifier, :NameValuePair)
+
+        attr_reader :request, :response
+
+        def initialize(request, response)
+          @request = request
+          @response = response
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getRequestSettings
+          @request_settings ||= WebRequestSettings.new(Java::Net::URL.new(request.url))
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getResponseHeaders
+          @headers ||= begin
+            headers = response.header.map { |key, value| NameValuePair.new(key, value) }
+            Java::Util::Arrays.asList(headers)
+          end
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getResponseHeaderValue(name)
+          response.header[name]
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getStatusCode
+          @status ||= response.status
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getStatusMessage
+          @message ||= Rack::Utils::HTTP_STATUS_CODES[getStatusCode.to_i]
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getContentType
+          @content_type ||= begin
+            content_type = response.content_type.split(';').first
+            content_type = 'application/x-javascript' if content_type == 'application/javascript'
+            content_type
+          end
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getContentCharset
+          @content_charset ||= Steam.config[:charset]
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getContentCharsetOrNull
+          @content_charset_or_null ||= Steam.config[:charset]
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getContentAsString
+          @content_as_string ||= response.body.join
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def getContentAsStream
+          @content_as_stream ||= begin
+            bytes = getContentAsString.unpack('C*')
+            Java::Io::ByteArrayInputStream.new_with_sig('[B', bytes)
+          end
+        rescue Exception => e
+          puts e.message
+          e.backtrace.each { |line| puts line }
+        end
+
+        def method_missing(method, *args)
+          puts "Method missing in WebResponse: #{method} #{args.map{ |a| a.inspect }.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/steam/connection.rb

@@ -0,0 +1,9 @@
+module Steam
+  module Connection
+    autoload :Mock,    'steam/connection/mock'
+    autoload :NetHttp, 'steam/connection/net_http'
+    autoload :OpenUri, 'steam/connection/open_uri'
+    autoload :Rails,   'steam/connection/rails'
+    autoload :Static,  'steam/connection/static'
+  end
+end

data/lib/steam/connection/mock.rb

@@ -0,0 +1,57 @@
+require 'cgi'
+
+module Steam
+  module Connection
+    class Mock
+      class << self
+        def default_content_types
+          {
+            :html       => 'text/html',
+            :xml        => 'application/xml',
+            :javascript => 'application/javascript',
+            :stylesheet => 'text/css'
+          }
+        end
+      end
+
+      def initialize
+        @responses = {}
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        response = response(request.request_method, request.url)
+        response = response.call if response.is_a?(Proc)
+        response.to_a
+      end
+
+      def response(method, url)
+        responses(method)[CGI::unescape(url)] || Rack::Response.new('', 404)
+      end
+
+      def mock(*args)
+        headers = args.last.is_a?(Hash) ? args.pop : {}
+        response, url, method = *args.reverse
+
+        responses(method || :get)[url] = case response
+          when Array
+            Rack::Response.new(*response)
+          when String
+            Rack::Response.new(response, 200, headers)
+          else
+            response
+          end
+      end
+
+      protected
+
+        def responses(method)
+          @responses[method.to_s.upcase] ||= {}
+        end
+
+        def content_type(type)
+          self.class.default_content_types[type]
+        end
+    end
+  end
+end