coderay 1.0.0 → 1.0.0.598.pre

data/test/functional/basic.rb

@@ -1,15 +1,11 @@
-# encoding: utf-8
 require 'test/unit'
-require File.expand_path('../../lib/assert_warning', __FILE__)
-
-$:.unshift File.expand_path('../../../lib', __FILE__)
 require 'coderay'
 
 class BasicTest < Test::Unit::TestCase
   
   def test_version
     assert_nothing_raised do
-      assert_match(/\A\d\.\d\.\d?\z/, CodeRay::VERSION)
+      assert_match(/\A\d\.\d\.\d\z/, CodeRay::VERSION)
     end
   end
   
@@ -26,52 +22,28 @@ class BasicTest < Test::Unit::TestCase
   ].flatten
   def test_simple_scan
     assert_nothing_raised do
-      assert_equal RUBY_TEST_TOKENS, CodeRay.scan(RUBY_TEST_CODE, :ruby).tokens
+      assert_equal RUBY_TEST_TOKENS, CodeRay.scan(RUBY_TEST_CODE, :ruby).to_ary
     end
   end
   
-  RUBY_TEST_HTML = 'puts <span class="string"><span class="delimiter">&quot;</span>' + 
-    '<span class="content">Hello, World!</span><span class="delimiter">&quot;</span></span>'
+  RUBY_TEST_HTML = 'puts <span class="s"><span class="dl">&quot;</span>' + 
+    '<span class="k">Hello, World!</span><span class="dl">&quot;</span></span>'
   def test_simple_highlight
     assert_nothing_raised do
       assert_equal RUBY_TEST_HTML, CodeRay.scan(RUBY_TEST_CODE, :ruby).html
     end
   end
   
-  def test_scan_file
-    CodeRay.scan_file __FILE__
-  end
-  
-  def test_encode
-    assert_equal 1, CodeRay.encode('test', :python, :count)
-  end
-  
-  def test_encode_tokens
-    assert_equal 1, CodeRay.encode_tokens(CodeRay::Tokens['test', :string], :count)
-  end
-  
-  def test_encode_file
-    assert_equal File.read(__FILE__), CodeRay.encode_file(__FILE__, :text)
-  end
-  
-  def test_highlight
-    assert_match '<pre>test</pre>', CodeRay.highlight('test', :python)
-  end
-  
-  def test_highlight_file
-    assert_match "require <span class=\"string\"><span class=\"delimiter\">'</span><span class=\"content\">test/unit</span><span class=\"delimiter\">'</span></span>\n", CodeRay.highlight_file(__FILE__)
-  end
-  
   def test_duo
     assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain, :text].highlight(RUBY_TEST_CODE))
+      CodeRay::Duo[:plain, :plain].highlight(RUBY_TEST_CODE))
     assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain => :text].highlight(RUBY_TEST_CODE))
+      CodeRay::Duo[:plain => :plain].highlight(RUBY_TEST_CODE))
   end
   
   def test_duo_stream
     assert_equal(RUBY_TEST_CODE,
-      CodeRay::Duo[:plain, :text].highlight(RUBY_TEST_CODE, :stream => true))
+      CodeRay::Duo[:plain, :plain].highlight(RUBY_TEST_CODE, :stream => true))
   end
   
   def test_comment_filter
@@ -126,179 +98,21 @@ more code  # and another comment, in-line.
     assert_equal 0, CodeRay.scan(rHTML, :html).lines_of_code
     assert_equal 0, CodeRay.scan(rHTML, :php).lines_of_code
     assert_equal 0, CodeRay.scan(rHTML, :yaml).lines_of_code
-    assert_equal 4, CodeRay.scan(rHTML, :erb).lines_of_code
+    assert_equal 4, CodeRay.scan(rHTML, :rhtml).lines_of_code
   end
   
+  def test_rubygems_not_loaded
+    assert_equal nil, defined? Gem
+  end if ENV['check_rubygems'] && RUBY_VERSION < '1.9'
+  
   def test_list_of_encoders
     assert_kind_of(Array, CodeRay::Encoders.list)
