chirp 0.2.0 → 0.3

data/lib/chirp/context.rb

@@ -0,0 +1,101 @@
+#
+# Copyright 2006-2007 Russell Olsen
+# Chirp is distributed under the same license as Ruby itself.
+#
+
+require 'pathname'
+require 'ftools'
+require 'fileutils'
+#require 'erb'
+
+module Chirp
+  class Context
+    include FileUtils
+
+    attr_accessor :field_separator, :line_no, :output_path, :paths, :dir
+    attr_reader :path, :line
+    attr_writer :fields, :contents
+    attr_accessor :verbose
+
+    def initialize
+      @field_separator = /[ \t]/
+      @verbose = false
+      @dir = '.'
+    end
+
+    def execute(action)
+      instance_eval(&action)
+    end
+  
+
+
+    def path=(new_path)
+      @path = new_path
+      @full_path = nil
+      @line = nil
+      @fields = nil
+      @path_array = nil
+      @path_name = nil
+      @full_path_name = nil
+      @contents = nil
+      @dirname = nil
+      @extname = nil
+      @name = nil
+      @basename = nil
+    end
+
+    def line=(new_line)
+      @line = new_line
+      @fields = nil
+    end
+
+    def full_path
+      @full_path || @full_path = File.join(dir, path)
+    end
+
+    def fields
+      @fields || @fields = line.split(@field_separator)
+    end
+
+    def path_name
+      @path_name || @path_name = Pathname.new(path)
+    end 
+  
+    def full_path_name
+      @full_path_name || @full_path_name = Pathname.new(File.join(dir,path))
+    end 
+  
+    def dirname
+      @dirname || @dirname = path_name.dirname.to_s
+    end
+
+    def basename
+      @basename || @basename = path_name.basename.to_s
+    end
+
+    def extname
+      @extname || @extname = path_name.extname.to_s
+    end
+
+    def name
+      return @name if @name
+      @name = basename[0..-extname.size-1]
+    end
+
+    def contents
+      @contents || @contents = File.read(full_path)
+    end
+
+    def comment(*msg)
+      STDERR.puts(msg.join(' '))
+    end
+
+    def debug(*msg)
+      STDERR.puts(msg.join(' ')) if @verbose
+    end
+
+    def to_s
+      return "Context: #{@path}"
+    end
+  end
+end

data/lib/chirp/fs_expression.rb

@@ -0,0 +1,180 @@
+
+module Chirp
+
+  class FSExpression
+    def &(other)
+      And.new(self, other)
+    end
+
+    def |(other)
+      Or.new(self, other)
+    end
+
+    def ~
+      Not.new(self)
+    end      
+  end
+
+  class Named < FSExpression
+    def initialize(name)
+      @name = name
+    end
+
+    def evaluate(path)
+      return true if @name.kind_of?(Regexp) and (@name =~ path)
+      return true if @name.kind_of?(String) and (File.fnmatch(@name, path))
+      false
+    end
+  end
+
+  class All < FSExpression
+    def evaluate(path)
+      true
+    end
+  end
+
+  class None < FSExpression
+    def evaluate(path)
+      false
+    end
+  end
+
+  class Contains < FSExpression
+    def initialize(re)
+      @re = re
+    end
+
+    def evaluate(path)
+      return false unless File.file?(path)
+      File.open(path) do |f|
+        until f.eof?
+          return true if @re =~ f.readline
+        end
+      end
+      false
+    end
+  end
+
+  class IsDir < FSExpression
+    def evaluate(path)
+      File.directory?(path)
+    end
+  end
+
+  class IsFile < FSExpression
+    def evaluate(path)
+      File.file?(path)
+    end
+  end
+
+  class Bigger < FSExpression
+    def initialize(size)
+      @size = size
+    end
+
+    def evaluate(path)
+      File.size(path) > @size
+    end
+  end
+
+  class Smaller < FSExpression
+    def initialize(size)
+      @size = size
+    end
+
+    def evaluate(path)
+      File.size(path) < @size
+    end
+  end
+
+  class SameSize < FSExpression
+    def initialize(size)
+      @size = size
+    end
+
+    def evaluate(path)
+      File.size(path) == @size
+    end
+  end
+
+
+  class And < FSExpression
+    def initialize(exp1, exp2)
+      @exp1 = exp1
+      @exp2 = exp2
+    end
+
+    def evaluate(path)
+      @exp1.evaluate(path) && @exp2.evaluate(path)
+    end
+  end
+
+  class Or < FSExpression
+    def initialize(exp1, exp2)
+      @exp1 = exp1
+      @exp2 = exp2
+    end
+
+    def evaluate(path)
+      @exp1.evaluate(path) || @exp2.evaluate(path)
+    end
+  end
+
+  class Not < FSExpression
+    def initialize(exp)
+      @exp1 = exp
+    end
+
+    def evaluate(path)
+      not @exp1.evaluate(path)
+    end
+  end
+
+  module FSSugar
+
+    def all
+      All.new
+    end
+
+    def none
+      None.new
+    end
+
+    def bigger(size)
+      Bigger.new(size)
+    end
+
+    def smaller(size)
+      Smaller.new(size)
+    end
+
+    def named(name)
+      Named.new(name)
+    end
+
+    def contains(pattern)
+      Contains.new(pattern)
+    end
+
+    def length(n)
+      SameSize.new(n)
+    end
+
+    def dir?
+      IsDir.new
+    end
+
+    def file?
+      IsFile.new
+    end
+
+    def except(expr)
+      Not.new(expr)
+    end
+  end
+
+end
+
+#require 'pp'
+#include Chirp::FSSugar
+#pp (bigger(100) & contains('foobar')) | (dir? | named('xxx.txt'))

