gf-treevisitor 0.0.6

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 gf
+
+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.rdoc

@@ -0,0 +1,22 @@
+= dirtree.rb / tree visitor lib
+
+<pre>dirtree.rb</pre> is a 'clone' of tree unix command. 
+It is based on lib tree visitor.
+
+Tree visitor is an implementation of visitor design pattern.
+
+== REQUIREMENTS:
+
+* utilizza la libreria abstract di kwartz
+
+== INSTALL:
+
+sudo gem install tree_visitor
+
+or
+
+sudo gem install gf-tree_visitor -s gems.github.com
+
+== Copyright
+
+Copyright (c) 2009 gf. See LICENSE for details.

data/bin/dirtree.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#
+# Piccolo wrapper per richiamare il programma
+# clidirtree
+#
+
+$TREEVISITOR_HOME = File.expand_path( File.join( File.dirname( __FILE__), ".." ) )
+$:.unshift( File.join($TREEVISITOR_HOME, "lib" ) )
+
+require "treevisitor/cli/cli_dir_tree"
+
+CliDirTree.run
+exit

data/lib/gf_utility/file_utilities.rb

@@ -0,0 +1,70 @@
+# stdlib
+require 'fileutils'
+
+def recursive_run( dir, &block )
+  block.call( dir )
+  Dir.entries( dir ).each { |entry|
+    next if entry == "." or entry == ".."
+    next if not FileTest.directory?( dir + File::Separator + entry )
+    next if $config.ignore_dir( entry )
+    recursive_run( dir + File::Separator + entry, block )
+  }
+end
+
+def copy_dir( indir, outdir, re )
+  if not File.directory?()
+    raise "#{indir} is not a directory"
+  end
+  if not File.directory?( outdir )
+    FileUtils.mkpath( outdir )
+  end
+  Dir.entries( indir ).each { |e|
+    if e.match( re )
+      from = File.join( indir,  e )
+      to   = File.join( outdir, e )
+      # puts "#{from}  #{to}"
+      if File.exist?(to) and File.mtime(from) <= File.mtime(to)
+        next
+      end
+      FileUtils.cp from, to
+    end
+  }
+end
+
+def copy_file( inpath, outdir )
+  from = inpath
+  to   = File.join( outdir, File.basename( from ) )
+  # puts "#{from}  #{to}"
+  if File.exist?(to) and File.mtime(from) <= File.mtime(to)
+    next
+  end
+  FileUtils.cp from, to
+end
+
+#
+# substitute into a file
+#
+def subfile( filename, map )
+  lines = IO.readlines( filename)
+  if $options.backup
+    FileUtils.mv( filename, filename + ".bck" )
+  end
+
+  lines.each_with_index { |l,i|
+    map.each { |l1, l2|
+      #puts "#{l} #{l1} #{l.index(l1)}"
+      if l.index( l1 ) == 0
+        puts "subst #{l1}"
+        lines[i] = l2
+      end
+    }
+  }
+
+  File.open( filename,  "w" ) { |f|
+    lines.each{ |l| f.puts l }
+  }
+  puts "patched #{filename}"
+
+rescue Errno::ENOENT => e
+  puts "file not found '#{filename}'"
+end

data/lib/gf_utility/kwartzhelper.rb