-    assert CodeRay::Encoders.list.include?(:count)
+    assert CodeRay::Encoders.list.include?('count')
   end
   
   def test_list_of_scanners
     assert_kind_of(Array, CodeRay::Scanners.list)
-    assert CodeRay::Scanners.list.include?(:text)
-  end
-  
-  def test_token_kinds
-    assert_kind_of Hash, CodeRay::TokenKinds
-    for kind, css_class in CodeRay::TokenKinds
-      assert_kind_of Symbol, kind
-      if css_class != false
-        assert_kind_of String, css_class, "TokenKinds[%p] == %p" % [kind, css_class]
-      end
-    end
-    assert_equal 'reserved', CodeRay::TokenKinds[:reserved]
-    assert_warning 'Undefined Token kind: :shibboleet' do
-      assert_equal false, CodeRay::TokenKinds[:shibboleet]
-    end
-  end
-  
-  class Milk < CodeRay::Encoders::Encoder
-    FILE_EXTENSION = 'cocoa'
-  end
-  
-  class HoneyBee < CodeRay::Encoders::Encoder
-  end
-  
-  def test_encoder_file_extension
-    assert_nothing_raised do
-      assert_equal 'html', CodeRay::Encoders::Page::FILE_EXTENSION
-      assert_equal 'cocoa', Milk::FILE_EXTENSION
-      assert_equal 'cocoa', Milk.new.file_extension
-      assert_equal 'honeybee', HoneyBee::FILE_EXTENSION
-      assert_equal 'honeybee', HoneyBee.new.file_extension
-    end
-    assert_raise NameError do
-      HoneyBee::MISSING_CONSTANT
-    end
-  end
-  
-  def test_encoder_tokens
-    encoder = CodeRay::Encoders::Encoder.new
-    encoder.send :setup, {}
-    assert_raise(ArgumentError) { encoder.token :strange, '' }
-    encoder.token 'test', :debug
-  end
-  
-  def test_encoder_deprecated_interface
-    encoder = CodeRay::Encoders::Encoder.new
-    encoder.send :setup, {}
-    assert_warning 'Using old Tokens#<< interface.' do
-      encoder << ['test', :content]
-    end
-    assert_raise ArgumentError do
-      encoder << [:strange, :input]
-    end
-    assert_raise ArgumentError do
-      encoder.encode_tokens [['test', :token]]
-    end
-  end
-  
-  def encoder_token_interface_deprecation_warning_given
-    CodeRay::Encoders::Encoder.send :class_variable_get, :@@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN
-  end
-  
-  def test_scanner_file_extension
-    assert_equal 'rb', CodeRay::Scanners::Ruby.file_extension
-    assert_equal 'rb', CodeRay::Scanners::Ruby.new.file_extension
-    assert_equal 'java', CodeRay::Scanners::Java.file_extension
-    assert_equal 'java', CodeRay::Scanners::Java.new.file_extension
-  end
-  
-  def test_scanner_lang
-    assert_equal :ruby, CodeRay::Scanners::Ruby.lang
-    assert_equal :ruby, CodeRay::Scanners::Ruby.new.lang
-    assert_equal :java, CodeRay::Scanners::Java.lang
-    assert_equal :java, CodeRay::Scanners::Java.new.lang
-  end
-  
-  def test_scanner_tokenize
-    assert_equal ['foo', :plain], CodeRay::Scanners::Plain.new.tokenize('foo')
-    assert_equal [['foo', :plain], ['bar', :plain]], CodeRay::Scanners::Plain.new.tokenize(['foo', 'bar'])
-    CodeRay::Scanners::Plain.new.tokenize 42
-  end
-  
-  def test_scanner_tokens
-    scanner = CodeRay::Scanners::Plain.new
-    scanner.tokenize('foo')
-    assert_equal ['foo', :plain], scanner.tokens
-    scanner.string = ''
-    assert_equal ['', :plain], scanner.tokens
-  end
-  
-  def test_scanner_line_and_column
-    scanner = CodeRay::Scanners::Plain.new "foo\nbär+quux"
-    assert_equal 0, scanner.pos
-    assert_equal 1, scanner.line
-    assert_equal 1, scanner.column
-    scanner.scan(/foo/)
-    assert_equal 3, scanner.pos
-    assert_equal 1, scanner.line
-    assert_equal 4, scanner.column
-    scanner.scan(/\n/)
-    assert_equal 4, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 1, scanner.column
-    scanner.scan(/b/)
-    assert_equal 5, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 2, scanner.column
-    scanner.scan(/a/)
-    assert_equal 5, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 2, scanner.column
-    scanner.scan(/ä/)
-    assert_equal 7, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 4, scanner.column
-    scanner.scan(/r/)
-    assert_equal 8, scanner.pos
-    assert_equal 2, scanner.line
-    assert_equal 5, scanner.column
-  end
-  
-  def test_scanner_use_subclasses
-    assert_raise NotImplementedError do
-      CodeRay::Scanners::Scanner.new
-    end
-  end
-  
-  class InvalidScanner < CodeRay::Scanners::Scanner
-  end
-  
-  def test_scanner_scan_tokens
-    assert_raise NotImplementedError do
-      InvalidScanner.new.tokenize ''
-    end
-  end
-  
-  class RaisingScanner < CodeRay::Scanners::Scanner
-    def scan_tokens encoder, options
-      raise_inspect 'message', [], :initial
-    end
-  end
-  
-  def test_scanner_raise_inspect
-    assert_raise CodeRay::Scanners::Scanner::ScanError do
-      RaisingScanner.new.tokenize ''
-    end
-  end
-  
-  def test_scan_a_frozen_string
-    assert_nothing_raised do
-      CodeRay.scan RUBY_VERSION, :ruby
-      CodeRay.scan RUBY_VERSION, :plain
-    end
-  end
-  
-  def test_scan_a_non_string
-    assert_nothing_raised do
-      CodeRay.scan 42, :ruby
-      CodeRay.scan nil, :ruby
-      CodeRay.scan self, :ruby
-      CodeRay.encode ENV.to_hash, :ruby, :page
-      CodeRay.highlight CodeRay, :plain
-    end
+    assert CodeRay::Scanners.list.include?('plaintext')
   end
   
 end

