sample_tasks 0.10.0

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: Simon Chiang, Biomolecular Structure Program, Hansen Lab
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+
+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

@@ -0,0 +1,28 @@
+= Sample Tasks
+
+A set of generally-useful sample tap[http://tap.rubyforge.org] tasks.
+
+== Description
+
+Sample tasks is a library of tap[http://tap.rubyforge.org] tasks that are both
+instructive and generally useful.  Currently consists of a few file tasks for 
+concatenation, searching, copying, etc.
+
+* Website[http://tap.rubyforge.org]
+* Rubyforge[http://rubyforge.org/projects/tap]
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/14735-sample-tasks/overview]
+* Github[http://github.com/bahuvrihi/sample_tasks/tree/master]
+
+== Installation
+
+The sample_tasks gem is available through RubyForge[http://rubyforge.org/projects/tap].  Use:
+
+  % gem install sample_tasks
+
+== Info 
+
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: MIT-Style
+

data/lib/tap/support/simple_table.rb

@@ -0,0 +1,99 @@
+module Tap
+  module Support
+  
+    # SimpleTable represents a simple table where each row has
+    # the same number of columns.  Provides accessors of column
+    # data, and supports headers.
+    #
+    class SimpleTable
+      class << self
+      
+        # Parses the string into an array of table data, using the
+        # specified row and column delimiters.
+        def parse_data(string, row_delimiter=/\r?\n/, col_delimiter="\t")
+          string.split(row_delimiter).collect do |row|
+            row.split(col_delimiter)
+          end
+        end
+      end
+    
+      # An array of table data.  Each entry (row) is an array of column 
+      # data padded to a uniform length (n_columns) using default_value.
+      attr_reader :data
+    
+      # The default value for empty cells
+      attr_reader :default_value
+  
+      # The number of columns in self
+      attr_reader :n_columns
+    
+      # An array of headers, padded to n_columns.
+      attr_reader :headers
+    
+      def initialize(data, options={})
+        @data = data
+        @default_value = options[:default_value] || nil
+        @headers = case options[:header_row]
+        when true
+          if @data.length == 0
+            raise "no header row available"
+          end
+          
+          @data.shift
+        else []
+        end
+         
+        normalize!
+      end
+      
+      def normalize!
+        # Determine the number of columns in self.
+        @n_columns = data.inject(0) do |max, column|
+          max > column.length ? max : column.length
+        end
+        
+        # Normalize the data rows to the number of columns.
+        @data = data.collect {|row| normalize_row(row) }
+        @headers = normalize_row(@headers)
+        
+        self
+      end
+      
+      # The number of rows in self.
+      def n_rows
+        @data.length
+      end
+    
+      # Returns an array of n_columns length and default_value
+      def blank_row
+        Array.new(n_columns, default_value)
+      end
+      
+      # Returns column data for the specified index.
+      def column(index)
+        data.collect {|row| row[index] }
+      end
+      
+      # Returns column data for the specified header.
+      def column_by_header(header)
+        index = headers.index(header)
+        raise "could not find header: #{header}" if index == nil
+      
+        column(index)
+      end
+      
+      def join(row_delimiter="\n", col_delimiter="\t", include_headers=true)
+        (include_headers ? headers.join(col_delimiter) + row_delimiter : "") +
+        data.collect do |row|
+          row.join(col_delimiter)
+        end.join(row_delimiter)
+      end
+      
+      private
+      
+      def normalize_row(array)
+        array + Array.new(n_columns - array.length, default_value)
+      end
+    end
+  end
+end

data/lib/tap/tasks/concat.rb

@@ -0,0 +1,78 @@
+require 'erb'
+
+module Tap
+  module Tasks
+    # :startdoc::manifest concatenate files with formatting
+    #
+    # Concatenates a list of files into the specified target.  Raises an error 
+    # for non-existant, non-file inputs.  Concat allows a variety configurable
+    # separators to be specified.  These strings are formatted using ERB so
+    # that you can concat and insert text at the same time. For instance 
+    # with source files:
+    #
+    #   [one.txt]
+    #   contents of file one
+    #
+    #   [two.txt]
+    #   contents of file two
+    #
+    # And configurations:
+    #   
+    #   pre: "# <%= File.basename(source) %>\n"
+    #   post: "\n"
+    #
+    # You obtain the following:
+    #
+    #   [concat.txt]
+    #   # one.txt
+    #   contents of file one
+    #
+    #   # two.txt
+    #   contents of file two
+    #
+    # The ERB binding (and hence each insert configuration) has access to all 
+    # task methods and the following variables:
+    #   target   the target file
+    #   source   the current source
+    #   sources  an array of the source files
+    #
+    class Concat < Tap::FileTask
+      config :before, "", &c.string   # string before all entries
+      config :pre, "", &c.string      # separator before each entry
+      config :post, "", &c.string     # separator after each entry
+      config :after, "", &c.string    # string after all entries
+      
+      # Alias for self.  Allows self to be accessed within separator ERB.
+      def task
+        self
+      end
+      
+      def process(target, *sources)
+        # prepare backs up the target to allow rollback on error,
+        # and ensures the target parent directory exists.
+        prepare(target)
+        log_basename :prepare, target
+        
+        # open the output file and read the file contents 
+        # of each input file into the output
+        File.open(target, "wb" ) do |output|
+          output << ERB.new(before).result(binding) unless before.empty?
+          
+          sources.each do |source|
+            raise "Not a file: #{source}" unless File.exists?(source) && File.file?(source)
+       
+            log_basename :concat, source
+            output << ERB.new(pre).result(binding) unless pre.empty?
+            output << File.read(source)
+            output << ERB.new(post).result(binding) unless post.empty?
+          end
+          
+          output << ERB.new(after).result(binding) unless after.empty?
+        end
+        
+        # return the concatenated file
+        target
+      end
+    end
+  end
+end

data/lib/tap/tasks/copy.rb

@@ -0,0 +1,53 @@
+module Tap
+  module Tasks
+    # :startdoc::manifest copies files
+    #
+    # Copies a list of files to the specified directory.  The files will
+    # be copied using the relative filepath from Dir.pwd, or the file
+    # basename if the filepath is not relative to Dir.pwd.  For example:
+    # when copying to '/target_dir' from Dir.pwd = '/dir':
+    #
+    #   source path              target path
+    #   /dir/path/to/file.txt    /target_dir/path/to/file.txt
+    #   /path/to/file.txt        /target_dir/file.txt
+    #
+    # Existing files are backed up as '<file>_before_<timestamp>'
+    # into the standard backup directory. Up-to-date files are not copied. 
+    # Raises an error for non-existing and non-file input files, as well 
+    # as a non-directory target_dir.
+    #
+    class Copy < Tap::FileTask
+
+      # Determines the copy filepath using the target_dir and the
+      # relative filepath from Dir.pwd to path.  Uses the basename 
+      # of path if path is not relative to Dir.pwd.
+      def copy_filepath(target_dir, path)
+        relative_path = Root.relative_filepath(Dir.pwd, path) || File.basename(path)
+        File.join(target_dir, relative_path)
+      end
+  
+      # Determines a backup filepath by adding a timestamp to the input path.
+      def backup_filepath(path)
+        extname = File.extname(path)
+        File.expand_path("#{path.chomp(extname)}_before_#{Time.now.strftime(timestamp)}#{extname}")
+      end
+  
+      def process(target_dir, *filepaths)
+        filepaths.collect do |filepath|
+          target = copy_filepath(target_dir, filepath)
+          
+          if uptodate?(target, filepath)
+            log_basename :skip, filepath, Logger::DEBUG
+          else
+            prepare target
+        
+            log_basename :cp, filepath
+            FileUtils.cp(filepath, target) 
+          end
+      
+          target
+        end
+      end
+    end  
+  end
+end

data/lib/tap/tasks/grep.rb

@@ -0,0 +1,54 @@
+module Tap
+  module Tasks
+    # :startdoc::manifest search for lines matching a pattern
+    #
+    # A simple line-matching task patterned after the *nix grep utility.
+    # Grep find and prints all lines matching the regexp pattern in files 
+    # matched by the globs.
+    #
+    class Grep < Tap::Task
+      
+      config :case_insensitive, false, :short => :i, &c.switch  # set case-insensitive matching
+      config :extended, false, :short => :e, &c.switch          # set extended matching
+      config :multiline, false, :short => :m, &c.switch         # set multiline matching
+      config :escape, false, &c.flag                            # escape pattern beforehand
+      
+      # Returns an array of the regexp options specified by the config.
+      def regexp_options
+        [ case_insensitive ? Regexp::IGNORECASE : nil,
+          extended ? Regexp::EXTENDED : nil,
+          multiline ? Regexp::MULTILINE : nil
+          ].compact
+      end
+      
+      def process(pattern, *globs)
+        pattern = Regexp.escape(pattern) if escape
+        regexp = Regexp.new(pattern, *regexp_options)
+        
+        input_files = Tap::Root.glob(*globs)
+        input_files.each do |input_file|
+          next unless File.exists?(input_file) && File.file?(input_file)
+          
+          File.open(input_file) do |file|
+            line_num = -1
+            file.each_line do |line|
+              line_num += 1
+              next unless line =~ regexp
+              task_block.call(self, input_file, line_num, line)
+            end
+          end
+        end
+        
+        input_files
+      end
+      
+      protected
+      
+      def default_task_block # :nodoc:
+        lambda do |task, filepath, line_num, line|
+          task.log "#{File.basename(filepath)} (#{line_num})", line.strip
+        end
+      end
+    end
+  end
+end

data/lib/tap/tasks/print_tree.rb

@@ -0,0 +1,78 @@
+require 'pathname'
+
+module Tap
+  module Tasks
+    # :startdoc::manifest print a directory tree
+    #
+    # Prints a directory tree using a nice algorithm from
+    # http://www.xxeo.com/archives/2007/06/06/a-simple-directory-tree-printer-in-ruby.html
+    #
+    # The output format is like this:
+    #
+    #   sample
+    #   |- MIT-LICENSE
+    #   |- README
+    #   |- Rakefile
+    #   |- lib
+    #   |   `- sample.rb
+    #   |- sample.gemspec
+    #   |- tap.yml
+    #   `- test
+    #       |- sample_test.rb
+    #       |- tap_test_helper.rb
+    #       `- tap_test_suite.rb
+    # 
+    #
+    class PrintTree < Tap::Task
+      ARM_MAP = Hash.new("|   ")
+      ARM_MAP[""] = ""
+      ARM_MAP["`"] = "    "
+      
+      config :hidden_files, false, &c.switch  # Flag to print hidden files.
+      
+      def process(*paths)
+        paths << "." if paths.empty?
+        paths.map { |path| visit(Pathname.new("."), "", "", "", Pathname.new(path)) }
+        
+        nil
+      end
+      
+      # Returns true if the path is hidden.  If the hidden_files
+      # config is specified as true, then hidden? always returns
+      # false, indicating that under these conditions no path
+      # is considered hidden.
+      def hidden?(path)
+        !hidden_files && path.to_s =~ /^\.[^\.]/
+      end
+      
+      protected
+      
+      def default_task_block # :nodoc:
+        lambda {|line| puts line }
+      end
+      
+      # slightly modified from the original algorithm
+      def visit(path, leader, tie, arm, node) # :nodoc:
+        task_block.call("#{leader}#{arm}#{tie}#{node}\n") unless hidden?(node)
+        visitChildren(path + node, leader + ARM_MAP[arm])
+      end
+      
+      # slightly modified from the original algorithm
+      def visitChildren(path, leader) # :nodoc:
+        return unless FileTest.directory? path
+        return unless FileTest.readable? path
+        return if hidden?(path.basename)
+
+        files = path.children(false).sort    #false = return name, not full path
+
+        return if files.empty?
+
+        arms = Array.new(files.length - 1, "|") << "`"
+
+        pairs = files.zip(arms)
+        pairs.each { |e|  visit(path, leader, "- ", e[1], e[0]) } 
+      end
+      
+    end
+  end
+end

data/lib/tap/tasks/table_task.rb

@@ -0,0 +1,24 @@
+require 'tap/support/simple_table'
+
+module Tap
+  module Tasks
+    
+    # TableTask is a base class for table-related FileTasks.
+    class TableTask < Tap::FileTask
+      SimpleTable = Support::SimpleTable
+      
+      config :header_row, false, &c.flag             # indicates a header row
+      config :row_sep, "\n", &c.string               # row delimiter
+      config :col_sep, "\t", &c.string               # column delimiter
+      config :default_value, nil, &c.string_or_nil   # a default value for empty cells
+      
+      # Parses a Tap::Support::SimpleTable from the string using the
+      # table configurations.
+      def parse_table(str)
+        data = SimpleTable.parse_data(str, row_sep, col_sep)
+        SimpleTable.new(data, :default_value => default_value, :header_row => header_row)
+      end
+      
+    end 
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: sample_tasks
+version: !ruby/object:Gem::Version 
+  version: 0.10.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-08 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+description: 
+email: simon.chiang@uchsc.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- MIT-LICENSE
+- README
+- lib/tap/support/simple_table.rb
+- lib/tap/tasks/concat.rb
+- lib/tap/tasks/copy.rb
+- lib/tap/tasks/grep.rb
+- lib/tap/tasks/print_tree.rb
+- lib/tap/tasks/table_task.rb
+- tap.yml
+has_rdoc: true
+homepage: http://tap.rubyforge.org/sample_tasks/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tap
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Sample Tap Tasks
+test_files: []
+