RubyGems - bahuvrihi-tap - Versions diffs - 0.11.1 → 0.11.2 - Mend

bahuvrihi-tap 0.11.1 → 0.11.2

Files changed (22) hide show

data/cmd/server.rb +42 -0
data/lib/tap/constants.rb +1 -1
data/lib/tap/spec.rb +39 -0
data/lib/tap/support/configurable_class.rb +2 -2
data/lib/tap/support/gems/rack.rb +279 -0
data/lib/tap/support/lazydoc.rb +2 -2
data/lib/tap/support/lazydoc/attributes.rb +48 -0
data/lib/tap/test.rb +59 -54
data/lib/tap/test/file_test.rb +1 -1
data/public/javascripts/prototype.js +4221 -0
data/public/javascripts/run.js +54 -0
data/public/stylesheets/run.css +22 -0
data/template/404.erb +12 -0
data/template/index.erb +56 -0
data/template/run.erb +31 -0
data/template/run/join.erb +3 -0
data/template/run/manifest.erb +8 -0
data/template/run/node.erb +50 -0
data/template/run/round.erb +0 -0
data/vendor/url_encoded_pair_parser.rb +93 -0
metadata +16 -2
data/lib/tap/support/lazy_attributes.rb +0 -45

data/cmd/server.rb ADDED Viewed

@@ -0,0 +1,42 @@
+# tap server {options}
+#
+# Initializes a tap server.
+require 'tap'
+require 'tap/support/gems/rack'
+env = Tap::Env.instance
+#
+# handle options
+#
+options = {:Port => 8080}
+OptionParser.new do |opts|
+  opts.separator ""
+  opts.separator "options:"
+  opts.on("-h", "--help", "Show this message") do
+    opts.banner = Tap::Support::TDoc.usage(__FILE__)
+    puts opts
+    exit
+  end
+  opts.on("-p", "--port PORT", Integer, "Specifies the port (default #{options[:Port]})") do |value|
+    options[:Port] = value
+  end
+  opts.on("-d", "--development", Integer, "Specifies development mode") do
+    env.config[:development] = true
+  end
+end.parse!(ARGV)
+#
+# cgi dir and public dir can be set in tap.yml
+#
+env.extend Tap::Support::Gems::Rack
+Rack::Handler::WEBrick.run(env, options) do |handler|
+  env.handler = handler
+end

data/lib/tap/constants.rb CHANGED Viewed

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 11
-  TINY = 1
+  TINY = 2
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}"
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/spec.rb ADDED Viewed

@@ -0,0 +1,39 @@
+$:.unshift File.expand_path("#{File.dirname(__FILE__)}/..")
+require 'tap/test/extensions'
+require 'rubygems'
+require 'minitest/spec'
+class MiniTest::Unit::TestCase
+  extend Tap::Test::Extensions
+  class << self
+    # Causes a test suite to be skipped.  If a message is given, it will
+    # print and notify the user the test suite has been skipped.
+    def skip_test(msg=nil)
+      @@test_suites.delete(self)
+      puts "Skipping #{self}#{msg.empty? ? '' : ': ' + msg}"
+    end
+    private
+    # Infers the test root directory from the calling file.
+    #   'some_class.rb' => 'some_class'
+    #   'some_class_test.rb' => 'some_class'
+    def test_root_dir # :nodoc:
+      # caller[1] is considered the calling file (which should be the test case)
+      # note that caller entries are like this:
+      #   ./path/to/file.rb:10
+      #   ./path/to/file.rb:10:in 'method'
+      calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
+      calling_file.chomp(File.extname(calling_file)).chomp("_spec")
+    end
+  end
+  def method_name
+    @method_name ||= name.gsub(/\s/, "_").gsub(/^test_/, "")
+  end
+end
+MiniTest::Unit.autorun

data/lib/tap/support/configurable_class.rb CHANGED Viewed

@@ -1,6 +1,6 @@
 require 'tap/support/class_configuration'
 require 'tap/support/validation'
-require 'tap/support/lazy_attributes'
+require 'tap/support/lazydoc/attributes'
 require 'tap/support/lazydoc/config'
 module Tap
@@ -23,7 +23,7 @@ module Tap
     #   c.respond_to?('one=')                      # => true
     #
     module ConfigurableClass
-      include Tap::Support::LazyAttributes
+      include Lazydoc::Attributes
       # A ClassConfiguration holding the class configurations.
       attr_reader :configurations

data/lib/tap/support/gems/rack.rb ADDED Viewed