data/test/functional/examples.rb

@@ -1,6 +1,4 @@
 require 'test/unit'
-
-$:.unshift File.expand_path('../../../lib', __FILE__)
 require 'coderay'
 
 class ExamplesTest < Test::Unit::TestCase
@@ -10,7 +8,7 @@ class ExamplesTest < Test::Unit::TestCase
     div = CodeRay.scan('puts "Hello, world!"', :ruby).div
     assert_equal <<-DIV, div
 <div class="CodeRay">
-  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.05)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, world!</span><span style="color:#710">&quot;</span></span></pre></div>
+  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.1)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, world!</span><span style="color:#710">&quot;</span></span></pre></div>
 </div>
     DIV
     
@@ -22,12 +20,12 @@ end
     CODE
     assert_equal <<-DIV, div
 <table class="CodeRay"><tr>
-  <td class="line-numbers" title="double click to toggle" ondblclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><a href="#n1" name="n1">1</a>
+  <td class="line_numbers" title="double click to toggle" ondblclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><a href="#n1" name="n1">1</a>
 <a href="#n2" name="n2">2</a>
 <a href="#n3" name="n3">3</a>
 </pre></td>
-  <td class="code"><pre><span style="color:#00D">5</span>.times <span style="color:#080;font-weight:bold">do</span>
-  puts <span style="background-color:hsla(0,100%,50%,0.05)"><span style="color:#710">'</span><span style="color:#D20">Hello, world!</span><span style="color:#710">'</span></span>
+  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><span style="color:#00D;font-weight:bold">5</span>.times <span style="color:#080;font-weight:bold">do</span>
+  puts <span style="background-color:hsla(0,100%,50%,0.1)"><span style="color:#710">'</span><span style="color:#D20">Hello, world!</span><span style="color:#710">'</span></span>
 <span style="color:#080;font-weight:bold">end</span></pre></td>
 </tr></table>
     DIV
@@ -38,9 +36,9 @@ end
 <body style="background-color: white;">
 
 <table class="CodeRay"><tr>
