codnar 0.1.64

data/test/format_code_sunlight_configurations.rb

@@ -0,0 +1,37 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test built-in split code formatting configurations using Sunlight.
+class TestSunlightFormatCodeConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  CODE_TEXT = <<-EOF.unindent
+    local = $global;
+  EOF
+
+  SUNLIGHT_HTML = <<-EOF.unindent.chomp
+    <pre class='sunlight-highlight-ruby'>
+    local = $global;
+    </pre>
+  EOF
+
+  def test_sunlight_code
+    check_split_file(CODE_TEXT,
+                     Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("ruby"),
+                     Codnar::Configuration::FORMAT_CODE_SUNLIGHT.call("ruby")) do |path|
+      [ {
+        "name" => path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [],
+        "html" => SUNLIGHT_HTML,
+      } ]
+    end
+  end
+
+end

data/test/format_comment_configurations.rb

@@ -0,0 +1,86 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test built-in split comment formatting configurations.
+class TestFormatCommentsConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  COMMENT_TEXT = <<-EOF.unindent.gsub("#!", "#")
+    #! Comment *text*.
+  EOF
+
+  PRE_HTML = <<-EOF.unindent.chomp
+    <pre class='comment'>
+    Comment *text*.
+    </pre>
+  EOF
+
+  def test_pre_comments
+    check_any_format(PRE_HTML, Codnar::Configuration::FORMAT_PRE_COMMENTS)
+  end
+
+  RDOC_HTML = <<-EOF.unindent.chomp
+    <table class='layout'>
+    <tr>
+    <td class='indentation'>
+    <pre></pre>
+    </td>
+    <td class='html'>
+    <div class='rdoc comment markup'>
+    <p>
+    Comment <b>text</b>.
+    </p>
+    </div>
+    </td>
+    </tr>
+    </table>
+  EOF
+
+  def test_rdoc_comments
+    check_any_format(RDOC_HTML, Codnar::Configuration::FORMAT_RDOC_COMMENTS)
+  end
+
+  MARKDOWN_HTML = <<-EOF.unindent.chomp
+    <table class='layout'>
+    <tr>
+    <td class='indentation'>
+    <pre></pre>
+    </td>
+    <td class='html'>
+    <div class='markdown comment markup'>
+    <p>
+    Comment <em>text</em>.
+    </p>
+    </div>
+    </td>
+    </tr>
+    </table>
+  EOF
+
+  def test_markdown_comments
+    check_any_format(MARKDOWN_HTML, Codnar::Configuration::FORMAT_MARKDOWN_COMMENTS)
+  end
+
+protected
+
+  def check_any_format(html, configuration)
+    check_split_file(COMMENT_TEXT,
+                     Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("any"),
+                     Codnar::Configuration::CLASSIFY_SHELL_COMMENTS.call,
+                     configuration) do |path|
+      [ {
+        "name" => path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [],
+        "html" => html,
+      } ]
+    end
+  end
+
+end

data/test/format_lines.rb