@@ -0,0 +1,82 @@
+# ruby gems
+#
+# Check dependecies
+require 'rubygems'
+begin
+  require "kwartz"
+  require "kwartz/main"
+rescue LoadError
+  abort 'kwartz gem required!!'
+end
+
+#
+# kwartz utility
+# template_dir: directory containing kwartz template
+# template_include_dir: nil or a directory contained kwarz template referenced by template
+# template_out_dir: where the output goes
+#
+def kwartz_compile( template_dir, template_include_dir, template_out_dir )
+  if not File.directory?(template_dir)
+    raise "template_dir: '#{template_dir}' is not a directory"
+  end
+
+  if not File.directory?(template_out_dir)
+    raise "template_out_dir: '#{template_out_dir}' is not a directory"
+  end
+  
+  re_templatefile = /^[^\.](.+).html$/ 
+
+  maxtime_incs = Time.local( 1980 ) 
+  incs = []
+  if template_include_dir
+    if not File.directory?( template_include_dir )
+      raise "include_dir: '#{template_include_dir}' is not a directory"
+    end
+    incs = Dir.new( template_include_dir ).find_all { |f| f =~ re_templatefile }
+    incs = incs.map{ |f| File.join(template_include_dir, f) }
+    maxtime_incs = incs.inject(maxtime_incs) {|t,f|
+      t1 = File.mtime( f )
+      if t1 > t then t1 else t end
+    }
+    incs = incs.join(",")
+  end
+  
+  Dir.foreach( template_dir ) { |f|
+    next unless f =~ re_templatefile
+
+    inpath = File.join(template_dir, f)
+    inpath_time = File.mtime( inpath )
+
+    plogicpath = template_dir + File::Separator + f.sub( /.html$/, ".plogic" )
+    plogicpath_time = Time.local( 1980 )
+    if File.exists?( plogicpath )
+      plogicpath_time = File.mtime( plogicpath )
+    end
+    
+    outpath = File.join( template_out_dir, f.sub( /.html$/, ".rb" ) )
+    outpath_time = Time.local( 1980 )
+    if File.exist?( outpath )
+      outpath_time = File.mtime( outpath )
+    end
+    
+    argv = %w[--delspan -a defun -l ruby]
+    if incs.length > 0
+      argv << "-i"
+      argv.push( incs )
+    end
+
+    if File.exist?( plogicpath )
+      argv.push( "-p", plogicpath )
+    end
+    argv.push( inpath )
+
+    if outpath_time < maxtime_incs or 
+        outpath_time < inpath_time or
+        outpath_time < plogicpath_time
+      # puts "kwartz " + argv.join(" ")
+      main = Kwartz::Main.new(argv)
+      output = main.execute()
+      File.open(outpath, 'w') { |f| f.write(output) }      
+    end
+  }
+end

data/lib/gf_utility/md5.rb

@@ -0,0 +1,17 @@
+# stdlib
+require 'md5'
+
+#
+# calcola md5 di file grandi, copiata da usenet
+#
+class MD5
+  def self.file(file)
+    File.open(file, "rb") do |f|
+      res = self.new
+      while (data = f.read(4096))
+        res << data
+      end
+      res
+    end
+  end
+end

data/lib/gf_utility/numeric.rb

@@ -0,0 +1,17 @@
+class Numeric
+  #
+  # ritorna una stringa con le migliaia serparate da <separator>
+  # es.: 100000 -> 1.000.000
+  #
+  #
+  # copiata da http://wiki.rubygarden.org/Ruby/page/show/FixNumFormat
+  #
+  def with_separator( separator = ',', length = 3 )
+    splitter = Regexp.compile "(\\d{#{length}})"
+    before, after = self.to_s.split('.')
+    before = before.reverse.gsub splitter, '\1' + separator
+    str = "#{ before.chomp( separator ).reverse }"
+    str += ".#{ after }" if after
+    return str
+  end
+end

data/lib/treevisitor.rb

@@ -0,0 +1,3 @@
+class TreeVisitor
+  VERSION = '0.0.1'
+end

data/lib/treevisitor/abs_node.rb

@@ -0,0 +1,116 @@
+# rubygems
+require "rubygems"
+require "abstract"
+
+#
+# Nodo Astratto
+#   Gerarchia delle classi
+#
+#   AbsNode ha un nome, un parent
+#    |      definisce un path
+#    |
+#    |- LeafNode
+#    |
+#    |- TreeNode
+# 
+#
+class AbsNode
+
+  attr_reader :parent
+  attr_reader :name
+  
+  # solo TreeNode puo' scrivere vedi funzione add_leaf
+  attr_accessor :prev
+  attr_accessor :next
+  
+
+  def initialize( name )
+    @parent = nil
+    @name = name
+    @prefix_path = nil
+    invalidate
+  end
+  
+  #
+  # invalidate cached info
+  #
+  def invalidate
+    @path = nil
+    @path_from_root = nil
+    @depth = nil    
+  end
+  
+  def prefix_path
+    if not @parent.nil?
+      raise "Not root!!"
+    end
+    @prefix_path
+  end
+  
+  def prefix_path=( prefix )
+    if not @parent.nil?
+      raise "Not root!!"
+    end
+    if prefix != @prefix_path
+      @prefix_path = prefix
+      invalidate
+    end
+  end
+
+  def root
+    if root?
+      self
+    else
+      parent.root
+    end
+  end
+  
+  def path
+    return @path unless @path.nil?
+    if @parent.nil?
+      if @prefix_path
+        @path = @prefix_path + @name
+      else
+        @path = @name
+      end
+    else
+      @path = File.join( @parent.path, @name )
+    end
+    @path
+  end
+  
+  def path_from_root
+    return @path_from_root unless @path_from_root.nil?
+    if @parent.nil?
+      if @prefix_path
+        @path_from_root = @prefix_path
+      else
+        @path_from_root = ""
+      end
+    else
+      @path_from_root = File.join( @parent.path_from_root, @name )
+    end
+    @path_from_root
+  end
+
+  def depth
+    return @depth unless @depth.nil?
+    if @parent.nil?
+      @depth = 1
+    else
+      @depth = @parent.depth + 1
+    end
+    @depth
+  end
+  
+  def accept( visitor )
+    not_implemented
+  end
+
+  protected
+
+  def parent=( parent )
+    @parent = parent
+  end
+
+end

