deg-yard 0.8.7.1

data/spec/cli/command_parser_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::CommandParser do
+  describe '#run' do
+    before do
+      @cmd = CLI::CommandParser.new
+    end
+
+    it "should show help if --help is provided" do
+      command = mock(:command)
+      command.should_receive(:run).with('--help')
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run *%w( foo --help )
+    end
+
+    it "should use default command if first argument is a switch" do
+      command = mock(:command)
+      command.should_receive(:run).with('--a', 'b', 'c')
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run *%w( --a b c )
+    end
+
+    it "should use default command if no arguments are provided" do
+      command = mock(:command)
+      command.should_receive(:run)
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run
+    end
+
+    it "should list commands if command is not found" do
+      @cmd.should_receive(:list_commands)
+      @cmd.run *%w( unknown_command --args )
+    end
+
+    it "should list commands if --help is provided as sole argument" do
+      @cmd.should_receive(:list_commands)
+      @cmd.run *%w( --help )
+    end
+  end
+end

data/spec/cli/command_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'optparse'
+
+describe YARD::CLI::Command do
+  describe '#parse_options' do
+    before do
+      @options = OptionParser.new
+      @saw_foo = false
+      @options.on('--foo') { @saw_foo = true }
+    end
+
+    def parse(*args)
+      CLI::Command.new.send(:parse_options, @options, args)
+      args
+    end
+
+    it "should skip unrecognized options but continue to next option" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      log.should_receive(:warn).with(/Unrecognized.*--list2/)
+      parse('--list', '--list2', '--foo')
+      @saw_foo.should be_true
+    end
+
+    it "should skip unrecognized options and any extra non-option arg that follows" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      parse('--list', 'foo', '--foo')
+      @saw_foo.should be_true
+    end
+
+    it "should stop retrying to parse at non-switch argument" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      args = parse('--list', 'foo', 'foo', 'foo')
+      args.should == %w(foo foo)
+    end
+  end
+end

data/spec/cli/config_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'yaml'
+
+describe YARD::CLI::Config do
+  before do
+    @config = YARD::CLI::Config.new
+    YARD::Config.options = YARD::Config::DEFAULT_CONFIG_OPTIONS.dup
+    YARD::Config.stub!(:save)
+  end
+
+  def run(*args)
+    @config.run(*args)
+  end
+
+  describe 'Listing configuration' do
+    it "should accept --list" do
+      opts = YARD::Config.options
+      YAML.should_receive(:dump).twice.and_return("--- foo\nbar\nbaz")
+      log.should_receive(:puts).twice.with("bar\nbaz")
+      run
+      run('--list')
+      YARD::Config.options.should == opts
+    end
+  end
+
+  describe 'Viewing an item' do
+    it "should view item if no value is given" do
+      YARD::Config.options[:foo] = 'bar'
+      log.should_receive(:puts).with('"bar"')
+      run 'foo'
+      YARD::Config.options[:foo].should == 'bar'
+    end
+  end
+
+  describe 'Modifying an item' do
+    it "should accept --reset to set value" do
+      YARD::Config.options[:load_plugins] = 'foo'
+      run('--reset', 'load_plugins')
+      YARD::Config.options[:load_plugins].should == false
+    end
+
+    it "should accept --as-list to force single item as list" do
+      run('--as-list', 'foo', 'bar')
+      YARD::Config.options[:foo].should == ['bar']
+    end
+
+    it "should accept --append to append values to existing key" do
+      YARD::Config.options[:foo] = ['bar']
+      run('--append', 'foo', 'baz', 'quux')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux']
+      run('-a', 'foo', 'last')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux', 'last']
+    end
+
+    it "should turn key into list if --append is used on single item" do
+      YARD::Config.options[:foo] = 'bar'
+      run('-a', 'foo', 'baz')
+      YARD::Config.options[:foo].should == ['bar', 'baz']
+    end
+
+    it "should modify item if value is given" do
+      run('foo', 'xxx')
+      YARD::Config.options[:foo].should == 'xxx'
+    end
+
+    it "should turn list of values into array of values" do
+      run('foo', 'a', 'b', '1', 'true', 'false')
+      YARD::Config.options[:foo].should == ['a', 'b', 1, true, false]
+    end
+
+    it "should turn number into numeric Ruby type" do
+      run('foo', '1')
+      YARD::Config.options[:foo].should == 1
+    end
+
+    it "should turn true into TrueClass" do
+      run('foo', 'true')
+      YARD::Config.options[:foo].should == true
+    end
+
+    it "should turn false into FalseClass" do
+      run('foo', 'false')
+      YARD::Config.options[:foo].should == false
+    end
+
+    it "should save on modification" do
+      YARD::Config.should_receive(:save)
+      run('foo', 'true')
+    end
+  end
+end

