rabbit 0.9.2 → 0.9.3

data/lib/rabbit/theme/comment/comment.rb

@@ -1,5 +0,0 @@
-@xx_large_font_size ||= screen_size(10 * Pango::SCALE)
-@lightning_talk_as_large_as_possible = true
-include_theme("lightning-talk")
-
-proc_name = "comment"

data/lib/rabbit/theme/comment/property.rb

@@ -1,3 +0,0 @@
-@category = N_("Theme")
-@title = N_("Comment")
-@description = N_("A theme for comment window")

data/lib/rt/rt2html-lib.rb

@@ -1,157 +0,0 @@
-=begin
-rt2html-lib.rb
-$Id: rt2html-lib.rb 433 2006-11-07 00:45:14Z znz $
-=end
-require 'rt/rtvisitor'
-
-module RT
-  class RT2HTMLVisitor < RTVisitor
-    OUTPUT_SUFFIX = "html"
-    INCLUDE_SUFFIX = ["html"]
-    
-    def initialize
-      super
-    end
-    
-    def block(name)
-      %Q[<!-- #{name} -->\n] +
-      yield +
-      %Q[<!-- #{name} end -->\n\n]
-    end
-    private :block
-
-    def setup
-      block('setup') do
-        s = %Q[<table border="1">\n]
-        s << %Q[<caption>#{caption}</caption>\n] if caption
-        s
-      end
-    end
-    
-    def teardown
-      block('teardown') do
-        %Q[</table>\n]
-      end
-    end
-    
-    def cell_element(cell, name)
-      rs, cs = cell.rowspan, cell.colspan
-      if rs == 1 and cs == 1
-        ret = "<#{name}>"
-      elsif rs == 1
-        ret = %Q[<#{name} colspan="#{cs}">]
-      elsif cs == 1
-        ret = %Q[<#{name} rowspan="#{rs}">]
-      else
-        ret = %Q[<#{name} colspan="#{cs}" rowspan="#{rs}">]
-      end
-      ret
-    end
-    private :cell_element
-
-    def visit_Header(ary = @header)
-      block('Header') do
-        if ary.empty?
-          ""
-        else
-          ret = "<thead>\n"
-          ary.each do |line|
-            ret << '<tr>'
-            each_cell(line) do |cell|
-              ret << cell_element(cell, 'th')
-              ret << cell.value
-              ret << '</th>'
-            end
-            ret << "</tr>\n"
-          end
-          ret << "</thead>\n"
-        end
-      end
-    end
-    
-    def visit_Body(ary = @body)
-      block('Body') do
-        ret = "<tbody>\n"
-        ary.each do |line|
-          ret << '<tr>'
-          each_cell(line) do |cell|
-            ret << cell_element(cell, %Q[td align="#{cell.align.id2name}"])
-            ret << cell.value
-            ret << '</td>'
-          end
-          ret << "</tr>\n"
-        end
-        ret << "</tbody>\n"
-      end
-    end
-    
-  end                           # RT2HTMLVisitor
-end
-$Visitor_Class = RT::RT2HTMLVisitor
-if __FILE__ == $0
-  require 'runit-init'
-  
-  include RT
-  class RT2HTMLVisitorTest < RUNIT::TestCase
-    def setup
-      @x = RT2HTMLVisitor::new
-      @x.visit(RTParser::parse(<<-END))
-      caption = ɽ�ƥ���
-
-           , �ʹ�, == , �� , ==
-       ||  , ��  , �� ,����,�᥹
-
-        x  , 1.0 , 2.0, 1.1, 1.2
-        y  , 0.4 , 0.5, 0.3, 0.1
-      END
-    end
-    
-    def uncomment(str)
-      rep = "\001"
-      #if str =~ /\A<!--\s+.+?\s+-->\n(.+)<!--\s+.+?\s+-->\n\n\Z/p# POSIX
-      if str.gsub(/\n/, rep) =~ /\A<!--\s+.+?\s+-->#{rep}(.+)<!--\s+.+?\s+-->#{rep}#{rep}\Z/
-        #$1
-        $1.gsub(/#{rep}/, "\n")
-      else
-        assert_fail("not RTBlock format")
-      end
-    end
-    
-    def test_setup
-      lines =
-        %Q[<table border="1">\n] +
-        %Q[<caption>ɽ�ƥ���</caption>\n]
-      assert_equal(lines, uncomment(@x.setup))
-    end
-    
-    def test_teardown
-      assert_equal(%Q[</table>\n], uncomment(@x.teardown))
-    end
-    
-    def test_visit_Header
-      lines =
-        %Q[<thead>\n] +
-        %Q[<tr><th rowspan="2"></th><th colspan="2">�ʹ�</th><th colspan="2">��</th></tr>\n] +
-        %Q[<tr><th>��</th><th>��</th><th>����</th><th>�᥹</th></tr>\n] +
-        %Q[</thead>\n]
-      assert_equal(lines, uncomment(@x.visit_Header))
-    end
-    
-    def test_visit_Body
-      lines =
-        %Q[<tbody>\n] +
-        %Q[<tr><td align="left">x</td><td align="right">1.0</td><td align="right">2.0</td><td align="right">1.1</td><td align="right">1.2</td></tr>\n] +
-        %Q[<tr><td align="left">y</td><td align="right">0.4</td><td align="right">0.5</td><td align="right">0.3</td><td align="right">0.1</td></tr>\n] +
-        %Q[</tbody>\n]
-      assert_equal(lines, uncomment(@x.visit_Body))
-    end
-    
-    def test0
-      assert_equal(RT::RTCell, RT::RTCell::new("a").type)
-    end
-
-  end
-  testrunner RT2HTMLVisitorTest
-end
-
-

data/lib/rt/rtparser.rb

@@ -1,226 +0,0 @@
-#!/usr/bin/ruby
-=begin
-rtparser.rb
-$Id: rtparser.rb 433 2006-11-07 00:45:14Z znz $
-=end
-module RT
-  class RTCell
-    def initialize(value, align = nil)
-      @rowspan = @colspan = 1
-      @value = value
-      @align = case align       # {:left, :center :right}
-               when :left, :center, :right
-                 align
-               when nil
-                 if /^[+\-]?[0-9]+\.?[0-9]*/ === value
-                   :right
-                 else
-                   :left
-                 end
-               else
-                 raise "[BUG]Illegal align type"
-               end
-    end
-    def == (x)
-      case x
-      when self.class
-        self.value == "" && x.value == "" || self.value == x.value && self.align == x.align
-      else
-        false
-      end
-    end
-    def inspect
-      if value==""
-        "()"
-      else
-        a = case align
-            when :left
-              "l"
-            when :center
-              "c"
-            when :right
-              "r"
-            else
-              raise "[BUG]Illegal align type"
-            end
-        "#{a}(#{value})"
-      end
-    end
-
-    attr_reader :value, :align
-    attr_accessor :rowspan, :colspan
-  end
-
-  class RTParser
-    DefaultConfig = {
-      'delimiter' => "[,\t]",
-      'rowspan'   => "||",
-      'colspan'   => "==",
-      'escape'    => nil,
-      'caption'   => nil,
-    }
-      
-    def initialize(str="")
-      @str = str.dup
-      normalize_linefeed! @str
-      @config_line = []
-      @header_line = []
-      @body_line = []
-      @config = DefaultConfig.dup
-      @header = []
-      @body = []
-    end
-    attr_reader :str, :config, :header, :body
-    
-    def normalize_linefeed!(str)
-      str.gsub!("\r\n", "\n")
-      str.gsub!("\r", "\n")
-    end
-
-    def self::parse(str)
-      obj = self::new str
-      obj.make_blocks
-      obj.parse_config
-      obj.parse_header
-      obj.parse_body
-      obj.calc_span(obj.header)
-      obj.calc_span(obj.body)
-      obj
-    end
-    
-    def blocks
-      [@config_line, @header_line, @body_line]
-    end
-
-    def make_blocks(str = @str)
-      part = str.split(/\n\n/).collect{|x| x.split(/\n/)}
-      case part.length
-      when 0
-      when 1
-        @body_line, = part
-      when 2
-        @config_line, @body_line = part
-      when 3
-        @config_line, @header_line, @body_line = part
-      else
-        raise "RT: blocks are too many."
-      end
-      self
-    end
-    
-    def parse_config(lines = @config_line)
-      lines.each do |line|
-        case line
-        when /^#/               # comment
-        when /^\s*(\S+)\s*=\s*(.+)$/
-          @config[$1] = $2
-        else
-          raise "RT: syntax error in config block"
-        end
-      end
-      self
-    end
-    
-    def split2(str,re)
-      ret = str.split(re, -1)
-    end
-    private :split2
-
-    ESCAPE_TMP = "\001\002"
-    def _escape!(str)
-      esc = config['escape']
-      str.gsub!(/#{Regexp.quote(esc)}#{config['delimiter']}/, ESCAPE_TMP)  if esc
-    end
-    private :_escape!
-
-    def _unescape!(str)
-      str.gsub!(/#{ESCAPE_TMP}/, config['delimiter'])
-    end
-    private :_unescape!
-
-    def parse_table_data(lines)  # iterator
-      ret = []
-      lines.each do |line|
-        case line
-        when /^#/             # comment
-        else
-          _escape! line
-          ret << split2(line, /\s*#{config['delimiter']}\s*/).collect {|x|
-            _unescape! x
-            yield(x.strip)
-          }
-        end
-      end
-      unless ret.find_all{|x| x.length == ret[0].length} == ret
-        raise "RT: different column size"
-      end
-      ret
-    end
-    private :parse_table_data
-
-    def _make_cell(x, align)
-      case x
-      when config['rowspan'], config['colspan']
-        x
-      else
-        RTCell::new(x, align)
-      end
-    end
-    private :_make_cell
-
-    def parse_header(lines = @header_line)
-      @header = parse_table_data(lines) {|x|
-        _make_cell x, :center
-      }
-      self
-    end
-
-    def parse_body(lines = @body_line)
-      @body = parse_table_data(lines) {|x|
-        _make_cell x, nil
-      }
-      self
-    end
-    
-    def calc_span(tbl)
-      return if tbl.empty?
-      cols = tbl[0].length
-      tbl.each do |row|
-        row.each_with_index do |elm, j|
-          case elm
-          when String
-          when RTCell
-            nspan = 1
-            1.upto(cols-j-1) do |k|
-              break unless row[j+k] == config['colspan']
-              nspan += 1
-            end
-            row[j].colspan = nspan
-          else
-            raise "[BUG] invalid cell"
-          end
-        end
-      end
-      
-      rows = tbl.length
-      0.upto(cols-1) do |j|
-        0.upto(rows-1) do |i|
-          case tbl[i][j]
-          when String
-          when RTCell
-            nspan = 1
-            1.upto(rows-i-1) do |k|
-              break unless tbl[i+k][j] == config['rowspan']
-              nspan += 1
-            end
-            tbl[i][j].rowspan = nspan
-          else
-            raise "[BUG] invalid cell"
-          end
-        end
-      end
-    end    
-  end                           # class RTCell, RTParser
-end                             # module RT
-
-      

data/lib/rt/rtvisitor.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/ruby
-=begin
-rtvisitor.rb
-$Id: rtvisitor.rb 433 2006-11-07 00:45:14Z znz $
-=end
-require 'rt/rtparser'
-
-module RT
-  class RTVisitor
-    def each_cell(ary)
-      ary.each do |x|
-        if x.class == RT::RTCell
-          yield x
-        else
-        end
-      end
-    end
-    private :each_cell
-    
-    def initialize
-    end
-    attr_reader :rt, :header, :body, :caption
-    attr_accessor :filename, :charcode
-    
-    def self.visit(parsed)
-      self::new.visit(parsed)
-    end
-
-    def visit(parsed)
-      @filename = @charset = nil
-      @rt = parsed
-      @header = @rt.header
-      @body = @rt.body
-      @caption = @rt.config['caption']
-
-      setup +
-        visit_Caption +
-        visit_Header +
-        visit_Body +
-        teardown
-    end
-    
-    def setup
-      ""
-    end
-    
-    def teardown
-      ""
-    end
-    
-    def visit_Caption
-      ""
-    end
-    
-    def visit_Header
-      ""
-    end
-    
-    def visit_Body
-      ""
-    end
-  end
-end
-
-
-
-      
-