codnar 0.1.64

data/test/split_code.rb

@@ -0,0 +1,109 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test splitting code files.
+class TestSplitCode < Test::Unit::TestCase
+
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  def test_split_ruby
+    splitter = Codnar::Splitter.new(@errors, RUBY_CONFIGURATION)
+    path = write_tempfile("ruby.rb", RUBY_FILE)
+    chunks = splitter.chunks(path)
+    @errors.should == []
+    chunks.should == ruby_chunks(path)
+  end
+
+protected
+
+  def ruby_chunks(path)
+    RUBY_CHUNKS[0].name = path
+    RUBY_CHUNKS[1].containers[0] = path
+    RUBY_CHUNKS.each { |chunk| chunk.locations[0].file = path }
+    return RUBY_CHUNKS
+  end
+
+  RUBY_FILE = <<-EOF.unindent.gsub("#!", "#")
+    #! This is *rdoc*.
+      #! {{{ assignment
+      local = $global
+        indented
+      #! }}}
+  EOF
+
+  RUBY_CONFIGURATION = {
+    "formatters" => {
+      "code" => "Formatter.cast_lines(lines, 'ruby')",
+      "comment" => "Formatter.cast_lines(lines, 'rdoc')",
+      "ruby" => "GVim.lines_to_html(lines, 'ruby')",
+      "rdoc" => "Formatter.markup_lines_to_html(lines, 'RDoc')",
+      "begin_chunk" => "[]",
+      "end_chunk" => "[]",
+      "nested_chunk" => "Formatter.nested_chunk_lines_to_html(lines)",
+      "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
+    },
+    "syntax" => {
+      "start_state" => "ruby",
+      "patterns" => {
+        "comment" => { "regexp" => "^(\\s*)#\\s*(.*)$" },
+        "code" => { "regexp" => "^(\\s*)(.*)$" },
+        "begin_chunk" => { "regexp" => "^(\\s*)\\W*\\{\\{\\{\\s*(.*?)\\s*$" },
+        "end_chunk" => { "regexp" => "^(\\s*)\\W*\\}\\}\\}\\s*(.*?)\\s*$" },
+      },
+      "states" => {
+        "ruby" => {
+          "transitions" => [
+            { "pattern" => "begin_chunk" },
+            { "pattern" => "end_chunk" },
+            { "pattern" => "comment" },
+            { "pattern" => "code" },
+          ],
+        },
+      },
+    },
+  }
+
+  RUBY_CHUNKS = [ {
+    "name" => "PATH",
+    "locations" => [ "file" => "PATH", "line" => 1 ],
+    "containers" => [],
+    "contained" => [ "assignment" ],
+    "html" => <<-EOF.unindent.chomp, #! ((( html
+      <table class='layout'>
+      <tr>
+      <td class='indentation'>
+      <pre></pre>
+      </td>
+      <td class='html'>
+      <div class='rdoc rdoc markup'>
+      <p>
+      This is <b>rdoc</b>.
+      </p>
+      </div>
+      </td>
+      </tr>
+      </table>
+      <pre class='nested chunk'>
+        <a class='nested chunk' href='#assignment'>assignment</a>
+      </pre>
+    EOF
+    #! ))) html
+  }, {
+    "name" => "assignment",
+    "containers" => [ "PATH" ],
+    "contained" => [],
+    "locations" => [ "file" => "PATH", "line" => 2 ],
+    "html" => <<-EOF.unindent.chomp, #! ((( html
+      <div class='ruby code syntax' bgcolor="#ffffff" text="#000000">
+      <font face="monospace">
+      local =&nbsp;<font color="#00ffff">$global</font><br />
+      &nbsp;&nbsp;indented<br />
+      </font>
+      </div>
+    EOF
+    #! ))) html
+  } ]
+
+end

data/test/split_code_configurations.rb

