readorder 1.0.0

data/lib/readorder/log.rb

@@ -0,0 +1,58 @@
+require 'logging'
+require 'readorder'
+
+module Readorder
+  ::Logging::Logger[self].level = :info
+
+  def self.logger
+    ::Logging::Logger[self]
+  end
+
+  module Log
+    def self.init( options = {} )
+      appender = Logging.appenders.stderr
+      appender.layout = self.console_layout
+      if options['log-file'] then
+        appender = ::Logging::Appenders::File.new(
+          'readorder',
+          :filename => options['log-file'],
+          :layout   => self.layout
+        )
+      end
+      
+      Readorder.logger.add_appenders( appender )
+      self.level = options['log-level'] || :info
+    end
+    
+    def self.console
+      Logging.appenders.stderr.level
+    end
+
+    def self.console=( level )
+      Logging.appenders.stderr.level = level
+    end
+    
+    def self.level
+      ::Logging::Logger[Readorder].level 
+    end
+
+    def self.level=( l )
+      ::Logging::Logger[Readorder].level = l
+    end
+
+    def self.layout
+      @layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "[%d] %5l %6p %c : %m\n",
+        :date_pattern => "%Y-%m-%d %H:%M:%S"
+      )
+    end
+
+    def self.console_layout
+      @console_layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "%d %5l : %m\n",
+        :date_pattern => "%H:%M:%S"
+      )
+    end
+
+  end
+end

data/lib/readorder/paths.rb

@@ -0,0 +1,69 @@
+module Readorder
+  module Paths
+    # The root directory of the project is considered to be the parent directory
+    # of the 'lib' directory.
+    #   
+    def root_dir
+      @root_dir ||= (
+        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+        lib_index  = path_parts.rindex("lib")
+        path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      )
+    end 
+
+    def root_path( sub, *args )
+      sub_path( root_dir, sub, *args )
+    end
+
+    def bin_path( *args )
+      root_path( 'bin', *args )
+    end
+
+    def lib_path( *args )
+      root_path( "lib", *args )
+    end 
+
+    def spec_path( *args )
+      root_path( "spec", *args )
+    end
+
+    # The home dir is the home directory of the project while it is running
+    # by default, this the same as the root_dir.  But if this value is set 
+    # then it affects other paths
+    def home_dir
+      @home_dir ||= root_dir
+    end
+
+    def home_dir=( other )
+      @home_dir = File.expand_path( other )
+    end
+
+    def home_path( sub, *args )
+      sub_path( home_dir, sub, *args )
+    end
+
+    def config_path( *args )
+      home_path( "config", *args )
+    end 
+
+    def data_path( *args )
+      home_path( "data", *args )
+    end 
+
+    def log_path( *args )
+      home_path( "log", *args )
+    end
+
+    def tmp_path( *args )
+      home_path( "tmp", *args )
+    end
+
+    def sub_path( parent, sub, *args )
+      sp = ::File.join( parent, sub ) + File::SEPARATOR
+      sp = ::File.join( sp, *args ) if args
+    end
+
+    extend self
+  end
+  extend Paths
+end

data/lib/readorder/runner.rb

@@ -0,0 +1,48 @@
+require 'readorder/log'
+require 'readorder/command'
+
+module Readorder
+  class Runner
+    attr_reader :options
+
+    def initialize( opts = {} )
+      @options = opts.dup
+      initialize_logging
+    end
+
+    def logger
+      @logger ||= ::Logging::Logger[self]
+    end
+
+    def setup_signal_handling( cmd )
+      %w[ INT QUIT TERM ].each do |s|
+        Signal.trap( s ) do
+          logger.info "received signal #{s} -- shutting down"
+          cmd.shutdown
+          exit 1
+        end
+      end
+    end
+
+    def initialize_logging
+      Readorder::Log.init( options )
+    end
+
+    def run( command_name )
+      cmd = Command.find( command_name ).new( @options )
+      begin
+        setup_signal_handling( cmd )
+        cmd.before
+        cmd.run
+      rescue => e
+        logger.error "while running #{command_name} : #{e.message}"
+        e.backtrace.each do |l|
+          logger.debug l
+        end
+        cmd.error
+      ensure
+        cmd.after
+      end
+    end
+  end
+end