data/lib/chirp/path_filter.rb

@@ -0,0 +1,58 @@
+module Chirp
+  class PathFilter
+    def initialize(options={})
+      @regexp = @glob = nil
+      @regexp = options[:path] if options[:path].kind_of?(Regexp)
+      @glob = options[:path] if options[:path].kind_of?(String)
+      @fsexp = options[:fsexp]
+      @contains = options[:contains]
+      @name = options[:name]
+      @dir=options[:dir]
+      @type = options[:type]
+    end
+
+    def passes?(path)
+#puts "trying filter #{self} on #{path}"
+      if @type == :file
+        return false unless File.file?(path)
+      end
+      if @type == :dir
+        return false unless File.directory?(path)
+      end
+      if @name
+        return false unless File.fnmatch(@name, File.basename(path))
+      end
+      if @fsexp
+        return false unless @fsexp.evaluate(path)
+      end
+      if @glob
+        return false unless File.fnmatch(@glob, path,  File::FNM_PATHNAME | File::FNM_DOTMATCH )
+      end
+      if @regexp
+        return false unless @regexp =~ path
+      end
+      if @dir
+        return false unless File.dirname(path) == @dir
+      end
+      if @contains
+        return false unless file_contains(path, @contains)
+      end
+#puts "passed filter: #{path}"
+      true
+    end
+
+    def file_contains(path, re)
+      return false unless File.file?(path)
+      File.open(path) do |f|
+        until f.eof?
+          return true if re =~ f.readline
+        end
+      end
+      false
+    end
+
+    def to_s
+      "Filter: #{@glob} #{@dir} #{@type}"
+    end
+  end
+end

