climine 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/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

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/cli/list_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::List do
+  it "should pass command off to Yardoc with --list" do
+    YARD::CLI::Yardoc.should_receive(:run).with('-c', '--list', '--foo')
+    YARD::CLI::List.run('--foo')
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/cli/markup_types_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::MarkupTypes do
+  it "lists all available markup types" do
+    YARD::CLI::MarkupTypes.run
+    data = log.io.string
+    exts = YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS
+    YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS.each do |name, providers|
+      data.should match(/\b#{name}\b/)
+
+      # Match all extensions
+      exts[name].each do |ext|
+        data.should include(".#{ext}")
+      end if exts[name]
+
+      # Match all provider libs
+      providers.each do |provider|
+        data.should match(/\b#{provider[:lib]}\b/)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/cli/server_spec.rb

@@ -0,0 +1,327 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Server::WebrickAdapter; def start; end end
+
+describe YARD::CLI::Server do
+  before do
+    CLI::Yardoc.stub!(:run)
+    @no_verify_libraries = false
+    @set_libraries = true
+    @no_adapter_mock = false
+    @libraries = {}
+    @options = {:single_library => true, :caching => false}
+    @server_options = {:Port => 8808}
+    @adapter = mock(:adapter)
+    @adapter.stub!(:setup)
+    new_cli
+  end
+
+  after(:all) do
+    Server::Adapter.shutdown
+  end
+
+  def new_cli
+    @cli = subject
+  end
+
+  def rack_required
+    begin; require 'rack'; rescue LoadError; pending "rack required for this test" end
+  end
+
+  def bundler_required
+    begin; require 'bundler'; rescue LoadError; pending "bundler required for this test" end
+  end
+
+  def unstub_adapter
+    @no_adapter_mock = true
+  end
+
+  def run(*args)
+    if @set_libraries && @libraries.empty?
+      library = Server::LibraryVersion.new(
+        File.basename(Dir.pwd), nil, File.expand_path('.yardoc'))
+      @libraries = {library.name => [library]}
+    end
+    unless @no_verify_libraries
+      @libraries.values.each do |libs|
+        libs.each do |lib|
+          yfile = File.expand_path(lib.yardoc_file)
+          File.stub!(:exist?).with(yfile).and_return(true)
+        end
+      end
+    end
+    unless @no_adapter_mock
+      @cli.stub!(:adapter).and_return(@adapter)
+      @adapter.should_receive(:new).
+        with(@libraries, @options, @server_options).and_return(@adapter)
+      @adapter.should_receive(:start)
+    end
+
+    @cli.run(*args.flatten)
+    assert_libraries @libraries, @cli.libraries
+
+    new_cli
+  end
+
+  def assert_libraries(expected_libs, actual_libs)
+    actual_libs.should == expected_libs
+    expected_libs.each do |name, libs|
+      libs.each_with_index do |expected,i|
+        actual = actual_libs[name][i]
+        [:source, :source_path, :yardoc_file].each do |m|
+          actual.send(m).should == expected.send(m)
+        end
+      end
+    end
+  end
+
+  # Mocks the existence of a file.
+  def mock_file(filename, content = nil)
+    File.stub!(:exist?).with(filename).and_return(true)
+    File.stub!(:read_binary).with(filename).and_return(content) if content
+    filename_e = File.expand_path(filename)
+    mock_file(filename_e) unless filename_e == filename
+  end
+
+  describe 'when .yardopts file exists' do
+    before :each do
+      Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
+      Dir.stub!(:pwd).and_return('/path/to/bar')
+      @name = 'bar'
+    end
+
+    it "should use .yardoc as the yardoc db if .yardopts doesn't specify an alternate path" do
+      mock_file '/path/to/bar/.yardopts', '--protected'
+      @libraries[@name] = [Server::LibraryVersion.new(@name, nil, '/path/to/bar/.yardoc')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run
+    end
+
+    it "should use the yardoc db location specified by .yardopts" do
+      mock_file '/path/to/bar/.yardopts', '--db foo'
+      @libraries[@name] = [Server::LibraryVersion.new(@name, nil, '/path/to/bar/foo')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run
+    end
+
+    it "should parse .yardopts when the library list is odd" do
+      mock_file '/path/to/bar/.yardopts', '--db foo'
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, '/path/to/bar/foo')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run 'a'
+    end
+  end
+
+  describe "when .yardopts file doesn't exist" do
+    before :each do
+      File.stub(:exist?).with(/^(.*[\\\/])?\.yardopts$/).and_return(false)
+    end
+
+    it "should default to .yardoc if no library is specified" do
+      Dir.should_receive(:pwd).at_least(:once).and_return('/path/to/foo')
+      @libraries['foo'] = [Server::LibraryVersion.new('foo', nil, '/path/to/foo/.yardoc')]
+      run
+    end
+
+    it "should use .yardoc as yardoc file if library list is odd" do
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('.yardoc'))]
+      run 'a'
+    end
+
+    it "should force multi library if more than one library is listed" do
+      File.stub(:exist?).with('b').and_return(true)
+      @options[:single_library] = false
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('b'))]
+      @libraries['c'] = [Server::LibraryVersion.new('c', nil, File.expand_path('.yardoc'))]
+      run %w(a b c)
+    end
+
+    it "should fail if specified directory does not exist" do
+      @set_libraries = false
+      File.stub(:exist?).with('b').and_return(false)
+      log.should_receive(:warn).with(/Cannot find yardoc db for a: "b"/)
+      run %w(a b)
+    end
+  end
+
+  describe 'General options' do
+    before do
+      File.stub(:exist?).with(/\.yardopts$/).and_return(false)
+    end
+
+    it "should accept -m, --multi-library" do
+      @options[:single_library] = false
+      run '-m'
+      run '--multi-library'
+    end
+
+    it "should accept -c, --cache" do
+      @options[:caching] = true
+      run '-c'
+      run '--cache'
+    end
+
+    it "should accept -r, --reload" do
+      @options[:incremental] = true
+      run '-r'
+      run '--reload'
+    end
+
+    it "should accept -d, --daemon" do
+      @server_options[:daemonize] = true
+      run '-d'
+      run '--daemon'
+    end
+
+    it "should accept -B, --bind" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com'
+      run '--bind', 'example.com'
+    end    
+
+    it "should bind address with WebRick adapter" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com', '-a', 'webrick'
+      run '--bind', 'example.com', '-a', 'webrick'
+    end  
+
+    it "should bind address with Rack adapter" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com', '-a', 'rack'
+      run '--bind', 'example.com', '-a', 'rack'
+    end          
+
+    it "should accept -p, --port" do
+      @server_options[:Port] = 10
+      run '-p', '10'
+      run '--port', '10'
+    end
+
+    it "should accept --docroot" do
+      @server_options[:DocumentRoot] = Dir.pwd + '/__foo/bar'
+      run '--docroot', '__foo/bar'
+    end
+
+    it "should accept -a webrick to create WEBrick adapter" do
+      @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+      run '-a', 'webrick'
+    end
+
+    it "should accept -a rack to create Rack adapter" do
+      rack_required
+      @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+      run '-a', 'rack'
+    end
+
+    it "should default to Rack adapter if exists on system" do
+      rack_required
+      @cli.should_receive(:require).with('rubygems').and_return(false)
+      @cli.should_receive(:require).with('rack').and_return(true)
+      @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+      @cli.send(:select_adapter)
+    end
+
+    it "should fall back to WEBrick adapter if Rack is not on system" do
+      @cli.should_receive(:require).with('rubygems').and_return(false)
+      @cli.should_receive(:require).with('rack').and_raise(LoadError)
+      @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+      @cli.send(:select_adapter)
+    end
+
+    it "should accept -s, --server" do
+      @server_options[:server] = 'thin'
+      run '-s', 'thin'
+      run '--server', 'thin'
+    end
+
+    it "should accept -g, --gems" do
+      @no_verify_libraries = true
+      @options[:single_library] = false
+      @libraries['gem1'] = [Server::LibraryVersion.new('gem1', '1.0.0', nil, :gem)]
+      @libraries['gem2'] = [Server::LibraryVersion.new('gem2', '1.0.0', nil, :gem)]
+      gem1 = mock(:gem1)
+      gem1.stub!(:name).and_return('gem1')
+      gem1.stub!(:version).and_return('1.0.0')
+      gem1.stub!(:full_gem_path).and_return('/path/to/foo')
+      gem2 = mock(:gem2)
+      gem2.stub!(:name).and_return('gem2')
+      gem2.stub!(:version).and_return('1.0.0')
+      gem2.stub!(:full_gem_path).and_return('/path/to/bar')
+      specs = {'gem1' => gem1, 'gem2' => gem2}
+      source = mock(:source_index)
+      source.stub!(:find_name).and_return do |k, ver|
+        k == '' ? specs.values : specs.grep(k).map {|name| specs[name] }
+      end
+      Gem.stub!(:source_index).and_return(source)
+      run '-g'
+      run '--gems'
+    end
+
+    it "should accept -G, --gemfile" do
+      bundler_required
+      @no_verify_libraries = true
+      @options[:single_library] = false
+
+      @libraries['gem1'] = [Server::LibraryVersion.new('gem1', '1.0.0', nil, :gem)]
+      @libraries['gem2'] = [Server::LibraryVersion.new('gem2', '1.0.0', nil, :gem)]
+      gem1 = mock(:gem1)
+      gem1.stub!(:name).and_return('gem1')
+      gem1.stub!(:version).and_return('1.0.0')
+      gem1.stub!(:full_gem_path).and_return('/path/to/foo')
+      gem2 = mock(:gem2)
+      gem2.stub!(:name).and_return('gem2')
+      gem2.stub!(:version).and_return('1.0.0')
+      gem2.stub!(:full_gem_path).and_return('/path/to/bar')
+      specs = {'gem1' => gem1, 'gem2' => gem2}
+      lockfile_parser = mock(:new)
+      lockfile_parser.stub!(:specs).and_return([gem1, gem2])
+      Bundler::LockfileParser.stub!(:new).and_return(lockfile_parser)
+
+      File.should_receive(:exist?).at_least(2).times.with("Gemfile.lock").and_return(true)
+      File.stub!(:read)
+
+      run '-G'
+      run '--gemfile'
+
+      File.should_receive(:exist?).with("different_name.lock").and_return(true)
+      run '--gemfile', 'different_name'
+    end
+
+    it "should warn if lockfile is not found (with -G)" do
+      bundler_required
+      File.should_receive(:exist?).with(/\.yardopts$/).at_least(:once).and_return(false)
+      File.should_receive(:exist?).with('somefile.lock').and_return(false)
+      log.should_receive(:warn).with(/Cannot find somefile.lock/)
+      run '-G', 'somefile'
+    end
+
+    it "should error if Bundler not available (with -G)" do
+      @cli.should_receive(:require).with('bundler').and_raise(LoadError)
+      log.should_receive(:error).with(/Bundler not available/)
+      run '-G'
+    end
+
+    it "should load template paths after adapter template paths" do
+      unstub_adapter
+      @cli.adapter = Server::WebrickAdapter
+      run '-t', 'foo'
+      Templates::Engine.template_paths.last.should == 'foo'
+    end
+
+    it "should load ruby code (-e) after adapter" do
+      unstub_adapter
+      @cli.adapter = Server::WebrickAdapter
+      path = File.dirname(__FILE__) + '/tmp.adapterscript.rb'
+      begin
+        File.open(path, 'w') do |f|
+          f.puts "YARD::Templates::Engine.register_template_path 'foo'"
+          f.flush
+          run '-e', f.path
+          Templates::Engine.template_paths.last.should == 'foo'
+        end
+      ensure
+        File.unlink(path)
+      end
+    end
+  end
+end