data/lib/readorder/version.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details
+#++
+
+module Readorder
+  module Version
+    MAJOR   = 1
+    MINOR   = 0
+    BUILD   = 0
+
+    def to_a 
+      [MAJOR, MINOR, BUILD]
+    end
+
+    def to_s
+      to_a.join(".")
+    end
+
+    def to_hash
+      { :major => MAJOR, :minor => MINOR, :build => BUILD }
+    end
+
+    STRING = Version.to_s
+    extend self
+
+  end
+  VERSION = Version.to_s
+  extend Version
+end

data/lib/readorder.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright (c) 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#
+# Take a look in the README and the Analyzer and Datum classes.  That is where
+# all the real work is done.
+#
+module Readorder
+  #
+  # root Error class for Readorder
+  # 
+  class Error < StandardError; end 
+end
+
+require 'rubygems'
+require 'logging'
+require 'readorder/version'
+require 'readorder/paths'
+require 'readorder/cli'
+require 'readorder/filelist'
+require 'readorder/datum'
+require 'readorder/analyzer'

data/spec/analyzer_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ),"spec_helper.rb"))
+
+require 'readorder/analyzer'
+
+describe Readorder::Analyzer do
+  before( :each ) do
+    s = StringIO.new
+    fl = Dir.glob("#{Readorder::Paths.spec_path}/*_spec.rb")
+    s.puts fl.to_a.join("\n")
+    s.rewind
+    @filelist = Readorder::Filelist.new( s )
+    @analyzer = Readorder::Analyzer.new( @filelist, false )
+  end
+
+  it "collects data about files" do
+    @analyzer.collect_data
+    @analyzer.good_data.size.should > 0
+    @analyzer.inode_order.size.should > 0
+    @analyzer.physical_order.size.should == 0
+  end
+
+  it "logs a summary report" do
+    @analyzer.collect_data
+    @analyzer.log_summary_report
+    spec_log.should =~ /Collection Rate/
+  end
+
+  it "can have bad data and dump it to a file" do
+    s = StringIO.new
+    s.puts "/a/nonexistent/file"
+    s.rewind
+    analyzer = Readorder::Analyzer.new( Readorder::Filelist.new( s ) )
+    analyzer.collect_data
+    analyzer.bad_data.size.should > 0
+
+    s2 = StringIO.new
+    analyzer.dump_bad_data_to( s2 )
+    s2.rewind
+    s2.gets.should == "error_reason,filename\n"
+    s2.gets.should == "No such file or directory - /a/nonexistent/file,/a/nonexistent/file\n"
+  end
+
+  it "can dump good data to a csv" do
+    @analyzer.collect_data
+    s = StringIO.new
+    @analyzer.dump_good_data_to( s )
+    s.rewind
+    s.gets.should == "filename,size,inode_number\n"
+    s.read.split("\n").size.should == @analyzer.good_data.size
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ),"spec_helper.rb"))
+
+require 'readorder/command'
+
+class Readorder::Junk < Readorder::Command; end
+
+describe Readorder::Command do
+  before( :each ) do
+    @cmd = Readorder::Command.new
+  end
+
+  it "has a command name" do
+    @cmd.command_name.should == "command"
+  end
+
+  it "can log" do
+    @cmd.logger.info "this is a log statement"
+    spec_log.should =~ /this is a log statement/
+  end
+
+  it "cannot be run" do
+    lambda { @cmd.run }.should raise_error( Readorder::Command::Error, /Unknown command `command`/ )
+  end
+
+  it "registers inherited classes" do
+    Readorder::Command.commands.should be_include( Readorder::Junk )
+    Readorder::Command.commands.delete( Readorder::Junk )
+    Readorder::Command.commands.should_not be_include(Readorder::Junk)
+  end
+
+  it "classes cannot be run without implementing 'run'" do
+    j = Readorder::Junk.new
+    j.respond_to?(:run).should == true
+    lambda { j.run }.should raise_error( Readorder::Command::Error, /Unknown command `junk`/)
+  end
+
+end

