codnar 0.1.64

data/test/rake_tasks.rb

@@ -0,0 +1,38 @@
+require "codnar/rake"
+require "olag/test"
+require "test/spec"
+
+# Test rake tasks.
+class TestRakeTasks < Test::Unit::TestCase
+
+  include Test::WithFakeFS
+  include Test::WithRake
+
+  def test_default
+    run_rake
+    test_results
+  end
+
+protected
+
+  def run_rake
+    File.open("foo", "w") { |file| file.puts("foo") }
+    Codnar::Rake::SplitTask.new([ "foo" ], [])
+    Codnar::Rake::WeaveTask.new("foo", [])
+    @rake["codnar"].invoke
+  end
+
+  def test_results
+    chunk_file = Codnar::Rake.chunks_dir + "/foo"
+    YAML.load_file(chunk_file).should == [ {
+      "html" => "foo",
+      "name" => "foo",
+      "locations" => [ { "file" => "foo", "line" => 1 } ],
+      "containers" => [],
+      "contained" => [],
+    } ]
+    File.read("codnar.html").should == "foo\n"
+    Codnar::Rake.chunk_files.should == [ chunk_file ]
+  end
+
+end

data/test/read_chunks.rb

@@ -0,0 +1,110 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test reading chunks from files.
+class TestReadChunks < Test::Unit::TestCase
+
+  include Test::WithErrors
+  include Test::WithFakeFS
+
+  def test_read_chunks
+    Codnar::Writer.write("foo.chunks", { "name" => "foo" })
+    Codnar::Writer.write("bar.chunks", [ { "name" => "bar" }, { "name" => "baz" } ])
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
+    check_read_data(reader, "foo" => { "name" => "foo" },
+                            "bar" => { "name" => "bar" },
+                            "baz" => { "name" => "baz" })
+    @errors.should == []
+  end
+
+  def test_read_invalid_chunks
+    file_path = nil
+    File.open("foo.chunks", "w") { |file| file_path = File.expand_path(file.path) }
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
+    @errors.should == [ "#{$0}: Invalid chunks data in file: #{file_path}" ]
+  end
+
+  def test_read_unused_chunks
+    Codnar::Writer.write("foo.chunks", { "name" => "foo",
+                                         "locations" => [ { "file" => "a", "line" => 1 } ] })
+    Codnar::Writer.write("bar.chunks", { "name" => "bar",
+                                         "locations" => [ { "file" => "b", "line" => 2 } ] })
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
+    check_read_data(reader, "foo" => { "name" => "foo",
+                                       "locations" => [ { "file" => "a", "line" => 1 } ] })
+    @errors.should == [ "#{$0}: Unused chunk: bar in file: b at line: 2" ]
+  end
+
+  def test_read_duplicate_chunks
+    Codnar::Writer.write("foo.chunks", { "name" => "foo", "locations" => [ { "file" => "a" } ],
+                                         "contained" => [ "A" ], "containers" => [ "c" ] })
+    Codnar::Writer.write("bar.chunks", [
+      { "name" => "foo", "locations" => [ { "file" => "b" } ],
+        "contained" => [ "a" ], "containers" => [ "d" ] },
+      { "name" => "foo", "locations" => [ { "file" => "c" } ],
+        "contained" => [ "a" ], "containers" => [] }
+    ])
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
+    check_read_data(reader, "foo" => {
+      "name" => "foo",
+      "locations" => [ { "file" => "a" }, { "file" => "b" }, { "file" => "c" } ],
+      "contained" => [ "a" ],
+      "containers" => [ "c", "d" ],
+    })
+  end
+
+  def test_read_different_chunks
+    Codnar::Writer.write("foo.chunks", [
+      { "name" => "foo", "html" => "bar", "locations" => [ { "file" => "foo.chunks", "line" => 1 } ],
+        "contained" => [ "a" ], "containers" => [] },
+      { "name" => "foo", "html" => "baz", "locations" => [ { "file" => "foo.chunks", "line" => 2 } ],
+        "contained" => [ "A" ], "containers" => [] }
+    ])
+    Codnar::Writer.write("bar.chunks", [ { "name" => "foo", "html" => "bar",
+                                           "locations" => [ { "file" => "bar.chunks", "line" => 1 } ],
+                                           "contained" => [ "a" ], "containers" => [] } ])
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks").sort)
+    @errors.should == [ "#{$0}: Chunk: foo is different in file: foo.chunks at line: 2, " \
+                      + "and in file: bar.chunks at line: 1 or in file: foo.chunks at line: 1" ]
+    check_read_data(reader, "foo" => {
+      "name" => "foo",
+      "html" => "bar",
+      "locations" => [ { "file" => "bar.chunks", "line" => 1 }, { "file" => "foo.chunks", "line" => 1 } ],
+      "contained" => [ "a" ],
+      "containers" => [],
+    })
+  end
+
+  def test_read_fake_chunk
+    reader = Codnar::Reader.new(@errors, [])
+    reader["foo"].should == Codnar::Reader.fake_chunk("foo")
+    @errors.should == [ "#{$0}: Missing chunk: foo" ]
+  end
+
+  def test_read_equivalent_name_chunks
+    Codnar::Writer.write("foo.chunks", [
+      { "name" => "Foo?", "locations" => [ { "file" => "foo.chunks", "line" => 1 } ],
+        "containers" => [ "1" ], "contained" => [ "c" ] },
+      { "name" => "FOO!!", "locations" => [ { "file" => "foo.chunks", "line" => 2 } ],
+        "containers" => [ "2" ], "contained" => [ "C" ] }
+    ])
+    reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
+    check_read_data(reader, "foo-" => {
+      "name" => "Foo?",
+      "locations" => [ { "file" => "foo.chunks", "line" => 1 }, { "file" => "foo.chunks", "line" => 2 } ],
+      "containers" => [ "1", "2" ],
+      "contained" => [ "c" ],
+    })
+  end
+
+protected
+
+  def check_read_data(reader, chunks)
+    chunks.each do |name, chunk|
+      reader[name].should == chunk
+    end
+    reader.collect_unused_chunk_errors
+  end
+
+end

