Olag

$LOAD_PATH.unshift(File.dirname(__FILE__) + "/lib")

require "olag/rake"

Gem specification

Olag::Rake.new(spec)

spec = Gem::Specification.new do |spec|
  spec.name = "olag"
  spec.version = Olag::VERSION
  spec.author = "Oren Ben-Kiki"
  spec.email = "rubygems-oren@ben-kiki.org"
  spec.homepage = "https://rubygems.org/gems/olag"
  spec.summary = "Olag - Oren's Library/Application Gem framework"
  spec.description = (<<-EOF).gsub(/^\s+/, "").chomp.gsub("\n", " ")
    Olag is Oren's set of utilities for creating a well-behaved gem. This is
    very opinionated software; it eliminates a lot of the boilerplate, at the
    cost of making many decisions which may not be suitable for everyone
    (directory structure, code verification, codnar for documentation, etc.).
  EOF
end

module Gem

  class Specification

    attr_accessor :title

    attr_accessor :version_file

    alias_method :original_initialize, :initialize

    def initialize(&block)
      original_initialize(&block)
      setup_default_members
      add_development_dependencies
      setup_file_members
      setup_rdoc
    end

    def setup_default_members
      name = self.name
      @title ||= name.capitalize
      @version_file ||= "lib/#{name}/version.rb"
    end

    def add_development_dependencies
      add_dependency("olag") unless self.name == "olag"
      %w(Saikuro codnar fakefs flay rake rcov rdoc reek roodi test-spec).each do |gem|
        add_development_dependency(gem)
      end
    end

    def setup_file_members

      setup_file_member(:files, "{lib,doc}/**/*")
      self.files << "Rakefile" << "codnar.html"
      setup_file_member(:executables, "bin/*") { |path| path.sub("bin/", "") }
      setup_file_member(:test_files, "test/**/*")
    end

    def setup_file_member(member, pattern, &block)
      old_value = instance_variable_get("@#{member}")
      new_value = FileList[pattern].find_all { |path| File.file?(path) }
      new_value.map!(&block) if block
      instance_variable_set("@#{member}", old_value + new_value)
    end

    def setup_rdoc
      self.extra_rdoc_files = [ "README.rdoc", "LICENSE", "ChangeLog" ]
      self.rdoc_options << "--title" << "#{title} #{version}" \
                        << "--main" << "README.rdoc" \
                        << "--line-numbers" \
                        << "--all" \
                        << "--quiet"
    end

  end

end

require "codnar/rake"
require "olag/change_log"
require "olag/gem_specification"
require "olag/update_version"
require "olag/version"
require "rake/clean"
require "rake/testtask"
require "rcov/rcovtask"
require "rdoc/task"
require "reek/rake/task"
require "roodi"
require "rubygems/package_task"

module Olag

  class Rake

    include ::Rake::DSL

    def initialize(spec)
      @spec = spec
      @ruby_sources = @spec.files.find_all { |file| file =~ /^Rakefile$|\.rb$/ }
      @weave_configurations = [ :weave_include, :weave_named_chunk_with_containers, :weave_plain_chunk ]
      task(:default => :all)
      define_all_task
      CLOBBER << "saikuro"
    end

  protected

    def define_all_task
      define_desc_task("Version, verify, document, package", :all => [ :version, :verify, :doc, :package ])
      define_verify_task
      define_doc_task
      define_commit_task

      Gem::PackageTask.new(@spec) { |package| }
    end

    Verify gem functionality

    Analyze the source code

    Generate RDoc documentation

    Generate Codnar documentation

    Automate Git commit process

    Task utilities

  end

end

def define_desc_task(description, *parameters)
  desc(description)
  task(*parameters) do
    yield(task) if block_given?
  end
end

def define_desc_class(description, klass, *parameters)
  desc(description)
  klass.new(*parameters) do |task|
    yield(task) if block_given?
  end
end

