challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/class_condition_handler_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
+  before(:all) { parse_file :class_condition_handler_001, __FILE__ }
+
+  def verify_method(*names)
+    names.each {|name| Registry.at("A##{name}").should_not be_nil }
+    names.each {|name| Registry.at("A##{name}not").should be_nil }
+  end
+
+  def no_undoc_error(code)
+    lambda { StubbedSourceParser.parse_string(code) }.should_not raise_error
+  end
+
+  it "should parse all unless blocks for complex conditions" do
+    verify_method :g
+  end
+
+  it "should not parse conditionals inside methods" do
+    verify_method :h
+  end
+
+  it "should only parse then block if condition is literal value `true`" do
+    verify_method :p
+  end
+
+  it "should only parse then block if condition is literal integer != 0" do
+    verify_method :o
+  end
+
+  it "should invert block to parse for literal condition if it's an unless block" do
+    verify_method :e
+  end
+
+  it "should handle conditions such as 'defined? VALUE'" do
+    verify_method :j, :k
+  end
+
+  it "should parse all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
+
+  it "should only parse else block if condition is literal value `false`" do
+    verify_method :q
+  end
+
+  it "should only parse else block if condition is literal integer == 0" do
+    verify_method :n
+  end
+
+  it "should maintain visibility and scope state inside condition" do
+    Registry.at('A#m').visibility.should == :private
+    Registry.at('A#mnot').visibility.should == :private
+  end
+
+  it "should not fail on complex conditions" do
+    log.should_not_receive(:warn)
+    log.should_not_receive(:error)
+    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
+    no_undoc_error(<<-eof)
+      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
+        'String'
+      TEST
+    eof
+    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/class_handler_spec.rb

