qwikdoc 0.0.1

data/vendor/qwik/util-time.rb

@@ -0,0 +1,125 @@
+# Copyright (C) 2003-2006 Kouichirou Eto, All rights reserved.
+# This is free software with ABSOLUTELY NO WARRANTY.
+# You can redistribute it and/or modify it under the terms of the GNU GPL 2.
+
+require 'parsedate'
+
+class Time
+  def md
+    return strftime('%m-%d')	# 01-01
+  end
+
+  def ymd_s
+    return strftime('%Y%m%d')	# 20000101
+  end
+
+  def ymd
+    return strftime('%Y-%m-%d')	# 2000-01-01
+  end
+
+  def ymdx
+    return strftime('%Y-%m-%d %X')	# 2000-01-01 12:34:56
+  end
+
+  def ymdax
+    return strftime("%Y-%m-%d(%a) %X")	# 2000-01-01(Sat) 12:34:56
+  end
+
+  def format_date
+    day = %w(�� �� �� �� �� �� �y)	# 2000-01-01 (�y) 12:34:56
+    return strftime("%Y-%m-%d #DAY# %H:%M:%S").sub(/#DAY#/, "(#{day[wday]})")
+  end
+
+  def rfc1123_date
+    return strftime('%a, %d %b %Y %H:%M:%S GMT') # Sat, 01 Jan 2000 12:34:56 GMT
+  end
+
+  def rfc_date
+    return strftime('%Y-%m-%dT%H:%M:%S')	# 2000-01-01T12:34:56
+  end
+
+  # ============================== date
+  def self.date_parse(tag)
+    if /\A(\d\d\d\d)-(\d\d)-(\d\d)\z/ =~ tag
+      return Time.local($1.to_i, $2.to_i, $3.to_i)
+    end
+    return nil
+  end
+
+  def self.date_abbr(now, date)
+    year  = date.year
+    month = date.month
+    mday  = date.mday
+    return date.ymd if now.year != date.year
+    return date.md
+  end
+
+  def self.date_emphasis(now, date, title)
+    diff = date - now
+    day = 60*60*24
+    if diff < -day	# past
+      return [:span, {:class=>'past'}, title]
+    elsif diff < day*7	# This week.
+      return [:strong, title]
+    elsif diff < day*30	# This month.
+      return [:em, title]
+    else
+      return [:span, {:class=>'future'}, title]
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  $test = true 
+end
+
+if defined?($test) && $test
+  class TestUtilTime < Test::Unit::TestCase
+    def test_time
+      t = Time.gm(2000, 1, 1, 12, 34, 56)
+      assert_equal '01-01', t.md
+      assert_equal '20000101', t.ymd_s
+      assert_equal '2000-01-01', t.ymd
+      assert_equal '2000-01-01 12:34:56', t.ymdx
+      assert_equal "2000-01-01(Sat) 12:34:56", t.ymdax
+      assert_equal "2000-01-01 (�y) 12:34:56", t.format_date
+      assert_equal 'Sat, 01 Jan 2000 12:34:56 GMT', t.rfc1123_date
+      assert_equal '2000-01-01T12:34:56', t.rfc_date
+    end
+  end
+
+  def test_date
+    # test_date_parse
+    time = Time.date_parse('1970-01-01')
+    assert_equal(-32400, time.to_i)
+
+    # test_date_abbr
+    now = Time.local(1970, 1, 1)
+    t2 = Time.local(1970, 1, 2)
+    abbr = Time.date_abbr(now, t2)
+    assert_equal '01-02', abbr
+
+    t2 = Time.local(1971, 1, 1)
+    abbr = Time.date_abbr(now, t2)
+    assert_equal '1971-01-01', abbr
+
+    # test_date_emphasis
+    now = Time.local(1970, 2, 1)
+    past = Time.local(1970, 1, 30)
+    span = Time.date_emphasis(now, past, 't')
+    assert_equal [:span, {:class=>'past'}, 't'], span
+
+    tomorrow = Time.local(1970, 2, 2)
+    span = Time.date_emphasis(now, tomorrow, 't')
+    assert_equal [:strong, 't'], span
+
+    nextweek = Time.local(1970, 2, 9)
+    span = Time.date_emphasis(now, nextweek, 't')
+    assert_equal [:em, 't'], span
+
+    nextmonth = Time.local(1970, 3, 3)
+    span = Time.date_emphasis(now, nextmonth, 't')
+    assert_equal [:span, {:class=>'future'}, 't'], span
+  end
+end

data/vendor/qwik/util-webrick.rb

@@ -0,0 +1,176 @@
+# Copyright (C) 2003-2006 Kouichirou Eto, All rights reserved.
+# This is free software with ABSOLUTELY NO WARRANTY.
+# You can redistribute it and/or modify it under the terms of the GNU GPL 2.
+
+require 'webrick'
+
+$LOAD_PATH.unshift '..' unless $LOAD_PATH.include? '..'
+
+module WEBrick
+  class BasicLog
+    # FIXEM: Ad hoc reopen support.
+    def reopen
+      log_file = @log.path
+      @log.close
+      @log = open(log_file, "a+")
+      @log.sync = true
+      @opened = true
+    end
+  end
+
+  class HTTPRequest
+    # copied from gonzui-0.1
+    # FIXME: it should be deleted if WEBrick supports the method
+    def parse_accept_language
+      if self['Accept-Language']
+        tmp = []
+        parts = self['Accept-Language'].split(/,\s*/)
+        parts.each {|part|
+          if m = /\A([\w-]+)(?:;q=([\d]+(?:\.[\d]+)))?\z/.match(part)
+            lang = m[1]
+            q = (m[2] or 1).to_f
+            tmp.push([lang, q])
+          end
+        }
+        @accept_language = 
+          tmp.sort_by {|lang, q| q}.map {|lang, q| lang}.reverse
+      else
+        @accept_language = ['en'] # FIXME: should be customizable?
+      end
+    end
+
+   #DEFINE_ACCEPT_LANGUAGE = true
+    DEFINE_ACCEPT_LANGUAGE = false
+    if DEFINE_ACCEPT_LANGUAGE || ! defined?(:accept_language)
+      def accept_language
+	if !defined?(@accept_language) || @accept_language.nil? ||
+	    @accept_language.empty?
+	  parse_accept_language
+	end
+	return @accept_language
+      end
+    end
+
+    def gzip_encoding_supported?
+      /\bgzip\b/.match(self['accept-encoding'])
+    end
+  end
+
+  # from webrick/httputils.rb
+  module HTTPUtils
+    undef parse_header
+    # FIXME: it should be deleted if WEBrick fix the problem
+    def parse_header(raw)
+      header = Hash.new([].freeze)
+      field = nil
+      raw.each{|line|
+        case line
+       #when /^([A-Za-z0-9_\-]+):\s*(.*?)\s*\z/om
+       #when /^([A-Za-z0-9_\-\!\#\$\%\&\'\*\+\.\^\`\|\~]+):\s*(.*?)\s*\z/om
+        when /^([A-Za-z0-9_\-~]+):\s*(.*?)\s*\z/om
+          field, value = $1, $2
+          field.downcase!
+          header[field] = [] unless header.has_key?(field)
+          header[field] << value
+        when /^\s+(.*?)\s*\z/om
+          value = $1
+          unless field
+            raise "bad header '#{line.inspect}'."
+          end
+          header[field][-1] << ' ' << value
+        else
+          raise "bad header '#{line.inspect}'."
+        end
+      }
+      header.each{|key, values|
+        values.each{|value|
+          value.strip!
+          value.gsub!(/\s+/, ' ')
+        }
+      }
+      header
+    end
+    module_function :parse_header
+
+    undef parse_query
+    # FIXME: it should be deleted if WEBRick fix the problem
+    def parse_query(str)
+      query = Hash.new
+      if str
+        str.split(/[&;]/).each{|x|
+          key, val = x.split(/=/,2)
+	  next if key.nil?
+          key = unescape_form(key)
+          val = unescape_form(val.to_s)
+          val = FormData.new(val)
+          val.name = key
+          if query.has_key?(key)
+            query[key].append_data(val)
+            next
+          end
+          query[key] = val
+        }
+      end
+      query
+    end
+    module_function :parse_query
+  end
+end
+
+if $0 == __FILE__
+  require 'qwik/testunit'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestHTTPUtils < Test::Unit::TestCase
+    def test_parse_accept_language
+      request = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      request.instance_eval {
+        @header = WEBrick::HTTPUtils::parse_header('Accept-Language: ja')
+	@accept_language = WEBrick::HTTPUtils.parse_qvalues(self['accept-language'])
+      }
+      ok_eq(['ja'], request.accept_language)
+
+      request.instance_eval {
+        @header = WEBrick::HTTPUtils::parse_header('Accept-Language: ja,en-us;q=0.7,en;q=0.3')
+	@accept_language = WEBrick::HTTPUtils.parse_qvalues(self['accept-language'])
+      }
+      ok_eq(['ja', 'en-us', 'en'], request.accept_language)
+
+      request.instance_eval {
+        @header = WEBrick::HTTPUtils::parse_header('Accept-Language: ja,en-us;q=0.7,en;q=0.9')
+	@accept_language = WEBrick::HTTPUtils.parse_qvalues(self['accept-language'])
+      }
+      ok_eq(['ja', 'en', 'en-us'], request.accept_language)
+    end
+
+    def test_gzip_encofing_supported?
+      request = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      request.instance_eval {
+        @header = WEBrick::HTTPUtils::parse_header('Accept-Encoding: gzip, deflate')
+      }
+      ok_eq('gzip, deflate', request['accept-encoding'])
+      ok_eq(true, !!request.gzip_encoding_supported?)
+    end
+
+    def test_parse_header
+      ok_eq("{\"header\"=>[\"content\"]}",
+	    WEBrick::HTTPUtils::parse_header('Header: content').inspect)
+      ok_eq('{"~"=>["~"]}',
+	    WEBrick::HTTPUtils::parse_header("~: ~\r\n").inspect)
+
+      # real situation
+      str = <<EOS
+Accept: */*
+Accept-Language: ja
+~~~~~~~~~~: ~~~~~~~~~~
+EOS
+      ok_eq({"accept-language"=>["ja"], "accept"=>["*/*"], "~~~~~~~~~~"=>["~~~~~~~~~~"]}, WEBrick::HTTPUtils::parse_header(str))
+    end
+
+    def test_parse_query
+      ok_eq({'a'=>'b'}, WEBrick::HTTPUtils::parse_query('&a=b'))
+    end
+  end
+end

data/vendor/qwik/version.rb

@@ -0,0 +1,11 @@
+# Automatically generated.
+# DO NOT EDIT!
+
+module Qwik
+  VERSION = '0.8.4.1'
+  RELEASE_DATE = '20060807'
+end
+
+module QuickML
+  VERSION =  '0.6q'
+end

data/vendor/qwik/wabisabi-basic.rb

@@ -0,0 +1,163 @@
+# Copyright (C) 2003-2006 Kouichirou Eto, All rights reserved.
+# This is free software with ABSOLUTELY NO WARRANTY.
+# You can redistribute it and/or modify it under the terms of the GNU GPL 2.
+
+$LOAD_PATH.unshift '..' unless $LOAD_PATH.include? '..'
+
+module WabisabiBasicModule
+  def attr(k=nil)
+    attr = self[1]
+    return nil unless attr.is_a?(Hash)
+    return attr[k] if k
+    return attr
+  end
+
+  def set_attr(new_attr)
+    attr = self.attr
+    if attr
+      attr.update(new_attr)
+    else
+      self.insert(1, new_attr)
+    end
+    return self		# For chain method.
+  end
+
+  def element_name
+    return self[0] if self[0].is_a?(Symbol)
+    return nil
+  end
+
+  def inside
+    self.reject {|x| x.is_a?(Symbol) || x.is_a?(Hash) }
+  end
+
+  def each_child
+    self.each {|e|
+      next if e.is_a?(Symbol) || e.is_a?(Hash)
+      yield(e)
+    }
+  end
+
+  def children
+    children = []
+    self.each_child {|child|
+      children << child
+    }
+    return children
+  end
+
+  def each_child_with_index
+    i = 0
+    self.each_child {|e|
+      yield(e, i)
+      i += 1
+    }
+  end
+
+  def text
+    i = 0
+    while true
+      x = self[i]
+      if x.is_a?(Symbol) || x.is_a?(Hash)
+	i += 1
+	next
+      else
+	break
+      end
+    end
+
+    (i...self.length).map {|i|
+      x = self[i]
+      if x.is_a?(String)
+	x
+      elsif x.is_a?(Array)
+	if x[0] != :"!--"
+	  x.text
+	end
+      else
+	nil
+      end
+    }.join
+  end
+
+  def get_single
+    if self.length == 1 && self.first.is_a?(Array)
+      return self.first.get_single
+    end
+    return self
+  end
+
+  def each_element(elementname)
+    self.each {|e|
+      if e.is_a?(Array) && e[0] == elementname
+	yield(e)
+      end
+    }
+  end
+end
+
+class Array
+  include WabisabiBasicModule
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestWabisabiBasic < Test::Unit::TestCase
+    def test_all
+      # test_attr
+      w = [:a, {:href=>'t1', :class=>'t2'}, 't3']
+      assert_equal({:href=>'t1', :class=>'t2'}, w.attr)
+
+      # test_set_attr
+      w = [:a]
+      assert_equal [:a, {:href=>'u'}], w.set_attr(:href=>'u')
+      assert_equal [:a, {:href=>'u', :class=>'c'}], w.set_attr(:class=>'c')
+
+      w = [:a, {:href=>'t.html'}, 't', [:b, 'b']]
+
+      # test_element_name
+      assert_equal nil, [].element_name
+      assert_equal nil, ['t'].element_name
+      assert_equal :b, [:b, 't'].element_name
+      assert_equal :a, w.element_name
+
+      # test_inside
+      assert_equal ['t', [:b, 'b']], w.inside
+
+      # test_each_child
+      w.each_child {|e|
+	assert(e == "t" || e == [:b, "b"])
+      }
+
+      # test_children
+      assert_equal ['t', [:b, 'b']], w.children
+
+      # test_each_child_with_index
+      w.each_child_with_index {|e, i|
+	case i
+	when 0; assert_equal "t", e
+	when 1; assert_equal [:b, "b"], e
+	end
+      }
+
+      # test_text
+      assert_equal 't', [:a, 't'].text
+      assert_equal 't', [:a, ['t']].text
+      assert_equal 'tb', w.text
+
+      # test_get_single
+      assert_equal [:a], [:a].get_single
+      assert_equal [:a], [[:a]].get_single
+      assert_equal [[:a], [:b]], [[:a], [:b]].get_single
+
+      # test_each_element
+      w.each_element(:b) {|e|
+	assert_equal [:b, "b"], e
+      }
+    end
+  end
+end