docjs 0.1

data/templates/views/tokens/_default.html.erb

@@ -0,0 +1,11 @@
+<%
+
+  opts = tokens.first.html
+  opts[:class] = (opts[:class] || "") + " subsection"
+%>
+<section <%= attributize opts %>>
+  <%= tag :h3, tokens.first %>
+  <ul>
+    <%= render :partial => 'tokens/default_token', :collection => tokens %>
+  </ul>
+</section>

data/templates/views/tokens/_default_token.html.erb

@@ -0,0 +1,19 @@
+<li>
+  <% unless default_token.name.nil? %>
+    <h4><%= default_token.name %></h4>
+  <% end %>
+
+  <% unless default_token.children.nil? %>
+    <ul>
+      <%= render :partial => 'tokens/default_token', :collection => default_token.children %>
+    </ul>  
+    
+  <% else %>
+    
+    <% unless default_token.types.nil? %>
+      (<span class="types"><%= default_token.types.map {|t| link_to(t) }.join ', ' %></span>)
+    <% end %>
+    <%= replace_links to_html default_token.content %>
+  
+  <% end %>
+</li>  

data/templates/views/tokens/_example.html.erb

@@ -0,0 +1,2 @@
+<h3>Example <%= example.name %></h3>
+<%=code example.content %>

data/templates/views/tokens/_examples.html.erb

@@ -0,0 +1 @@
+<%= render :partial => 'tokens/example', :collection => tokens %>

data/test/code_object/converter.rb

@@ -0,0 +1,78 @@
+# ../data.img#1785915:1
+require_relative '../../lib/parser/comment'
+
+describe CodeObject::Converter, "#to_code_object" do
+
+  before :each do
+    @comment = Parser::Comment.new
+  end
+
+  context "comment with function-token" do
+  
+    before do      
+      @comment.add_tokenline :function, "foo"
+    end
+    
+    describe "the result" do
+      
+      subject { @comment.to_code_object }
+      
+      it "should be a CodeObject::Function" do
+        subject.class.should == CodeObject::Function
+      end
+      
+    end 
+  end
+
+  context "comment with object-token" do
+  
+    before do      
+      @comment.add_tokenline "object", "bar"
+    end
+    
+    describe "the result" do
+      
+      subject { @comment.to_code_object }
+      
+      it "should be a CodeObject::Object" do
+        subject.class.should == CodeObject::Object
+        subject.name.should == "bar"
+      end
+      
+    end 
+  end
+  
+  context "comment with unknown token" do
+  
+    before do      
+      @comment.add_tokenline "some_unkown_token", "bar"
+    end    
+    
+    it "should not create a CodeObject" do
+      @comment.to_code_object.should == nil
+    end
+  end
+  
+  context "comment with no tokens" do
+      
+    it "should not create a CodeObject" do
+      @comment.to_code_object.should == nil
+    end
+    
+  end
+  
+  context "comment with multiple tokens" do
+      
+    before do
+      @comment.add_tokenline "function", "foobar"
+      @comment.add_tokenline "object", "baz"
+    end
+      
+    it "should raise an error" do
+      should_raise CodeObject::MultipleTypeDeclarations do 
+        @comment.to_code_object
+      end
+    end
+    
+  end
+end

data/test/code_object/prototype.rb

@@ -0,0 +1,70 @@
+# ../data.img#1774507:1
+require_relative '../../lib/boot'
+
+describe CodeObject::Prototype, ".new" do
+
+  context "Parsing prototype.js" do
+    
+    before do
+      Logger.setup :level => :warn
+    
+      Dom.clear
+      Processor.process_files_to_dom File.expand_path('../../js-files/prototype.js', __FILE__)
+    end
+    
+    describe "the constructor-function" do    
+      
+      subject { Dom[:Person] }
+      
+      it "should be a CodeObject::Function" do
+        subject.is_a?(CodeObject::Function).should == true
+      end
+      
+      it "should have a children, called 'prototype'" do
+        subject[:prototype].should == subject.prototype
+        subject[:prototype].nil?.should == false
+      end
+      
+      it "should be flagged as constructor" do
+        subject.constructor?.should == true
+      end
+      
+      it "should contain only one child" do
+        subject.children.length.should == 1
+      end
+      
+    end
+
+
+    describe "the prototype-object" do    
+      
+      subject { Dom[:Person][:prototype] }
+      
+      it "should be a CodeObject::Prototype" do
+        subject.is_a?(CodeObject::Prototype).should == true
+      end
+      
+      it "should have Person as parent" do
+        subject.parent.should == Dom[:Person]
+        subject.constructor.should == subject.parent
+        subject.constructor.nil?.should == false
+      end
+            
+      it "should contain only one child" do
+        subject.children.length.should == 1
+      end
+    end
+    
+    
+    describe "the child of the prototype" do
+      
+      subject { Dom[:Person][:prototype][:sayHello] }
+      
+      it "should be a function" do
+        subject.is_a?(CodeObject::Function).should == true
+      end    
+    end
+    
+  end 
+  
+end

