chirp 0.2.0 → 0.3

data/Manifest.txt

@@ -5,8 +5,17 @@ Rakefile
 bin/chirp
 lib/chirp.rb
 lib/chirp/application.rb
-lib/chirp/statement.rb
-test/test_statement.rb
+lib/chirp/pathmap.rb
+lib/chirp/context.rb
+lib/chirp/fs_expression.rb
+lib/chirp/span.rb
+lib/chirp/path_filter.rb
+test/copy_file.dir/output
+test/copy_file.dir/input
+test/copy_file.dir/program.chirp
+test/copy_file.dir/a.txt
+test/copy_file.dir/b.txt
+test/copy_file.dir/c.txt
 test/test_application.rb
 test/span.dir/output
 test/span.dir/input
@@ -53,3 +62,36 @@ test/proc.dir/program.chirp
 test/account.dir/program.chirp
 test/account.dir/output
 test/account.dir/input
+test/path.dir/output
+test/path.dir/input
+test/path.dir/program.chirp
+test/path.dir/new
+test/path.dir/dir1/dir2/dir3/a.txt
+test/test_span.rb
+test/rename_file.dir/output
+test/rename_file.dir/input
+test/rename_file.dir/program.chirp
+test/rename_file.dir/a.txt
+test/rename_file.dir/b.txt
+test/rename_file.dir/c.txt
+test/copy1.dir/program.chirp
+test/copy1.dir/source
+test/copy1.dir/input
+test/copy1.dir/output
+test/copy2.dir/program.chirp
+test/copy2.dir/source
+test/copy2.dir/input
+test/copy2.dir/output
+test/copy3.dir/program.chirp
+test/copy3.dir/source
+test/copy3.dir/input
+test/copy3.dir/output
+test/test_fs_expression.rb
+test/fs_expr.dir/output
+test/fs_expr.dir/input
+test/fs_expr.dir/program.chirp
+test/fs_expr.dir/dir1/dir2/dir3/a.txt
+test/fs_expr.dir/bb.txt
+test/fs_expr.dir/aa.txt
+test/fs_expr.dir/cc.txt
+test/requires.rb

data/README.txt

@@ -4,11 +4,19 @@ chirp
 
 == DESCRIPTION:
   
-Chirp is a Ruby based DSL inspiried by awk.
+Chirp is a Ruby based DSL originally inspiried by awk.
 
 == FEATURES/PROBLEMS:
   
-* Need to add documentation
+Chirp is a DSL for manipulating file systems. In the same
+way that rake is aimed at making system buildig easy,
+chirp is designed to make doing things to entire file
+systems easy. 
+
+Chirp is still very much in development and you should
+be very careful with it: since chirp does operate on
+whole directory trees, it is capable of doing a lot of
+damage.
 
 == SYNOPSIS:
 

data/Rakefile

@@ -9,7 +9,7 @@ Hoe.new('chirp', Chirp::VERSION) do |p|
   p.author = 'Russ Olsen'
   p.email = 'russ@russolsen.com'
   p.summary = 'Chirp is a Ruby based text processing DSL similar to awk'
-  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
   # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
 end

data/bin/chirp

@@ -12,7 +12,7 @@ program_text=nil
 verbose=false
 
 option_parser = OptionParser.new do |op|
-  op.banner = "Usage: $0 [-v] [-e chirp_program_text] [chirp_program_file] [input_file ...]"
+  op.banner = "Usage: chirp [-v] [-e chirp_program_text] [chirp_program_file] [input_file ...]"
 
   op.on('-p', '--program [chirp-program-text]',
         'Execute this Chirp program') do |string|
@@ -33,10 +33,12 @@ if files.empty? and program_text.nil?
 end
 
 program_text = File.read(files.shift) unless program_text
+ARGV.replace(files)
 
-app =  Chirp::Application.new(program_text, verbose)
-app.files(files)
-app.evaluate
+app =  Chirp::Application.new
+app.program(program_text)
+app.verbose(verbose)
+app.execute
 
 
 

data/lib/chirp.rb

@@ -4,11 +4,15 @@
 # Chirp is distributed under the same license as Ruby itself.
 #
 
-ChirpLibDir=File.dirname(__FILE__)
+ChirpLibDir=File.dirname(__FILE__) unless self.class.const_defined?(:ChirpLibDir)
 
-require "#{ChirpLibDir}/chirp/statement"
+require "#{ChirpLibDir}/chirp/pathmap"
+require "#{ChirpLibDir}/chirp/fs_expression"
+require "#{ChirpLibDir}/chirp/context"
+require "#{ChirpLibDir}/chirp/path_filter"
+require "#{ChirpLibDir}/chirp/span"
 require "#{ChirpLibDir}/chirp/application"
 
 module Chirp