data/lib/treevisitor/build_dir_tree_visitor.rb

@@ -0,0 +1,58 @@
+# common
+require 'treevisitor/tree_node'
+require 'treevisitor/dir_tree_walker'
+require 'treevisitor/tree_node_visitor'
+
+#
+# costruisce una albero TreeNode a partire dalla struttura
+# della directory, simile a clona
+# Clona un TreeNode
+#
+class BuildDirTreeVisitor < TreeNodeVisitor
+  
+  attr_reader :root
+  
+  def initialize
+    super
+    @root = nil
+    @stack = []
+  end
+  
+  def enter_treeNode( pathname )
+    if @stack.empty?
+      treeNode = TreeNode.new( File.basename( pathname ) )
+      @root = treeNode
+    else
+      treeNode = TreeNode.new( File.basename( pathname ), @stack.last )
+    end
+    @stack.push( treeNode )
+  end
+
+  def exit_treeNode( pathname )
+    @stack.pop
+  end
+
+  def visit_leafNode( pathname )
+    leafNode = LeafNode.new( File.basename(pathname), @stack.last )
+  end
+
+end
+
+#
+# Utilizzo della classa astratta DirTreeProcessor
+# per stampare i nodi di un TreeNode
+#
+class PrintDirTreeVisitor < TreeNodeVisitor
+
+  def enter_treeNode( pathname )
+    puts pathname
+  end
+
+  def exit_treeNode( treeNode )
+  end
+
+  def visit_leafNode( pathname )
+    puts pathname
+  end
+
+end

data/lib/treevisitor/cli/cli_dir_tree.rb

@@ -0,0 +1,84 @@
+# stdlib
+require 'optparse'
+
+# common
+require 'treevisitor/dir_tree_walker'
+require 'treevisitor/build_dir_treevisitor'
+
+#
+#
+#
+class CliDirTree
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+
+  def parse_args( argv )
+
+    options = { :verbose => true, :force => false, :algo => 'build' }
+
+    opts = OptionParser.new
+    opts.banner = "Usage: example.rb [options]"
+    
+    opts.separator ""
+    opts.separator "programma per testare la classe DirProcessor"
+    opts.separator "Inserire il nome della directory da cui costuire il tree"
+    
+    opts.separator ""
+    opts.separator "opzioni: "
+    
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+
+    opts.on("-q", "--quiet", "quiet mode as --no-verbose") do |v|
+      options[:verbose] = false
+    end
+    
+    opts.on("-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+
+
+    algos = %w[build visit]
+    algo_aliases = { "b" => "build", "v" => "visit" }
+
+    algo_list = (algo_aliases.keys + algos).join(',')
+    opts.on("-a", "--algo ALGO", algos, algo_aliases, "Select algo","  (#{algo_list})") do |algo|
+      options[:algo] = algo
+    end
+
+    rest = opts.parse(argv)
+
+    # p options
+    # p ARGV
+
+    if rest.length < 1
+      puts opts
+      return 1
+    end
+
+    dirname = rest[0]
+    dirname = File.expand_path( dirname )
+
+    puts "reading : #{dirname}"
+
+    dtw = DirTreeWalker.new( dirname )
+    dtw.add_ignore_dir( ".svn" )
+    dtw.add_ignore_dir( "catalog_data" )
+
+    case options[:algo]
+    when 'build'
+      visitor = BuildDirTreeVisitor.new
+      dtw.run( visitor )
+      puts visitor.root.to_str
+    when 'visit'  
+      visitor = PrintDirTreeVisitor.new
+      dtw.run( visitor )
+    end
+
+  end
+
+end