Turn @SInCE & @new to builtin Tag classes.

For now I'm leaving out the tooltip text implementation for
the @new tag - needs some further refactoring.

Rakefile

@@ -257,6 +257,8 @@ task :sdk => :sass do
     "--output", OUT_DIR,
     "--config", "#{SDK_DIR}/extjs/docs/config.json",
     "--examples-base-url", "extjs-build/examples/",
+    # "--import", "4.1:../docs.sencha.com/exports/extjs-4.1.1",
+    # "--import", "4.2",
     "--seo"
   )
   runner.add_debug

lib/jsduck/builtins/new.rb

@@ -0,0 +1,23 @@
+require "jsduck/builtins/boolean_tag"
+
+module JsDuck::Builtins
+  class New < BooleanTag
+    def initialize
+      @key = :new
+      @signature = {:long => "&#9733;", :short => "&#9733;"} # unicode black star char
+    end
+
+    # Initializes the tooltip text.
+    #
+    # FIXME: Copy-pasted code from old Boolean tag class, doesn't
+    # currently work as it's never called.
+    def create_tooltip!(imports, new_since)
+      if new_since
+        @signature[:tooltip] = "New since #{new_since}"
+      elsif imports.length > 0
+        @signature[:tooltip] = "New since #{imports.last[:version]}"
+      end
+    end
+
+  end
+end

lib/jsduck/builtins/since.rb

@@ -0,0 +1,32 @@
+require "jsduck/builtins/tag"
+require "jsduck/logger"
+
+module JsDuck::Builtins
+  class Since < Tag
+    def initialize
+      @pattern = "since"
+      @key = :since
+      @html_position = :bottom
+    end
+
+    def parse(p)
+      p.add_tag(:since)
+      p.skip_horiz_white
+      p.current_tag[:version] = p.match(/.*$/).strip
+    end
+
+    def process_doc(tags)
+      if tags.length > 1
+        JsDuck::Logger.warn(nil, "Only one @since tag allowed per class/member.")
+      end
+      tags[0][:version]
+    end
+
+    def to_html(context)
+      <<-EOHTML
+        <p>Available since: <b>#{context[:since]}</b></p>
+      EOHTML
+    end
+
+  end
+end

lib/jsduck/categories_class_name.rb

@@ -25,7 +25,7 @@ def render(name)
 
     # Adds small star to new classes in the current version.
     def render_new_label(cls)
-      if cls[:meta][:new]
+      if cls[:new]
         "&nbsp;<span class='new-class' title='New class'>#{stars(1)}</span>"
       else
         n = new_members_count(cls)
@@ -53,7 +53,7 @@ def stars(n)
 
     # Returns number of new members the class has in the current version
     def new_members_count(cls)
-      cls.find_members(:local => true).find_all {|m| m[:meta][:new] && !m[:private] }.length
+      cls.find_members(:local => true).find_all {|m| m[:new] && !m[:private] }.length
     end
 
   end

lib/jsduck/importer.rb

@@ -64,14 +64,14 @@ def generate_since_tags(versions, relations, new_since=nil)
       new_versions = build_new_versions_map(versions, new_since)
 
       relations.each do |cls|
-        v = cls[:meta][:since] || class_since(versions, cls)
-        cls[:meta][:since] = v
-        cls[:meta][:new] = true if new_versions[v]
+        v = cls[:since] || class_since(versions, cls)
+        cls[:since] = v
+        cls[:new] = true if new_versions[v]
 
         cls.all_local_members.each do |m|
-          v = m[:meta][:since] || member_since(versions, cls, m)
-          m[:meta][:since] = v
-          m[:meta][:new] = true if new_versions[v]
+          v = m[:since] || member_since(versions, cls, m)
+          m[:since] = v
+          m[:new] = true if new_versions[v]
         end
       end
     end

lib/jsduck/options.rb

