tap 0.17.1 → 0.18.0

data/lib/tap/tasks/dump.rb

@@ -46,7 +46,7 @@ module Tap
         open_io(output, overwrite ? 'w' : 'a') do |io|
           dump(input, io)
         end
-        output
+        input
       end
     
       # Dumps the object to io, by default dump puts (not prints) obj.to_s.

data/lib/tap/tasks/load.rb

@@ -22,7 +22,7 @@ module Tap
     # :startdoc::task-
     #
     # Load serves as a baseclass for more complicated loads.  A YAML load
-    # (see {tap-tasks}[http://tap.rubyforge.org/tap-tasks]) looks like this:
+    # could look like this:
     #
     #   class Yaml < Tap::Tasks::Load
     #     def load(io)
@@ -30,10 +30,9 @@ module Tap
     #     end
     #   end
     #
-    # Load is constructed to reque itself in cases where objects are to
-    # be loaded sequentially from the same io.  Load will reque until the
-    # end-of-file is reached, but this behavior can be modified by
-    # overriding the complete? method.  An example is a prompt task:
+    # Load subclasses may be constructed to reque itself in cases where objects
+    # are sequentially loaded from the same io.  Load will reque until the
+    # complete? method returns true.  An example is a prompt task:
     #
     #   class Prompt < Tap::Tasks::Load
     #     config :exit_seq, "\n"
@@ -87,7 +86,7 @@ module Tap
       # * Returning all other objects
       #
       def open(io)
-        return File.open(io) if file
+        return(io.kind_of?(File) ? io : File.open(io)) if file
         
         case io
         when String
@@ -110,10 +109,10 @@ module Tap
         io.close
       end
       
-      # Returns io.eof?  Override in subclasses for the desired behavior
-      # (see process).
+      # Returns true by default.  Override in subclasses to allow recurrent 
+      # loading (see process).
       def complete?(io, last)
-        io.eof?
+        true
       end
     end
   end

data/lib/tap/templater.rb