@@ -0,0 +1,72 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test converting classified lines to HTML.
+class TestFormatLines < Test::Unit::TestCase
+
+  include Test::WithErrors
+
+  alias_method :original_setup, :setup
+
+  def setup
+    original_setup
+    Codnar::Formatter.send(:public, *Codnar::Formatter.protected_instance_methods)
+    @formatter = Codnar::Formatter.new(@errors,
+                               "code" => "Formatter.lines_to_pre_html(lines)",
+                               "fail" => "TestFormatLines.fail")
+  end
+
+  def test_process_html_lines
+    lines_group = @formatter.process_lines_group([
+      { "kind" => "html", "number" => 1, "payload" => "foo", },
+      { "kind" => "html", "number" => 2, "payload" => "bar", },
+      { "kind" => "html", "number" => 3, "payload" => "baz", },
+    ])
+    @errors.should == []
+    lines_group.should == [ { "kind" => "html", "number" => 1, "payload" => "foo\nbar\nbaz" } ]
+  end
+
+  def test_process_unknown_lines
+    lines_group = @formatter.process_lines_group([
+      { "kind" => "unknown-kind", "number" => 1, "payload" => "<foo>", },
+    ])
+    @errors.should == [ "#{$0}: No formatter specified for lines of kind: unknown-kind" ]
+    lines_group.should == [ { "kind" => "html", "number" => 1,
+                              "payload" => "<pre class='missing formatter error'>\n&lt;foo&gt;\n</pre>" } ]
+  end
+
+  def test_process_code_lines
+    lines_group = @formatter.process_lines_group([
+      { "kind" => "code", "number" => 1, "payload" => "<foo>", },
+      { "kind" => "code", "number" => 2, "payload" => "bar", },
+    ])
+    @errors.should == []
+    lines_group.should == [ { "kind" => "html", "number" => 1,
+                              "payload" => "<pre>\n&lt;foo&gt;\nbar\n</pre>" } ]
+  end
+
+  def test_failed_formatter
+    lines_group = @formatter.process_lines_group([ { "kind" => "fail", "number" => 1, "payload" => "foo", } ])
+    @errors.size.should == 1
+    @errors.last.should =~ \
+      /#{$0}: Formatter: TestFormatLines.fail for lines of kind: fail failed with exception:.*in `fail': Reason/
+    lines_group.should == [ { "kind" => "html", "number" => 1,
+                              "payload" => "<pre class='failed formatter error'>\nfoo\n</pre>" } ]
+  end
+
+  def test_lines_to_html
+    lines_group = @formatter.lines_to_html([
+      { "kind" => "html", "number" => 1, "payload" => "foo" },
+      { "kind" => "code", "number" => 2, "payload" => "<bar>" },
+      { "kind" => "html", "number" => 3, "payload" => "baz" },
+    ])
+    @errors.should == []
+    lines_group.should == "foo\n<pre>\n&lt;bar&gt;\n</pre>\nbaz"
+  end
+
+  def self.fail
+    raise "Reason"
+  end
+
+end

data/test/group_lines.rb

@@ -0,0 +1,31 @@
+require "codnar"
+require "test/spec"
+
+# Test grouping classified lines by their kind.
+class TestGroupLines < Test::Unit::TestCase
+
+  def test_group_empty_lines
+    Codnar::Grouper.lines_to_groups([]).should == []
+  end
+
+  def test_group_one_line
+    Codnar::Grouper.lines_to_groups([ { "kind" => "code" } ]).should == [ [ { "kind" => "code" } ] ]
+  end
+
+  def test_group_lines
+    Codnar::Grouper.lines_to_groups([
+      { "kind" => "code", "line" => "0" },
+      { "kind" => "code", "line" => "1" },
+      { "kind" => "comment", "line" => "2" },
+      { "kind" => "code", "line" => "3" },
+    ]).should == [ [
+      { "kind" => "code", "line" => "0" },
+      { "kind" => "code", "line" => "1" },
+    ], [
+      { "kind" => "comment", "line" => "2" },
+    ], [
+      { "kind" => "code", "line" => "3" },
+    ] ]
+  end
+
+end

data/test/gvim_highlight_syntax.rb

@@ -0,0 +1,49 @@
+require "codnar"
+require "test/spec"
+
+# Test highlighting syntax using GVim.
+class TestGVimHighlightSyntax < Test::Unit::TestCase
+
+  def setup
+    Codnar::GVim.force_recompute = true
+  end
+
+  def teardown
+    Codnar::GVim.force_recompute = false
+  end
+
+  def test_ruby_no_css
+    ruby = <<-EOF.unindent
+      def foo
+        return bar = baz
+      end
+    EOF
+    Codnar::GVim.cached_syntax_to_html(ruby, "ruby").should == <<-EOF.unindent #! ((( html
+      <div class='ruby code syntax' bgcolor="#ffffff" text="#000000">
+      <font face="monospace">
+      <font color="#ff40ff">def</font>&nbsp;<font color="#00ffff">foo</font><br />
+      &nbsp;&nbsp;<font color="#ffff00">return</font>&nbsp;bar = baz<br />
+      <font color="#ff40ff">end</font><br />
+      </font>
+      </div>
+    EOF
+    #! ))) html
+  end
+
+  def test_ruby_css
+    ruby = <<-EOF.unindent
+      def foo
+        return bar = baz
+      end
+    EOF
+    Codnar::GVim.cached_syntax_to_html(ruby, "ruby", [ "+:let html_use_css=1" ]).should == <<-EOF.unindent #! ((( html
+      <pre class='ruby code syntax'>
+      <span class="PreProc">def</span> <span class="Identifier">foo</span>
+        <span class="Statement">return</span> bar = baz
+      <span class="PreProc">end</span>
+      </pre>
+    EOF
+    #! ))) html
+  end
+
+end

