langscan 1.2

data/test/langscan/rpmspec/test/test_rpmspec.rb

@@ -0,0 +1,51 @@
+$LOAD_PATH << "../../.." unless $LOAD_PATH.include?("../../..")
+require 'test/unit'
+require 'langscan/rpmspec'
+
+class TestRPMSpec < Test::Unit::TestCase
+  def assert_yield_any(recv, meth, *args)
+    success = false
+    recv.__send__(meth, *args) {|*block_args|
+      if yield(*block_args)
+        assert(true)
+        success = true
+        break
+      end
+    }
+    assert(false, "no expected yields") unless success
+  end
+
+  def assert_yield_all(recv, meth, *args)
+    recv.__send__(meth, *args) {|*block_args|
+      if !yield(*block_args)
+        assert(false, "unexpected yields")
+        return
+      end
+    }
+    assert(true)
+  end
+
+  def test_preamble
+    assert_yield_any(LangScan::RPMSpec, :scan, "\nName: gonzui") {|f|
+      f.type == :keyword && f.text == 'Name'
+    }
+  end
+
+  def test_part
+    assert_yield_any(LangScan::RPMSpec, :scan, "\n%description devel") {|f|
+      f.type == :keyword && f.text == '%description'
+    }
+  end
+
+  def test_comment
+    assert_yield_any(LangScan::RPMSpec, :scan, "\n# comment") {|f|
+      f.type == :comment && f.text == '# comment'
+    }
+  end
+
+  def test_string
+    assert_yield_any(LangScan::RPMSpec, :scan, "\nCFLAGS=\"$RPM_OPT_FLAGS -Wall\"") {|f|
+      f.type == :string && f.text == '"$RPM_OPT_FLAGS -Wall"'
+    }
+  end
+end

data/test/langscan/ruby/test/test_scan.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'langscan/ruby'
+
+class TestRuby < Test::Unit::TestCase
+  def assert_yield_any(recv, meth, *args)
+    recv.__send__(meth, *args) {|*block_args|
+      if yield(*block_args)
+        assert(true)
+        return
+      end
+    }
+    assert(false, "no expected yields")
+  end
+
+  def assert_yield_all(recv, meth, *args)
+    recv.__send__(meth, *args) {|*block_args|
+      if !yield(*block_args)
+        assert(false, "unexpected yields")
+        return
+      end
+    }
+    assert(true)
+  end
+
+  def test_class
+    assert_yield_any(LangScan::Ruby, :scan, "class A\nend") {|f|
+      f.type == :classdef && f.text == 'A'
+    }
+  end
+
+  def test_module
+    assert_yield_any(LangScan::Ruby, :scan, "module A\nend") {|f|
+      f.type == :moduledef && f.text == 'A'
+    }
+  end
+
+  def test_symbol
+    assert_yield_any(LangScan::Ruby, :scan, ":aaa") {|f|
+      f.type == :symbol && f.text == 'aaa'
+    }
+  end
+
+  def test_const
+    assert_yield_any(LangScan::Ruby, :scan, "ABC") {|f|
+      f.type == :const && f.text == 'ABC'
+    }
+  end
+
+  def assert_fragment_type(type, text, src)
+    found = false
+    LangScan::Ruby.scan(src) {|f|
+      if f.text == text
+        if found
+          raise "token #{text} occurred twice"
+        else
+          found = true
+          assert_equal(type, f.type, "fragment type of #{text}")
+        end
+      end
+    }
+    unless found
+      raise "token #{text} not found"
+    end
+  end
+
+  def test_singleton_method
+    assert_fragment_type(:fundef, 'm', "def o.m() end")
+  end
+
+
+end

data/test/langscan/scheme/test/test_scan.rb