-  VERSION = '0.2.0'
+  VERSION = '0.3'
 end

data/lib/chirp/application.rb

@@ -1,252 +1,341 @@
-#
-# Copyright 2006-2007 Russell Olsen
-# Chirp is distributed under the same license as Ruby itself.
-#
-
-require 'pathname'
-require 'ftools'
-require 'fileutils'
+require 'pp'
+require 'tempfile'
+require 'set'
+require 'find'
 
 module Chirp
-  def self.redirect_io_and_run(input, output=$stdout, &block)
-    old_stdout, $stdout = $stdout, output
-    old_stdin, $stdin = $stdin, input
+
+  def self.run_with_input_stream(in_stream, &block)
+    old_stdin, $stdin = $stdin, in_stream
     begin
       block.call
     ensure
-      $stdin, $stdout = old_stdin, old_stdout
+      $stdin = old_stdin
     end
   end
 
-  class Context
-    include FileUtils
+  def self.run_with_output_stream(out_stream, &block)
+    old_stdout, $stdout = $stdout, out_stream
+    begin
+      block.call
+    ensure
+      $stdout = old_stdout
+    end
+  end
 
-    attr_accessor :field_separator, :line, :line_no, :path, :paths
-    attr_writer :fields, :contents
+  def self.run_with_input_file(in_file, &block)
+    File.open(in_file) {|f| run_with_input_stream(f, &block)}
+  end
 
-    def initialize(field_separator)
-      @field_separator = field_separator
+  def self.run_with_output_file(out_file, create_backups=false, &block)
+    temp_file = Tempfile.new('chirp').path
+    File.open(temp_file, 'w') do |out_stream|
+      run_with_output_stream(out_stream, &block)
     end
-
-    def execute(action)
-      instance_eval(&action)
+    backup_file = nil
+    if create_backups and File.exist?(out_file)
+      backup_file = Tempfile.new('chirp').path
+      FileUtils.cp(out_file, backup_file) if File.exist?(out_file)
     end
-  
-    def get_binding
-      binding
+    FileUtils.cp(temp_file, out_file)
+    FileUtils.rm(temp_file)
+    if backup_file
+      FileUtils.cp(backup_file, "#{out_file}.bak")
+      FileUtils.rm(backup_file) 
     end
+  end
 
-    def fields
-      @fields || @fields = line.split(@field_separator)
+
+  def self.debug(*msg)
+    STDERR.puts msg.join(' ')
+  end
+
+
+  class PathProcessor
+    def initialize(context, options={}, &block)
+      @context = context
+      @filter = PathFilter.new(options)
+      @block = block
     end
-  
-    def contents
-      @contents || @contents = File.read(@file)
+
+    def execute
+      @context.debug("PathProcessor execute for #{@context.path}")
+      if @filter.passes?(@context.path)
+        @context.execute(@block)
+      else
+        @context.debug("Filter blocked #{@context.path}")
+        @context.debug("Filter: #{@filter}")
+      end
     end
   end
 
-  class Action
+  class LineProcessor
+    DEFAULT_ACTION = lambda { puts(line) }
+
+    def initialize(context, options={}, &block)
+
+     @context = context
+     @expression = options[:expr]
+     @pattern = options[:pattern]
+     @match = options[:match]
+     @number = options[:number]
+     if options[:start]
+       @span = Span.new(options[:start], options[:end])
+     else
+       @span=nil
+     end
+     @options = options
+     @block = block ||  DEFAULT_ACTION
+    end
+
+    def execute
+     if @match
+       return unless @match == @context.line
+     end
+     if @pattern
+       return unless @pattern =~ @context.line
+     end
+     if @number
+       return unless @number == @context.line_no
+     end
+     if @expression
+       return unless @context.execute(@expression)
+     end
+     if @span
+       return unless @span.evaluate(@context)
+     end
+     @context.execute(@block)
+    end
+
+    def reset
+      @span.reset if @span
+    end
+  end    
+
+  class NowProcessor
     def initialize(context, &block)
       @context = context
       @block = block
     end
 
-    def evaluate(path)
-      @context.path = path
+    def execute
       @context.execute(@block)
     end
+  end
 
-    def evaluate_paths(paths)
-      @context.paths = paths
-      @context.execute(@block)
+  class StaringWithProcessor
+    def initialize(context, path)
+      @context = context
+      @path = path
     end
 
+    def execute
+      @context.dir = @path
+    end
   end
 
-  class PathAction
-    DEFAULT_ACTION = lambda {puts line}
+  class EachProcessor
 
-    attr_accessor :verbose
+    include Chirp::FSSugar
 
-    def initialize(glob, context, &block)
-      @glob = glob
+    def initialize(context, options={}, &block)
       @context = context