data/test/identify_chunks.rb

@@ -0,0 +1,32 @@
+require "codnar"
+require "test/spec"
+
+# Test converting chunk names to identifiers.
+class TestIdentifyChunks < Test::Unit::TestCase
+
+  def test_lower_case_to_id
+    "a".to_id.should == "a"
+  end
+
+  def test_upper_case_to_id
+    "A".to_id.should == "a"
+  end
+
+  def test_digits_to_id
+    "1".to_id.should == "1"
+  end
+
+  def test_non_alnum_to_id
+    "!@-$#".to_id.should == "-"
+  end
+
+  def test_complex_to_id
+    "C# for .NET!".to_id.should == "c-for-net-"
+  end
+
+  def test_strip_to_id
+    " a ".to_id.should == "a"
+  end
+
+
+end

data/test/lib/test_with_configurations.rb

@@ -0,0 +1,15 @@
+# Tests with Codnar split configurations.
+module Test::WithConfigurations
+
+  # Test running the Splitter with merged configurations.
+  def check_split_file(file_text, *configurations, &block)
+    configuration = configurations.inject({}) do |merged_configuration, next_configuration|
+      merged_configuration.deep_merge(next_configuration)
+    end
+    splitter = Codnar::Splitter.new(@errors, configuration)
+    chunks = splitter.chunks(path = write_tempfile("splitted", file_text))
+    @errors.should == []
+    chunks.should == yield(path)
+  end
+
+end

data/test/merge_lines.rb