@@ -0,0 +1,198 @@
+require 'test/unit'
+require 'langscan/scheme'
+
+class TestScheme < Test::Unit::TestCase
+  def assert_yield(recv, meth, *args)
+    yielded = false
+    recv.__send__(meth, *args) {|*block_args|
+      yielded = true
+      yield(*block_args)
+    }
+    assert(yielded, "block not yielded")
+  end
+  
+  def assert_not_yield(recv, meth, *args)
+    yielded = false
+    recv.__send__(meth, *args) {|*block_args|
+      assert(false, "block yielded")
+    }
+  end
+  
+  def assert_yield_any(recv, meth, *args)
+    success = false
+    recv.__send__(meth, *args) {|*block_args|
+      if yield(*block_args)
+        assert(true)
+        success = true
+        break
+      end
+    }
+    assert(false, "no expected yields") unless success
+  end
+  
+  def assert_yield_all(recv, meth, *args)
+    recv.__send__(meth, *args) {|*block_args|
+      if !yield(*block_args)
+        assert(false, "unexpected yields")
+        return
+      end
+    }
+    assert(true)
+  end
+  
+  def test_fundef
+    [
+      {:str => "(define (foo))", :text => "foo"},
+      {:str => "(define (foo bar))", :text => "foo"},
+      {:str => "(define (foo bar) baz)", :text => "foo"},
+      {:str => "(define (foo= a) (= a a))", :text => "foo="}
+    ].each {|src|
+      assert_yield_any(LangScan::Scheme, :scan, src[:str]) {|f|
+        f.type == :fundef && f.text == src[:text]
+      }
+    }
+  end
+  
+  def test_funcall
+    [
+      {:str => "(foo)", :text => "foo"},
+      {:str => "(foo bar)", :text => "foo"},
+      {:str => "(let ((a 1) (b 2)) (+ a b))", :text => "+"},
+      {:str => "(do ((i 0 (+ i 1))) ((= i 10)) (foo))", :text => "foo"}
+    ].each {|src|
+      assert_yield_any(LangScan::Scheme, :scan, src[:str]) {|f|
+        f.type == :funcall && f.text == src[:text]
+      }
+    }
+  end
+
+  def test_string
+    [
+      '"foo"',
+      %Q!"foo\nbar"!,
+      '"foo\"bar"',
+      '"foo\\"',
+    ].each { |src|
+      assert_yield(LangScan::Scheme, :scan, src) {|f|
+        f.type == :string
+      }
+    }
+  end
+  
+  def test_ident
+    %w(foo foo= foo? + <=>? @foo fo!o ~foo foo^ foo$ &foo ** +- .foo
+       /hoge:
+    ).each {|src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :ident
+      }
+    }
+  end
+
+  def test_quote
+    [
+      "'(a b c)",
+      "(quote (a b c)",
+      "(quasiquote (a b c))",
+    ].each { |src|
+      assert_yield_all(LangScan::Scheme, :scan, src) {|f|
+        f.type != :funcall
+      }
+    }
+  end
+
+  def test_number
+    %w(
+      1 -1 1050 #d1 #o0766 #b10 #xab  #d#e16 #e#x1f #e10
+    ).each { |src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :integer
+      }
+    }
+
+    %w(
+      10.5 .543 .5e-5 10e10 10e-10 10#f4 10##.#d2 10/4 #xe/f
+    ).each { |src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :floating
+      }
+    }
+
+    %w(
+      3+i +i -i 0+i 0-10i #d0-10i -10i #x-i #d+i #x1+2i #xab+2i
+      #x1-2i #xa-2i #xa-i #xab/cd+1/23#i
+    ).each { |src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :imaginary
+      }
+    }
+  end
+
+  def test_comment
+    [
+      '; comment',
+      "(foo bar) ; comment"
+    ].each { |src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :comment
+      }
+    }
+  end
+  
+  def test_space
+    [
+      '\  ',
+      "' 'foo bar"
+    ].each { |src|
+      assert_yield_any(LangScan::Scheme, :scan, src) {|f|
+        f.type == :space
+      }
+    }
+  end
+
+  def assert_fragment_type(type, text, src)
+    found = false
+    LangScan::Scheme.scan(src) {|f|
+      if f.text == text
+        if found
+          raise "token #{text} occurred twice"
+        else
+          found = true
+          assert_equal(type, f.type, "fragment type of #{text}")
+        end
+      end
+    }
+    unless found
+      raise "token #{text} not found"
+    end
+  end
+
+  def self.define_assert_fragment_type(name, type, text, src)
+    self.module_eval {
+      define_method("test_#{name}") {
+        assert_fragment_type(type, text, src)
+      }
+    }
+  end
+
+  def test_nest_in_quote
+    assert_fragment_type(:ident, 'a', "'(a (b))")
+    assert_fragment_type(:ident, 'a', "(quote (a (b)))")
+    assert_fragment_type(:ident, 'b', "'(a (b))")
+    assert_fragment_type(:ident, 'b', "`(a (b))")
+    assert_fragment_type(:ident, 'b', "(quasiquote (a (b)))")
+    assert_fragment_type(:ident, 'b', "(quasiquote `(a (unquote (b))))")
+    assert_fragment_type(:funcall, 'b', "`(a ,(b))")
+    assert_fragment_type(:funcall, 'b', "``(a ,,(b))")
+    assert_fragment_type(:funcall, 'b', "`(a ,@(b))")
+    assert_fragment_type(:funcall, 'b', "(quasiquote `(a (unquote ,(b))))")
+  end
+
+  def test_let_body
+    assert_fragment_type(:funcall, 'y', "(let ((x 1)) ((y)))")
+    assert_fragment_type(:funcall, 'y', "(let ((x 1) (z 2)) ((y)))")
+    assert_fragment_type(:funcall, 'y', "(let ((x 1) (z 2)) (y))")
+    assert_fragment_type(:ident, 'z', "(let ((x 1) (z 2)) ((y)))")
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'stringio'
+require 'test/unit'
+begin
+  require 'redgreen'
+rescue
+end
+require File.dirname(__FILE__) + '/../lib/langscan'