-      @edit_in_place = false
-      @before_actions = []
-      @match_statements=[]
-      @after_actions = []
-      @field_separator = /[ \t]/
-      instance_eval(&block)
-    end
- 
-    def field_separator(sep=nil)
-      @field_separator=sep
+      @filter = PathFilter.new(options)
+      @field_separator = options[:field_separator]
+      @block = block
+      @output_spec = options[:output]
+      @create_backups = options[:create_backups]
+      @redirect_output = options.key?(:redirect_output) ? options[:redirect_output] : true
+      @context = context
+      @before_processors = []
+      @content_processors = []
+      @after_processors = []
+      instance_eval(&block) if block
     end
 
-    def edit_in_place(new_value=true)
-      @edit_in_place = new_value
+    def before(options={}, &block)
+      @before_processors << PathProcessor.new(@context, options, &block) 
     end
 
-    def evaluate_paths(paths)
-      @context.paths = paths
-      paths.each do |path|         
-        evaluate_path(path)
-      end
+    def after(options={}, &block)
+      @after_processors << PathProcessor.new(@context, options, &block) 
     end
 
-    def line(arg1=nil, arg2=nil, &block)
-      action = block || DEFAULT_ACTION
-
-      if arg1.nil? and arg2.nil?
-        @match_statements << Statement.new( MatchPredicate.new(/.*/), action)
-      elsif arg2.nil?
-        @match_statements << Statement.new( predicate_for(arg1), action)
-      else
-        @match_statements << Statement.new(
-          SpanPredicate.new(predicate_for(arg1), predicate_for(arg2)), action)
-      end
+    def path(options={}, &block)
+      before(options, &block)
     end
 
-    def before(&block)
-      @before_actions << block
-    end
-  
-    def after(&block)
-      @after_actions << block
+    def file(options={}, &block)
+      new_options = options.clone
+      new_options[:type] = :file
+      before(new_options, &block)
     end
 
-    def applies_to(path)
-      File.fnmatch(@glob, path)
+    def dir(options={}, &block)
+      new_options = options.clone
+      new_options[:type] = :dir
+      before(new_options, &block)
     end
 
-    def evaluate_path(path)
-      return nil unless applies_to(path)
-      unless @edit_in_place
-        File.open(path) do |in_stream|
-          Chirp::redirect_io_and_run(in_stream, $stdout) {evaluate(path)}
-        end
-      else
-        backup_path = path + ".bak"
-        File.copy(path, backup_path)
-        File.open(backup_path) do |in_stream|
-          File.open(path, 'w') do |out_stream|
-            Chirp::redirect_io_and_run(in_stream, out_stream) {evaluate(path)}
+    def line(options={}, &block)
+      @content_processors << LineProcessor.new(@context, options, &block)
+    end
+      
+    def execute
+        @context.paths = filtered_files(@context.dir)
+        @context.paths.each do |path|
+          @context.debug( "Trying out processor #{self} for #{path} and #{@filter}" )
+          @context.path = path
+          @context.debug( "Executing processor #{self} for #{path}" )
+          @context.output_path = @context.path.pathmap(@output_spec) if @output_spec
+          if @output_spec and @redirect_output
+            Chirp::run_with_output_file(@context.output_path, @create_backups) {process}
+          else
+            process
           end
         end
-      end
     end
 
-    def evaluate(path)
-      @context.path = path
+    def process
+      @before_processors.each {|p| p.execute}
+      process_contents
+      @after_processors.each {|p| p.execute}
+    end
+
+    def process_contents
+      return if @content_processors.empty?
+      return unless File.file?(@context.full_path)
+
+      @content_processors.each {|p| p.reset}
       @context.field_separator = @field_separator
-      @before_actions.each {|a| @context.execute(a)}
-      unless @match_statements.empty?
+
+      Chirp::run_with_input_file(@context.full_path) do
         @context.line_no = 1
         while not $stdin.eof?
-          @context.fields=nil
           @context.line = $stdin.readline.chomp
-          @match_statements.each do |statement|
-            statement.evaluate(@context)
-          end
+          @content_processors.each {|p| p.execute}
           @context.line_no += 1
         end
+        @context.contents = nil
       end
-      @context.contents = nil
-      @after_actions.each {|a| @context.execute(a)}
     end
 