@@ -0,0 +1,203 @@
+require 'ostruct'
+autoload(:ERB, 'erb')
+autoload(:YAML, 'yaml')
+
+module Tap
+  # Templater is a convenience class for creating ERB templates.  As
+  # a subclass of OpenStruct, attributes can be assigned/unassigned
+  # directly.  When the template is built, all the method of 
+  # Templater (and hence all the assigned attributes) are available.
+  #
+  #   t = Templater.new( "key: <%= value %>")
+  #   t.value = "default"
+  #   t.build                 # => "key: default"
+  #
+  #   t.value = "another"
+  #   t.build                 # => "key: another"
+  #
+  # Templater includes the Templater::Utils utility methods.
+  #
+  # === ERB Redirection
+  #
+  # Templater hooks into the ERB templating mechanism by providing itself 
+  # as the ERB output target (_erbout).  ERB concatenates each line of an 
+  # ERB template to _erbout, as can be seen here:
+  #
+  #   e = ERB.new("<%= 1 + 2 %>")
+  #   e.src                   # => "_erbout = ''; _erbout.concat(( 1 + 2 ).to_s); _erbout"
+  #
+  # By setting itself as _erbout, instances of Templater can redirect 
+  # output to a temporary target and perform string transformations.  
+  # For example, redirection allows indentation of nested content:
+  #
+  #   template = %Q{
+  #   # Un-nested content
+  #   <% redirect do |target| %>
+  #   # Nested content
+  #   <% module_nest("Nesting::Module") { target } %>
+  #   <% end %>
+  #   }
+  #
+  #   t = Templater.new(template)
+  #   t.build
+  #   # => %Q{
+  #   # # Un-nested content
+  #   # module Nesting
+  #   #   module Module
+  #   #     # Nested content
+  #   #     
+  #   #   end
+  #   # end}
+  #
+  class Templater < OpenStruct
+    
+    # Utility methods for Templater; mostly string manipulations
+    # useful in creating documentation.
+    module Utils
+      
+      # yamlize converts the object to YAML (using to_yaml), omitting
+      # the header and final newline:
+      #
+      #   {'key' => 'value'}.to_yaml           # => "--- \nkey: value\n"
+      #   yamlize {'key' => 'value'}           # => "key: value"
+      def yamlize(object)
+        object == nil ? "~" : YAML.dump(object)[4...-1].strip
+      end
+      
+      # Comments out the string.
+      def comment(str)
+        str.split("\n").collect {|line| "# #{line}" }.join("\n")
+      end
+      
+      # Nest the return of the block in the nesting lines.
+      #
+      #  nest([["\nmodule Some", "end\n"],["module Nested", "end"]]) { "class Const\nend" }
+      #  # => %Q{
+      #  # module Some
+      #  #   module Nested
+      #  #     class Const
+      #  #     end
+      #  #   end
+      #  # end
+      #  # }
+      #
+      def nest(nesting, indent="  ", line_sep="\n")
+        content = yield
+        return content if nesting.empty?
+        
+        depth = nesting.length
+        lines = [indent * depth + content.gsub(/#{line_sep}/, line_sep + indent * depth)]
+
+        nesting.reverse_each do |(start_line, end_line)|
+          depth -= 1
+          lines.unshift(indent * depth + start_line)
+          lines << (indent * depth + end_line)
+        end
+
+        lines.join(line_sep)
+      end
+      
+      # Nest the return of the block in the nesting module.
+      #
+      #  module_nest('Some::Nested') { "class Const\nend" }
+      #  # => %Q{
+      #  # module Some
+      #  #   module Nested
+      #  #     class Const
+      #  #     end
+      #  #   end
+      #  # end
+      #  # }.strip
+      #
+      def module_nest(const_name, indent="  ", line_sep="\n")
+        nesting = const_name.split(/::/).collect do |name|
+          ["module #{name}", "end"]
+        end
+        
+        nest(nesting, indent, line_sep) { yield }
+      end
+    end
+    
+    class << self
+      
+      # Builds the erb template with the specified attributes.
+      def build(template,  attributes={}, filename=nil)
+        new(template, attributes, filename).build
+      end
+    end
+    
+    include Utils
+    
+    # Initialized a new Templater.  An ERB or String may be provided as the
+    # template.  If a String is provided, it will be used to initialize an
+    # ERB with a trim_mode of "<>".
+    def initialize(template, attributes={})
+      @template = case template
+      when ERB
+        # matching w/wo the coding effectively checks @src
+        # across ruby versions (encoding appears in 1.9)
+        if template.instance_variable_get(:@src) !~ /^(#coding:US-ASCII\n)?_erbout =/
+          raise ArgumentError, "Templater does not work with ERB templates where eoutvar != '_erbout'"
+        end
+        template
+      when String then ERB.new(template, nil, "<>")
+      else raise ArgumentError, "cannot convert #{template.class} into an ERB template"
+      end
+      
+      src = @template.instance_variable_get(:@src)
+      @template.instance_variable_set(:@src, "self." + src) 
+
+      super(attributes)
+    end
+    
+    # Returns self (not the underlying erbout storage that actually receives 
+    # the output lines).  In the ERB context, this method directs erb outputs
+    # to Templater#concat and into the redirect mechanism.
+    def _erbout
+      self
+    end
+    
+    # Sets the underlying erbout storage to input.
+    def _erbout=(input)
+      @_erbout = input
+    end
+    
+    unless RUBY_VERSION < "1.9"
+      #-- TODO
+      # check if this is still needed...
+      def force_encoding(encoding)
+        @_erbout.force_encoding(encoding)
+        @_erbout
+      end
+    end
+    
+    # Redirects output of erb to the redirected_erbout string
+    # for the duration of the block.  When redirect completes,
+    # the redirected_erbout is concatenated to the main
+    # erbout storage.
+    def redirect # :yields: redirected_erbout
+      current = @_erbout
+      @_erbout = ""
+      result = yield(@_erbout)
+      @_erbout = current
+      concat(result)
+    end
+    
+    # Concatenates the specified input to the underlying erbout storage.
+    def concat(input)
+      @_erbout << input
+    end
+    
+    # Build the template, setting the attributes and filename if specified.
+    # All methods of self will be accessible in the template.
+    def build(attrs=nil, filename=nil)
+      attrs.each_pair do |key, value|
+        send("#{key}=", value)
+      end if attrs
+      
+      @template.filename = filename
+      @template.result(binding)
+      @_erbout
+    end
+  end
+end

data/lib/tap/{constants.rb → version.rb}

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap
 version: !ruby/object:Gem::Version 
-  version: 0.17.1
+  version: 0.18.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-06 00:00:00 -06:00
+date: 2009-06-17 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,7 +46,7 @@ files:
 - lib/tap/app/queue.rb
 - lib/tap/app/stack.rb
 - lib/tap/app/state.rb
-- lib/tap/constants.rb
+- lib/tap/version.rb
 - lib/tap/tasks/dump.rb
 - lib/tap/env.rb
 - lib/tap/env/constant.rb
@@ -59,6 +59,7 @@ files:
 - lib/tap/joins.rb
 - lib/tap/joins/switch.rb
 - lib/tap/joins/sync.rb
+- lib/tap/middleware.rb
 - lib/tap/tasks/load.rb
 - lib/tap/root.rb
 - lib/tap/root/utils.rb
@@ -66,8 +67,8 @@ files:
 - lib/tap/schema.rb
 - lib/tap/schema/parser.rb
 - lib/tap/schema/utils.rb
-- lib/tap/support/intern.rb
-- lib/tap/support/templater.rb
+- lib/tap/intern.rb
+- lib/tap/templater.rb
 - lib/tap/task.rb
 - README
 - MIT-LICENSE

data/lib/tap/support/intern.rb

@@ -1,53 +0,0 @@
-module Tap
-  module Support
-    
-    # Generates an Intern module to override the specified method_name.  Intern
-    # modules are useful to override a tiny bit of functionality without having
-    # to generate a full subclass.
-    #
-    # An Intern module:
-    #
-    # - adds an accessor for <method_name>_block
-    # - overrides <method_name> to call the block, prepending self to
-    #   the input arguments
-    #
-    # For example:
-    #
-    #   array = [1,2,3].extend Intern(:last)
-    #
-    #   array.last             # => 3
-    #   array.last_block = lambda {|arr| arr.first }
-    #   array.last             # => 3
-    #
-    def self.Intern(method_name)
-      mod = INTERN_MODULES[method_name.to_sym]
-      return mod unless mod == nil
-
-      mod = INTERN_MODULES[method_name.to_sym] = Module.new
-      mod.module_eval %Q{
-      attr_accessor :#{method_name}_block
-
-      def #{method_name}(*inputs)
-        return super unless #{method_name}_block
-        inputs.unshift(self)
-
-        arity = #{method_name}_block.arity
-        n = inputs.length
-        unless n == arity || (arity < 0 && (-1-n) <= arity) 
-          raise ArgumentError.new("wrong number of arguments (\#{n} for \#{arity})")
-        end
-
-        #{method_name}_block.call(*inputs)
-      end
-      }
-      mod
-    end
-    
-    # An array of already-declared intern modules,
-    # keyed by method_name.
-    INTERN_MODULES = {}
-    
-    # An Intern module for :process.
-    Intern = Support.Intern(:process)
-  end
-end

data/lib/tap/support/templater.rb

@@ -1,207 +0,0 @@
-require 'ostruct'
-autoload(:ERB, 'erb')
-autoload(:YAML, 'yaml')
-
-module Tap
-  module Support
-    
-    # Templater is a convenience class for creating ERB templates.  As
-    # a subclass of OpenStruct, attributes can be assigned/unassigned
-    # directly.  When the template is built, all the method of 
-    # Templater (and hence all the assigned attributes) are available.
-    #
-    #   t = Templater.new( "key: <%= value %>")
-    #   t.value = "default"
-    #   t.build                 # => "key: default"
-    #
-    #   t.value = "another"
-    #   t.build                 # => "key: another"
-    #
-    # Templater includes the Templater::Utils utility methods.
-    #
-    # === ERB Redirection
-    #
-    # Templater hooks into the ERB templating mechanism by providing itself 
-    # as the ERB output target (_erbout).  ERB concatenates each line of an 
-    # ERB template to _erbout, as can be seen here:
-    #
-    #   e = ERB.new("<%= 1 + 2 %>")
-    #   e.src                   # => "_erbout = ''; _erbout.concat(( 1 + 2 ).to_s); _erbout"
-    #
-    # By setting itself as _erbout, instances of Templater can redirect 
-    # output to a temporary target and perform string transformations.  
-    # For example, redirection allows indentation of nested content:
-    #
-    #   template = %Q{
-    #   # Un-nested content
-    #   <% redirect do |target| %>
-    #   # Nested content
-    #   <% module_nest("Nesting::Module") { target } %>
-    #   <% end %>
-    #   }
-    #
-    #   t = Templater.new(template)
-    #   t.build
-    #   # => %Q{
-    #   # # Un-nested content
-    #   # module Nesting
-    #   #   module Module
-    #   #     # Nested content
-    #   #     
-    #   #   end
-    #   # end}
-    #
-    class Templater < OpenStruct
-      
-      # Utility methods for Templater; mostly string manipulations
-      # useful in creating documentation.
-      module Utils
-        
-        # yamlize converts the object to YAML (using to_yaml), omitting
-        # the header and final newline:
-        #
-        #   {'key' => 'value'}.to_yaml           # => "--- \nkey: value\n"
-        #   yamlize {'key' => 'value'}           # => "key: value"
-        def yamlize(object)
-          object == nil ? "~" : YAML.dump(object)[4...-1].strip
-        end
-        
-        # Comments out the string.
-        def comment(str)
-          str.split("\n").collect {|line| "# #{line}" }.join("\n")
-        end
-        
-        # Nest the return of the block in the nesting lines.
-        #
-        #  nest([["\nmodule Some", "end\n"],["module Nested", "end"]]) { "class Const\nend" }
-        #  # => %Q{
-        #  # module Some
-        #  #   module Nested
-        #  #     class Const
-        #  #     end
-        #  #   end
-        #  # end
-        #  # }
-        #
-        def nest(nesting, indent="  ", line_sep="\n")
-          content = yield
-          return content if nesting.empty?
-          
-          depth = nesting.length
-          lines = [indent * depth + content.gsub(/#{line_sep}/, line_sep + indent * depth)]
-
-          nesting.reverse_each do |(start_line, end_line)|
-            depth -= 1
-            lines.unshift(indent * depth + start_line)
-            lines << (indent * depth + end_line)
-          end
-
-          lines.join(line_sep)
-        end
-        
-        # Nest the return of the block in the nesting module.
-        #
-        #  module_nest('Some::Nested') { "class Const\nend" }
-        #  # => %Q{
-        #  # module Some
-        #  #   module Nested
-        #  #     class Const
-        #  #     end
-        #  #   end
-        #  # end
-        #  # }.strip
-        #
-        def module_nest(const_name, indent="  ", line_sep="\n")
-          nesting = const_name.split(/::/).collect do |name|
-            ["module #{name}", "end"]
-          end
-          
-          nest(nesting, indent, line_sep) { yield }
-        end
-      end
-      
-      class << self
-        
-        # Builds the erb template with the specified attributes.
-        def build(template,  attributes={}, filename=nil)
-          new(template, attributes, filename).build
-        end
-      end
-      
-      include Utils
-      
-      # Initialized a new Templater.  An ERB or String may be provided as the
-      # template.  If a String is provided, it will be used to initialize an
-      # ERB with a trim_mode of "<>".
-      def initialize(template, attributes={})
-        @template = case template
-        when ERB
-          # matching w/wo the coding effectively checks @src
-          # across ruby versions (encoding appears in 1.9)
-          if template.instance_variable_get(:@src) !~ /^(#coding:US-ASCII\n)?_erbout =/
-            raise ArgumentError, "Templater does not work with ERB templates where eoutvar != '_erbout'"
-          end
-          template
-        when String then ERB.new(template, nil, "<>")
-        else raise ArgumentError, "cannot convert #{template.class} into an ERB template"
-        end
-        
-        src = @template.instance_variable_get(:@src)
-        @template.instance_variable_set(:@src, "self." + src) 
-
-        super(attributes)
-      end
-      
-      # Returns self (not the underlying erbout storage that actually receives 
-      # the output lines).  In the ERB context, this method directs erb outputs
-      # to Templater#concat and into the redirect mechanism.
-      def _erbout
-        self
-      end
-      
-      # Sets the underlying erbout storage to input.
-      def _erbout=(input)
-        @_erbout = input
-      end
-      
-      unless RUBY_VERSION < "1.9"
-        #-- TODO
-        # check if this is still needed...
-        def force_encoding(encoding)
-          @_erbout.force_encoding(encoding)
-          @_erbout
-        end
-      end
-      
-      # Redirects output of erb to the redirected_erbout string
-      # for the duration of the block.  When redirect completes,
-      # the redirected_erbout is concatenated to the main
-      # erbout storage.
-      def redirect # :yields: redirected_erbout
-        current = @_erbout
-        @_erbout = ""
-        result = yield(@_erbout)
-        @_erbout = current
-        concat(result)
-      end
-      
-      # Concatenates the specified input to the underlying erbout storage.
-      def concat(input)
-        @_erbout << input
-      end
-      
-      # Build the template.  All methods of self will be 
-      # accessible in the template.
-      def build(attrs={}, filename=nil)
-        attrs.each_pair do |key, value|
-          send("#{key}=", value)
-        end
-        
-        @template.filename = filename
-        @template.result(binding)
-        @_erbout
-      end
-      
-    end
-  end
-end