@@ -0,0 +1,73 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test combinations of the built-in split code configurations.
+class TestSplitCodeConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  SOURCE_CODE = <<-EOF.unindent
+    a = b
+    b = 1
+  EOF
+
+  def test_source_code
+    check_split_file(SOURCE_CODE, Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("ruby")) do |path|
+      [ {
+        "name" => path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [],
+        "html" => "<pre class='code'>\n#{SOURCE_CODE}</pre>"
+      } ]
+    end
+  end
+
+  ISLAND_CODE = <<-EOF.unindent
+    a = b
+    b = 1
+    HTML = <<-EOH.unindent # ((( html
+      <p>
+      HTML
+      </p>
+    EOH
+    # ))) html
+  EOF
+
+  ISLAND_HTML = <<-EOF.unindent.chomp
+    <pre class='ruby code syntax'>
+    a = b
+    b = <span class="Constant">1</span>
+    <span class="Type">HTML</span> = &lt;&lt;-<span class="Special">EOH</span>.unindent <span class="Comment"># ((( html</span>
+    </pre>
+    <pre class='html code syntax'>
+      <span class="Identifier">&lt;</span><span class="Statement">p</span><span class="Identifier">&gt;</span>
+      HTML
+      <span class="Identifier">&lt;/</span><span class="Statement">p</span><span class="Identifier">&gt;</span>
+    EOH
+    </pre>
+    <pre class='ruby code syntax'>
+    <span class="Comment"># ))) html</span>
+    </pre>
+  EOF
+
+  def test_island_code
+    check_split_file(ISLAND_CODE, Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("ruby"),
+                                  Codnar::Configuration::FORMAT_CODE_GVIM_CSS.call("ruby"),
+                                  Codnar::Configuration::CLASSIFY_NESTED_CODE.call("ruby", "html"),
+                                  Codnar::Configuration::FORMAT_CODE_GVIM_CSS.call("html")) do |path|
+      [ {
+        "name" => path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [],
+        "html" => ISLAND_HTML
+      } ]
+    end
+  end
+
+end

data/test/split_combined_configurations.rb