@@ -0,0 +1,279 @@
+require 'rack'
+require 'yaml'
+# in a future release, it looks like this will be changed
+require 'rack/file'
+#require 'rack/mime'
+module Tap
+  module Support
+    module Gems
+      Tap::Env.manifest(:cgis) do |env|
+        entries = env.root.glob(:cgi, "**/*.rb").sort_by {|path| File.basename(path) }
+        Support::Manifest.intern(entries) do |manifest, path|
+          "/" + manifest.env.root.relative_filepath(:cgi, path)
+        end
+      end
+      # = UNDER CONSTRUCTION
+      # Support for a Tap::Server, built on {Rack}[http://rack.rubyforge.org/].
+      #
+      # Tap::Support::Gems::Rack is intended to extend a Tap::Env
+      module Rack
+        # The handler for the server (ex Rack::Handler::WEBrick)
+        attr_accessor :handler
+        # The default error template used by response
+        # when an error occurs.
+        DEFAULT_ERROR_TEMPLATE = %Q{
+<html>
+<body>
+# Error handling request: <%= error.message %></br>
+# <%= error.backtrace.join("<br/># ") %>
+<code><pre>
+<%= cgi.to_yaml %>
+<%= rack.to_yaml %>
+</pre></code>
+</body>
+</html>
+}
+        # Creates a [status, headers, body] response using the result of the
+        # block as the body.  The status and headers the defaults for
+        # {Rack::Response}[http://rack.rubyforge.org/doc/classes/Rack/Response.html].
+        # If an error occurs, a default error message is generated using the
+        # DEFAULT_ERROR_TEMPLATE.
+        def response(rack_env)
+          ::Rack::Response.new.finish do |res|
+            res.write begin
+              yield(res)
+            rescue
+              template(DEFAULT_ERROR_TEMPLATE, env_attrs(rack_env).merge(:error => $!))
+            end
+          end
+        end
+        # The {Rack}[http://rack.rubyforge.org/doc/] interface method.  Call
+        # routesrequests (with preference) to:
+        # * static pages
+        # * cgi scripts
+        # * default responses
+        #
+        # === Static pages
+        # Static pages may be served from any env in self.  A static page is
+        # served if a file with the request path exists under the 'public'
+        # directory for any env.
+        #
+        # Envs are searched in order, using the Env#search_path method.
+        #
+        # === CGI scripts
+        # Like static pages, cgi scripts may be served from any env in self.
+        # Scripts are discovered using a search of the cgi manifest.  See
+        # cgi_response for more details.
+        #
+        # === Default responses
+        # The default response is path-dependent:
+        #
+        #   path            action
+        #   /, /index       render the manifest.
+        #   all others      render a 404 response
+        #
+        # The manifest may be refreshed by setting a query string:
+        #
+        #   /?refresh=true
+        #   /index?refresh=true
+        #
+        def call(rack_env)
+          path = rack_env['PATH_INFO']
+          case
+          when static_path = search_path(:public, path) {|file| File.file?(file) }
+            # serve named static pages
+            file_response(static_path, rack_env)
+          when cgi_path = cgis.search(path)
+            # serve cgis
+            cgi_response(cgi_path, rack_env)
+          # when task_path = search(:tasks, path)
+          #   # serve tasks
+          #   cgi_response('task', rack_env)
+          when path == "/" || path == "/index"
+            # serve up the homepage
+            if rack_env["QUERY_STRING"] == "refresh=true"
+              # reset(:cgis) do |key, path|
+              #   Support::Lazydoc[path].resolved = false
+              # end
+            end
+            render_response('index.erb', rack_env)
+          else
+            # handle all other requests as errors
+            render_response('404.erb', rack_env)
+          end
+        end
+        # Generates a [status, headers, body] response for the specified file.
+        # Patterned after {Rack::File#._call}[http://rack.rubyforge.org/doc/classes/Rack/File.html].
+        def file_response(path, rack_env)
+          response(rack_env) do |res|
+            content = File.read(path)
+            res.headers.merge!(
+              "Last-Modified" => File.mtime(path).httpdate,
+              "Content-Type" => ::Rack::File::MIME_TYPES[File.extname(path)] || "text/plain", # Rack::Mime.mime_type(File.extname(path), 'text/plain'),
+              "Content-Length" => content.size.to_s)
+            content
+          end
+        end
+        # Generates a [status, headers, body] response for the specified cgi.
+        # The cgi will be run with ENV set as specified in rack_env.
+        def cgi_response(cgi_path, rack_env)
+          # setup standard ios for capture
+          current_input = $stdin
+          current_output = $stdout
+          cgi_input = rack_env['rack.input']
+          cgi_output = StringIO.new("")
+          begin
+            $stdin = cgi_input
+            $stdout = cgi_output
+            # run the cgi
+            with_ENV(rack_env) { load(cgi_path) }
+            # collect the headers and body from the output
+            headers, body = cgi_output.string.split(/\r?\n\r?\n/, 2)
+            raise "missing headers from: #{cgi_path}" if headers == nil
+            body = "" if body == nil
+            headers = headers.split(/\r?\n/).inject({}) do |hash, line|
+              key, value = line.split(/:/, 2)
+              hash[key] = value
+              hash
+            end
+            # generate the response
+            [headers.delete('Status') || 200, headers, body]
+          rescue(Exception)
+            # when an error occurs, return a standard cgi error with backtrace
+            [500, {'Content-Type' => 'text/plain'}, %Q{#{$!.class}: #{$!.message}\n#{$!.backtrace.join("\n")}}]
+          ensure
+            $stdin = current_input
+            $stdout = current_output
+          end
+        end
+        # def cgi_template(name, attributes={})
+        #   path = root.filepath(:template, "#{name}.erb")
+        #   Templater.new( File.read(path), {:server => self}.merge(attributes) ).build
+        # end
+        # Generates a [status, headers, body] response using the first existing
+        # template matching path (as determined by Env#search_path) and the
+        # specified rack_env.
+        def render_response(path, rack_env)
+          # partition and sort the env variables into
+          # cgi and rack variables.
+          rack, cgi = rack_env.to_a.partition do |(key, value)|
+            key =~ /^rack/
+          end.collect do |part|
+            part.sort_by do |key, value|
+              key
+            end.inject({}) do |hash, (key,value)|
+              hash[key] = value
+              hash
+            end
+          end
+          response(rack_env) do
+            render(path, env_attrs(rack_env))
+          end
+        end
+        module Render
+          def renderer(path)
+            template = env.search_path(:template, path) {|file| File.file?(file) }
+            raise("no such template: #{path}") if template == nil
+            Tap::Support::Templater.new(File.read(template), marshal_dump).extend(Render)
+          end
+          def render(path, attrs={})
+            renderer(path).build(attrs)
+          end
+        end
+        # Builds the specified template using the rack_env and additional
+        # attributes. The rack_env is partitioned into rack-related and
+        # cgi-related hashes (all rack_env entries where the key starts
+        # with 'rack' are rack-related, the others are cgi-related).
+        #
+        # The template is built with the following standard locals:
+        #
+        #   server   self
+        #   cgi      the cgi-related hash
+        #   rack     the rack-related hash
+        #
+        # Plus the attributes.
+        def render(path, attributes={}) # :nodoc:
+          path = search_path(:template, path) {|file| File.file?(file) }
+          raise("no such template: #{path}") if path == nil
+          template(File.read(path) , attributes)
+        end
+        def env_attrs(rack_env)
+          # partition and sort the env variables into
+          # cgi and rack variables.
+          rack, cgi = rack_env.to_a.partition do |(key, value)|
+            key =~ /^rack/
+          end.collect do |part|
+            part.sort_by do |key, value|
+              key
+            end.inject({}) do |hash, (key,value)|
+              hash[key] = value
+              hash
+            end
+          end
+          {:env => self, :cgi => cgi, :rack => rack}
+        end
+        def template(template, attributes={}) # :nodoc:
+          Templater.new(template, attributes).extend(Render).build
+        end
+        protected
+        # Executes block with ENV set to the specified hash.
+        # Non-string values in hash are skipped.
+        def with_ENV(hash) # :nodoc:
+          current_env = {}
+          ENV.each_pair {|key, value| current_env[key] = value }
+          begin
+            ENV.clear
+            hash.each_pair {|key, value| ENV[key] = value if value.kind_of?(String)}
+            yield
+          ensure
+            ENV.clear
+            current_env.each_pair {|key, value| ENV[key] = value }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tap/support/lazydoc.rb CHANGED Viewed

@@ -4,7 +4,7 @@ module Tap
   module Support
     # Lazydoc lazily pulls documentation out of source files and makes it
-    # available through LazyAttributes.  Lazydoc can find two types of
+    # available through Attributes.  Lazydoc can find two types of
     # documentation, constant attributes and code comments.  To illustrate,
     # consider the following:
     #
@@ -19,7 +19,7 @@ module Tap
     #   # line, the next constant attribute,
     #   # or an end key
     #   class Sample
-    #     extend Tap::Support::LazyAttributes
+    #     extend Tap::Support::Lazydoc::Attributes
     #     self.source_file = __FILE__
     #
     #     lazy_attr :key

data/lib/tap/support/lazydoc/attributes.rb ADDED Viewed

@@ -0,0 +1,48 @@
+require 'tap/support/lazydoc'
+module Tap
+  module Support
+    module Lazydoc
+      # Attributes adds methods to declare class-level accessors
+      # for Lazydoc attributes.  The source_file for the class must
+      # be set manually.
+      #
+      #   # ConstName::key value
+      #   class ConstName
+      #     class << self
+      #       include Lazydoc::Attributes
+      #     end
+      #
+      #     self.source_file = __FILE__
+      #     lazy_attr :key
+      #   end
+      #
+      #   ConstName::key.subject           # => 'value'
+      #
+      module Attributes
+        # The source_file for self.  Must be set independently.
+        attr_accessor :source_file
+        # Returns the lazydoc for source_file
+        def lazydoc(resolve=true)
+          lazydoc = Lazydoc[source_file]
+          lazydoc.resolve if resolve
+          lazydoc
+        end
+        # Creates a lazy attribute accessor for the specified attribute.
+        def lazy_attr(key, attribute=key)
+          instance_eval %Q{
+          def #{key}
+            lazydoc[to_s]['#{attribute}'] ||= Lazydoc::Comment.new
+          end
+          def #{key}=(comment)
+            Lazydoc[source_file][to_s]['#{attribute}'] = comment
+          end}
+        end
+      end
+    end
+  end
+end