data/spec/filelist_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+require 'stringio'
+require 'readorder/filelist'
+
+describe ::Readorder::Filelist do
+  it "can read from an object that responds to gets" do
+    s = StringIO.new
+    files = %w[ /tmp/here /tmp/there ]
+    files.each { |f| s.puts f }
+    s.rewind
+
+    fl = ::Readorder::Filelist.new( s )
+    fl.gets.should == "/tmp/here\n"
+    fl.gets.should == "/tmp/there\n"
+  end
+
+  it "raises an error if given a filename and it cannot open or read from the file" do
+    lambda { ::Readorder::Filelist.new( "/does/not/exist" ) }.should raise_error( Readorder::Filelist::Error, /does not exist/ )
+  end
+
+  it "raises an error if given something that is not a string that does not respond to gets" do
+    x = Object.new
+    def x.close
+      true
+    end
+    lambda { ::Readorder::Filelist.new( x ) }.should raise_error( Readorder::Filelist::Error, /does not respond to 'gets'/ )
+  end
+  
+  it "raises an error if given something that is not a string that does not respond to close" do
+    x = Object.new
+    def x.gets
+      true
+    end
+    lambda { ::Readorder::Filelist.new( x ) }.should raise_error( Readorder::Filelist::Error, /does not respond to 'close'/ )
+  end
+
+  it "can be iterated over with each_line" do
+    s = StringIO.new
+    files = [ "/tmp/here\n", "/tmp/there\n" ]
+
+    files.each { |f| s.print f }
+    s.rewind
+
+    fl = ::Readorder::Filelist.new( s )
+    out = []
+    fl.each_line do |l| 
+      out << l 
+    end
+    out.size.should == 2
+    out.should == files
+  end
+end

data/spec/log_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ),"spec_helper.rb"))
+
+require 'readorder/log'
+
+describe Readorder::Log do
+  it "creates its own layout" do
+    Readorder::Log.layout.should be_instance_of(Logging::Layouts::Pattern)
+  end
+
+  it "can retrieves its level" do
+    Readorder::Log.level.should == 0
+  end
+end