data/test/run_application.rb

@@ -0,0 +1,56 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+module Codnar
+
+  # Test running a Codnar Application.
+  class TestRunApplication < Test::Unit::TestCase
+  
+    include Test::WithFakeFS
+    include Test::WithTempfile
+
+    def test_print_version
+      Codnar::Application.with_argv(%w(-o nested/stdout -v -h dummy)) { Codnar::Application.new(true).run }.should == 0
+      File.read("nested/stdout").should == "#{$0}: Version: #{Codnar::VERSION}\n"
+    end
+
+    def test_print_help
+      Codnar::Application.with_argv(%w(-o stdout -h -v dummy)) { Codnar::Application.new(true).run }.should == 0
+      File.read("stdout").should.include?("OPTIONS")
+    end
+
+    USER_CONFIGURATION = {
+      "formatters" => {
+        "doc" => "Formatter.lines_to_pre_html(lines, :class => :pre)",
+      }
+    }
+
+    def test_merge_configurations
+      File.open("user_configuration.yaml", "w") { |file| file.print(USER_CONFIGURATION.to_yaml) }
+      Codnar::Application.with_argv(%w(-o stdout -c split_pre_documentation -c user_configuration.yaml -p)) { Codnar::Application.new(true).run }.should == 0
+      YAML.load_file("stdout").should == Codnar::Configuration::SPLIT_PRE_DOCUMENTATION.deep_merge(USER_CONFIGURATION)
+    end
+
+    def test_require_missing_configuration
+      status = Application.with_argv(%w(-e stderr -c no-such-configuration)) { Codnar::Application.new(true).run }.should == 1
+      File.read("stderr").should \
+        == "#{$0}: Configuration: no-such-configuration is neither a disk file nor a known configuration\n"
+    end
+
+    def test_require_module
+      FakeFS.deactivate! # The additional_module is read by Ruby and is not affected by FakeFS.
+      directory = create_tempdir
+      File.open(directory + "/additional_module.rb", "w") { |file| file.puts("puts 'HERE'") }
+      Application.with_argv(["-o", stdout = directory + "/stdout", "-I", directory, "-r", "additional_module" ]) { Codnar::Application.new(true).run }.should == 0
+      File.read(stdout).should == "HERE\n"
+    end
+
+    def test_require_missing_module
+      Application.with_argv(%w(-e stderr -I support -r no_such_module)) { Codnar::Application.new(true).run }.should == 1
+      File.read("stderr").should == "#{$0}: no such file to load -- no_such_module\n"
+    end
+
+  end
+
+end

data/test/run_split.rb

