RubyGems - bahuvrihi-tap - Versions diffs - 0.10.8 → 0.11.0 - Mend

bahuvrihi-tap 0.10.8 → 0.11.0

Files changed (31) hide show

data/History +12 -0
data/README +2 -0
data/bin/rap +1 -1
data/doc/Class Reference +16 -7
data/doc/Command Reference +1 -2
data/doc/Tutorial +3 -5
data/lib/tap/app.rb +70 -75
data/lib/tap/constants.rb +2 -2
data/lib/tap/env.rb +23 -25
data/lib/tap/file_task.rb +1 -1
data/lib/tap/generator/generators/command/command_generator.rb +2 -2
data/lib/tap/generator/generators/command/templates/command.erb +2 -2
data/lib/tap/generator/generators/config/config_generator.rb +1 -1
data/lib/tap/generator/generators/file_task/file_task_generator.rb +1 -1
data/lib/tap/generator/generators/generator/generator_generator.rb +1 -1
data/lib/tap/generator/generators/root/root_generator.rb +1 -1
data/lib/tap/generator/generators/root/templates/gemspec +1 -1
data/lib/tap/generator/generators/task/task_generator.rb +1 -1
data/lib/tap/support/constant_manifest.rb +3 -2
data/lib/tap/support/executable.rb +6 -0
data/lib/tap/support/gems/rake.rb +20 -2
data/lib/tap/task.rb +66 -108
data/lib/tap/tasks/rake.rb +2 -39
data/lib/tap/test/file_test.rb +1 -1
data/lib/tap/test/utils.rb +2 -2
metadata +1 -6
data/cmd/server.rb +0 -42
data/lib/tap/support/gems/rack.rb +0 -282
data/template/404.erb +0 -12
data/template/index.erb +0 -49
data/vendor/url_encoded_pair_parser.rb +0 -93

@@ -384,7 +384,7 @@ module Tap
           end
           # get output files from the block, expand and sort
-          output_files = [block.call(input_files)].flatten.collect do |output_file|
+          output_files = [*block.call(input_files)].collect do |output_file|
             File.expand_path(output_file)
           end.sort

data/lib/tap/test/utils.rb CHANGED

@@ -60,7 +60,7 @@ module Tap
       #  # !> DereferenceError
       #
       def reference_map(source_dir, reference_dir, pattern='**/*.ref')