@@ -0,0 +1,133 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test merging classified lines to chunks.
+class TestMergeLines < Test::Unit::TestCase
+
+  include Test::WithErrors
+
+  def test_merge_no_chunks
+    lines = [ { "kind" => "code", "line" => "foo", "number" => 1, "indentation" => "", "payload" => "foo" } ]
+    chunks = Codnar::Merger.chunks(@errors, "path", lines)
+    @errors.should == []
+    chunks.should == [ {
+      "name" => "path",
+      "locations" => [ { "file" => "path", "line" => 1 } ],
+      "containers" => [],
+      "contained" => [],
+      "lines" => lines
+    } ]
+  end
+
+  def test_valid_merge
+    chunks = Codnar::Merger.chunks(@errors, "path", VALID_LINES)
+    @errors.should == []
+    chunks.should == VALID_CHUNKS
+  end
+
+  VALID_LINES = [
+    { "kind" => "code",        "number" => 1,  "line" => "before top",
+      "indentation" => "",     "payload" => "before top"          },
+    { "kind" => "begin_chunk", "number" => 2, "line" => " {{{ top chunk",
+      "indentation" => " ",    "payload" => "top chunk"           },
+    { "kind" => "code",         "number" => 3, "line" => " before intermediate",
+      "indentation" => " ",    "payload" => "before intermediate" },
+    { "kind" => "begin_chunk", "number" => 4,  "line" => "  {{{ intermediate chunk",
+      "indentation" => "  ",   "payload" => "intermediate chunk"  },
+    { "kind" => "code",        "number" => 5,  "line" => "  before inner",
+      "indentation" => "  ",   "payload" => "before inner"        },
+    { "kind" => "begin_chunk", "number" => 6,  "line" => "   {{{ inner chunk",
+      "indentation" => "   ",  "payload" => "inner chunk"         },
+    { "kind" => "code",        "number" => 7,  "line" => "   inner line",
+      "indentation" => "   ",  "payload" => "inner line"          },
+    { "kind" => "end_chunk",   "number" => 8,  "line" => "   }}} inner chunk",
+      "indentation" => "   ",  "payload" => "inner chunk"         },
+    { "kind" => "code",        "number" => 9,  "line" => "  after inner",
+      "indentation" => "  ",   "payload" => "after inner"         },
+    { "kind" => "end_chunk",   "number" => 10, "line" => "  }}}",
+      "indentation" => "  ",   "payload" => ""                    },
+    { "kind" => "code",        "number" => 11, "line" => " after intermediate",
+      "indentation" => " ",    "payload" => "after intermediate"  },
+    { "kind" => "end_chunk",   "number" => 12, "line" => " }}} TOP CHUNK",
+      "indentation" => " ",    "payload" => "TOP CHUNK"           },
+    { "kind" => "code",        "number" => 13, "line" => "after top",
+      "indentation" => "",     "payload" => "after top"           }
+  ]
+
+  VALID_CHUNKS = [
+    { "name" => "path",
+      "locations" => [ { "file" => "path", "line" => 1 } ],
+      "containers" => [],
+      "contained" => [ "top chunk" ],
+      "lines" => [
+        VALID_LINES[0].merge("indentation" => ""),
+        { "kind" => "nested_chunk", "number" => 2, "line" => " {{{ top chunk",
+          "indentation" => " ",     "payload" => "top chunk" },
+        VALID_LINES[12].merge("indentation" => ""),
+      ] },
+    { "name" => "top chunk",
+      "locations" => [ { "file" => "path", "line" => 2 } ],
+      "containers" => [ "path" ],
+      "contained" => [ "intermediate chunk" ],
+      "lines" => [
+        VALID_LINES[1].merge("indentation" => ""),
+        VALID_LINES[2].merge("indentation" => ""),
+        { "kind" => "nested_chunk", "number" => 4, "line" => "  {{{ intermediate chunk",
+          "indentation" => " ",     "payload" => "intermediate chunk" },
+        VALID_LINES[10].merge("indentation" => ""),
+        VALID_LINES[11].merge("indentation" => ""),
+      ] },
+    { "name" => "intermediate chunk",
+      "locations" => [ { "file" => "path", "line" => 4 } ],
+      "containers" => [ "top chunk" ],
+      "contained" => [ "inner chunk" ],
+      "lines" => [
+        VALID_LINES[3].merge("indentation" => ""),
+        VALID_LINES[4].merge("indentation" => ""),
+        { "kind" => "nested_chunk", "number" => 6, "line" => "   {{{ inner chunk",
+          "indentation" => " ",     "payload" => "inner chunk" },
+        VALID_LINES[8].merge("indentation" => ""),
+        VALID_LINES[9].merge("indentation" => ""),
+      ] },
+    { "name" => "inner chunk",
+      "locations" => [ { "file" => "path", "line" => 6 } ],
+      "containers" => [ "intermediate chunk" ],
+      "contained" => [],
+      "lines" => [
+        VALID_LINES[5].merge("indentation" => ""),
+        VALID_LINES[6].merge("indentation" => ""),
+        VALID_LINES[7].merge("indentation" => "")
+      ] }
+  ]
+
+  def test_mismatching_end_chunk_line
+    lines = [
+      { "kind" => "begin_chunk", "number" => 1, "line" => "{{{ top chunk",
+        "indentation" => "",     "payload" => "top chunk"     },
+      { "kind" => "end_chunk",   "number" => 2, "line" => "}}} not top chunk",
+        "indentation" => "",     "payload" => "not top chunk" }
+    ]
+    Codnar::Merger.chunks(@errors, "path", lines)
+    @errors.should == [
+      "#{$0}: End line for chunk: not top chunk mismatches begin line for chunk: top chunk in file: path at line: 2"
+    ]
+  end
+
+  def test_missing_begin_chunk_name
+    lines = [
+      { "kind" => "begin_chunk", "number" => 1, "line" => "{{{", "indentation" => "", "payload" => "" },
+      { "kind" => "end_chunk",   "number" => 2, "line" => "}}}", "indentation" => "", "payload" => "" }
+    ]
+    Codnar::Merger.chunks(@errors, "path", lines)
+    @errors.should == [ "#{$0}: Begin line for chunk with no name in file: path at line: 1" ]
+  end
+
+  def test_missing_end_chunk_line
+    lines = [ { "kind" => "begin_chunk", "number" => 1, "line" => "{{{ top chunk",
+                "indentation" => "",     "payload" => "top chunk" } ]
+    Codnar::Merger.chunks(@errors, "path", lines)
+    @errors.should == [ "#{$0}: Missing end line for chunk: top chunk in file: path at line: 1" ]
+  end
+
+end