def define_verify_task
  define_desc_task("Test, coverage, analyze code", :verify => [ :coverage, :analyze ])
  define_desc_class("Test code covarage with RCov", Rcov::RcovTask, "coverage") { |task| Rake.configure_coverage_task(task) }
  define_desc_class("Test code without coverage", ::Rake::TestTask, "test") { |task| Rake.configure_test_task(task) }
  define_analyze_task
end

def self.configure_coverage_task(task)
  task.test_files = FileList["test/*.rb"]
  task.libs << "lib" << "test/lib"
  task.rcov_opts << "--failure-threshold" << "100" \
                 << "--exclude" << "^/"

end

def self.configure_test_task(task)
  task.test_files = FileList["test/*.rb"]
  task.libs << "lib" << "test/lib"
end

def define_analyze_task
  define_desc_task("Analyze source code", :analyze => [ :reek, :roodi, :flay, :saikuro ])
  define_desc_class("Check for smelly code with Reek", Reek::Rake::Task) { |task| configure_reek_task(task) }
  define_desc_task("Check for smelly code with Roodi", :roodi) { run_roodi_task }
  define_desc_task("Check for duplicated code with Flay", :flay) { run_flay_task }
  define_desc_task("Check for complex code with Saikuro", :saikuro) { run_saikuro_task }
end

def configure_reek_task(task)
  task.reek_opts << "--quiet"
  task.source_files = @ruby_sources
end

def run_roodi_task
  runner = Roodi::Core::Runner.new
  runner.config = "roodi.config" if File.exist?("roodi.config")
  @ruby_sources.each { |ruby_source| runner.check_file(ruby_source) }
  (errors = runner.errors).each { |error| puts(error) }
  raise "Roodi found #{errors.size} errors." unless errors.empty?
end

def run_flay_task
  dirs = %w(bin lib test/lib).find_all { |dir| File.exist?(dir) }
  result = IO.popen("flay " + dirs.join(' '), "r").read.chomp
  return if result == "Total score (lower is better) = 0\n"
  puts(result)
  raise "Flay found code duplication."
end

def run_saikuro_task
  dirs = %w(bin lib test).find_all { |dir| File.exist?(dir) }
  system("saikuro -c -t -y 0 -e 10 -o saikuro/ -i #{dirs.join(' -i ')} > /dev/null")
  result = File.read("saikuro/index_cyclo.html")
  raise "Saikuro found complicated code." if result.include?("Errors and Warnings")
end

def define_doc_task
  desc "Generate all documentation"
  task :doc => [ :rdoc, :codnar ]
  ::Rake::RDocTask.new { |task| configure_rdoc_task(task) }
  define_codnar_task
end

def configure_rdoc_task(task)
  task.rdoc_files += @ruby_sources.reject { |file| file =~ /^test|Rakefile/ } + [ "LICENSE", "README.rdoc" ]
  task.main = "README.rdoc"
  task.rdoc_dir = "rdoc"
  task.options = @spec.rdoc_options
end

CODNAR_CONFIGURATIONS = [
  [

    "ChangeLog|codnar\.html",
  ], [

    "Rakefile|.*\.rb|bin/.*",
    "classify_source_code:ruby",
    "format_code_gvim_css:ruby",
    "classify_shell_comments",
    "format_rdoc_comments",
    "chunk_by_vim_regions",
  ], [

    ".*\.hs",
    "classify_source_code:haskell",
    "format_code_gvim_css:haskell",
    "classify_haddock_comments",
    "format_haddock_comments",
    "chunk_by_vim_regions",
  ], [

    ".*\.dot",
    "split_graphviz_documentation",
  ], [

    ".*\.html",
    "split_html_documentation",
  ], [

    ".*\.markdown|.*\.md",
    "split_markdown_documentation",
  ], [

    "LICENSE|.*\.rdoc",
    "split_rdoc_documentation",
  ],
]