data/spec/paths_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+describe Readorder::Paths do
+  before(:each) do
+    @root_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+    @root_dir += "/"
+  end
+
+  it "root dir should be correct" do
+    Readorder.root_dir.should == @root_dir
+  end
+
+  it "home dir should be correct" do
+    Readorder.home_dir.should == @root_dir
+  end
+
+  %w[ bin lib spec config data log tmp ].each do |d|
+    it "#{d} path should be correct" do
+      Readorder.send( "#{d}_path" ).should == File.join(@root_dir, "#{d}/" )
+    end
+  end
+
+  describe "setting home_dir" do
+    before( :each ) do
+      @tmp_dir = "/some/location/#{Process.pid}"
+      Readorder.home_dir = @tmp_dir
+    end
+
+    %w[ config data log tmp ].each do |d|
+      check_path = "#{d}_path"
+      it "affects the location of #{check_path}" do
+        p = Readorder.send( check_path )
+        p.should == ( File.join( @tmp_dir, d ) + File::SEPARATOR )
+      end
+    end
+
+    %w[ bin lib spec ].each do |d|
+      check_path = "#{d}_path"
+      it "does not affect the location of #{check_path}" do
+        p = Readorder.send( check_path )
+        p.should == ( File.join( @root_dir, d ) + File::SEPARATOR )
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ),"spec_helper.rb"))
+
+require 'readorder/runner'
+
+class Readorder::Junk4Runner < Readorder::Command
+  def self.command_name
+    'junk4runner'
+  end
+
+  def run
+    logger.info "doing junk, as instructed #{options['foo']}"
+    if options['boom'] then
+      raise options['boom']
+    end
+  end
+end
+
+describe Readorder::Runner do
+  before(:each) do
+    @old_level = ::Readorder::Log.console
+    ::Readorder::Log.console = :off
+  end
+
+  after(:each) do
+    ::Readorder::Log.console = @old_level
+  end
+
+  it "can log" do
+    r = Readorder::Runner.new
+    r.logger.info "log statement from Runner"
+    spec_log.should =~ /log statement from Runner/
+  end
+
+  it "runs a command" do
+    r = Readorder::Runner.new( "foo" => "bar" )
+    r.run( 'junk4runner' )
+    spec_log.should =~ /doing junk, as instructed bar/
+  end
+
+  it "logs an exception raised by a Command" do
+    r = Readorder::Runner.new( 'boom' => 'a big kaboom!' )
+    r.run( 'junk4runner' )
+    spec_log.should =~ /doing junk, as instructed/
+    spec_log.should =~ /a big kaboom!/
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'readorder'
+
+Logging::Logger['Readorder'].level = :all
+module Spec
+  module Log
+    def self.io
+      @io ||= StringIO.new
+    end
+    def self.appender
+      @appender ||= Logging::Appenders::IO.new( "speclog", io )
+    end
+
+    Logging::Logger['Readorder'].add_appenders( Log.appender )
+
+    def self.layout
+      @layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "[%d] %5l %6p %c : %m\n",
+        :date_pattern => "%Y-%m-%d %H:%M:%S"
+      )
+    end
+
+    Log.appender.layout = layout
+
+  end
+
+  module Helpers
+    require 'tmpdir'
+    def make_temp_dir( unique_id = $$ )
+      dirname = File.join( Dir.tmpdir, "snipe-#{unique_id}" ) 
+      FileUtils.mkdir_p( dirname ) unless File.directory?( dirname )
+      return dirname
+    end
+
+    # the logging output from the test, if that class has any logging
+    def spec_log
+      Log.io.string
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include Spec::Helpers
+
+  config.before do
+    Spec::Log.io.rewind
+    Spec::Log.io.truncate( 0 )
+  end
+
+  config.after do
+    Spec::Log.io.rewind
+    Spec::Log.io.truncate( 0 )
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+describe "Readorder::Version" do
+
+  it "should have a version string" do
+    Readorder::Version.to_s.should =~ /\d+\.\d+\.\d+/
+    Readorder::VERSION.should =~ /\d+\.\d+\.\d+/
+  end
+
+  it "should have a version hash" do
+    h = Readorder::Version.to_hash
+    [ :major, :minor, :build ].each do |k|
+      h[k].should_not be_nil
+    end
+  end
+end

data/tasks/announce.rake

@@ -0,0 +1,39 @@
+require 'tasks/config'
+#-------------------------------------------------------------------------------
+# announcement methods
+#-------------------------------------------------------------------------------
+
+proj_config = Configuration.for('project')
+namespace :announce do
+  desc "create email for ruby-talk"
+  task :email do
+    info = Utils.announcement
+
+    File.open("email.txt", "w") do |mail|
+      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
+      mail.puts "To: ruby-talk@ruby-lang.org"
+      mail.puts "Date: #{Time.now.rfc2822}"
+      mail.puts "Subject: [ANN] #{info[:subject]}"
+      mail.puts
+      mail.puts info[:title]
+      mail.puts
+      mail.puts "  gem install #{Readorder::GEM_SPEC.name}"
+      mail.puts
+      mail.puts info[:urls]
+      mail.puts 
+      mail.puts info[:description]
+      mail.puts 
+      mail.puts "{{ Release notes for Version #{Readorder::VERSION} }}"
+      mail.puts 
+      mail.puts info[:release_notes]
+      mail.puts
+    end 
+    puts "Created the following as email.txt:"
+    puts "-" * 72
+    puts File.read("email.txt")
+    puts "-" * 72
+  end 
+
+  CLOBBER << "email.txt"
+end
+