@@ -0,0 +1,114 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test combination of many built-in configurations.
+class TestSplitCombinedConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  CODE_TEXT = <<-EOF.unindent.gsub("#!", "#")
+    #!!/usr/bin/ruby -w
+
+    #! {{{ HTML snippet
+
+    HELLO_WORLD_IN_HTML = <<-EOH.unindent.chomp #! ((( html
+      <p>
+      Hello, world!
+      </p>
+    EOH
+    #! ))) html
+
+    #! }}}
+
+    #! {{{ Ruby code
+
+    #! Hello, *world*!
+    puts HELLO_WORLD_IN_HTML
+
+    #! }}}
+  EOF
+
+  FILE_HTML = <<-EOF.unindent.chomp
+    <pre class='ruby code syntax'>
+    <span class="PreProc">#!/usr/bin/ruby -w</span>
+
+    </pre>
+    <pre class='nested chunk'>
+    <a class='nested chunk' href='#html-snippet'>HTML snippet</a>
+    </pre>
+    <pre class='ruby code syntax'>
+
+    </pre>
+    <pre class='nested chunk'>
+    <a class='nested chunk' href='#ruby-code'>Ruby code</a>
+    </pre>
+  EOF
+
+  HTML_CHUNK = <<-EOF.unindent.chomp
+    <pre class='ruby code syntax'>
+
+    <span class="Type">HELLO_WORLD_IN_HTML</span> = &lt;&lt;-<span class="Special">EOH</span>.unindent.chomp <span class="Comment"># ((( html</span>
+    </pre>
+    <pre class='html code syntax'>
+      <span class="Identifier">&lt;</span><span class="Statement">p</span><span class="Identifier">&gt;</span>
+      Hello, world!
+      <span class="Identifier">&lt;/</span><span class="Statement">p</span><span class="Identifier">&gt;</span>
+    EOH
+    </pre>
+    <pre class='ruby code syntax'>
+    <span class="Comment"># ))) html</span>
+
+    </pre>
+  EOF
+
+  RUBY_CHUNK = <<-EOF.unindent.chomp
+    <pre class='ruby code syntax'>
+
+    </pre>
+    <table class='layout'>
+    <tr>
+    <td class='indentation'>
+    <pre></pre>
+    </td>
+    <td class='html'>
+    <div class='rdoc comment markup'>
+    <p>
+    Hello, <b>world</b>!
+    </p>
+    </div>
+    </td>
+    </tr>
+    </table>
+    <pre class='ruby code syntax'>
+    puts <span class="Type">HELLO_WORLD_IN_HTML</span>
+
+    </pre>
+  EOF
+
+  def test_gvim_chunks
+    check_split_file(CODE_TEXT,
+                     Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("ruby"),
+                     Codnar::Configuration::FORMAT_CODE_GVIM_CSS.call("ruby"),
+                     Codnar::Configuration::CLASSIFY_NESTED_CODE.call("ruby", "html"),
+                     Codnar::Configuration::FORMAT_CODE_GVIM_CSS.call("html"),
+                     Codnar::Configuration::CLASSIFY_SHELL_COMMENTS.call,
+                     Codnar::Configuration::FORMAT_RDOC_COMMENTS,
+                     Codnar::Configuration::CHUNK_BY_VIM_REGIONS) do |path|
+      [ {
+        "name" => path, "html" => FILE_HTML,
+        "locations" => [ { "line" => 1, "file" => path } ], "containers" => [], "contained" => [ "HTML snippet", "Ruby code" ],
+      }, {
+        "name" => "HTML snippet", "html" => HTML_CHUNK,
+        "locations" => [ { "line" => 3, "file" => path } ], "containers" => [ path ], "contained" => [],
+      }, {
+        "name" => "Ruby code", "html" => RUBY_CHUNK,
+        "locations" => [ { "line" => 14, "file" => path } ], "containers" => [ path ], "contained" => [],
+      } ]
+    end
+  end
+
+end

data/test/split_complex_comment_configurations.rb

@@ -0,0 +1,73 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test built-in split complex comment configurations.
+class TestSplitComplexCommentsConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  def test_custom_comments
+    # Since the prefix/inner/suffix passed to the configuration are regexps,
+    # we need to escape special characters such as "{" and "|".
+    check_any_comment([ "@{", " |", " }@" ], Codnar::Configuration::CLASSIFY_COMPLEX_COMMENTS.call("@\\{", " \\|", " \\}@"))
+  end
+
+  def test_c_comments
+    check_any_comment([ "/*", " *", " */" ], Codnar::Configuration::CLASSIFY_C_COMMENTS.call)
+  end
+
+  def test_html_comments
+    check_any_comment([ "<!--", " -", "-->" ], Codnar::Configuration::CLASSIFY_HTML_COMMENTS.call)
+  end
+
+protected
+
+  # The "<<<" will be replaced by the complex comment prefix,
+  # the "<>" will be replaced by the inner line comment prefix,
+  # and the ">>>" will be replaced by the complex comment suffix.
+  ANY_COMMENT_CODE = <<-EOF.unindent
+    /-- One-line comment --/
+    Code
+    /--
+     - Multi-line
+     - comment.
+    --/
+  EOF
+
+  ANY_COMMENT_HTML = <<-EOF.unindent.chomp # ((( html
+    <pre class='comment'>
+    One-line comment
+    </pre>
+    <pre class='code'>
+    Code
+    </pre>
+    <pre class='comment'>
+
+    Multi-line
+    comment.
+
+    </pre>
+  EOF
+  # )))
+
+  def check_any_comment(patterns, configuration)
+    prefix, inner, suffix = patterns
+    check_split_file(ANY_COMMENT_CODE.gsub("/--", prefix).gsub("--/", suffix).gsub(" -", inner),
+                     Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("any"),
+                     Codnar::Configuration::FORMAT_PRE_COMMENTS,
+                     configuration) do |path|
+      [ {
+        "name" => path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [],
+        "html" => ANY_COMMENT_HTML.gsub("/--", prefix).gsub("--/", suffix).gsub(" -", inner),
+      } ]
+    end
+  end
+
+end