def define_codnar_task
  @spec.files.each do |file|
    configurations = Rake.split_configurations(file)
    Codnar::Rake::SplitTask.new([ file ], configurations) unless configurations == []
  end
  Codnar::Rake::WeaveTask.new("doc/root.html", @weave_configurations)
end

def self.split_configurations(file)
  CODNAR_CONFIGURATIONS.each do |configurations|
    regexp = configurations[0] = convert_to_regexp(configurations[0])
    return configurations[1..-1] if regexp.match(file)
  end
  abort("No Codnar configuration for file: #{file}")
end

def self.convert_to_regexp(regexp)
  return regexp if Regexp == regexp
  begin
    return Regexp.new("^(#{regexp})$")
  rescue
    abort("Invalid pattern regexp: ^(#{regexp})$ error: #{$!}")
  end
end

def define_commit_task
  define_desc_task("Git commit process", :commit => [ :all, :first_commit, :changelog, :second_commit ])
  define_desc_task("Update version file from Git", :version) { update_version_file }
  define_desc_task("Perform the 1st (main) Git commit", :first_commit) { run_git_first_commit }
  define_desc_task("Perform the 2nd (amend) Git commit", :second_commit) { run_git_second_commit }
  define_desc_task("Update ChangeLog from Git", :changelog) { Olag::ChangeLog.new("ChangeLog") }
end

def update_version_file
  version_file = @spec.version_file
  updated_version = Olag::Version::update(version_file)
  abort("Updated gem version; re-run rake") if @spec.version.to_s != updated_version
end

def run_git_first_commit
  raise "Git 1st commit failed" unless system("set +x; git commit")
end

def run_git_second_commit
  raise "Git 2nd commit failed" unless system("set +x; EDITOR=true git commit --amend ChangeLog")
end

module Olag

  VERSION = "0.1.22"

end