@@ -0,0 +1,38 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test running the Split Codnar Application.
+class TestRunSplit < Test::Unit::TestCase
+
+  include Test::WithFakeFS
+
+  def test_print_help
+    Codnar::Application.with_argv(%w(-o stdout -h)) { Codnar::Split.new(true).run }.should == 0
+    help = File.read("stdout")
+    [ "codnar-split", "OPTIONS", "DESCRIPTION" ].each { |text| help.should.include?(text) }
+  end
+
+  def test_run_split
+    File.open("input", "w") { |file| file.puts("<foo>") }
+    Codnar::Application.with_argv(%w(-o stdout input)) { Codnar::Split.new(true).run }.should == 0
+    YAML.load_file("stdout").should == [ {
+      "name" => "input",
+      "locations" => [ { "file" => "input", "line" => 1 } ],
+      "html" => "<foo>",
+      "containers" => [],
+      "contained" => [],
+    } ]
+  end
+
+  def test_run_split_no_file
+    Codnar::Application.with_argv(%w(-e stderr)) { Codnar::Split.new(true).run }.should == 1
+    File.read("stderr").should == "#{$0}: No input file to split\n"
+  end
+
+  def test_run_split_many_file
+    Codnar::Application.with_argv(%w(-e stderr one two)) { Codnar::Split.new(true).run }.should == 1
+    File.read("stderr").should == "#{$0}: Too many input files to split\n"
+  end
+
+end

data/test/run_weave.rb

@@ -0,0 +1,75 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test running the Weave Codnar Application.
+class TestRunWeave < Test::Unit::TestCase
+
+  include Test::WithFakeFS
+
+  def test_print_help
+    Codnar::Application.with_argv(%w(-o stdout -h)) { Codnar::Weave.new(true).run }.should == 0
+    help = File.read("stdout")
+    [ "codnar-weave", "OPTIONS", "DESCRIPTION" ].each { |text| help.should.include?(text) }
+  end
+
+  ROOT_CHUNKS = [ {
+    "name" => "root",
+    "locations" => [ { "file" => "root", "line" => 1 } ],
+    "html" => "Root\n<embed src='included' type='x-codnar/include'/>\n"
+  } ]
+
+  INCLUDED_CHUNKS = [ {
+    "name" => "included",
+    "locations" => [ { "file" => "included", "line" => 1 } ],
+    "html" => "Included"
+  } ]
+
+  def test_run_weave
+    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
+    File.open("included", "w") { |file| file.write(INCLUDED_CHUNKS.to_yaml) }
+    Codnar::Application.with_argv(%w(-o stdout root included)) { Codnar::Weave.new(true).run }.should == 0
+    File.read("stdout").should == "Root\nIncluded\n"
+  end
+
+  def test_run_weave_missing_chunk
+    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
+    Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 1
+    File.read("stderr").should == "#{$0}: Missing chunk: included in file: root\n"
+  end
+
+  def test_run_weave_unused_chunk
+    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
+    File.open("included", "w") { |file| file.write(INCLUDED_CHUNKS.to_yaml) }
+    Codnar::Application.with_argv(%w(-e stderr -o stdout included root)) { Codnar::Weave.new(true).run }.should == 1
+    File.read("stderr").should == "#{$0}: Unused chunk: root in file: root at line: 1\n"
+  end
+
+  def test_run_weave_no_chunks
+    Codnar::Application.with_argv(%w(-e stderr)) { Codnar::Weave.new(true).run }.should == 1
+    File.read("stderr").should == "#{$0}: No chunk files to weave\n"
+  end
+
+  FILE_CHUNKS = [ {
+    "name" => "root",
+    "locations" => [ { "file" => "root", "line" => 1 } ],
+    "html" => "Root\n<embed src='included.file' type='x-codnar/file'/>\n"
+  } ]
+
+  def test_run_weave_missing_file
+    File.open("root", "w") { |file| file.write(FILE_CHUNKS.to_yaml) }
+    Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 1
+    double_message = "No such file or directory - " * 2 # Something weird in Ruby Exception.to_s
+    File.read("stdout").should == "Root\nFILE: included.file EXCEPTION: #{double_message}\n"
+    File.read("stderr").should \
+      == "#{$0}: Reading file: included.file exception: #{double_message} in file: root at line: 1\n"
+  end
+
+  def test_run_weave_existing_file
+    File.open("root", "w") { |file| file.write(FILE_CHUNKS.to_yaml) }
+    File.open("included.file", "w") { |file| file.write("included file\n") }
+    Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 0
+    File.read("stdout").should == "Root\nincluded file\n"
+  end
+
+end