-  <td class="line-numbers" title="double click to toggle" ondblclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>
+  <td class="line_numbers" title="double click to toggle" ondblclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre>
 </pre></td>
-  <td class="code"><pre>puts <span class="string"><span class="delimiter">&quot;</span><span class="content">Hello, world!</span><span class="delimiter">&quot;</span></span></pre></td>
+  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }">puts <span class="s"><span class="dl">&quot;</span><span class="k">Hello, world!</span><span class="dl">&quot;</span></span></pre></td>
 </tr></table>
 
 </body>
@@ -48,8 +46,6 @@ end
     
     # keep scanned tokens for later use
     tokens = CodeRay.scan('{ "just": "an", "example": 42 }', :json)
-    assert_kind_of CodeRay::TokensProxy, tokens
-    
     assert_equal ["{", :operator, " ", :space, :begin_group, :key,
       "\"", :delimiter, "just", :content, "\"", :delimiter,
       :end_group, :key, ":", :operator, " ", :space,
@@ -58,8 +54,8 @@ end
       " ", :space, :begin_group, :key, "\"", :delimiter,
       "example", :content, "\"", :delimiter, :end_group, :key,
       ":", :operator, " ", :space, "42", :integer,
-      " ", :space, "}", :operator], tokens.tokens
-    
+      " ", :space, "}", :operator], tokens
+
     # produce a token statistic
     assert_equal <<-STATISTIC, tokens.statistic
 
@@ -69,30 +65,28 @@ Tokens                  26
   Non-Whitespace        15
 Bytes Total             31
 
-Token Types (7):
+Token Types (5):
   type                     count     ratio    size (average)
 -------------------------------------------------------------
   TOTAL                       26  100.00 %     1.2
   delimiter                    6   23.08 %     1.0
   operator                     5   19.23 %     1.0
   space                        5   19.23 %     1.0
-  key                          4   15.38 %     0.0
-  :begin_group                 3   11.54 %     0.0
-  :end_group                   3   11.54 %     0.0
+  begin_group                  3   11.54 %     0.0
   content                      3   11.54 %     4.3
-  string                       2    7.69 %     0.0
+  end_group                    3   11.54 %     0.0
   integer                      1    3.85 %     2.0
 
     STATISTIC
     
     # count the tokens
-    assert_equal 26, tokens.count
+    assert_equal 26, tokens.count  # => 26
     
     # produce a HTML div, but with CSS classes
     div = tokens.div(:css => :class)
     assert_equal <<-DIV, div
 <div class="CodeRay">
-  <div class="code"><pre>{ <span class="key"><span class="delimiter">&quot;</span><span class="content">just</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">an</span><span class="delimiter">&quot;</span></span>, <span class="key"><span class="delimiter">&quot;</span><span class="content">example</span><span class="delimiter">&quot;</span></span>: <span class="integer">42</span> }</pre></div>
+  <div class="code"><pre>{ <span class="ke"><span class="dl">&quot;</span><span class="k">just</span><span class="dl">&quot;</span></span>: <span class="s"><span class="dl">&quot;</span><span class="k">an</span><span class="dl">&quot;</span></span>, <span class="ke"><span class="dl">&quot;</span><span class="k">example</span><span class="dl">&quot;</span></span>: <span class="i">42</span> }</pre></div>
 </div>
     DIV
     
@@ -122,7 +116,7 @@ Token Types (7):
     div = ruby_highlighter.encode('puts "Hello, world!"')
     assert_equal <<-DIV, div
 <div class="CodeRay">
-  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.05)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, world!</span><span style="color:#710">&quot;</span></span></pre></div>
+  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.1)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, world!</span><span style="color:#710">&quot;</span></span></pre></div>
 </div>
     DIV
   end

data/test/functional/for_redcloth.rb

@@ -1,7 +1,5 @@
 require 'test/unit'
-require File.expand_path('../../lib/assert_warning', __FILE__)
-
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$:.unshift 'lib'
 require 'coderay'
 
 begin
@@ -10,18 +8,17 @@ begin
   require 'redcloth'
 rescue LoadError
   warn 'RedCloth not found - skipping for_redcloth tests.'