module Olag

  module Version

    def self.update(path)
      current_file_contents, current_version, correct_version = current_status(path)
      if current_version != correct_version
        correct_file_contents = current_file_contents.sub(current_version, correct_version)
        File.open(path, "w") { |file| file.write(correct_file_contents) }
      end
      return correct_version
    end

  protected

    def self.current_status(path)
      prefix, current_suffix = extract_version(path, current_file_contents = File.read(path))
      correct_suffix = count_git_commits.to_s
      current_version = prefix + current_suffix
      correct_version = prefix + correct_suffix
      return current_file_contents, current_version, correct_version
    end

    def self.extract_version(path, file_contents)
      abort("#{path}: Does not contain a valid VERSION line.") unless file_contents =~ /VERSION\s+=\s+["'](\d+\.\d+\.)(\d+)["']/
      return [ $1, $2 ]
    end

    def self.count_git_commits
      git_commits = IO.popen("git rev-list --all | wc -l").read.chomp.to_i
      git_status = IO.popen("git status").read
      git_commits += 1 unless git_status.include?("working directory clean")
      return git_commits
    end

  end

end

module Olag

  class ChangeLog

    def initialize(path)
      @subjects_by_id = {}
      @sorted_ids = []
      read_log_lines
      File.open(path, "w") do |file|
        @log_file = file
        write_log_file
      end
    end

  protected

    def read_log_lines
      IO.popen("git log --pretty='format:%ci::%an <%ae>::%s'", "r").each_line do |log_line|
        load_log_line(log_line)
      end
    end

    def load_log_line(log_line)
      id, subject = ChangeLog.parse_log_line(log_line)
      @sorted_ids << id
      @subjects_by_id[id] ||= []
      @subjects_by_id[id] << subject
    end

    def self.parse_log_line(log_line)
      date, author, subject = log_line.chomp.split("::")
      date, time, zone = date.split(" ")
      id = "#{date}\t#{author}"
      return id, subject
    end

    def write_log_file
      @sorted_ids.uniq.each do |id|
        write_log_entry(id, @subjects_by_id[id])
      end
    end

    def write_log_entry(id, subjects)
      @log_file.puts "#{id}\n\n"
      @log_file.puts subjects.map { |subject| "\t* #{subject}" }.join("\n")
      @log_file.puts "\n"
    end

  end

end

require "olag/string_unindent"
require "test/spec"

class TestUnindentText < ::Test::Unit::TestCase

  def test_automatic_unindent
    <<-EOF.unindent.should == "a\n  b\n"
      a
        b
    EOF
  end

  def test_invalid_unindent
    "    a\n  b\n".unindent.should == "a\n  b\n"
  end

  def test_integer_unindent
    "  a\n    b\n".unindent(1).should == " a\n   b\n"
  end

  def test_string_unindent
    "  a\n    b\n".unindent(" ").should == " a\n   b\n"
  end

end

class String

  def unindent(unindentation = 0)
    unindentation = " " * (indentation.length - unindentation) if Fixnum === unindentation
    return gsub(/^#{unindentation}/, "")
  end

  def indentation
    return sub(/[^ ].*$/m, "")
  end

end

require "olag/data_files"
require "test/spec"

class TestAccessDataFiles < Test::Unit::TestCase

  def test_access_data_file
    File.exist?(Olag::DataFiles.expand_path("olag/data_files.rb")).should == true
  end

  def test_access_missing_file
    Olag::DataFiles.expand_path("no-such-file").should == "no-such-file"
  end

end

module Olag

  module DataFiles

    def self.expand_path(relative_path)
      $LOAD_PATH.each do |load_directory|
        absolute_path = File.expand_path(load_directory + "/" + relative_path)
        return absolute_path if File.exist?(absolute_path)
      end
      return relative_path # This will cause "file not found error" down the line.
    end

  end

end

require "olag/hash_struct"
require "test/spec"

class TestMissingKeys < ::Test::Unit::TestCase

  def test_read_missing_key
    {}.missing.should == nil
  end

  def test_set_missing_key
    hash = {}
    hash.missing = "value"
    hash.missing.should == "value"
  end

end

class Hash

  def method_missing(method, *arguments)
    method = method.to_s
    key = method.chomp("=")
    return method == key ? self[key] : self[key] = arguments[0]
  end

end

require "yaml"

if RUBY_VERSION.include?("1.8")

  class Hash

    alias :unsorted_to_yaml :to_yaml

    def to_yaml(opts = {})
      YAML::quick_emit(self, opts) do |out|
        out.map(taguri, to_yaml_style) do |map|
          to_yaml_sorted_keys.each do |key|
            map.add(key, fetch(key))
          end
        end
      end
    end

    def to_yaml_sorted_keys
      begin
        return keys.sort
      rescue
        return to_yaml_lexicographically_sorted_keys
      end
    end

    def to_yaml_lexicographically_sorted_keys
      begin
        return keys.sort_by {|key| key.to_s}
      rescue
        return keys
      end
    end

  end

end

require "olag/hash_sorted_yaml"
require "test/spec"

class Uncomparable

  def initialize(value)
    @value = value
  end

  def to_yaml(opts = {})
    return @value.to_yaml(opts)
  end

  def to_s
    return @value.to_s
  end

  %w(<=> < <= >= >).each do |operator|
    define_method(operator) { raise "Prevent operator: #{operator}" }
  end

end

class Unsortable < Uncomparable

  def to_s
    raise "Prevent conversion to string as well."
  end

end

class TestSortedKeys < ::Test::Unit::TestCase

  SORTED_NUMERICALLY = <<-EOF.unindent
    ---
    2: 2
    4: 4
    11: 1
    33: 3
  EOF

  SORTED_LEXICOGRAPHICALLY = <<-EOF.unindent
    ---
    11: 1
    2: 2
    33: 3
    4: 4
  EOF

  def test_sortable_keys
    { 2 => 2, 4 => 4, 11 => 1, 33 => 3 }.to_yaml.gsub(/ +$/, "").should == SORTED_NUMERICALLY
  end

  def test_uncomparable_keys
    { Uncomparable.new(11) => 1, 2 => 2, 33 => 3, 4 => 4 }.to_yaml.gsub(/ +$/, "").should == SORTED_LEXICOGRAPHICALLY
  end

  def test_unsortable_keys
    yaml_should_not = { Unsortable.new(11) => 1, 2 => 2, 33 => 3, 4 => 4 }.to_yaml.gsub(/ +$/, "").should.not
    yaml_should_not == SORTED_NUMERICALLY
    yaml_should_not == SORTED_LEXICOGRAPHICALLY
  end

end

require "olag/errors"
require "olag/test"
require "test/spec"

class TestCollectErrors < Test::Unit::TestCase

  include Test::WithErrors
  include Test::WithFakeFS

  def test_one_error
    @errors << "Oops"
    @errors.should == [ "#{$0}: Oops" ]
  end

  def test_path_error
    @errors.in_path("foo") do
      @errors << "Oops"
      "result"
    end.should == "result"
    @errors.should == [ "#{$0}: Oops in file: foo" ]
  end

  def test_line_error
    @errors.in_path("foo") do
      @errors.at_line(1)
      @errors << "Oops"
    end
    @errors.should == [ "#{$0}: Oops in file: foo at line: 1" ]
  end

  def test_file_error
    write_fake_file("foo", "bar\n")
    @errors.in_file("foo") do
      @errors << "Oops"
      "result"
    end.should == "result"
    @errors.should == [ "#{$0}: Oops in file: foo" ]
  end

  def test_file_lines_error
    write_fake_file("foo", "bar\nbaz\n")
    @errors.in_file_lines("foo") do |line|
      @errors << "Oops" if line == "baz\n"
    end
    @errors.should == [ "#{$0}: Oops in file: foo at line: 2" ]
  end


end

require "olag/errors"

module Test

  module WithErrors

    def self.included(base)
      base.class_eval do

        alias_method :errors_original_setup, :setup

        def setup
          errors_original_setup
          @errors = Olag::Errors.new
        end

      end
    end

  end

end

module Olag

  class Errors < Array

    attr_reader :path

    attr_reader :line_number

    def initialize
      @path = nil
      @line_number = nil
    end

    def in_path(path, &block)
      prev_path, prev_line_number = @path, @line_number
      @path, @line_number = path, nil
      result = block.call(path)
      @path, @line_number = prev_path, prev_line_number
      return result
    end

    def in_file(path, mode = "r", &block)
      return in_path(path) { File.open(path, mode, &block) }
    end

    def in_file_lines(path, &block)
      in_file(path) do |file|
        @line_number = 0
        file.each_line do |line|
          @line_number += 1
          block.call(line)
        end
      end
    end

    def at_line(line_number)
      @line_number = line_number
    end

    def <<(message)
      push(annotate_error_message(message))
    end

  protected

    def annotate_error_message(message)
      return "#{$0}: #{message}" unless @path
      return "#{$0}: #{message} in file: #{@path}" unless @line_number
      return "#{$0}: #{message} in file: #{@path} at line: #{@line_number}"
    end

  end

end

require "fileutils"
require "fakefs/safe"

module Test

  module WithFakeFS

    def write_fake_file(path, content = nil, &block)
      directory = File.dirname(path)
      FileUtils.mkdir_p(directory) unless File.exists?(directory)
      File.open(path, "w") do |file|
        file.write(content) unless content.nil?
        block.call(file) unless block.nil?
      end
    end

    def self.included(base)
      base.class_eval do

        alias_method :fakefs_original_setup, :setup

        def setup
          fakefs_original_setup
          FakeFS.activate!
          FakeFS::FileSystem.clear
        end

        alias_method :fakefs_original_teardown, :teardown

        def teardown
          fakefs_original_teardown
          FakeFS.deactivate!
        end

      end

    end

  end

end

require "fileutils"
require "tempfile"

module Test

  module WithTempfile

    def write_tempfile(path, content, directory = ".")
      file = Tempfile.open(path, directory)
      file.write(content)
      file.close(false)
      (@tempfiles ||= []) << file
      return file.path
    end

    def create_tempdir(directory = ".")
      file = Tempfile.open("dir", directory)
      (@tempfiles ||= []) << file
      File.delete(path = file.path)
      Dir.mkdir(path)
      return path
    end

    def self.included(base)
      base.class_eval do

        alias_method :tempfile_original_teardown, :teardown

        def teardown
          tempfile_original_teardown
          (@tempfiles || []).each do |tempfile|
            path = tempfile.path
            FileUtils.rm_rf(path) if File.exist?(path)
          end
        end

      end
    end

  end

end

require "olag/test/with_tempfile"

module Test

  module WithTempdir

    def self.included(base)
      base.class_eval do

        alias_method :tempdir_original_setup, :setup

        def setup
          tempdir_original_setup
          @tempdir = create_tempdir
          @stdout = @tempdir + "/stdout"
          @stdin = @tempdir + "/stdin"
          @stderr = @tempdir + "/stderr"
        end

      end
    end

  end

end

module Test

  module WithRake

    def self.included(base)
      base.class_eval do

        alias_method :rake_original_setup, :setup

        def setup
          rake_original_setup
          @original_rake = Rake.application
          @rake = Rake::Application.new
          Rake.application = @rake
        end

        alias_method :rake_original_teardown, :teardown

        def teardown
          rake_original_teardown
          Rake.application = @original_rake
        end

      end
    end

  end

end

require "olag/test/with_errors"
require "olag/test/with_fakefs"
require "olag/test/with_rake"
require "olag/test/with_tempfile"

module Test
end

require "olag/application"
require "olag/test"
require "test/spec"

class ErrorApplication < Olag::Application

  def run
    super { @errors << "Oops!" }
  end

  def parse_arguments
    expect_at_least(2, "fake arguments")
    expect_at_most(3, "fake arguments")
  end

end

class TestRunApplication < Test::Unit::TestCase

  include Test::WithFakeFS

  def test_do_nothing
    Olag::Application.with_argv([]) { Olag::Application.new(true).run }.should == 0
  end

  def test_inexact_arguments
    Olag::Application.with_argv(%w(-e stderr foo)) { Olag::Application.new(true).run }.should == 1
    File.read("stderr").should.include?("Expects no arguments")
  end

  def test_missing_arguments
    Olag::Application.with_argv(%w(-e stderr foo)) { ErrorApplication.new(true).run }.should == 1
    File.read("stderr").should.include?("Expects at least 2 fake arguments")
  end

  def test_extra_arguments
    Olag::Application.with_argv(%w(-e stderr foo bar baz bad)) { ErrorApplication.new(true).run }.should == 1
    File.read("stderr").should.include?("Expects at most 3 fake arguments")
  end

  def test_print_version
    Olag::Application.with_argv(%w(-o nested/stdout -v -h)) { Olag::Application.new(true).run }.should == 0
    File.read("nested/stdout").should == "#{$0}: Version: #{Olag::VERSION}\n"
  end

  def test_print_help
    Olag::Application.with_argv(%w(-o stdout -h -v)) { Olag::Application.new(true).run }.should == 0
    File.read("stdout").should.include?("DESCRIPTION:")
  end

  def test_print_errors
    Olag::Application.with_argv(%w(-e stderr foo bar)) { ErrorApplication.new(true).run }.should == 1
    File.read("stderr").should.include?("Oops!")
  end

end

require "fileutils"
require "olag/errors"
require "olag/globals"
require "olag/string_unindent.rb"
require "olag/version"
require "optparse"

module Olag

  class Application

    def initialize(is_test = nil)
      @errors = Errors.new
      @is_test = !!is_test
    end

    def run(*arguments, &block)
      parse_options
      yield(*arguments) if block_given?
      return print_errors
    rescue ExitException => exception
      return exception.status
    end

    def self.with_argv(argv)
      return Globals.without_changes do
        ARGV.replace(argv)
        yield
      end
    end

  protected

    def parse_options
      parser = OptionParser.new do |options|
        (@options = options).banner = banner + "\n\nOPTIONS:\n\n"
        define_flags
      end
      parser.parse!
      parse_arguments
    end

    def expect_limited_arguments(message_prefix, arguments_limit, argument_type, &block)
      if !yield(ARGV.size)
        $stderr.puts("#{$0}: #{message_prefix} #{arguments_limit} #{argument_type}.")
        exit(1)
      end
    end

    def expect_at_least(minimal_arguments, argument_type)
      expect_limited_arguments("Expects at least", minimal_arguments, argument_type) { |remaining_arguments| remaining_arguments >= minimal_arguments }
    end

    def expect_at_most(maximal_arguments, argument_type)
      expect_limited_arguments("Expects at most", maximal_arguments, argument_type) { |remaining_arguments| remaining_arguments <= maximal_arguments }
    end

    def expect_exactly(exact_arguments, argument_type)
      arguments_limit = exact_arguments == 0 ? 'no' : exact_arguments
      expect_limited_arguments("Expects", arguments_limit, argument_type) { |remaining_arguments| remaining_arguments == exact_arguments }
    end

    def parse_arguments
      expect_exactly(0, "arguments")
    end

    def define_flags
      define_help_flag
      define_version_flag
      define_redirect_flag("$stdout", "output", "w")
      define_redirect_flag("$stderr", "error", "w")
      #! Most scripts do not use this, but they can add it.
      #! define_redirect_flag("$stdin", "input", "r")
    end

    def define_help_flag
      @options.on("-h", "--help", "Print this help message and exit.") do
        puts(@options)
        print_additional_help
        exit(0)
      end
    end

    def print_additional_help
      arguments_name, arguments_description = arguments
      puts(format("    %-33s%s", arguments_name, arguments_description)) if arguments_name
      print("\nDESCRIPTION:\n\n")
      print(description)
    end

    def banner
      return $0
    end

    def arguments
      return nil, nil
    end

    def description
      return "Sample description\n"
    end

    def define_version_flag
      version_number = version
      @options.on("-v", "--version", "Print the version number (#{version_number}) and exit.") do
        puts("#{$0}: Version: #{version_number}")
        exit(0)
      end
    end

    def define_redirect_flag(variable, name, mode)
      @options.on("-#{name[0,1]}", "--#{name} FILE", String, "Redirect standard #{name} to a file.") do |file|
        eval("#{variable} = Application::redirect_file(#{variable}, file, mode)")
      end
    end

    def self.redirect_file(default, file, mode)
      return default if file.nil? || file == "-"
      FileUtils.mkdir_p(File.dirname(File.expand_path(file))) if mode == "w"
      return File.open(file, mode)
    end

    def version
      return Olag::VERSION
    end

    def print_errors
      @errors.each do |error|
        $stderr.puts(error)
      end
      return @errors.size
    end

    def exit(status)
      Kernel.exit(status) unless @is_test
      raise ExitException.new(status)
    end

  end

  class ExitException < Exception

    attr_reader :status

    def initialize(status)
      @status = status
    end

  end

end

module Olag

  class Globals

    def self.without_changes(&block)
      state = Globals.new
      begin
        return block.call
      ensure
        state.restore
      end
    end

    def restore
      $stdin = Globals.restore_file($stdin, @original_stdin)
      $stdout = Globals.restore_file($stdout, @original_stdout)
      $stderr = Globals.restore_file($stderr, @original_stderr)
      ARGV.replace(@original_argv)
    end

  protected

    def initialize
      @original_stdin = $stdin
      @original_stdout = $stdout
      @original_stderr = $stderr
      @original_argv = ARGV.dup
    end

    def self.restore_file(current, original)
      current.close unless current == original
      return original
    end

  end

end