yard-go 0.5.0

data/lib/yard-go/parser.rb

@@ -0,0 +1,194 @@
+require 'json'
+
+module YARDGo
+  module Parser
+    class Statement < OpenStruct
+      def to_s; source end
+    end
+
+    class Go < YARD::Parser::Base
+      include YARD
+      include YARD::CodeObjects
+
+      @@matches = {
+        comment: %r{^\s*//(.*)},
+        package: /^package (\w+)/,
+        function: /^func (\w+)\((.*?)\)(.*?)\{/,
+        struct: /^type (\w+) struct\s+\{/,
+        interface: /^type (\w+) interface\s+\{/,
+        method: /^func \(\w+\s+\*?(.+?)\) (\w+)\((.*?)\)(.*)\{/,
+        close_brace: /^\}/,
+        close_paren: /^\)/,
+        single_var: /^(var|const)\s+(.+?)\s*=\s*(.+)/,
+        multi_var: /^(var|const)\s*\(/
+      }
+
+      def tokenize; [] end
+      def enumerator; @ast end
+
+      attr_reader :file
+
+      def initialize(source, file)
+        YARD::CodeObjects.send(:remove_const, :NSEP)
+        YARD::CodeObjects.const_set(:NSEP, '/')
+        YARD::CodeObjects.send(:remove_const, :NSEPQ)
+        YARD::CodeObjects.const_set(:NSEPQ, '/')
+        YARD::CodeObjects.send(:remove_const, :ISEP)
+        YARD::CodeObjects.const_set(:ISEP, '.')
+        YARD::CodeObjects.send(:remove_const, :ISEPQ)
+        YARD::CodeObjects.const_set(:ISEPQ, '.')
+        @lines = source.split(/\r?\n/)
+        @file = file
+        @svc_docs = {}
+        @ast = []
+        @structs = {}
+        @lineno = 0
+      end
+
+      def parse
+        clear_comments
+        consume_until do
+          case line
+          when @@matches[:comment]
+            add_comment($1)
+
+          when @@matches[:package]
+            @ast << s(:package, package_name: $1)
+
+          when @@matches[:function]
+            t = s(:function, name: $1, args: $2, ret: $3)
+            attach_source(t)
+            @ast << t
+
+          when @@matches[:struct]
+            t = init_struct($1)
+            consume_fields(t)
+
+          when @@matches[:interface]
+            t = s(:interface, name: $1, fields: [])
+            consume_fields(t)
+            @ast << t
+
+          when @@matches[:method]
+            t = init_struct($1)
+            m = s(:method, type: $1, name: $2, args: $3, ret: $4)
+            attach_source(m)
+            t.meths.push(m)
+
+          when @@matches[:single_var]
+            type, lhs, src = $1.to_sym, $2, [$3]
+            name, vartype = *lhs.split(/\s+/)
+            
+            @lineno += 1
+            consume_until %r{^(\w|\/\/)} do
+              src << line
+            end
+            @lineno -= 1
+
+            @ast << s(type, name: name, vartype: vartype, value: src.join("\n"))
+
+          when @@matches[:multi_var]
+            type = $1.to_sym
+            clear_comments
+
+            @lineno += 1
+            consume_until @@matches[:close_paren] do
+              case line
+              when @@matches[:comment]
+                add_comment($1)
+              when /^(\s*)(.+?)\s*=\s*(.+)/m
+                mindent, lhs, src = $1.length, $2, [$3]
+                name, vartype = *lhs.split(/\s+/)
+                
+                @lineno += 1
+                consume_until @@matches[:close_paren] do
+                  indent = (line[/^(\s+)/, 1] || "").length
+                  break if indent < mindent
+                  break if indent == mindent && line =~ /^\s+(\w|\/\/)/
+                  src << line
+                end
+                @lineno -= 1
+
+                @ast << s(type, name: name, vartype: vartype, value: src.join("\n"))
+              end
+            end
+
+          else
+            if @comments.size > 0
+              @ast << s(:comment)
+            else
+              clear_comments
+            end
+          end
+        end
+
+        @ast += @structs.values
+
+        self
+      end
+
+      private
+
+      def init_struct(name)
+        @structs[name] ||= s(:struct, name: name, fields: [], meths: [])
+      end
+
+      def consume_fields(t)
+        @lineno += 1
+        consume_until @@matches[:close_brace] do
+          case line
+          when @@matches[:comment]
+            add_comment($1)
+          when /^\s*\*?([\w\.]+)\s*(?:`(.+?)`)?\s*$/
+            path, tags = $1, $2
+            name = path.split('.').last
+            t.fields.push(s(:composition, name: name, path: path, tags: tags))
+          when /^\s*(\w+)(\(.*?\))\s*(.*)?\s*(?:`(.+?)`)?\s*$/
+            t.fields.push(s(:fieldfn, name: $1, args: $3, ret: $4, tags: $5))
+          when /^\s*(\w+)\s*(\S+)\s*(?:`(.+?)`)?\s*$/
+            t.fields.push(s(:field, name: $1, field_type: $2, tags: $3))
+          else
+            clear_comments
+          end
+        end
+      end
+
+      def s(type, opts = {})
+        options = {source: line}.merge(opts)
+        c = @comments.join("\n")
+        c = c.gsub(/(\n[ \t]*\n[ \t]*\n)(.+\n\n)/, '\1## \2')
+        clear_comments
+        Statement.new(options.merge(type: type.to_sym, comments: c, line: @lineno))
+      end
+
+      def line
+        @lines[@lineno]
+      end
+
+      def clear_comments
+        @comments = []
+      end
+
+      def add_comment(match)
+        @comments.push(match.sub(/^ /, ''))
+      end
+
+      def consume_until(re = nil, &block)
+        while @lineno < @lines.size
+          break if re && line =~ re
+          yield
+          @lineno += 1
+        end
+      end
+
+      def attach_source(t)
+        src = []
+        consume_until @@matches[:close_brace] do
+          src << line
+        end
+        src << line
+        t.source = src.join("\n")
+      end
+    end
+  end
+end

data/lib/yard-go/version.rb

@@ -0,0 +1,3 @@
+module YARDGo
+  VERSION = "0.5.0"
+end

data/templates/default/bare_struct/html/fields.erb

@@ -0,0 +1,15 @@
+<div class="tags">
+<p class="tag_title">Structure Fields:</p>
+<dl class="fields">
+<% @fields.sort_by {|m| m.tag(:gotags) && m.tag(:gotags).text =~ /required:"true"/ ? -1 : 1 }.each do |m| %>
+  <dt><code>
+    <strong><%= m.name %></strong> <%= signature_types m %> 
+    <% if m.tag(:gotags) && m.tag(:gotags).text =~ /required:"true"/ %><span class="note title readonly">required</span><% end %>
+  </code></dt>
+  <dd><%= htmlify m.docstring %></dd>
+<% end %>
+<% if @fields.size == 0 %>
+  <dt><em>(empty struct)</em></dt>
+<% end %>
+</dl>
+</div>

data/templates/default/bare_struct/html/inherited_fields.erb

@@ -0,0 +1,15 @@
+<% found_method = false %>
+<% object.inheritance_tree(true)[1..-1].each do |superclass| %>
+  <% next if superclass.is_a?(YARD::CodeObjects::Proxy) %>
+  <% next if options.embed_mixins.size > 0 && options.embed_mixins_match?(superclass) != false %>
+  <% meths = superclass.children.select {|c| c.type == :field } %>
+  <% next if meths.size == 0 %>
+  <% if method_listing.size == 0 && !found_method %><h2>Method Summary</h2><% end %>
+  <% found_method = true %>
+  <h3 class="inherited">Fields <%= superclass.type == :class ? 'inherited' : 'included' %> from <%= linkify superclass %></h3>
+  <p class="inherited"><%=
+    meths.sort_by {|o| o.name.to_s }.map do |m|
+      linkify(m)
+    end.join(", ")
+  %></p>
+<% end %>

data/templates/default/bare_struct/html/method_signature.erb

@@ -0,0 +1,18 @@
+<h3 class="signature <%= 'first' if @index == 0 %>" id="<%= anchor_for(object) %>">
+  <% if object.tags(:overload).size == 1 %>
+    <%= signature(object.tag(:overload), false) %>
+  <% elsif object.tags(:overload).size > 1 %>
+    <% object.tags(:overload).each do |overload| %>
+      <span class="overload"><%= signature(overload, false) %></span>
+    <% end %>
+  <% else %>
+    <%= signature(object, false) %>
+  <% end %>
+
+  <% if owner != object.namespace %>
+    <span class="not_defined_here">
+      Originally defined in <%= object.namespace.type %>
+        <%= linkify object, owner.relative_path(object.namespace) %>
+    </span>
+  <% end %>
+</h3>

data/templates/default/bare_struct/html/setup.rb

@@ -0,0 +1,11 @@
+include T('default/method_details/html')
+
+def init
+  super
+  sections.last.push(:fields, [T('docstring')], :inherited_fields)
+end
+
+def fields
+  @fields = object.children.select {|t| t.type == :field }
+  erb(:fields)
+end

data/templates/default/field/html/method_signature.erb

@@ -0,0 +1,4 @@
+<h3 class="signature <%= 'first' if @index == 0 %>" id="<%= anchor_for(object) %>">
+  <%= signature(object, false) %> 
+  <% if object.tag(:gotags).text && !object.tag(:gotags).text.empty? %><code>`<%= object.tag(:gotags).text %>`</code><% end %>
+</h3>

data/templates/default/field/html/setup.rb

@@ -0,0 +1 @@
+include T('default/method_details/html')

data/templates/default/fulldoc/html/css/common.css

@@ -0,0 +1,33 @@
+#content .tags dl.fields { margin-left: 30px; }
+#content .inline-objects p.children { line-height: 2.4em; }
+#content .inline-objects p.children .object_link a {
+  font-family: monospace;
+  padding: 5px 7px;
+  padding-right: 4px;
+  margin-right: 5px;
+  background: #f8f8f8;
+  border: 1px solid #f0f0f0;
+  border-radius: 5px;
+  font-weight: bold;
+}
+#content .package.signature {
+  font-weight: normal;
+  font-family: monospace;
+  font-size: 1.05em;
+}
+#content .inline-objects p.children .object_link a:hover {
+  background: #CFEBFF; border-color: #A4CCDA;
+}
+#content dl.constants { font-size: 1.05em; }
+#content dl.constants .note { padding-right: 6px; }
+#content dl.constants dt { font-weight: normal; }
+#content dl.constants dt .defn { margin-bottom: 10px; }
+#content dl.constants dd { font-family: sans-serif; white-space: normal; }
+#content dl.constants dd h3 { font-size: 1.05em; margin: 0; }
+.note.title.interface, .note.title.struct {
+  font-weight: bold;
+  color: #8C8B00;
+  background: #FEFFE1;
+  border-color: #D9DBBC;
+}
+pre, code { tab-size: 2; }

data/templates/default/fulldoc/html/css/highlight.github.css

@@ -0,0 +1,123 @@
+/*
+
+github.com style (c) Vasily Polovnyov <vast@whiteants.net>
+
+*/
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 0.5em;
+  color: #333;
+  background: #f8f8f8;
+  -webkit-text-size-adjust: none;
+}
+
+.hljs-comment,
+.diff .hljs-header {
+  color: #998;
+  font-style: italic;
+}
+
+.hljs-keyword,
+.css .rule .hljs-keyword,
+.hljs-winutils,
+.nginx .hljs-title,
+.hljs-subst,
+.hljs-request,
+.hljs-status {
+  color: #333;
+  font-weight: bold;
+}
+
+.hljs-number,
+.hljs-hexcolor,
+.hljs-constant {
+  color: #008080;
+}
+
+.hljs-string,
+.hljs-tag .hljs-value,
+.hljs-doctag,
+.tex .hljs-formula {
+  color: #d14;
+}
+
+.hljs-title,
+.hljs-id,
+.scss .hljs-preprocessor {
+  color: #900;
+  font-weight: bold;
+}
+
+.hljs-list .hljs-keyword,
+.hljs-subst {
+  font-weight: normal;
+}
+
+.hljs-class .hljs-title,
+.hljs-type,
+.vhdl .hljs-literal,
+.tex .hljs-command {
+  color: #458;
+  font-weight: bold;
+}
+
+.hljs-tag,
+.hljs-tag .hljs-title,
+.hljs-rule .hljs-property,
+.django .hljs-tag .hljs-keyword {
+  color: #000080;
+  font-weight: normal;
+}
+
+.hljs-attribute,
+.hljs-variable,
+.lisp .hljs-body,
+.hljs-name {
+  color: #008080;
+}
+
+.hljs-regexp {
+  color: #009926;
+}
+
+.hljs-symbol,
+.ruby .hljs-symbol .hljs-string,
+.lisp .hljs-keyword,
+.clojure .hljs-keyword,
+.scheme .hljs-keyword,
+.tex .hljs-special,
+.hljs-prompt {
+  color: #990073;
+}
+
+.hljs-built_in {
+  color: #0086b3;
+}
+
+.hljs-preprocessor,
+.hljs-pragma,
+.hljs-pi,
+.hljs-doctype,
+.hljs-shebang,
+.hljs-cdata {
+  color: #999;
+  font-weight: bold;
+}
+
+.hljs-deletion {
+  background: #fdd;
+}
+
+.hljs-addition {
+  background: #dfd;
+}
+
+.diff .hljs-change {
+  background: #0086b3;
+}
+
+.hljs-chunk {
+  color: #aaa;
+}

data/templates/default/fulldoc/html/full_list_package.erb

@@ -0,0 +1,2 @@
+<li id="object_" class="odd"><div class="item" style="padding-left:30px"><%= link_object(Registry.root, Registry.root.title, nil, false) %></div></li>
+<%= class_list %>

data/templates/default/fulldoc/html/setup.rb

@@ -0,0 +1,10 @@
+def run_verifier(objs)
+  super(objs.reject {|t| t.type == :bare_struct })
+end
+
+def generate_package_list
+  @items = options.objects if options.objects
+  @list_title = "Package List"
+  @list_type = "package"
+  generate_list_contents
+end

data/templates/default/interface/html/implemented_by.erb

@@ -0,0 +1,5 @@
+<% list = object.implementing_structs %>
+<% if list.size > 0 %>
+  <h3 class="inherited">Implemented By</h3>
+  <p class="inherited"><%= list.sort_by {|o| o.name.to_s }.map {|m| linkify(m) }.join(", ") %></p>
+<% end %>