-  undef RedCloth if defined? RedCloth
 end
 
 class BasicTest < Test::Unit::TestCase
   
   def test_for_redcloth
     require 'coderay/for_redcloth'
-    assert_equal "<p><span lang=\"ruby\" class=\"CodeRay\">puts <span style=\"background-color:hsla(0,100%,50%,0.05)\"><span style=\"color:#710\">&quot;</span><span style=\"color:#D20\">Hello, World!</span><span style=\"color:#710\">&quot;</span></span></span></p>",
+    assert_equal "<p><span lang=\"ruby\" class=\"CodeRay\">puts <span style=\"background-color:hsla(0,100%,50%,0.1)\"><span style=\"color:#710\">&quot;</span><span style=\"color:#D20\">Hello, World!</span><span style=\"color:#710\">&quot;</span></span></span></p>",
       RedCloth.new('@[ruby]puts "Hello, World!"@').to_html
     assert_equal <<-BLOCKCODE.chomp,
 <div lang="ruby" class="CodeRay">
-  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.05)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, World!</span><span style="color:#710">&quot;</span></span></pre></div>
+  <div class="code"><pre>puts <span style="background-color:hsla(0,100%,50%,0.1)"><span style="color:#710">&quot;</span><span style="color:#D20">Hello, World!</span><span style="color:#710">&quot;</span></span></pre></div>
 </div>
       BLOCKCODE
       RedCloth.new('bc[ruby]. puts "Hello, World!"').to_html
@@ -66,19 +63,15 @@ class BasicTest < Test::Unit::TestCase
   # See http://jgarber.lighthouseapp.com/projects/13054/tickets/124-code-markup-does-not-allow-brackets.
   def test_for_redcloth_false_positive
     require 'coderay/for_redcloth'
-    assert_warning 'CodeRay::Scanners could not load plugin :project; falling back to :text' do
-      assert_equal '<p><code>[project]_dff.skjd</code></p>',
-        RedCloth.new('@[project]_dff.skjd@').to_html
-    end
+    assert_equal '<p><code>[project]_dff.skjd</code></p>',
+      RedCloth.new('@[project]_dff.skjd@').to_html
     # false positive, but expected behavior / known issue
     assert_equal "<p><span lang=\"ruby\" class=\"CodeRay\">_dff.skjd</span></p>",
       RedCloth.new('@[ruby]_dff.skjd@').to_html
-    assert_warning 'CodeRay::Scanners could not load plugin :project; falling back to :text' do
-      assert_equal <<-BLOCKCODE.chomp,
+    assert_equal <<-BLOCKCODE.chomp,
 <pre><code>[project]_dff.skjd</code></pre>
-        BLOCKCODE
-        RedCloth.new('bc. [project]_dff.skjd').to_html
-    end
+      BLOCKCODE
+      RedCloth.new('bc. [project]_dff.skjd').to_html
   end
   
 end if defined? RedCloth

data/test/functional/load_plugin_scanner.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'coderay'
+
+class PluginScannerTest < Test::Unit::TestCase
+  
+  def test_load
+    require File.join(File.dirname(__FILE__), 'vhdl')
+    assert_equal 'VHDL', CodeRay.scanner(:vhdl).class.name
+  end
+  
+end

data/test/functional/suite.rb

@@ -1,15 +1,12 @@
 require 'test/unit'
 
-$VERBOSE = $CODERAY_DEBUG = true
-$:.unshift File.expand_path('../../../lib', __FILE__)
-require 'coderay'
-
-mydir = File.dirname(__FILE__)
-suite = Dir[File.join(mydir, '*.rb')].
-  map { |tc| File.basename(tc).sub(/\.rb$/, '') } - %w'suite for_redcloth'
+MYDIR = File.dirname(__FILE__)
 
-puts "Running basic CodeRay #{CodeRay::VERSION} tests: #{suite.join(', ')}"
+$:.unshift 'lib'
+require 'coderay'
+puts "Running basic CodeRay #{CodeRay::VERSION} tests..."
 
+suite = %w(basic examples load_plugin_scanner word_list)
 for test_case in suite
-  load File.join(mydir, test_case + '.rb')
+  load File.join(MYDIR, test_case + '.rb')
 end