data/lib/chirp/pathmap.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+
+#--
+
+# Copyright (c) 2003, 2004, 2005, 2006, 2007  Jim Weirich
+#
+# 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.
+#++
+#
+# = Rake -- Ruby Make
+#
+# This is the main file for the Rake application.  Normally it is referenced
+# as a library via a require statement, but it can be distributed
+# independently as an application.
+
+module Pathmap
+  # Replace the file extension with +newext+.  If there is no extenson on
+  # the string, append the new extension to the end.  If the new extension
+  # is not given, or is the empty string, remove any existing extension.
+  #
+  # +ext+ is a user added method for the String class.
+  def ext(newext='')
+    return self.dup if ['.', '..'].include? self
+    if newext != ''
+      newext = (newext =~ /^\./) ? newext : ("." + newext)
+    end
+    dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
+  end
+
+  # Explode a path into individual components.  Used by +pathmap+.
+  def pathmap_explode
+    head, tail = File.split(self)
+    return [self] if head == self
+    return [tail] if head == '.' || tail == '/'
+    return [head, tail] if head == '/'
+    return head.pathmap_explode + [tail]
+  end
+  protected :pathmap_explode
+
+  # Extract a partial path from the path.  Include +n+ directories from the
+  # front end (left hand side) if +n+ is positive.  Include |+n+|
+  # directories from the back end (right hand side) if +n+ is negative.
+  def pathmap_partial(n)
+    target = File.dirname(self)
+    dirs = target.pathmap_explode
+    if n > 0
+      File.join(dirs[0...n])
+    elsif n < 0
+      partial = dirs[n..-1]
+      if partial.nil? || partial.empty?
+        target
+      else
+        File.join(partial)
+      end
+    else
+      "."
+    end
+  end
+  protected :pathmap_partial
+
+  # Preform the pathmap replacement operations on the given path. The
+  # patterns take the form 'pat1,rep1;pat2,rep2...'.
+  def pathmap_replace(patterns, &block)
+    result = self
+    patterns.split(';').each do |pair|
+      pattern, replacement = pair.split(',')
+      pattern = Regexp.new(pattern)
+      if replacement == '*' && block_given?
+        result = result.sub(pattern, &block)
+      elsif replacement
+        result = result.sub(pattern, replacement)
+      else
+        result = result.sub(pattern, '')
+      end
+    end
+    result
+  end
+  protected :pathmap_replace
+
+  # Map the path according to the given specification.  The specification
+  # controls the details of the mapping.  The following special patterns are
+  # recognized:
+  #
+  # * <b>%p</b> -- The complete path.
+  # * <b>%f</b> -- The base file name of the path, with its file extension,
+  #   but without any directories.
+  # * <b>%n</b> -- The file name of the path without its file extension.
+  # * <b>%d</b> -- The directory list of the path.
+  # * <b>%x</b> -- The file extension of the path.  An empty string if there
+  #   is no extension.
+  # * <b>%X</b> -- Everything *but* the file extension.
+  # * <b>%s</b> -- The alternate file separater if defined, otherwise use
+  #   the standard file separator.
+  # * <b>%%</b> -- A percent sign.
+  #
+  # The %d specifier can also have a numeric prefix (e.g. '%2d'). If the
+  # number is positive, only return (up to) +n+ directories in the path,
+  # starting from the left hand side.  If +n+ is negative, return (up to)
+  # |+n+| directories from the right hand side of the path.
+  #
+  # Examples:
+  #
+  #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
+  #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
+  #
+  # Also the %d, %p, $f, $n, %x, and %X operators can take a
+  # pattern/replacement argument to perform simple string substititions on a
+  # particular part of the path.  The pattern and replacement are speparated
+  # by a comma and are enclosed by curly braces.  The replacement spec comes
+  # after the % character but before the operator letter.  (e.g.
+  # "%{old,new}d").  Muliple replacement specs should be separated by
+  # semi-colons (e.g. "%{old,new;src,bin}d").
+  #
+  # Regular expressions may be used for the pattern, and back refs may be
+  # used in the replacement text.  Curly braces, commas and semi-colons are
+  # excluded from both the pattern and replacement text (let's keep parsing
+  # reasonable).
+  #
+  # For example:
+  #
+  #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
+  #
+  # returns:
+  #
+  #    "bin/org/onestepback/proj/A.class"
+  #
+  # If the replacement text is '*', then a block may be provided to perform
+  # some arbitrary calculation for the replacement.
+  #
+  # For example:
+  #
+  #   "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext|
+  #      ext.downcase
+  #   }
+  #
+  # Returns:
+  #
+  #  "/path/to/file.txt"
+  #
+  def pathmap(spec=nil, &block)
+    return self if spec.nil?
+    result = ''
+    spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
+      case frag
+      when '%f'
+        result << File.basename(self)
+      when '%n'
+        result << File.basename(self).ext
+      when '%d'
+        result << File.dirname(self)
+      when '%x'
+        result << $1 if self =~ /[^\/](\.[^.]+)$/
+      when '%X'
+        if self =~ /^(.+[^\/])(\.[^.]+)$/
+          result << $1
+        else
+          result << self
+        end
+      when '%p'
+        result << self
+      when '%s'
+        result << (File::ALT_SEPARATOR || File::SEPARATOR)
+      when '%-'
+        # do nothing
+      when '%%'
+        result << "%"
+      when /%(-?\d+)d/
+        result << pathmap_partial($1.to_i)
+      when /^%\{([^}]*)\}(\d*[dpfnxX])/
+        patterns, operator = $1, $2
+        result << pathmap('%' + operator).pathmap_replace(patterns, &block)
+      when /^%/
+        fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
+      else
+        result << frag
+      end
+    end
+    result
+  end
+end
+
+class String
+  include Pathmap
+end