data/test/configs.rb

@@ -0,0 +1,65 @@
+# ../data.img#1818355:1
+require_relative '../lib/configs.rb'
+
+describe Configs, ".new" do  
+  it "should throw an error, when trying to instantiate" do
+    begin
+      Configs.new.should == nil
+    rescue NoMethodError
+      # Maybe there is a better way for this
+      true.should == true
+    end
+  end    
+end
+
+describe Configs, ".set" do
+  
+  before do
+    Configs.clear
+  end
+  
+  context "adding a single property" do
+          
+    it "should be added as a symbol" do
+      Configs.set :foo, 1234      
+      Configs.foo.should == 1234
+    end
+    
+    it "should be added as a string" do
+      Configs.set "bar", 1234      
+      Configs.bar.should == 1234
+    end
+    
+    it "should overwrite existing keys" do
+      Configs.set :foo, 456      
+      Configs.foo.should == 456
+    end
+  end
+  
+  it "should add multiple properties" do 
+    Configs.set :prop1 => 1,
+                :prop2 => 2,
+                :prop3 => 3
+                
+    Configs.prop1.should == 1
+    Configs.prop2.should == 2
+    Configs.prop3.should == 3
+  end
+  
+  it "should return nil when trying to access not existing property" do
+    Configs.prop99.should == nil
+  end
+end
+
+describe Configs, ".clear" do
+
+  it "should contain no items after clearing" do
+    Configs.set :foo => 4,
+                :bar => 5 
+    
+    Configs.clear
+      
+    Configs.foo.should == nil
+    Configs.bar.should == nil
+  end
+end

data/test/docs/README.CONCEPT.md

@@ -0,0 +1,83 @@
+Concept of the Documententation
+===============================
+
+There are only two build-in types, we want to pay attention to:
+
+  1. Objects
+  2. Functions
+  
+  
+Object
+------
+By **Objects** we mean all kind of *things*, that can contain other things. Those containted ones, we call **properties** of the Object.
+
+In JavaScript this may look like:
+
+    var obj = {
+      property_one: function() { ... },
+      property_two: {
+        // another object
+      },
+      property_three: 3
+    }
+
+
+Function
+--------
+**Functions** are *things*, that can be executed. They can have **parameters** and **return-values** There are two types of Functions: plain functions and **constructors**.
+
+Example for a plain function:
+
+    function my_func(param) {
+      return "Hello world!";
+    }
+
+Example for a function as a constructor
+
+    function my_constructor() {
+      this.message = "Hello world!";    
+    }
+
+
+  Remember: any return-value of a constructor-function will be ignored and replaced by this
+
+### Some third Headline ##
+
+But a function can be an object at the same time. For example:
+
+    function my_func_two() {
+      return "fancy function";    
+    }
+    my_func_two.message = "Say hello to Mr. Foo";
+
+Most important a function can contain one special property **prototype**.
+Linktest: {Core.logger The logger} and another doc-link: {doc:README.CONCEPT}
+
+  Remember: In this case the function has to be a constructor. Otherwise prototype would be useless, because it is only used when creating instances of the function using new. After creating an instance the prototype-object is accessible in the this-context of the instance.
+
+    function my_constructor() {
+      this.message = "Hello world!";    
+    }
+    my_constructor.prop1 = 456;
+    my_constructor.prototype = {
+      some_proto_prop: 123
+    }
+
+Revealing Module Pattern
+------------------------
+But what about revealing modules?
+
+    function my_module() {
+
+      // some private stuff here
+
+      return {
+        property_of_the: "returned object"
+      };    
+    }
+
+One should pay attention to this pattern while creating a documentation tool.
+
+Conclusion
+----------
+So we can break it down to Functions and Objects. Objects can have properties. Functions can, at the same time, be Objects. There are special functions, called *constructors*, which in turn have one special property called *prototype*. This property has to be handled special in documentation.