@@ -0,0 +1,246 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
+  before(:all) { parse_file :class_handler_001, __FILE__ }
+
+  it "should parse a class block with docstring" do
+    P("A").docstring.should == "Docstring"
+  end
+
+  it "should handle complex class names" do
+    P("A::B::C").should_not == nil
+  end
+
+  it "should handle the subclassing syntax" do
+    P("A::B::C").superclass.should == P(:String)
+    P("A::X").superclass.should == Registry.at("A::B::C")
+  end
+
+  it "should interpret class << self as a class level block" do
+    P("A.classmethod1").should_not == nil
+  end
+
+  it "should interpret class << ClassName as a class level block in ClassName's namespace" do
+    P("A::B::C.Hello").should be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "should make visibility public when parsing a block" do
+    P("A::B::C#method1").visibility.should == :public
+  end
+
+  it "should set superclass type to :class if it is a Proxy" do
+    P("A::B::C").superclass.type.should == :class
+  end
+
+  it "should look for a superclass before creating the class if it shares the same name" do
+    P('B::A').superclass.should == P('A')
+  end
+
+  it "should handle class definitions in the form ::ClassName" do
+    Registry.at("MyRootClass").should_not be_nil
+  end
+
+  it "should handle superclass as a constant-style method (camping style < R /path/)" do
+    P('Test1').superclass.should == P(:R)
+    P('Test2').superclass.should == P(:R)
+    P('Test6').superclass.should == P(:NotDelegateClass)
+  end
+
+  it "should handle superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
+    P('Test3').superclass.should == P(:Struct)
+    P('Test4').superclass.should == P(:OStruct)
+  end
+
+  it "should handle DelegateClass(CLASSNAME) superclass syntax" do
+    P('Test5').superclass.should == P(:Array)
+  end
+
+  it "should handle a superclass of the same name in the form ::ClassName" do
+    P('Q::Logger').superclass.should == P(:Logger)
+    P('Q::Foo').superclass.should_not == P('Q::Logger')
+  end
+
+  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
+    it "should raise an UndocumentableError for invalid class '#{klass}'" do
+      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
+    end
+  end
+
+  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
+    it "should raise an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
+      YARD::CodeObjects::ClassObject.should_receive(:new).with(Registry.root, 'A')
+      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
+      Registry.at('A').superclass.should == P(:Object)
+    end
+  end
+
+  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
+    it "should raise an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
+      with_parser(:ruby18) do
+        undoc_error <<-eof
+          CONST = #{klass}
+          class << CONST; end
+        eof
+      end
+      Registry.at(klass).should be_nil
+    end
+  end
+
+  it "should document 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
+    Registry.at('String.classmethod').should_not be_nil
+  end
+
+  it "should allow class << SomeRubyClass to create the class if it does not exist" do
+    Registry.at('Symbol.toString').should_not be_nil
+  end
+
+  it "should document 'class Exception' without running into superclass issues" do
+    Parser::SourceParser.parse_string <<-eof
+      class Exception
+      end
+    eof
+    Registry.at(:Exception).should_not be_nil
+  end
+
+  it "should document 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
+    Registry.at(:RT).should_not be_nil
+    Registry.at(:RT).superclass.should == P('XX::RT')
+  end
+
+  it "should not overwrite docstring with an empty one" do
+    Registry.at(:Zebra).docstring.should == "Docstring 2"
+  end
+
+  it "should turn 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
+    obj = Registry.at("Point")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:x, :y, :z].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+  end
+
+  it "should turn 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
+    obj = Registry.at("AnotherPoint")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+
+    Registry.at("XPoint").should be_nil
+  end
+
+  it "should create a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
+    obj = Registry.at("Struct::XPoint")
+    obj.should_not be_nil
+  end
+
+  it "should attach attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
+    obj = Registry.at("Struct::XPoint")
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+  end
+
+  it "should use @attr to set attribute descriptions on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#input")
+    obj.docstring.should == "the input stream"
+  end
+
+  it "should use @attr to set attribute types on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#someproc")
+    obj.should_not be_nil
+    obj.tag(:return).should_not be_nil
+    obj.tag(:return).types.should == ["Proc", "#call"]
+  end
+
+  it "should default types unspecified by @attr to Object on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#mode")
+    obj.should_not be_nil
+    obj.tag(:return).should_not be_nil
+    obj.tag(:return).types.should == ["Object"]
+  end
+
+  it "should create parameters for writers of Struct subclass's attributes" do
+    obj = Registry.at("DoccedStruct#input=")
+    obj.tags(:param).size.should == 1
+    obj.tag(:param).types.should == ["IO"]
+  end
+
+  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
+    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
+      it "defines both readers and writers when @attr is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:first][:read].should_not be_nil
+        attrs[:first][:write].should_not be_nil
+      end
+
+      it "defines only a reader when only @attr_reader is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:second][:read].should_not be_nil
+        attrs[:second][:write].should be_nil
+      end
+
+      it "defines only a writer when only @attr_writer is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:third][:read].should be_nil
+        attrs[:third][:write].should_not be_nil
+      end
+
+      it "defines a reader with correct return types when @attr_reader is used on Structs" do
+        obj = Registry.at("#{struct}#second")
+        obj.tag(:return).types.should == ["Fixnum"]
+      end
+
+      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
+        obj = Registry.at("#{struct}#third=")
+        obj.tag(:param).types.should == ["Array"]
+      end
+
+      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:fourth][:read].should_not be_nil
+        attrs[:fourth][:write].should_not be_nil
+      end
+
+      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth")
+        obj.tag(:return).types.should == ["#read"]
+      end
+
+      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth=")
+        obj.tag(:param).types.should == ["IO"]
+      end
+
+      it "extracts text from @attr_reader" do
+        Registry.at("#{struct}#fourth").docstring.should == "returns a proc that reads"
+      end
+
+      it "extracts text from @attr_writer" do
+        Registry.at("#{struct}#fourth=").docstring.should == "sets the proc that writes stuff"
+      end
+    end
+  end
+
+  it "should inherit from a regular struct" do
+    Registry.at('RegularStruct').superclass.should == P(:Struct)
+    Registry.at('RegularStruct2').superclass.should == P(:Struct)
+  end
+
+  it "should handle inheritance from 'self'" do
+    Registry.at('Outer1::Inner1').superclass.should == Registry.at('Outer1')
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/class_variable_handler_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
+  before(:all) { parse_file :class_variable_handler_001, __FILE__ }
+
+  it "should not parse class variables inside methods" do
+    obj = Registry.at("A::B::@@somevar")
+    obj.source.should == "@@somevar = \"hello\""
+    obj.value.should == '"hello"'
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/constant_handler_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
+  before(:all) { parse_file :constant_handler_001, __FILE__ }
+
+  it "should not parse constants inside methods" do
+    Registry.at("A::B::SOMECONSTANT").source.should == "SOMECONSTANT= \"hello\""
+  end
+
+  it "should only parse valid constants" do
+    Registry.at("A::B::notaconstant").should be_nil
+  end
+
+  it "should maintain newlines" do
+    Registry.at("A::B::MYCONSTANT").value.gsub("\r", "").should == "A +\nB +\nC +\nD"
+  end
+
+  it "should turn Const = Struct.new(:sym) into class Const with attr :sym" do
+    obj = Registry.at("MyClass")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+  end
+
+  it "should turn Const = Struct.new('Name', :sym) into class Const with attr :sym" do
+    obj = Registry.at("NotMyClass")
+    obj.should be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:b, :c].each do |key|
+      attrs.should have_key(key)
+      attrs[key][:read].should_not be_nil
+      attrs[key][:write].should_not be_nil
+    end
+
+    Registry.at("NotMyClass2").should be_nil
+  end
+
+  it "should turn Const = Struct.new into empty struct" do
+    obj = Registry.at("MyEmptyStruct")
+    obj.should_not be_nil
+    obj.attributes[:instance].should be_empty
+  end
+
+  it "should maintain docstrings on structs defined via constants" do
+    obj = Registry.at("DocstringStruct")
+    obj.should_not be_nil
+    obj.docstring.should == "A crazy struct."
+    obj.attributes[:instance].should_not be_empty
+    a1 = Registry.at("DocstringStruct#bar")
+    a2 = Registry.at("DocstringStruct#baz")
+    a1.docstring.should == "An attr"
+    a1.tag(:return).types.should == ["String"]
+    a2.docstring.should == "Another attr"
+    a2.tag(:return).types.should == ["Number"]
+  end
+
+  it "should raise undocumentable error in 1.9 parser for Struct.new assignment to non-const" do
+    undoc_error "nonconst = Struct.new"
+  end unless LEGACY_PARSER
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/dsl_handler_spec.rb

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'ostruct'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
+  before(:all) { parse_file :dsl_handler_001, __FILE__ }
+
+  it "should create a readable attribute when @!attribute r is found" do
+    obj = Registry.at('Foo#attr1')
+    obj.should_not be_nil
+    obj.should be_reader
+    obj.tag(:return).types.should == ['Numeric']
+    Registry.at('Foo#attr1=').should be_nil
+  end
+
+  it "should create a writable attribute when @!attribute w is found" do
+    obj = Registry.at('Foo#attr2=')
+    obj.should_not be_nil
+    obj.should be_writer
+    Registry.at('Foo#attr2').should be_nil
+  end
+
+  it "should default to readwrite @!attribute" do
+    obj = Registry.at('Foo#attr3')
+    obj.should_not be_nil
+    obj.should be_reader
+    obj = Registry.at('Foo#attr3=')
+    obj.should_not be_nil
+    obj.should be_writer
+  end
+
+  it "should allow @!attribute to define alternate method name" do
+    Registry.at('Foo#attr4').should be_nil
+    Registry.at('Foo#custom').should_not be_nil
+  end
+
+  it "should default to creating an instance method for any DSL method with special tags" do
+    obj = Registry.at('Foo#implicit0')
+    obj.should_not be_nil
+    obj.docstring.should == "IMPLICIT METHOD!"
+    obj.tag(:return).types.should == ['String']
+  end
+
+  it "should recognize implicit docstring when it has scope tag" do
+    obj = Registry.at("Foo.implicit1")
+    obj.should_not be_nil
+    obj.scope.should == :class
+  end
+
+  it "should recognize implicit docstring when it has visibility tag" do
+    obj = Registry.at("Foo#implicit2")
+    obj.should_not be_nil
+    obj.visibility.should == :protected
+  end
+
+  it "should not recognize implicit docstring with any other normal tag" do
+    obj = Registry.at('Foo#implicit_invalid3')
+    obj.should be_nil
+  end
+
+  it "should set the method name when using @!method" do
+    obj = Registry.at('Foo.xyz')
+    obj.should_not be_nil
+    obj.signature.should == 'def xyz(a, b, c)'
+    obj.parameters.should == [['a', nil], ['b', nil], ['c', nil]]
+    obj.source.should == 'foo_bar'
+    obj.docstring.should == 'The foo method'
+  end
+
+  it "should allow setting of @!scope" do
+    Registry.at('Foo.xyz').scope.should == :class
+  end
+
+  it "should create module function if @!scope is module" do
+    mod_c = Registry.at('Foo.modfunc1')
+    mod_i = Registry.at('Foo#modfunc1')
+    mod_c.scope.should == :class
+    mod_i.visibility.should == :private
+  end
+
+  it "should allow setting of @!visibility" do
+    Registry.at('Foo.xyz').visibility.should == :protected
+  end
+
+  it "should ignore DSL methods without tags" do
+    Registry.at('Foo#implicit_invalid').should be_nil
+  end
+
+  it "should accept a DSL method without tags if it has hash_flag (##)" do
+    Registry.at('Foo#implicit_valid').should_not be_nil
+    Registry.at('Foo#implicit_invalid2').should be_nil
+  end
+
+  it "should allow creation of macros" do
+    macro = CodeObjects::MacroObject.find('property')
+    macro.should_not be_nil
+    macro.should_not be_attached
+    macro.method_object.should be_nil
+  end
+
+  it "should handle macros with no parameters to expand" do
+    Registry.at('Foo#none').should_not be_nil
+    Registry.at('Baz#none').signature.should == 'def none(foo, bar)'
+  end
+
+  it "should expand $N on method definitions" do
+    Registry.at('Foo#regular_meth').docstring.should == 'a b c'
+  end
+
+  it "should apply new macro docstrings on new objects" do
+    obj = Registry.at('Foo#name')
+    obj.should_not be_nil
+    obj.source.should == 'property :name, String, :a, :b, :c'
+    obj.signature.should == 'def name(a, b, c)'
+    obj.docstring.should == 'A property that is awesome.'
+    obj.tag(:param).name.should == 'a'
+    obj.tag(:param).text.should == 'first parameter'
+    obj.tag(:return).types.should == ['String']
+    obj.tag(:return).text.should == 'the property name'
+  end
+
+  it "should allow reuse of named macros" do
+    obj = Registry.at('Foo#age')
+    obj.should_not be_nil
+    obj.source.should == 'property :age, Fixnum, :value'
+    obj.signature.should == 'def age(value)'
+    obj.docstring.should == 'A property that is awesome.'
+    obj.tag(:param).name.should == 'value'
+    obj.tag(:param).text.should == 'first parameter'
+    obj.tag(:return).types.should == ['Fixnum']
+    obj.tag(:return).text.should == 'the property age'
+  end
+
+  it "should know about method information on DSL with macro expansion" do
+    Registry.at('Foo#right_name').should_not be_nil
+    Registry.at('Foo#right_name').source.should ==
+      'implicit_with_different_method_name :wrong, :right'
+    Registry.at('Foo#wrong_name').should be_nil
+  end
+
+  it "should use attached macros" do
+    macro = CodeObjects::MacroObject.find('parser')
+    macro.macro_data.should == "@!method $1(opts = {})\n@return NOTHING!"
+    macro.should_not be_nil
+    macro.should be_attached
+    macro.method_object.should == P('Foo.parser')
+    obj = Registry.at('Foo#c_parser')
+    obj.should_not be_nil
+    obj.docstring.should == ""
+    obj.signature.should == "def c_parser(opts = {})"
+    obj.docstring.tag(:return).text.should == "NOTHING!"
+  end
+
+  it "should append docstring on DSL method to attached macro" do
+    obj = Registry.at('Foo#d_parser')
+    obj.should_not be_nil
+    obj.docstring.should == "Another docstring"
+    obj.signature.should == "def d_parser(opts = {})"
+    obj.docstring.tag(:return).text.should == "NOTHING!"
+  end
+
+  it "should only use attached macros on methods defined in inherited hierarchy" do
+    Registry.at('Bar#x_parser').should be_nil
+    Registry.at('Baz#y_parser').should_not be_nil
+  end
+
+  it "should look through mixins for attached macros" do
+    meth = Registry.at('Baz#mixin_method')
+    meth.should_not be_nil
+    meth.docstring.should == 'DSL method mixin_method'
+  end
+
+  it "should handle top-level DSL methods" do
+    obj = Registry.at('#my_other_method')
+    obj.should_not be_nil
+    obj.docstring.should == "Docstring for method"
+  end
+
+  it "should handle Constant.foo syntax" do
+    obj = Registry.at('#beep')
+    obj.should_not be_nil
+    obj.signature.should == 'def beep(a, b, c)'
+  end
+
+  it "should expand attached macros in first DSL method" do
+    Registry.at('DSLMethods#foo').docstring.should == "Returns String for foo"
+    Registry.at('DSLMethods#bar').docstring.should == "Returns Integer for bar"
+  end
+
+  it "should not detect implicit macros with invalid method names" do
+    undoc_error <<-eof
+      ##
+      # IMPLICIT METHOD THAT SHOULD
+      # NOT BE DETECTED
+      dsl_method '/foo/bar'
+    eof
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/examples/alias_handler_001.rb.txt

