htty-rack 0.0.5

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle/
+doc/
+vendor/
+*.gem

data/MIT-LICENSE.rdoc

@@ -0,0 +1,9 @@
+The MIT License
+
+Source code for _htty-rack_ is copyright (c) 2010 Florian Gilcher[mailto:florian.gilcher@asquera.de].
+
+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,40 @@
+   _________________________ 
+  < no fancy ASCII art here >
+   ------------------------- 
+          \   ^__^
+           \  (oo)\_______
+              (__)\       )\/\
+                  ||----w |
+                  ||     ||
+
+htty-rack[http://www.github.com/Asquera/htty-rack] is an extension to htty[http://htty.github.com] that switches the HTTP backend in favour of a Rack application. For that purpose, it also provides a set of commands for controlling which rack application is used etc.
+
+= Warning
+
+Alpha. No Features guaranteed.
+
+= Installation
+
+Use rubygems:
+
+ $ gem install htty-rack
+
+= Usage
+
+htty-rack uses a different executable than htty. Start htty-rack using:
+
+ $ htty-rack <config-file>
+
+If no config (*.ru) file is given, htty-rack will recursively descend to find a file called "config.ru".
+
+= Examples
+
+Beyond the examples described on the htty[http://htty.github.com] page, htty-rack supports a few other commands:
+
+* app <app> will change the rack appliation in use. The argument must be a ruby constant.
+* config <file> will load a new rackup file and use the application therein.
+* irb starts irb so that you can manipulate the environment.
+
+= Thanks
+
+* Nils Jonsson for writing htty and making this project possible

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+Rake::TestTask.new("test") do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.warning = false
+  test.verbose = true 
+  test.ruby_opts = ['-rubygems', '-rtest_helper']
+end
+
+task :default => [:test]

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/bin/htty-rack

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+gem 'htty'
+require 'htty'
+
+require File.expand_path("#{File.dirname __FILE__}/../lib/htty/rack")
+
+HTTY::Rack::CLI.new(ARGV).run!

data/config.ru

@@ -0,0 +1 @@
+run lambda {|env| [200,{"Content-Length" => "4"}, ["test"]]}

data/htty-rack.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "htty-rack"
+  s.version     = File.read("VERSION")
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Florian Gilcher"]
+  s.email       = ["florian.gilcher@asquera.de"]
+  s.homepage    = "http://www.github.com/Asquera/htty-rack"
+  s.summary     = "htty-rack is htty for rack applications"
+  s.description = "A CLI for rack applications based on htty."
+
+  s.add_dependency "htty", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/htty/rack.rb

@@ -0,0 +1,31 @@
+Dir.glob "#{File.dirname __FILE__}/rack/*.rb" do |f|
+  require File.expand_path("#{File.dirname __FILE__}/rack/" +
+                           File.basename(f, '.rb'))
+end
+
+require 'rack'
+HTTY::CLI::Commands::Help.register_additional_category("Rack")
+HTTY::CLI::Commands::Help.register_additional_category("Debug")
+
+module HTTY
+  module Rack
+    VERSION = File.read("#{File.dirname __FILE__}/../../VERSION").chomp
+    
+    def self.build_app(filename = nil)
+      config_file_name = File.basename(filename || find_config_file)
+      config_file = File.read(config_file_name)
+      app = ::Rack::Builder.new { instance_eval(config_file) }.to_app
+      [config_file_name, app]
+    end
+    
+    def self.find_config_file
+      if Dir.glob("config.ru").length > 0
+        File.join(Dir.pwd,"config.ru")
+      elsif Dir.pwd != "/"
+        Dir.chdir("..") { find_config_file }
+      else
+        raise "Cannot find config.ru"
+      end
+    end
+  end
+end

data/lib/htty/rack/cli.rb

@@ -0,0 +1,27 @@
+module HTTY::Rack
+  class CLI < HTTY::CLI
+    
+    attr_accessor :config_file_name
+    
+    def initialize(command_line_arguments, session_class = HTTY::Rack::Session)
+      super
+    end
+
+    def prompt
+      last_request = session.requests.last
+      if last_request.app.respond_to? :name
+        display = last_request.app.name
+      else
+        display = last_request.app_file
+      end
+      
+      strong(display + ":" + 
+             session.requests.last.send(:path_query_and_fragment)) +
+             normal('> ')
+    end
+    
+    def command_folders
+      super + ["#{File.dirname __FILE__}/commands"]
+    end    
+  end
+end

data/lib/htty/rack/commands/app.rb

@@ -0,0 +1,40 @@
+class HTTY::CLI::Commands::App < HTTY::CLI::Command
+
+  # Returns the name of a category under which help for the _app_ command
+  # should appear.
+  def self.category
+    'Rack'
+  end
+
+  # Returns the arguments for the command-line usage of the _app_ command.
+  def self.command_line_arguments
+    'constant'
+  end
+
+  # Returns the help text for the _app_ command.
+  def self.help
+    'Sets the active app'
+  end
+
+  # Returns the extended help text for the _app_ command.
+  def self.help_extended
+    'Sets the app to the constant provided. The app must be required first.' +
+    'This operation does not clear cookies.'
+  end
+
+  # Performs the _app_ command.
+  def perform
+    unless arguments.length == 1
+       raise ArgumentError,
+             "wrong number of arguments (#{arguments.length} for 1)"
+    end
+    
+    app = Module.const_get(arguments.first)
+    
+    add_request_if_has_response do |request|
+      request.app = app
+      request
+    end
+  end
+
+end

data/lib/htty/rack/commands/config.rb

@@ -0,0 +1,40 @@
+class HTTY::CLI::Commands::Config < HTTY::CLI::Command
+
+  include HTTY::CLI::CookieClearingCommand
+
+  # Returns the name of a category under which help for the _config_ command
+  # should appear.
+  def self.category
+    'Rack'
+  end
+
+  # Returns the arguments for the command-line usage of the _config_ command.
+  def self.command_line_arguments
+    'config'
+  end
+
+  # Returns the help text for the _config_ command.
+  def self.help
+    'Loads a new config'
+  end
+
+  # Returns the extended help text for the _config_ command.
+  def self.help_extended
+    'Loads a config (.ru-File) and sets the built class as the' +
+    'active application. This operation clears cookies.'
+  end
+
+  # Performs the _config_ command.
+  def perform
+    unless arguments.length == 1
+       raise ArgumentError,
+             "wrong number of arguments (#{arguments.length} for 1)"
+    end
+    
+    add_request_if_has_response do |request|
+      request.app_file, request.app = HTTY::Rack::build_app arguments.first
+      request
+    end
+  end
+
+end

data/lib/htty/rack/commands/irb.rb

@@ -0,0 +1,36 @@
+class HTTY::CLI::Commands::Irb < HTTY::CLI::Command
+
+  # Returns the name of a category under which help for the _irb_ command
+  # should appear.
+  def self.category
+    'Debug'
+  end
+
+  # Returns the arguments for the command-line usage of the _irb_ command.
+  def self.command_line_arguments
+    ''
+  end
+
+  # Returns the help text for the _irb_ command.
+  def self.help
+    'Starts irb'
+  end
+
+  # Returns the extended help text for the _irb_ command.
+  def self.help_extended
+    'Starts irb to let you modify the environment. Use it like IRB, using' +
+    '#exit brings you right back.'
+  end
+
+  # Performs the _irb_ command.
+  def perform
+    unless arguments.length == 0
+       raise ArgumentError,
+             "wrong number of arguments (#{arguments.length} for 0)"
+    end
+    require 'irb'
+    
+    IRB::start(__FILE__)
+  end
+
+end

data/lib/htty/rack/commands/require.rb

@@ -0,0 +1,35 @@
+class HTTY::CLI::Commands::Require < HTTY::CLI::Command
+
+  # Returns the name of a category under which help for the _require_ command
+  # should appear.
+  def self.category
+    'Rack'
+  end
+
+  # Returns the arguments for the command-line usage of the _require_ command.
+  def self.command_line_arguments
+    'file'
+  end
+
+  # Returns the help text for the _require_ command.
+  def self.help
+    'requires a file'
+  end
+
+  # Returns the extended help text for the _require_ command.
+  def self.help_extended
+    'allows you to require a file. Works like rubys require and allows you' +
+    'to load apps.'
+  end
+
+  # Performs the _require_ command.
+  def perform
+    unless arguments.length == 1
+       raise ArgumentError,
+             "wrong number of arguments (#{arguments.length} for 1)"
+    end
+
+    require arguments.first
+  end
+
+end

data/lib/htty/rack/request.rb

@@ -0,0 +1,462 @@
+
+# Defines HTTY::Request.
+
+require 'pathname'
+require 'uri'
+
+module HTTY; end
+
+# Encapsulates an HTTP(S) request.
+class HTTY::Rack::Request < HTTY::Payload
+  attr_accessor :app, :app_file
+  
+  COOKIES_HEADER_NAME = 'Cookie'
+
+  METHODS_SENDING_BODY = [:post, :put]
+
+  # Returns a URI authority (a combination of userinfo, host, and port)
+  # corresponding to the specified _components_ hash. Valid _components_ keys
+  # include:
+  #
+  # * <tt>:userinfo</tt>
+  # * <tt>:host</tt>
+  # * <tt>:port</tt>
+  def self.build_authority(components)
+    userinfo_and_host = [components[:userinfo],
+                         components[:host]].compact.join('@')
+    all               = [userinfo_and_host, components[:port]].compact.join(':')
+    return nil if (all == '')
+    all
+  end
+
+  # Returns a combination of a URI path, query, and fragment, corresponding to
+  # the specified _components_ hash. Valid _components_ keys include:
+  #
+  # * <tt>:path</tt>
+  # * <tt>:query</tt>
+  # * <tt>:fragment</tt>
+  def self.build_path_query_and_fragment(components)
+    path     = components[:path]
+    query    = components[:query]    ? "?#{components[:query]}"    : nil
+    fragment = components[:fragment] ? "##{components[:fragment]}" : nil
+    all      = [path, query, fragment].compact.join
+    return nil if (all == '')
+    all
+  end
+
+  # Returns a URI corresponding to the specified _components_ hash, or raises
+  # URI::InvalidURIError. Valid _components_ keys include:
+  #
+  # * <tt>:scheme</tt>
+  # * <tt>:userinfo</tt>
+  # * <tt>:host</tt>
+  # * <tt>:port</tt>
+  # * <tt>:path</tt>
+  # * <tt>:query</tt>
+  # * <tt>:fragment</tt>
+  def self.build_uri(components)
+    scheme                  = (components[:scheme] || 'http') + '://'
+    authority               = build_authority(components)
+    path_query_and_fragment = build_path_query_and_fragment(components)
+    path_query_and_fragment ||= '/' if authority
+    URI.parse([path_query_and_fragment].join)
+  end
+
+  # Returns a URI corresponding to the specified _address_, or raises
+  # URI::InvalidURIError.
+  def self.parse_uri(address)
+    address = '0.0.0.0' if address.nil? || (address == '')
+
+    scheme_missing = false
+    if (address !~ /^[a-z]+:\/\//) && (address !~ /^mailto:/)
+      scheme_missing = true
+      address = 'http://' + address
+    end
+
+    scheme,
+    userinfo,
+    host,
+    port,
+    registry, # Not used by HTTP
+    path,
+    opaque,   # Not used by HTTP
+    query,
+    fragment = URI.split(address)
+
+    scheme = nil if scheme_missing
+    path   = nil if (path == '')
+
+    unless scheme
+      scheme = (port.to_i == URI::HTTPS::DEFAULT_PORT) ? 'https' : 'http'
+    end
+
+    build_uri :scheme   => scheme,
+              :userinfo => userinfo,
+              :host     => host,
+              :port     => port,
+              :path     => path,
+              :query    => query,
+              :fragment => fragment
+  end
+
+protected
+
+  def self.clear_cookies_if_host_changes(request)
+    previous_host = request.uri.host
+    yield
+    request.cookies_remove_all unless request.uri.host == previous_host
+    request
+  end
+
+public
+
+  # Returns the HTTP method of the request, if any.
+  attr_reader :request_method
+
+  # Returns the response received for the request, if any.
+  attr_reader :response
+
+  # Returns the URI of the request.
+  attr_reader :uri
+
+  # Initializes a new HTTY::Request with a #uri corresponding to the specified
+  # _address_.
+  def initialize(address = "/")
+    super({:headers => [['User-Agent', "htty/#{HTTY::VERSION}"]]})
+    @uri = self.class.parse_uri(address)
+    establish_content_length
+  end
+
+  def initialize_copy(source) #:nodoc:
+    super
+    @response = @response.dup if @response
+    @uri      = @uri.dup
+  end
+
+  # Returns +true+ if _other_request_ is equivalent to the request.
+  def ==(other_request)
+    return false unless super(other_request)
+    return false unless other_request.kind_of?(self.class)
+    (other_request.response == response) && (other_request.uri == uri)
+  end
+  alias :eql? :==
+
+  # Establishes a new #uri corresponding to the specified _address_. If the host
+  # of the _address_ is different from the host of #uri, then #cookies are
+  # cleared.
+  def address(address)
+    uri = self.class.parse_uri(address)
+    if response
+      dup = dup_without_response
+      return self.class.clear_cookies_if_host_changes(dup) do
+        dup.uri = uri
+      end
+    end
+
+    self.class.clear_cookies_if_host_changes self do
+      @uri = uri
+    end
+  end
+
+  # Sets the body of the request.
+  def body_set(body)
+    return dup_without_response.body_set(body) if response
+
+    @body = body ? body.to_s : nil
+    establish_content_length
+  end
+
+  # Clears the body of the request.
+  def body_unset
+    body_set nil
+  end
+
+  # Makes an HTTP +CONNECT+ request using the path of #uri.
+  def connect!
+    request! :connect
+  end
+
+  # Appends to #cookies using the specified _name_ (required) and _value_
+  # (optional).
+  def cookie_add(name, value=nil)
+    return dup_without_response.cookie_add(name, value) if response
+
+    cookies_string = HTTY::CookiesUtil.cookies_to_string(cookies +
+                                                         [[name.to_s, value]])
+    if cookies_string
+      @headers[COOKIES_HEADER_NAME] = cookies_string
+    else
+      @headers.delete COOKIES_HEADER_NAME
+    end
+    self
+  end
+
+  # Removes the last element of #cookies having the specified _name_.
+  def cookie_remove(name)
+    return dup_without_response.cookie_remove(name) if response
+
+    # Remove just one matching cookie from the end.
+    rejected = false
+    new_cookies = cookies.reverse.reject do |cookie_name, cookie_value|
+      if !rejected && (cookie_name == name)
+        rejected = true
+      else
+        false
+      end
+    end.reverse
+
+    cookies_string = HTTY::CookiesUtil.cookies_to_string(new_cookies)
+    if cookies_string
+      @headers[COOKIES_HEADER_NAME] = cookies_string
+    else
+      @headers.delete COOKIES_HEADER_NAME
+    end
+    self
+  end
+
+  # Returns an array of the cookies belonging to the request.
+  def cookies
+    HTTY::CookiesUtil.cookies_from_string @headers[COOKIES_HEADER_NAME]
+  end
+
+  # Removes all #cookies.
+  def cookies_remove_all
+    return dup_without_response.cookies_remove_all if response
+
+    @headers.delete COOKIES_HEADER_NAME
+    self
+  end
+
+  # Sets #cookies according to the _Set-Cookie_ header of the specified
+  # _response_, or raises either HTTY::NoResponseError or
+  # HTTY::NoSetCookieHeaderError.
+  def cookies_use(response)
+    raise HTTY::NoResponseError unless response
+
+    cookies_header = response.headers.detect do |name, value|
+      name == HTTY::Response::COOKIES_HEADER_NAME
+    end
+    unless cookies_header && cookies_header.last
+      raise HTTY::NoSetCookieHeaderError
+    end
+    header_set COOKIES_HEADER_NAME, cookies_header.last
+  end
+
+  # Makes an HTTP +DELETE+ request using the path of #uri.
+  def delete!
+    request! :delete
+  end
+
+  # Establishes a new #uri according to the _Location_ header of the specified
+  # _response_, or raises either HTTY::NoResponseError or
+  # HTTY::NoLocationHeaderError.
+  def follow(response)
+    raise HTTY::NoResponseError unless response
+
+    location_header = response.headers.detect do |name, value|
+      name == 'Location'
+    end
+    unless location_header && location_header.last
+      raise HTTY::NoLocationHeaderError
+    end
+    address location_header.last
+  end
+
+  # Establishes a new #uri with the specified _fragment_.
+  def fragment_set(fragment)
+    rebuild_uri :fragment => fragment
+  end
+
+  # Establishes a new #uri without a fragment.
+  def fragment_unset
+    fragment_set nil
+  end
+
+  # Makes an HTTP +GET+ request using the path of #uri.
+  def get!
+    request! :get
+  end
+
+  # Makes an HTTP +HEAD+ request using the path of #uri.
+  def head!
+    request! :head
+  end
+
+  # Appends to #headers or changes the element of #headers using the specified
+  # _name_ and _value_.
+  def header_set(name, value)
+    return dup_without_response.header_set(name, value) if response
+
+    name = name.to_s
+    if value.nil?
+      @headers.delete name
+      return self
+    end
+
+    @headers[name] = value.to_s
+    self
+  end
+
+  # Removes the element of #headers having the specified _name_.
+  def header_unset(name)
+    header_set name, nil
+  end
+
+  # Returns an array of the headers belonging to the payload. If
+  # _include_content_length_ is +false+, then a 'Content Length' header will be
+  # omitted. If _include_content_length_ is not specified, then it will be
+  # +true+ if #request_method is an HTTP method for which body content is
+  # expected.
+  def headers(include_content_length=
+              METHODS_SENDING_BODY.include?(request_method))
+    unless include_content_length
+      return super().reject do |name, value|
+        name == 'Content-Length'
+      end
+    end
+
+    super()
+  end
+
+  # Removes all #headers.
+  def headers_unset_all
+    return dup_without_response.headers_unset_all if response
+
+    @headers.clear
+    self
+  end
+
+  # Establishes a new #uri with the specified _host_.
+  def host_set(host)
+    rebuild_uri :host => host
+  end
+
+  # Makes an HTTP +OPTIONS+ request using the path of #uri.
+  def options!
+    request! :options
+  end
+
+  # Makes an HTTP +PATCH+ request using the path of #uri.
+  def patch!
+    request! :patch
+  end
+
+  # Establishes a new #uri with the specified _path_ which may be absolute or
+  # relative.
+  def path_set(path)
+    absolute_path = (Pathname.new(uri.path) + path).to_s
+    rebuild_uri :path => absolute_path
+  end
+
+  # Establishes a new #uri with the specified _port_.
+  def port_set(port)
+    rebuild_uri :port => port
+  end
+
+  # Makes an HTTP +POST+ request using the path of #uri.
+  def post!
+    request! :post
+  end
+
+  # Makes an HTTP +PUT+ request using the path of #uri.
+  def put!
+    request! :put
+  end
+
+  # Establishes a new #uri, with the specified _value_ for the query-string
+  # parameter specified by _name_.
+  def query_set(name, value)
+    query     = uri.query ? "&#{uri.query}&" : ''
+    parameter = Regexp.new("&#{Regexp.escape name}=.+?&")
+    if query =~ parameter
+      new_query = value.nil? ?
+                  query.gsub(parameter, '&') :
+                  query.gsub(parameter, "&#{name}=#{value}&")
+    else
+      new_query = value.nil? ? query : "#{query}#{name}=#{value}"
+    end
+    new_query = new_query.gsub(/^&/, '').gsub(/&$/, '')
+    new_query = nil if (new_query == '')
+    rebuild_uri :query => new_query
+  end
+
+  # Establishes a new #uri, without the query-string parameter specified by
+  # _name_.
+  def query_unset(name)
+    query_set name, nil
+  end
+
+  # Establishes a new #uri without a query string.
+  def query_unset_all
+    rebuild_uri :query => nil
+  end
+
+  # Establishes a new #uri with the specified _scheme_.
+  def scheme_set(scheme)
+    rebuild_uri :scheme => scheme
+  end
+
+  # Makes an HTTP +TRACE+ request using the path of #uri.
+  def trace!
+    request! :trace
+  end
+
+  # Establishes a new #uri with the specified _userinfo_.
+  def userinfo_set(userinfo)
+    rebuild_uri :userinfo => userinfo
+  end
+
+  # Establishes a new #uri without userinfo.
+  def userinfo_unset
+    userinfo_set nil
+  end
+
+protected
+
+  def dup_without_response
+    request = self.dup
+    request.response = nil
+    request.instance_variable_set '@request_method', nil
+    request
+  end
+
+  def establish_content_length
+    header_set 'Content-Length', body.to_s.length
+  end
+
+  def path_query_and_fragment
+    self.class.build_path_query_and_fragment :path     => uri.path,
+                                             :query    => uri.query,
+                                             :fragment => uri.fragment
+  end
+
+  def rebuild_uri(changed_components)
+    return dup_without_response.rebuild_uri(changed_components) if response
+
+    components = URI::HTTP::COMPONENT.inject({}) do |result, c|
+      result.merge c => uri.send(c)
+    end
+    self.class.clear_cookies_if_host_changes self do
+      @uri = self.class.build_uri(components.merge(changed_components))
+    end
+  end
+
+  attr_writer :response
+
+  attr_writer :uri
+
+private
+
+  def authority
+    self.class.build_authority :userinfo => uri.userinfo,
+                               :host     => uri.host,
+                               :port     => uri.port
+  end
+
+  def request!(method)
+    request = response ? dup_without_response : self
+    request.instance_variable_set '@request_method', method
+    HTTY::Rack::RequestsUtil.send method, request
+  end
+
+end

data/lib/htty/rack/requests_util.rb

@@ -0,0 +1,53 @@
+require 'rack/test'
+
+module HTTY::Rack 
+  class RequestsUtil
+    class RackApp
+      
+      def initialize(app)
+        @app = app
+      end
+      
+      def app
+        @app
+      end
+      
+      include Rack::Test::Methods
+    end
+    
+    class << self
+      %w(get post put delete option trace).each do |v|
+        define_method(v) do |request|
+          request(request) do |app|
+            a = RackApp.new(app)
+            
+            a.send(v, 
+                   request.send(:path_query_and_fragment),
+                   Hash[*request.headers])
+          end
+        end
+      end
+    end
+    
+    protected
+      def self.http_response_to_status(http_response)
+        [http_response.status,
+         Rack::Utils::HTTP_STATUS_CODES[http_response.status]]
+      end
+      
+    private
+      def self.request(request)
+        http_response = yield request.app
+        headers = []
+        http_response.headers.each do |*h|
+          headers << h
+        end
+        request.send :response=,
+                     HTTY::Response.new(:status  => http_response_to_status(http_response),
+                                        :headers => headers,
+                                        :body    => http_response.body)
+        request
+      end
+
+  end
+end

data/lib/htty/rack/session.rb

@@ -0,0 +1,11 @@
+class HTTY::Rack::Session < HTTY::Session
+  attr_accessor :app_file
+  
+  def initialize(app_file_name)
+    request = HTTY::Rack::Request.new("/")
+    request.app_file, request.app = HTTY::Rack.build_app(app_file_name)
+    @requests = [request]
+  end
+  
+ 
+end

data/test/rack-htty_test.rb

@@ -0,0 +1,7 @@
+context "htty-rack" do
+  context "tests" do
+    asserts("do exist") do
+      false
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+require 'riot'

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: htty-rack
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Florian Gilcher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: htty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+description: A CLI for rack applications based on htty.
+email: 
+- florian.gilcher@asquera.de
+executables: 
+- htty-rack
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE.rdoc
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/htty-rack
+- config.ru
+- htty-rack.gemspec
+- lib/htty/rack.rb
+- lib/htty/rack/cli.rb
+- lib/htty/rack/commands/app.rb
+- lib/htty/rack/commands/config.rb
+- lib/htty/rack/commands/irb.rb
+- lib/htty/rack/commands/require.rb
+- lib/htty/rack/request.rb
+- lib/htty/rack/requests_util.rb
+- lib/htty/rack/session.rb
+- test/rack-htty_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://www.github.com/Asquera/htty-rack
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: htty-rack is htty for rack applications
+test_files: []
+