-    def predicate_for(arg)
-      return LineNumberPredicate.new(arg) if arg.kind_of?(Numeric)
-      return StringPredicate.new(arg) if arg.kind_of?(String)
-      return MatchPredicate.new(arg) if arg.kind_of?(Regexp)
-      return RangePredicate.new(arg) if arg.kind_of?(Range)
-      return LambdaPredicate.new(arg) if arg.kind_of?(Proc)
-      raise "Unknown argument: #{arg}"
+    def filtered_files(dir)
+      results = Set.new
+      FileUtils.chdir(dir) do
+        Find.find('.') do |p|
+          path = p.sub(/^\.\//, '')
+          next if path == '.'
+          next if path == '..'
+          next unless @filter.passes?(path)
+          results << path
+        end
+      end
+      results.sort
     end
-  end
-
 
+  end
 
   class Application
+    include Chirp::FSSugar
 
-    DEFAULT_ACTION = lambda {puts line}
+    def initialize
+      @processors = []
+      @context = Context.new
+    end
 
-    attr_accessor :verbose
+    def program(chirp_string, file='-')
+      instance_eval(chirp_string, file)
+    end
 
-    def initialize(program_string, verbose=false)
-      @glob = nil
-      @actions=[]
-      @verbose=verbose
-      @context = Chirp::Context.new(/[ \t]/)
-      self.program=program_string if program_string
+    def dir(path)
+      @processors << StaringWithProcessor.new(@context, path)
     end
 
-    def setup(args)
-      self.program=File.read(args[0])
+    def verbose(setting=true)
+      @context.verbose = setting
     end
 
-    def program=(chirp_program_string)
-      instance_eval(chirp_program_string, 'user program')
+    def now(&block)
+      @context.debug('Processing now command:', block)
+      @processors << NowProcessor.new(@context, &block)
     end
 
-    def run(&block)
-      @actions << Action.new(@context, &block)
+    def comment(*args)
+      @context.comment(*args)
     end
 
-    def file(glob='*', &block)
-      @actions << PathAction.new(glob, @context, &block)
+    def each(options={}, &block)
+      @context.debug('Processing each command:', block)
+      @processors << EachProcessor.new(@context, options, &block)
     end
 
-    def files(args)
-      @glob = args unless args.empty?
-      @glob
+    def mv(options={})
+      @context.debug('Processing mv command:', options)
+      options = options.clone
+      options[:create_backups] = false unless options.key?(:create_backups)
+      options[:redirect_output]= false
+      each_path options do
+        raise "Output path not specified for rename" unless output_path
+        mv full_path, output_path
+      end
     end
 
-    def evaluate(in_stream=$stdin, out_stream=$stdout)
-      log('Running Chirp program')
-      Chirp::redirect_io_and_run(in_stream, out_stream) do
-        log('Running before actions')  
-        if not @glob
-          process_stream(in_stream, out_stream, '-')
-        else
-          process_files(@glob) 
-        end  
-        log('Running after actions')
+    def copy(options={})
+      options = options.clone
+      options[:create_backups] = false unless options.key?(:create_backups)
+      options[:redirect_output]= false
+      @context.debug('Processing copy command:', options)
+      each_path options do
+        raise "Output path not specified for copy" unless output_path
+        cp   full_path, output_path unless options[:recursive]
+        cp_r full_path, output_path if options[:recursive]
       end
-      log('Chirp program done')
     end
 
-    def process_stream(in_stream, outstream, name)
-      @actions.each do |path_action|
-        Chirp::redirect_io_and_run(in_stream, outstream) do
-          path_action.evaluate(name)
-        end
+    def each_path(options={}, &block)
+      @context.debug('Processing each_path command:', options, block)
+      each(options) do
+        before(&block)
       end
     end
 
-    def process_files(globs)
-      @actions.each do |action|
-        paths = expand_globs(globs)
-        action.evaluate_paths(paths)
+    def each_file(options={}, &block)
+      @context.debug('Processing each_file command:', options, block)
+      new_options = options.clone
+      new_options[:type] = :file
+      each_path(new_options, &block)
+    end
+
+    def each_line(options={}, &block)
+      @context.debug('Processing each_line command:', options, block)
+      each(options) do
+        line(options,&block)
       end
     end
 
-    def log(*args)
-      return unless @verbose
-      STDERR.puts args.join(' ')
+    def each_dir(options={}, &block)
+      @context.debug('Processing each_dir command:', options, block)
+      new_options = options.clone
+      new_options[:type] = :dir
+      each_path(new_options, &block)
     end
 
-    def expand_globs(globs)
-      results = []
-      globs.each do |path_pattern|
-        this_glob_results = []
-        Dir.glob(path_pattern) do |path|
-	  this_glob_results << path if Pathname.new(path).file?
+    def execute(in_stream=$stdin, out_stream=$stdout)
+      @context.debug('Application execute')
+
+      temp_file = nil
+      @context.debug('Sources: ', *@context.paths)
+      Chirp::run_with_input_stream(in_stream) do
+        Chirp::run_with_output_stream(out_stream) do
+          @processors.each do |processor|
+            @context.debug('Calling ', processor)
+            processor.execute
+          end
         end
-        this_glob_results.sort!
-        results << this_glob_results
       end
-      results.flatten!
+      temp_file.unlink if temp_file
     end
   end
 end
+