data/test/split_documentation.rb

@@ -0,0 +1,92 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test "splitting" documentation files.
+class TestSplitDocumentation < Test::Unit::TestCase
+
+  include Test::WithErrors
+  include Test::WithFakeFS
+
+  def test_split_raw
+    File.open("raw.html", "w") { |file| file.write("<foo>\nbar\n</foo>\n") }
+    splitter = Codnar::Splitter.new(@errors, configuration("html"))
+    chunks = splitter.chunks("raw.html")
+    @errors.should == []
+    chunks.should == [ {
+      "name" => "raw.html",
+      "containers" => [],
+      "contained" => [],
+      "locations" => [ { "file" => "raw.html", "line" => 1 } ],
+      "html" => "<foo>\nbar\n</foo>"
+    } ]
+  end
+
+  def test_split_markdown
+    File.open("markdown.md", "w") { |file| file.write("*foo*\nbar\n") }
+    splitter = Codnar::Splitter.new(@errors, configuration("markdown"))
+    chunks = splitter.chunks("markdown.md")
+    @errors.should == []
+    chunks.should == [ {
+      "name" => "markdown.md",
+      "containers" => [],
+      "contained" => [],
+      "locations" => [ { "file" => "markdown.md", "line" => 1 } ],
+      "html" => "<div class='markdown markdown markup'>\n<p>\n<em>foo</em>\nbar\n</p>\n</div>"
+    } ]
+  end
+
+  def test_split_rdoc
+    File.open("rdoc.rdoc", "w") { |file| file.write("*foo*\nbar\n") }
+    splitter = Codnar::Splitter.new(@errors, configuration("rdoc"))
+    chunks = splitter.chunks("rdoc.rdoc")
+    @errors.should == []
+    chunks.should == [ {
+      "name" => "rdoc.rdoc",
+      "containers" => [],
+      "contained" => [],
+      "locations" => [ { "file" => "rdoc.rdoc", "line" => 1 } ],
+      "html" => "<div class='rdoc rdoc markup'>\n<p>\n<b>foo</b> bar\n</p>\n</div>"
+    } ]
+  end
+
+  def test_split_unknown_kind
+    File.open("unknown.kind", "w") { |file| file.write("foo\nbar\n") }
+    splitter = Codnar::Splitter.new(@errors, configuration("unknown-kind"))
+    chunks = splitter.chunks("unknown.kind")
+    @errors.should == [ "#{$0}: No formatter specified for lines of kind: unknown-kind" ]
+    chunks.should == [ {
+      "name" => "unknown.kind",
+      "containers" => [],
+      "contained" => [],
+      "locations" => [ { "file" => "unknown.kind", "line" => 1 } ],
+      "html" => "<pre class='missing formatter error'>\nfoo\nbar\n</pre>"
+    } ]
+  end
+
+protected
+
+  def configuration(kind)
+    return {
+      "formatters" => {
+        "markdown" => "Formatter.markup_lines_to_html(lines, 'Markdown')",
+        "unindented_html" => "Formatter.unindented_lines_to_html(lines)",
+        "rdoc" => "Formatter.markup_lines_to_html(lines, 'RDoc')",
+      },
+      "syntax" => {
+        "start_state" => kind,
+        "patterns" => {
+          kind => { "regexp" => "^(.*)$", "groups" => [ "payload" ] },
+        },
+        "states" => {
+          kind => {
+            "transitions" => [
+              { "pattern" => kind }
+            ]
+          }
+        }
+      }
+    }
+  end
+
+end