data/test/scan_lines.rb

@@ -0,0 +1,78 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+
+# Test scanning classified lines.
+class TestScanLines < Test::Unit::TestCase
+
+  include Test::WithErrors
+  include Test::WithFakeFS
+
+  def test_scan_lines
+    File.open("comments", "w") { |file| file.write(INPUT) }
+    scanner = Codnar::Scanner.new(@errors, SYNTAX)
+    scanner.lines("comments").should == LINES
+    @errors.should == ERRORS
+  end
+
+  SYNTAX = {
+    "start_state" => "comment",
+    "patterns" => {
+      "shell" => {
+        "regexp" => "^(\\s*)#+\\s*(.*)$",
+        "groups" => [ "indentation", "payload" ],
+        "kind" => "comment",
+      },
+      "c++" => {
+        "regexp" => /^(\s*)\/\/+\s*(.*)$/,
+        "groups" => [ "indentation", "payload" ],
+        "kind" => "comment",
+      },
+      "invalid" => { "regexp" => "(" },
+    },
+    "states" => {
+      "comment" => {
+        "transitions" => [
+          { "pattern" => "shell" },
+          { "pattern" => "c++" },
+          { "pattern" => "no-such-pattern", "next_state" => "no-such-state" },
+        ],
+      },
+    },
+  }
+
+  INPUT = <<-EOF.unindent.gsub("#!", "#")
+    #! foo
+     // bar
+      baz
+  EOF
+
+  LINES = [ {
+    "kind" => "comment",
+    "line" => "# foo",
+    "indentation" => "",
+    "payload" => "foo",
+    "number" => 1,
+  }, {
+    "kind" => "comment",
+    "line" => " // bar",
+    "indentation" => " ",
+    "payload" => "bar",
+    "number" => 2,
+  }, {
+    "kind" => "error",
+    "line" => "  baz",
+    "indentation" => "  ",
+    "payload" => "baz",
+    "state" => "comment",
+    "number" => 3,
+  } ]
+
+  ERRORS = [
+    "#{$0}: Invalid pattern: invalid regexp: ( error: premature end of regular expression: /(/",
+    "#{$0}: Reference to a missing pattern: no-such-pattern",
+    "#{$0}: Reference to a missing state: no-such-state",
+    "#{$0}: State: comment failed to classify line: baz in file: comments at line: 3"
+  ]
+
+end

data/test/split_chunk_configurations.rb

@@ -0,0 +1,55 @@
+require "codnar"
+require "olag/test"
+require "test/spec"
+require "test_with_configurations"
+
+# Test built-in split code formatting configurations.
+class TestSplitChunkConfigurations < Test::Unit::TestCase
+
+  include Test::WithConfigurations
+  include Test::WithErrors
+  include Test::WithTempfile
+
+  CODE_TEXT = <<-EOF.unindent.gsub("#!", "#")
+    int x;
+    #! {{{ chunk
+    int y;
+    #! }}}
+  EOF
+
+  CODE_HTML = <<-EOF.unindent.chomp
+    <pre class='code'>
+    int x;
+    </pre>
+    <pre class='nested chunk'>
+    <a class='nested chunk' href='#chunk'>chunk</a>
+    </pre>
+  EOF
+
+  CHUNK_HTML = <<-EOF.unindent.chomp
+    <pre class='code'>
+    int y;
+    </pre>
+  EOF
+
+  def test_gvim_chunks
+    check_split_file(CODE_TEXT,
+                     Codnar::Configuration::CLASSIFY_SOURCE_CODE.call("c"),
+                     Codnar::Configuration::CHUNK_BY_VIM_REGIONS) do |path|
+      [ {
+        "name"=> path,
+        "locations" => [ { "file" => path, "line" => 1 } ],
+        "containers" => [],
+        "contained" => [ "chunk" ],
+        "html"=> CODE_HTML,
+      }, {
+        "name" => "chunk",
+        "locations" => [ { "file" => path, "line" => 2 } ],
+        "containers" => [ path ],
+        "contained" => [],
+        "html" => CHUNK_HTML,
+      } ]
+    end
+  end
+
+end