data/test/test_langscan.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestLangscan < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_c
+    fragments = []
+    LangScan::C.scan('#include <"stdio.h">') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(6, fragments.size)
+  end
+
+  def test_csharp
+    fragments = []
+    LangScan::Csharp.scan('namespace Sample{useing System;}') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(9, fragments.size)
+  end
+
+
+  def test_d
+    fragments = []
+    LangScan::D.scan('import std.stdio;') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(6, fragments.size)
+  end
+
+  def test_java
+    fragments = []
+    LangScan::Java.scan('package com.example;') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(6, fragments.size)
+  end
+
+  def test_ruby
+    fragments = []
+    LangScan::Ruby.scan('print "Hello", "World"') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(10, fragments.size)
+  end
+
+  def test_python
+    fragments = []
+    LangScan::Python.scan('puts "Hello World"') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(3, fragments.size)
+  end
+
+  def test_javascript
+    fragments = []
+    LangScan::JavaScript.scan('(function(){})();') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(10, fragments.size)
+  end
+
+  def test_css
+    fragments = []
+    LangScan::CSS.scan('div#example p.sample { border: 1px solid red; }') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(14, fragments.size)
+  end
+
+  def test_php
+    fragments = []
+    LangScan::PHP.scan('<?php echo "php"') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(4, fragments.size)
+  end
+
+  def test_sh
+    fragments = []
+    LangScan::Shell.scan('#!/bin/sh\necho $1') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(1, fragments.size)
+  end
+
+  def test_text
+    fragments = []
+    LangScan::Text.scan('This is plain text') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(1, fragments.size)
+  end
+
+  def test_elisp
+    fragments = []
+    LangScan::EmacsLisp.scan('(line-number-mode 1)') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(5, fragments.size)
+  end
+
+  def test_scheme
+    fragments = []
+    LangScan::Scheme.scan('(line-number-mode 1)') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(5, fragments.size)
+  end
+
+  def test_brainfuck
+    fragments = []
+    LangScan::Brainfuck.scan('>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>++++++++[<++
+++>-]<.>+++++++++++[<+++++>-]<.>++++++++[<+++>-]<.+++.------.--------.[-]>
+++++++++[<++++>-]<+.[-]++++++++++.') do |fragment|
+      fragments << fragment
+    end
+    assert_equal(182, fragments.size)
+  end
+
+end