-        Dir.glob(File.join(source_dir, pattern)).collect do |source|
+        Dir.glob(File.join(source_dir, pattern)).sort.collect do |source|
           # use the path specified in the source file
           relative_path = File.read(source).gsub(/#.*$/, "").strip
@@ -228,4 +228,4 @@ module Tap
       end
     end
   end
-end
+end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bahuvrihi-tap
 version: !ruby/object:Gem::Version
-  version: 0.10.8
+  version: 0.11.0
 platform: ruby
 authors:
 - Simon Chiang
@@ -35,7 +35,6 @@ files:
 - cmd/generate.rb
 - cmd/manifest.rb
 - cmd/run.rb
-- cmd/server.rb
 - doc/Tutorial
 - doc/Class Reference
 - doc/Command Reference
@@ -90,7 +89,6 @@ files:
 - lib/tap/support/executable.rb
 - lib/tap/support/executable_queue.rb
 - lib/tap/support/gems/rake.rb
-- lib/tap/support/gems/rack.rb
 - lib/tap/support/gems.rb
 - lib/tap/support/instance_configuration.rb
 - lib/tap/support/intern.rb
@@ -139,9 +137,6 @@ files:
 - lib/tap/test/utils.rb
 - lib/tap/test.rb
 - lib/tap.rb
-- template/404.erb
-- template/index.erb
-- vendor/url_encoded_pair_parser.rb
 - README
 - MIT-LICENSE
 - History

data/cmd/server.rb DELETED

@@ -1,42 +0,0 @@
-# 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/support/gems/rack.rb DELETED

@@ -1,282 +0,0 @@
-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").each do |path|
-          env.root.relative_filepath(:cgi, path)
-        end
-        entries = entries.sort_by {|path| File.basename(path) }
-        Support::Manifest.intern(entries) {|path| "/" + path }
-      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 = search(:cgis, 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/template/404.erb DELETED

@@ -1,12 +0,0 @@
-<html>
-<body>
-<p>
-# 404 error<br/>
-# Could not handle request:
-</p>
-<code><pre>
-<%= cgi.to_yaml %>
-<%= rack.to_yaml %>
-</pre></code>
-</body>
-</html>

data/template/index.erb DELETED

@@ -1,49 +0,0 @@
-<% env_names = {} %>
-<% env.manifest(:envs, true).minimize.each do |name, environment| %>
-<%   env_names[environment] = name %>
-<% end %>
-<html>
-<head>
-  <title>Tap::Manifest</title>
-</head>
-<body>
-<div id="branding">
-  <h1><a href="<%= Tap::WEBSITE %>">Tap (<ins>T</ins>ask <ins>Ap</ins>plication) <%= Tap::VERSION %> </a></h1>
-</div>
-<div id="content_main">
-<dl id="envs" class="manifest">
-<% env.each do |current| %>
-  <dt class="key"><%= env_names[current] %> (<%= current.root.root %>)</dt>
-  <dd class="value">
-<%   manifest_keys = (Tap::Env.manifests.keys + current.manifests.keys).uniq %>
-<%   manifest_keys -= [:envs] %>
-<%   manifest_keys.each do |key| %>
-<%     manifest = current.manifest(key, true) %>
-<%     next if manifest.empty? %>
-    <dl id="manifests" class="manifest">
-    <dt class="key"><%= key %></dt>
-    <dd class="value">
-      <ol>
-<%     manifest.each do |(name, path)| %>
-<%       path = path.kind_of?(Tap::Support::Constant) ? path.require_path : path %>
-        <li><%= name %> (<%= current.root.relative_filepath(:root, path) || path %>)</li>
-<%     end %>
-      </ol>
-    </dd>
-    </dl>
-<%   end %>
-  </dd>
-<% end %>
-  </dl>
-</div>
-<div id="nav">
-  <ul>
-    <li><a href="index?refresh=true">Refresh</a></li>
-  </ul>
-</div>
-</body>
-</html>

data/vendor/url_encoded_pair_parser.rb DELETED

@@ -1,93 +0,0 @@
-require 'strscan'
-class UrlEncodedPairParser < StringScanner #:nodoc:
-  attr_reader :top, :parent, :result
-  def initialize(pairs = [])
-    super('')
-    @result = {}
-    pairs.each { |key, value| parse(key, value) }
-  end
-  KEY_REGEXP = %r{([^\[\]=&]+)}
-  BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
-  # Parse the query string
-  def parse(key, value)
-    self.string = key
-    @top, @parent = result, nil
-    # First scan the bare key
-    key = scan(KEY_REGEXP) or return
-    key = post_key_check(key)
-    # Then scan as many nestings as present
-    until eos?
-      r = scan(BRACKETED_KEY_REGEXP) or return
-      key = self[1]
-      key = post_key_check(key)
-    end
-    bind(key, value)
-  end
-  private
-  # After we see a key, we must look ahead to determine our next action. Cases:
-  #
-  # [] follows the key. Then the value must be an array.
-  # = follows the key. (A value comes next)
-  # & or the end of string follows the key. Then the key is a flag.
-  # otherwise, a hash follows the key.
-  def post_key_check(key)
-    if scan(/\[\]/) # a[b][] indicates that b is an array
-      container(key, Array)
-      nil
-    elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
-      container(key, Hash)
-      nil
-    else # End of key? We do nothing.
-      key
-    end
-  end
-  # Add a container to the stack.
-  def container(key, klass)
-    type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
-    value = bind(key, klass.new)
-    type_conflict! klass, value unless value.is_a?(klass)
-    push(value)
-  end
-  # Push a value onto the 'stack', which is actually only the top 2 items.
-  def push(value)
-    @parent, @top = @top, value
-  end
-  # Bind a key (which may be nil for items in an array) to the provided value.
-  def bind(key, value)
-    if top.is_a? Array
-      if key
-        if top[-1].is_a?(Hash) && ! top[-1].key?(key)
-          top[-1][key] = value
-        else
-          top << {key => value}#.with_indifferent_access
-          push top.last
-        end
-      else
-        top << value
-      end
-    elsif top.is_a? Hash
-      key = CGI.unescape(key)
-      parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
-      return top[key] ||= value
-    else
-      raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
-    end
-    return value
-  end
-  def type_conflict!(klass, value)
-    raise TypeError, "Conflicting types for parameter containers. Expected an instance of #{klass} but found an instance of #{value.class}. This can be caused by colliding Array and Hash parameters like qs[]=value&qs[key]=value."
-  end
-end