@@ -0,0 +1,44 @@
+module A
+  def a; end
+  alias_method :b, :a
+
+  # Handle keyword syntax too
+  alias :c :a
+  alias d? a
+  alias [] a
+  alias []= a
+  alias -@ a
+  alias % a
+  alias * a
+  alias for a
+  alias ConstantName a
+
+  # Handle quoted symbols
+  alias :'foo' :'a'
+end
+
+class C
+  def x; end
+end
+
+class B < C
+  alias_method(:q, :x)
+  alias_method :r?, :x
+  alias_method :s, :to_s
+  alias_method :t, :inspect if 500 == 3 * CONSTANT
+  alias_method :<<, :a
+  alias_method :for, :a
+  alias do x
+  alias x2 do
+end
+
+class D
+  # Foo bar
+  def a; "FOO" end
+
+  # @return [String]
+  alias b a
+
+  # @return [Numeric]
+  def a; 0 end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/handlers/examples/attribute_handler_001.rb.txt

@@ -0,0 +1,32 @@
+module A
+  attr_writer :x
+end
+
+class B
+  class << self
+    attr_accessor :z
+  end
+
+  attr :a, true
+  attr :a2, false
+  attr :a3
+  # Docstring
+  attr_reader :b, :c, :d
+  attr_writer :e
+  attr_accessor 'f'
+
+  attr_accessor :z
+end
+
+class C
+  def foo; end
+  attr_writer :foo
+
+  def bar=(value); end
+  attr_reader :bar
+end
+
+class D
+protected
+attr_reader :parser
+end