climine 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/templates/spec_helper.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include YARD::Templates
+
+def only_copy?(result, example, type)
+  if $COPY == :all || $COPY == example
+    puts(result) unless $COPYT && $COPYT != type
+  end
+  $COPY ? true : false
+end
+
+def text_equals(result, expected_example)
+  return if only_copy?(result, expected_example, :text)
+  text_equals_string(result, example_contents(expected_example, :txt))
+end
+
+def text_equals_string(result, expected)
+  result.should == expected
+end
+
+def html_equals(result, expected_example)
+  return if only_copy?(result, expected_example, :html)
+  html_equals_string(result, example_contents(expected_example))
+end
+
+def html_equals_string(result, expected)
+  [expected, result].each do |value|
+    value.gsub!(/(>)\s+|\s+(<)/, '\1\2')
+    value.gsub!(/&#39;/, "'")
+    value.strip!
+  end
+  text_equals_string(result, expected)
+end
+
+def example_contents(filename, ext = 'html')
+  File.read(File.join(File.dirname(__FILE__), 'examples', "#{filename}.#{ext}"))
+end
+
+module YARD::Templates::Engine
+  class << self
+    public :find_template_paths
+  end
+end
+
+class TestHtmlTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :html
+  default_attr :highlight, false
+end
+
+class TestTextTemplateOptions < Templates::TemplateOptions
+  default_attr :markup, :none
+  default_attr :default_return, ""
+  default_attr :format, :text
+  default_attr :highlight, false
+end
+
+def html_options(opts = {})
+  template_options(opts, TestHtmlTemplateOptions)
+end
+
+def text_options(opts = {})
+  template_options(opts, TestTextTemplateOptions)
+end
+
+def template_options(opts, klass)
+  options = klass.new
+  options.reset_defaults
+  options.update(opts)
+  options
+end
+

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/templates/tag_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Engine.template(:default, :tags) do
+  before { Registry.clear }
+
+  describe 'all known tags' do
+    before do
+      YARD.parse_string <<-'eof'
+        # Comments
+        # @abstract override me
+        # @param [Hash] opts the options
+        # @option opts :key ('') hello
+        # @option opts :key2 (X) hello
+        # @return [String] the result
+        # @raise [Exception] Exception class
+        # @deprecated for great justice
+        # @see A
+        # @see http://url.com
+        # @see http://url.com Example
+        # @author Name
+        # @since 1.0
+        # @version 1.0
+        # @yield a block
+        # @yieldparam [String] a a value
+        # @yieldreturn [Hash] a hash
+        # @example Wash your car
+        #   car.wash
+        # @example To kill a mockingbird
+        #   a = String.new
+        #   flip(a.reverse)
+        def m(opts = {}) end
+      eof
+    end
+
+    it "should render text format correctly" do
+      text_equals(Registry.at('#m').format(text_options), :tag001)
+    end
+  end
+
+  describe 'param tags on non-methods' do
+    it 'should not display @param tags on non-method objects' do
+      YARD.parse_string <<-'eof'
+        # @param [#to_s] name the name
+        module Foo; end
+      eof
+
+      proc = lambda { Registry.at('Foo').format(html_options) }
+      proc.should_not raise_error(NoMethodError)
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/spec/templates/template_spec.rb

@@ -0,0 +1,409 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Templates::Template do
+  def template(path)
+    YARD::Templates::Engine.template!(path, '/full/path/' + path.to_s)
+  end
+
+  before :each do
+    YARD::Templates::ErbCache.clear!
+  end
+
+  describe '.include_parent' do
+    it "should not include parent directory if parent directory is a template root path" do
+      mod = template('q')
+      mod.should_not include(template(''))
+    end
+
+    it "should include overridden parent directory" do
+      Engine.stub!(:template_paths).and_return(['/foo', '/bar'])
+      File.should_receive(:directory?).with('/foo/a/b').and_return(true)
+      File.should_receive(:directory?).with('/bar/a/b').and_return(false)
+      File.should_receive(:directory?).with('/foo/a').at_least(1).times.and_return(true)
+      File.should_receive(:directory?).with('/bar/a').at_least(1).times.and_return(true)
+      ancestors = Engine.template('a/b').ancestors.map {|c| c.class_name }
+      ancestors[0, 3].should == %w( Template__foo_a_b Template__bar_a Template__foo_a )
+    end
+
+    it "should include parent directory template if exists" do
+      mod1 = template('x')
+      mod2 = template('x/y')
+      mod2.should include(mod1)
+    end
+  end
+
+  describe '.full_paths' do
+    it "should list full_path" do
+      mod = template(:a)
+      mod.full_paths.should == ['/full/path/a']
+    end
+
+    it "should list paths of included modules" do
+      mod = template(:a)
+      mod.send(:include, template(:b))
+      mod.full_paths.should == ['/full/path/a', '/full/path/b']
+    end
+
+    it "should list paths from modules of included modules" do
+      mod = template(:c)
+      mod.send(:include, template(:d))
+      mod.send(:include, template(:a))
+      mod.full_paths.should == ['c', 'a', 'b', 'd'].map {|o| '/full/path/' + o }
+    end
+
+    it "should only list full paths of modules that respond to full_paths" do
+      mod = template(:d)
+      mod.send(:include, Enumerable)
+      mod.full_paths.should == ['/full/path/d']
+    end
+  end
+
+  describe '.load_setup_rb' do
+    it "should load setup.rb file for module" do
+      File.should_receive(:file?).with('/full/path/e/setup.rb').and_return(true)
+      File.should_receive(:read).with('/full/path/e/setup.rb').and_return('def success; end')
+      template(:e).new.should respond_to(:success)
+    end
+  end
+
+  describe '.T' do
+    it "should load template from absolute path" do
+      mod = template(:a)
+      Engine.should_receive(:template).with('other')
+      mod.T('other')
+    end
+  end
+
+  describe '.find_file' do
+    it "should find file in module's full_path" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_file('basename').should == '/full/path/b/basename'
+    end
+
+    it "should return nil if no file is found" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(false)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(false)
+      template(:a).find_file('basename').should be_nil
+    end
+  end
+
+  describe '.find_nth_file' do
+    it "should find 2nd existing file in template paths" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_nth_file('basename', 2).should == '/full/path/b/basename'
+    end
+
+    it "should return nil if no file is found" do
+      File.should_receive(:file?).with('/full/path/a/basename').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/basename').and_return(true)
+      template(:a).find_nth_file('basename', 3).should be_nil
+    end
+  end
+
+  describe '.extra_includes' do
+    it "should be included when a module is initialized" do
+      module MyModule; end
+      Template.extra_includes << MyModule
+      template(:e).new.should be_kind_of(MyModule)
+    end
+
+    it "should support lambdas in list" do
+      module MyModule2; end
+      Template.extra_includes << lambda {|opts| MyModule2 if opts.format == :html }
+      template(:f).new(:format => :html).should be_kind_of(MyModule2)
+      metaclass = (class << template(:g).new(:format => :text); self end)
+      metaclass.ancestors.should_not include(MyModule2)
+    end
+  end
+
+  describe '.is_a?' do
+    it "should be kind of Template" do
+      template(:e).is_a?(Template).should == true
+    end
+  end
+
+  describe '#T' do
+    it "should delegate to class method" do
+      template(:e).should_receive(:T).with('test')
+      template(:e).new.T('test')
+    end
+  end
+
+  describe '#init' do
+    it "should be called during initialization" do
+      module YARD::Templates::Engine::Template__full_path_e
+        def init; sections 1, 2, 3 end
+      end
+      template(:e).new.sections.should == Section.new(nil, 1, 2, 3)
+    end
+  end
+
+  describe '#file' do
+    it "should read the file if it exists" do
+      File.should_receive(:file?).with('/full/path/e/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/e/abc').and_return('hello world')
+      template(:e).new.file('abc').should == 'hello world'
+    end
+
+    it "should raise ArgumentError if the file does not exist" do
+      File.should_receive(:file?).with('/full/path/e/abc').and_return(false)
+      lambda { template(:e).new.file('abc') }.should raise_error(ArgumentError)
+    end
+
+    it "should replace {{{__super__}}} with inherited template contents if allow_inherited=true" do
+      File.should_receive(:file?).with('/full/path/a/abc').twice.and_return(true)
+      File.should_receive(:file?).with('/full/path/b/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      IO.should_receive(:read).with('/full/path/b/abc').and_return('bar')
+      template(:a).new.file('abc', true).should == "foo bar"
+    end
+
+    it "should not replace {{{__super__}}} with inherited template contents if allow_inherited=false" do
+      File.should_receive(:file?).with('/full/path/a/abc').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/abc').and_return('foo {{{__super__}}}')
+      template(:a).new.file('abc').should == "foo {{{__super__}}}"
+    end
+  end
+
+  describe '#superb' do
+    it "should return the inherited erb template contents" do
+      File.should_receive(:file?).with('/full/path/a/test.erb').and_return(true)
+      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+      template = template(:a).new
+      template.section = :test
+      template.superb.should == "bar"
+    end
+
+    it "should work inside an erb template" do
+      File.should_receive(:file?).with('/full/path/a/test.erb').twice.and_return(true)
+      File.should_receive(:file?).with('/full/path/b/test.erb').and_return(true)
+      IO.should_receive(:read).with('/full/path/a/test.erb').and_return('foo<%= superb %>!')
+      IO.should_receive(:read).with('/full/path/b/test.erb').and_return('bar')
+      template = template(:a).new
+      template.section = :test
+      template.erb(:test).should == "foobar!"
+    end
+  end
+
+  describe '#sections' do
+    it "should allow sections to be set if arguments are provided" do
+      mod = template(:e).new
+      mod.sections 1, 2, [3]
+      mod.sections.should == Section.new(nil, 1, 2, [3])
+    end
+  end
+
+  describe '#run' do
+    it "should render all sections" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(Section.new(:a)).and_return('a')
+      mod.should_receive(:render_section).with(Section.new(:b)).and_return('b')
+      mod.should_receive(:render_section).with(Section.new(:c)).and_return('c')
+      mod.sections :a, :b, :c
+      mod.run.should == 'abc'
+    end
+
+    it "should render all sections with options" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(Section.new(:a)).and_return('a')
+      mod.should_receive(:add_options).with(:a => 1).and_yield
+      mod.sections :a
+      mod.run(:a => 1).should == 'a'
+    end
+
+    it "should run section list if provided" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(Section.new(:q))
+      mod.should_receive(:render_section).with(Section.new(:x))
+      mod.run({}, [:q, :x])
+    end
+
+    it "should accept a nil section as empty string" do
+      mod = template(:e).new
+      mod.should_receive(:render_section).with(Section.new(:a))
+      mod.sections :a
+      mod.run.should == ""
+    end
+  end
+
+  describe '#add_options' do
+    it "should set instance variables in addition to options" do
+      mod = template(:f).new
+      mod.send(:add_options, {:a => 1, :b => 2})
+      mod.options.should == {:a => 1, :b => 2}
+      mod.instance_variable_get("@a").should == 1
+      mod.instance_variable_get("@b").should == 2
+    end
+
+    it "should set instance variables and options only for the block" do
+      mod = template(:f).new
+      mod.send(:add_options, {:a => 100, :b => 200}) do
+        mod.options.should == {:a => 100, :b => 200}
+      end
+      mod.options.should_not == {:a => 100, :b => 200}
+    end
+  end
+
+  describe '#render_section' do
+    it "should call method if method exists by section name as Symbol" do
+      mod = template(:f).new
+      mod.should_receive(:respond_to?).with(:a).and_return(true)
+      mod.should_receive(:respond_to?).with('a').and_return(true)
+      mod.should_receive(:send).with(:a).and_return('a')
+      mod.should_receive(:send).with('a').and_return('a')
+      mod.run({}, [:a, 'a']).should == 'aa'
+    end
+
+    it "should call erb if no method exists by section name" do
+      mod = template(:f).new
+      mod.should_receive(:respond_to?).with(:a).and_return(false)
+      mod.should_receive(:respond_to?).with('a').and_return(false)
+      mod.should_receive(:erb).with(:a).and_return('a')
+      mod.should_receive(:erb).with('a').and_return('a')
+      mod.run({}, [:a, 'a']).should == 'aa'
+    end
+
+    it "should run a template if section is one" do
+      mod2 = template(:g)
+      mod2.should_receive(:run)
+      mod = template(:f).new
+      mod.sections mod2
+      mod.run
+    end
+
+    it "should run a template instance if section is one" do
+      mod2 = template(:g).new
+      mod2.should_receive(:run)
+      mod = template(:f).new
+      mod.sections mod2
+      mod.run
+    end
+  end
+
+  describe '#yield' do
+    it "should yield a subsection" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; "b" end
+        def c; "c" end
+      end
+
+      mod.run.should == "(b)"
+    end
+
+    it "should yield a subsection within a yielded subsection" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c]]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; yield end
+        def c; "c" end
+      end
+
+      mod.run.should == "(c)"
+    end
+
+    it "should support arbitrary nesting" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c, [:d, [:e]]]]
+      class << mod
+        def a; "(" + yield + ")" end
+        def b; yield end
+        def c; yield end
+        def d; yield end
+        def e; "e" end
+      end
+
+      mod.run.should == "(e)"
+    end
+
+    it "should yield first two elements if yield is called twice" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c, :d]
+      class << mod
+        def a; "(" + yield + yield + ")" end
+        def b; 'b' end
+        def c; "c" end
+      end
+
+      mod.run.should == "(bc)"
+    end
+
+    it "should ignore any subsections inside subsection yields" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:c], :d]
+      class << mod
+        def a; "(" + yield + yield + ")" end
+        def b; 'b' end
+        def d; "d" end
+      end
+
+      mod.run.should == "(bd)"
+    end
+
+    it "should allow extra options passed via yield" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "(" + yield(:x => "a") + ")" end
+        def b; options.x + @x end
+      end
+
+      mod.run.should == "(aa)"
+    end
+  end
+
+  describe '#yieldall' do
+    it "should yield all subsections" do
+      mod = template(:e).new
+      mod.sections :a, [:b, [:d, [:e]], :c]
+      class << mod
+        def a; "(" + yieldall + ")" end
+        def b; "b" + yieldall end
+        def c; "c" end
+        def d; 'd' + yieldall end
+        def e; 'e' end
+      end
+
+      mod.run.should == "(bdec)"
+    end
+
+    it "should yield options to all subsections" do
+      mod = template(:e).new
+      mod.sections :a, [:b, :c]
+      class << mod
+        def a; "(" + yieldall(:x => "2") + ")" end
+        def b; @x end
+        def c; @x end
+      end
+      mod.run.should == "(22)"
+    end
+
+    it "should yield all subsections more than once" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "(" + yieldall + yieldall + ")" end
+        def b; "b" end
+      end
+
+      mod.run.should == "(bb)"
+    end
+
+    it "should not yield if no yieldall is called" do
+      mod = template(:e).new
+      mod.sections :a, [:b]
+      class << mod
+        def a; "()" end
+        def b; "b" end
+      end
+
+      mod.run.should == "()"
+    end
+  end
+end