@@ -150,7 +150,6 @@ def parse!(argv)
 
       reg = MetaTagRegistry.new
       reg.load([:builtins] + @meta_tag_paths)
-      reg[:new].create_tooltip!(@imports, @new_since)
       MetaTagRegistry.instance = reg
     end
 

spec/importer_spec.rb

@@ -24,28 +24,28 @@
     ]
 
     @relations = [
-      {:name => "VeryOldClass", :meta => {}, :alternateClassNames => [], :members => [
-          {:tagname => :cfg, :id => "cfg-foo", :meta => {}},
-          {:tagname => :cfg, :id => "cfg-bar", :meta => {}},
-          {:tagname => :cfg, :id => "cfg-baz", :meta => {}},
-          {:tagname => :cfg, :id => "cfg-zap", :meta => {:since => "1.0"}},
-          {:tagname => :cfg, :id => "cfg-new", :meta => {:new => true}},
+      {:name => "VeryOldClass", :alternateClassNames => [], :members => [
+          {:tagname => :cfg, :id => "cfg-foo"},
+          {:tagname => :cfg, :id => "cfg-bar"},
+          {:tagname => :cfg, :id => "cfg-baz"},
+          {:tagname => :cfg, :id => "cfg-zap", :since => "1.0"},
+          {:tagname => :cfg, :id => "cfg-new", :new => true},
         ]},
-      {:name => "OldClass", :meta => {}, :alternateClassNames => []},
-      {:name => "NewClass", :meta => {}, :alternateClassNames => []},
-      {:name => "ClassWithNewName", :meta => {}, :alternateClassNames => ["ClassWithOldName"]},
-      {:name => "ExplicitSinceClass", :meta => {:since => "1.0"}, :alternateClassNames => []},
-      {:name => "ExplicitNewClass", :meta => {:new => true}, :alternateClassNames => []},
+      {:name => "OldClass", :alternateClassNames => []},
+      {:name => "NewClass", :alternateClassNames => []},
+      {:name => "ClassWithNewName", :alternateClassNames => ["ClassWithOldName"]},
+      {:name => "ExplicitSinceClass", :since => "1.0", :alternateClassNames => []},
+      {:name => "ExplicitNewClass", :new => true, :alternateClassNames => []},
     ].map {|cfg| JsDuck::Class.new(cfg) }
 
     JsDuck::Importer.generate_since_tags(@versions, @relations)
 
     # build className/member index for easy lookup in specs
     @stuff = {}
     @relations.each do |cls|
-      @stuff[cls[:name]] = cls[:meta]
+      @stuff[cls[:name]] = cls
       cls[:members].each do |cfg|
-        @stuff[cls[:name]+"#"+cfg[:id]] = cfg[:meta]
+        @stuff[cls[:name]+"#"+cfg[:id]] = cfg
       end
     end
   end
@@ -159,9 +159,9 @@
     ]
 
     @relations = [
-      {:name => "VeryOldClass", :meta => {}, :alternateClassNames => []},
-      {:name => "OldClass", :meta => {}, :alternateClassNames => []},
-      {:name => "NewClass", :meta => {}, :alternateClassNames => []},
+      {:name => "VeryOldClass", :alternateClassNames => []},
+      {:name => "OldClass", :alternateClassNames => []},
+      {:name => "NewClass", :alternateClassNames => []},
     ].map {|cfg| JsDuck::Class.new(cfg) }
 
     JsDuck::Importer.generate_since_tags(@versions, @relations, "2.0")
@@ -170,14 +170,14 @@
   # @since
 
   it "gives no @new to VeryOldClass" do
-    @relations[0][:meta][:new].should_not == true
+    @relations[0][:new].should_not == true
   end
 
   it "gives @new to OldClass" do
-    @relations[1][:meta][:new].should == true
+    @relations[1][:new].should == true
   end
 
   it "gives no @new to NewClass" do
-    @relations[2][:meta][:new].should == true
+    @relations[2][:new].should == true
   end
 end