data/spec/cli/diff_spec.rb

@@ -0,0 +1,260 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+require 'open-uri'
+
+describe YARD::CLI::Diff do
+  before do
+    CLI::Yardoc.stub!(:run)
+    CLI::Gems.stub!(:run)
+    @diff = CLI::Diff.new
+  end
+
+  describe 'Argument handling' do
+    it "should exit if there is only one gem name" do
+      @diff.should_receive(:exit)
+      log.should_receive(:puts).with(/Usage/)
+      @diff.run
+    end
+  end
+
+  describe 'Diffing' do
+    before do
+      @objects1 = nil
+      @objects2 = nil
+    end
+
+    def run(*args)
+      @all_call = -1
+      @data = StringIO.new
+      @objects1 ||= %w( C#fooey C#baz D.bar )
+      @objects2 ||= %w( A A::B A::B::C A.foo A#foo B C.foo C.bar C#baz )
+      @objects = [@objects1, @objects2]
+      @diff.should_receive(:load_gem_data).ordered.with('gem1') do
+        Registry.clear
+        YARD.parse_string <<-eof
+          class C
+            def fooey; end
+            def baz; FOO end
+          end
+          class D
+            def self.bar; end
+          end
+        eof
+      end
+      @diff.should_receive(:load_gem_data).ordered.with('gem2') do
+        Registry.clear
+        YARD.parse_string <<-eof
+          module A
+            module B
+              class C; end
+            end
+            def self.foo; end
+            def foo; end
+          end
+          class C
+            def self.foo; end
+            def self.bar; end
+            def baz; BAR end
+          end
+        eof
+      end
+      log.stub!(:print) {|data| @data << data }
+      log.stub!(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
+      @diff.run(*(args + ['gem1', 'gem2']))
+    end
+
+    it "should show differences between objects" do
+      run
+      @data.string.should == <<-eof
+Added objects:
+
+  A ((stdin):1) (...)
+  A::B::C ((stdin):3)
+  C.bar ((stdin):10)
+  C.foo ((stdin):9)
+
+Modified objects:
+
+  C#baz ((stdin):3)
+
+Removed objects:
+
+  C#fooey ((stdin):2)
+  D ((stdin):5) (...)
+
+eof
+    end
+
+    it "should accept --compact" do
+      run('--compact')
+      @data.string.should == <<-eof
+A A ((stdin):1) (...)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D ((stdin):5) (...)
+eof
+    end
+
+    it "should accept -a/--all" do
+      ['-a', '--all'].each do |opt|
+        run(opt)
+        @data.string.should == <<-eof
+Added objects:
+
+  A ((stdin):1)
+  A#foo ((stdin):6)
+  A.foo ((stdin):5)
+  A::B ((stdin):2)
+  A::B::C ((stdin):3)
+  C.bar ((stdin):10)
+  C.foo ((stdin):9)
+
+Modified objects:
+
+  C#baz ((stdin):3)
+
+Removed objects:
+
+  C#fooey ((stdin):2)
+  D ((stdin):5)
+  D.bar ((stdin):6)
+
+eof
+      end
+    end
+
+    it "should accept --compact and --all" do
+      run('--compact', '--all')
+      @data.string.should == <<-eof
+A A ((stdin):1)
+A A#foo ((stdin):6)
+A A.foo ((stdin):5)
+A A::B ((stdin):2)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D ((stdin):5)
+D D.bar ((stdin):6)
+eof
+    end
+
+    it "should accept --no-modified" do
+      run('--compact', '--no-modified')
+      @data.string.should == <<-eof
+A A ((stdin):1) (...)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+D C#fooey ((stdin):2)
+D D ((stdin):5) (...)
+eof
+    end
+
+    it "should accept --query" do
+      run('--compact', '--query', 'o.type == :method')
+      @data.string.should == <<-eof
+A A#foo ((stdin):6)
+A A.foo ((stdin):5)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D.bar ((stdin):6)
+eof
+    end
+  end
+
+  describe 'File searching' do
+    before do
+      @diff.stub!(:generate_yardoc)
+    end
+
+    it "should search for gem/.yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(true)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1/.yardoc')
+      Registry.should_receive(:load_yardoc).with('gem2/.yardoc')
+      @diff.run('gem1', 'gem2')
+    end
+
+    it "should search for argument as yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(true)
+      File.should_receive(:directory?).with('gem2').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1')
+      Registry.should_receive(:load_yardoc).with('gem2')
+      @diff.run('gem1', 'gem2')
+    end
+
+    it "should search for installed gem" do
+      File.should_receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0').and_return(false)
+      gemmock = mock(:gemmock)
+      spec1 = mock(:spec)
+      spec2 = mock(:spec)
+      gemmock.should_receive(:find_name).at_least(1).times.and_return([spec1, spec2])
+      Gem.should_receive(:source_index).at_least(1).times.and_return(gemmock)
+      spec1.stub!(:full_name).and_return('gem1-1.0.0')
+      spec1.stub!(:name).and_return('gem1')
+      spec1.stub!(:version).and_return('1.0.0')
+      spec2.stub!(:full_name).and_return('gem2-1.0.0')
+      spec2.stub!(:name).and_return('gem2')
+      spec2.stub!(:version).and_return('1.0.0')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
+      Registry.should_receive(:load_yardoc).with('/path/to/file')
+      CLI::Gems.should_receive(:run).with('gem2', '1.0.0').and_return(nil)
+      Dir.stub!(:chdir)
+      @diff.run('gem1-1.0.0.gem', 'gem2-1.0.0')
+    end
+
+    it "should search for .gem file" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(true)
+      File.should_receive(:exist?).with('gem2.gem').and_return(true)
+      File.should_receive(:exist?).any_number_of_times
+      File.should_receive(:open).with('gem1.gem', 'rb')
+      File.should_receive(:open).with('gem2.gem', 'rb')
+      FileUtils.stub(:mkdir_p)
+      Gem::Package.stub(:open)
+      FileUtils.stub(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+
+    it "should search for .gem file on rubygems.org" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(false)
+      File.should_receive(:exist?).with('gem2.gem').and_return(false)
+      File.should_receive(:exist?).any_number_of_times
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem1.gem')
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem2.gem')
+      FileUtils.stub(:mkdir_p)
+      Gem::Package.stub(:open)
+      FileUtils.stub(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+
+    it "should error if gem is not found" do
+      log.should_receive(:error).with("Cannot find gem gem1")
+      log.should_receive(:error).with("Cannot find gem gem2.gem")
+      @diff.stub!(:load_gem_data).and_return(false)
+      @diff.run('gem1', 'gem2.gem')
+    end
+  end
+end

data/spec/cli/display_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Display do
+  before do
+    Registry.stub(:load)
+    @object = CodeObjects::ClassObject.new(:root, :Foo)
+    @object.docstring = 'Foo bar'
+  end
+
+  it "displays an object" do
+    YARD::CLI::Display.run('-f', 'text', 'Foo')
+    log.io.string.strip.should eq(@object.format.strip)
+  end
+
+  it "wraps output with -l (defaulting to layout)" do
+    YARD::CLI::Display.run('-l', '-f', 'html', 'Foo')
+    formatted_output = @object.format(:format => :html).strip
+    actual_output = log.io.string.strip
+    actual_output.should_not eq(formatted_output)
+    actual_output.should include(formatted_output)
+  end
+
+  it "wraps output with --layout onefile" do
+    YARD::CLI::Display.run('--layout', 'onefile', '-f', 'html', 'Foo')
+    formatted_output = @object.format(:format => :html).strip
+    actual_output = log.io.string.strip
+    actual_output.should_not eq(formatted_output)
+    actual_output.should include(formatted_output)
+  end
+end

data/spec/cli/gems_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ostruct'
+require 'rubygems'
+
+describe YARD::CLI::Gems do
+  before do
+    @rebuild = false
+    @gem1 = build_mock('gem1')
+    @gem2 = build_mock('gem2')
+    @gem3 = build_mock('gem3')
+  end
+
+  def build_mock(name, version = '1.0')
+    OpenStruct.new  :name => name,
+                    :version => version,
+                    :full_gem_path => "/path/to/gems/#{name}-#{version}",
+                    :yardoc_file => "/path/to/yardoc/#{name}-#{version}"
+  end
+
+  def build_specs(*specs)
+    specs.each do |themock|
+      Registry.should_receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}").and_return(themock.yardoc_file)
+      File.should_receive(:directory?).with(themock.yardoc_file).and_return(@rebuild)
+      File.should_receive(:directory?).with(themock.full_gem_path).and_return(true)
+      Registry.should_receive(:yardoc_file_for_gem).with(themock.name, "= #{themock.version}", true).and_return(themock.yardoc_file)
+      Dir.should_receive(:chdir).with(themock.full_gem_path)
+    end
+    Registry.should_receive(:clear).exactly(specs.size).times
+    CLI::Yardoc.should_receive(:run).exactly(specs.size).times
+  end
+
+  describe '#run' do
+    it "should build all gem indexes if no gem is specified" do
+      build_specs(@gem1, @gem2)
+      Gem.source_index.should_receive(:find_name).with('').and_return([@gem1, @gem2])
+      CLI::Gems.run
+    end
+
+    it "should allow gem to be specified" do
+      build_specs(@gem1)
+      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 0').and_return([@gem1])
+      CLI::Gems.run(@gem1.name)
+    end
+
+    it "should allow multiple gems to be specified for building" do
+      build_specs(@gem1, @gem2)
+      Gem.source_index.should_receive(:find_name).with(@gem1.name, @gem1.version).and_return([@gem1])
+      Gem.source_index.should_receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
+      CLI::Gems.run(@gem1.name, @gem1.version, @gem2.name)
+    end
+
+    it "should allow version to be specified with gem" do
+      build_specs(@gem1)
+      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 1.0').and_return([@gem1])
+      CLI::Gems.run(@gem1.name, '>= 1.0')
+    end
+
+    it "should warn if one of the gems is not found, but it should process others" do
+      build_specs(@gem2)
+      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
+      Gem.source_index.should_receive(:find_name).with(@gem2.name, '>= 0').and_return([@gem2])
+      log.should_receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
+      CLI::Gems.run(@gem1.name, '>= 2.0', @gem2.name)
+    end
+
+    it "should fail if specified gem(s) is/are not found" do
+      CLI::Yardoc.should_not_receive(:run)
+      Gem.source_index.should_receive(:find_name).with(@gem1.name, '>= 2.0').and_return([])
+      log.should_receive(:warn).with(/#{@gem1.name} >= 2.0 could not be found/)
+      log.should_receive(:error).with(/No specified gems could be found/)
+      CLI::Gems.run(@gem1.name, '>= 2.0')
+    end
+
+    it "should accept --rebuild" do
+      @rebuild = true
+      build_specs(@gem1)
+      Gem.source_index.should_receive(:find_name).with('').and_return([@gem1])
+      CLI::Gems.run('--rebuild')
+    end
+  end
+end

data/spec/cli/graph_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Graph do
+  it "should serialize output" do
+    Registry.should_receive(:load).at_least(1).times
+    subject.stub(:yardopts) { [] }
+    subject.options.serializer.should_receive(:serialize).once
+    subject.run
+  end
+
+  it 'should read yardoc file from .yardopts' do
+    subject.stub(:yardopts) { %w(--db /path/to/db) }
+    subject.options.serializer.should_receive(:serialize).once
+    subject.run
+    Registry.yardoc_file.should == '/path/to/db'
+  end
+end

data/spec/cli/help_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Help do
+  describe '#run' do
+    it "should accept 'help command'" do
+      CLI::Yardoc.should_receive(:run).with('--help')
+      CLI::Help.run('doc')
+    end
+
+    it "should accept no arguments (lists all commands)" do
+      CLI::CommandParser.should_receive(:run).with('--help')
+      CLI::Help.run
+    end
+
+    it "should show all commands if command isn't found" do
+      CLI::CommandParser.should_receive(:run).with('--help')
+      help = CLI::Help.new
+      log.should_receive(:puts).with(/not found/)
+      help.run('unknown')
+    end
+  end
+end

data/spec/cli/i18n_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::I18n do
+  before do
+    @i18n = YARD::CLI::I18n.new
+    @i18n.use_document_file = false
+    @i18n.use_yardopts_file = false
+    output_path = File.expand_path(@i18n.options.serializer.basepath)
+    File.stub!(:open!).with(output_path, "wb")
+    YARD.stub!(:parse)
+  end
+
+  describe 'Defaults' do
+    before do
+      @i18n = YARD::CLI::I18n.new
+      @i18n.stub!(:yardopts).and_return([])
+      @i18n.stub!(:support_rdoc_document_file!).and_return([])
+      @i18n.parse_arguments
+    end
+
+    it "should read .yardopts by default" do
+      @i18n.use_yardopts_file.should == true
+    end
+
+    it "should use {lib,app}/**/*.rb and ext/**/*.c as default file glob" do
+      @i18n.files.should == ['{lib,app}/**/*.rb', 'ext/**/*.c']
+    end
+
+    it "should only show public visibility by default" do
+      @i18n.visibilities.should == [:public]
+    end
+  end
+
+  describe 'General options' do
+    def self.should_accept(*args, &block)
+      @counter ||= 0
+      @counter += 1
+      counter = @counter
+      args.each do |arg|
+        define_method("test_options_#{@counter}", &block)
+        it("should accept #{arg}") { send("test_options_#{counter}", arg) }
+      end
+    end
+
+    should_accept('--yardopts') do |arg|
+      @i18n = YARD::CLI::I18n.new
+      @i18n.use_document_file = false
+      @i18n.should_receive(:yardopts).at_least(1).times.and_return([])
+      @i18n.parse_arguments(arg)
+      @i18n.use_yardopts_file.should == true
+      @i18n.parse_arguments('--no-yardopts', arg)
+      @i18n.use_yardopts_file.should == true
+    end
+
+    should_accept('--yardopts with filename') do |arg|
+      @i18n = YARD::CLI::I18n.new
+      File.should_receive(:read_binary).with('.yardopts_i18n').and_return('')
+      @i18n.use_document_file = false
+      @i18n.parse_arguments('--yardopts', '.yardopts_i18n')
+      @i18n.use_yardopts_file.should == true
+      @i18n.options_file.should == '.yardopts_i18n'
+    end
+
+    should_accept('--no-yardopts') do |arg|
+      @i18n = YARD::CLI::I18n.new
+      @i18n.use_document_file = false
+      @i18n.should_not_receive(:yardopts)
+      @i18n.parse_arguments(arg)
+      @i18n.use_yardopts_file.should == false
+      @i18n.parse_arguments('--yardopts', arg)
+      @i18n.use_yardopts_file.should == false
+    end
+
+    should_accept('--exclude') do |arg|
+      YARD.should_receive(:parse).with(['a'], ['nota', 'b'])
+      @i18n.run(arg, 'nota', arg, 'b', 'a')
+    end
+  end
+
+  describe '.yardopts handling' do
+    before do
+      @i18n.use_yardopts_file = true
+    end
+
+    it "should search for and use yardopts file specified by #options_file" do
+      File.should_receive(:read_binary).with("test").and_return("-o \n\nMYPATH\nFILE1 FILE2")
+      @i18n.use_document_file = false
+      @i18n.options_file = "test"
+      File.should_receive(:open!).with(File.expand_path("MYPATH"), "wb")
+      @i18n.run
+      @i18n.files.should == ["FILE1", "FILE2"]
+    end
+  end
+
+  describe '#run' do
+    it "should parse_arguments if run() is called" do
+      @i18n.should_receive(:parse_arguments)
+      @i18n.run
+    end
+
+    it "should parse_arguments if run(arg1, arg2, ...) is called" do
+      @i18n.should_receive(:parse_arguments)
+      @i18n.run('--private', '-p', 'foo')
+    end
+
+    it "should not parse_arguments if run(nil) is called" do
+      @i18n.should_not_receive(:parse_arguments)
+      @i18n.run(nil)
+    end
+  end
+end