data/test/docs/README.md

@@ -0,0 +1,14 @@
+jsdoc
+=====
+After total dataloss i have to rewrite the Readme's and Test's, so please be patient.
+jsdoc is currently **not a bit** stable. Stay tuned. {doc:README.CONCEPT#Function} oder {doc:README}
+
+For some more information about the architecture see:
+
+  - {Core Kern}  
+  - {CodeObject}
+  - {Token}
+  - {Dom}  
+  - {Renderer}
+  
+The 'executable' is {JsDoc}

data/test/dom/dom.absolute_nodes.rb

@@ -0,0 +1,40 @@
+require_relative '../../lib/dom/dom'
+require_relative '../../lib/code_object/function'
+require_relative '../../lib/processor'
+
+describe Dom, ".add_child" do
+  
+  context "Parsing absolute.js" do
+    
+    before do 
+      Dom.clear             
+      Processor.process_files_to_dom File.expand_path('../../js-files/absolute.js', __FILE__)
+    end
+    
+    it "should find only one root-object" do
+      Dom.children.length.should == 1
+    end
+    
+    describe "Object 'Person'" do
+    
+      subject { Dom[:Person] }
+    
+      it "should have one child 'config'" do
+        subject[:config].nil?.should == false
+      end
+    
+    end
+    
+    describe "Object 'config'" do
+    
+      subject { Dom[:Person][:config] }
+    
+      it "should have 'Person' as parent" do
+        subject.parent.should == Dom[:Person]
+      end
+    
+    end
+  
+  end 
+
+end

data/test/dom/dom.rb

@@ -0,0 +1,72 @@
+# ../data.img#1811393:1
+require_relative '../../lib/dom/dom'
+require_relative '../../lib/code_object/function'
+
+describe Dom, ".add_child" do
+
+  before do
+    Dom.clear
+    @o1 = CodeObject::Object.new
+    @o2 = CodeObject::Object.new
+  end
+  
+  it "should add absolute nodes" do
+    Dom.add_node "Foo", @o1
+    Dom[:Foo].should == @o1
+  end
+  
+  it "should add absolute nodes from node" do
+    @o1.add_node "Foo", @o2
+    Dom[:Foo].should == @o2
+  end
+  
+  it "should insert missing nodes as NoDoc" do
+    Dom.add_node "Foo.bar.baz.bam", @o1
+    Dom[:Foo].class.should == Dom::NoDoc
+    Dom[:Foo][:bar].class.should == Dom::NoDoc
+    Dom[:Foo][:bar][:baz].class.should == Dom::NoDoc
+    Dom[:Foo][:bar][:baz][:bam].should == @o1
+  end
+  
+  it "should replace NoDoc-leafs with nodes" do
+    Dom.add_node "Foo.bar.baz.bam", @o1
+    Dom.add_node "Foo.bar.baz", @o2
+    Dom[:Foo].class.should == Dom::NoDoc
+    Dom[:Foo][:bar].class.should == Dom::NoDoc
+    Dom[:Foo][:bar][:baz].should == @o2
+    Dom[:Foo][:bar][:baz][:bam].should == @o1
+  end
+  
+  it "should not allow replacing existing node" do
+    Dom.add_node "Foo.bar.baz.bam", @o1
+    
+    should_raise Dom::NodeAlreadyExists do
+      Dom.add_node "Foo.bar.baz.bam", @o2
+    end
+  end
+  
+  it "should reject not wellformed paths" do    
+    [ "Foo..bar.baz.bam",
+      "-foo.bar-baz.foo",
+      ""
+    ].each do |path|
+      should_raise Dom::WrongPath do
+        Dom.add_node path, @o2
+      end
+    end
+  end
+  
+  it "should set correct parent, while rebuilding" do
+    Dom.add_node "Foo.bar.baz.bam", @o1
+    Dom.add_node "Foo.bar.baz", @o2
+    
+    @o1.parent.should == @o2
+  end  
+  
+  it "should append relative paths to current object" do
+    Dom.add_node "Foo.bar", @o1    
+    @o1.add_node ".poo", @o2
+    
+    Dom[:Foo][:bar][:poo].should == @o2    
+  end
+end