qwikdoc 0.0.1

data/vendor/qwik/typekey.rb

@@ -0,0 +1,160 @@
+#
+# Copyright (C) 2005 jouno <jouno2002@yahoo.co.jp>
+# License under GPL-2
+#
+# original is Adam Bregenzer(<adam@bregenzer.net>)'s python version
+# http://adam.bregenzer.net/python/typekey/TypeKey.py
+#
+# modified by Kouichirou Eto
+#
+# note:
+# nick name field must be sent as utf-8 url_encoded string.
+
+# sample code:
+
+=begin
+token = 'your_site_token'
+tk = TypeKey.new(token, '1.1')
+
+if cgi.params['tk'][0] == '1'
+  ts    = cgi.params['ts'][0]
+  email = cgi.params['email'][0]
+  name  = cgi.params['name'][0]
+  nick  = cgi.params['nick'][0]
+  sig   = cgi.params['sig'][0]
+  if tk.verify(email, name, nick, ts, sig)
+    puts 'verify!'
+  else
+    puts 'not!'
+  end
+end
+
+return_url = 'http://localhost/cgi-bin/tk_test.cgi'
+
+url_sign_in = tk.get_login_url(return_url + '?tk=1')
+url_sign_out = tk.get_logout_url(return_url)
+
+puts "<a href=\"#{url_sign_in}\">sign in</a><br />"
+puts "<a href=\"#{url_sign_out}\">sign out</a><br />"
+=end
+
+require 'uri'
+require 'open-uri'
+require 'base64'
+require 'openssl'
+
+class TypeKeyError < StandardError; end
+class TimeOutError < TypeKeyError; end
+class VerifyFailed < TypeKeyError; end
+
+# This class handles TypeKey logins.
+class TypeKey
+  def initialize(token, version = '1.1')
+    @token = token
+    @version = version
+
+    # Base url for generating login and logout urls.
+    @base_url = 'https://www.typekey.com/t/typekey/'
+
+    # Url used to download the public key.
+    @key_url = 'http://www.typekey.com/extras/regkeys.txt'
+
+    # Location for caching the public key.
+    @key_cache_path = '/tmp/tk_key_cache'
+
+    # Length of time to wait before refreshing the public key cache, in seconds.
+    # Defaults to two days.
+    @key_cache_timeout = 60 * 60 * 24 * 2
+
+    # Length of time logins remain valid, in seconds.
+    # Defaults to five minutes.
+    @login_timeout = 60 * 5
+  end
+  attr_accessor :base_url, :login_timeout
+  attr_accessor :key_url, :key_cache_path, :key_cache_timeout
+
+  # Verify a typekey login
+  def verify(email, name, nick, ts, sig, key = nil)
+    sig.gsub!(/ /, '+') # sig isn't urlencoded.
+
+    key = get_key if key.nil?
+
+    message_ar = [email, name, nick, ts.to_s]
+    message_ar << @token if @version == '1.1'
+    message = message_ar.join('::')
+
+    raise VerifyFailed if ! dsa_verify(message, sig, key)
+    raise TimeOutError if (Time.now.to_i - ts.to_i) > @login_timeout
+    return true
+  end
+
+  # Return a URL to login to TypeKey
+  def get_login_url(return_url, email = false)
+    url  = @base_url
+    url += "login?t=#{@token}"
+    url += (email ? '&need_email=1' : '')
+    url += "&_return=#{URI.escape(return_url)}"
+    url += "&v=#{@version}"
+    return url
+  end
+
+  # Return a URL to logout of TypeKey
+  def get_logout_url(return_url)
+    return @base_url + 'logout?_return=' + URI.escape(return_url)
+  end
+
+  # Return the TypeKey public keys, cache results unless a url is passed
+  def get_key(url = nil)
+    if url.nil?
+      begin
+        mod_time = File.mtime(@key_cache_path).to_i
+      rescue SystemCallError
+        mod_time = 0
+      end
+
+      if @key_cache_timeout < (Time.now.to_i - mod_time) ||
+          ! File.exist?(@key_cache_path)
+        open(@key_url) {|fh| # using open-uri
+          @key_string = fh.read
+        }
+        File.open(@key_cache_path, 'w') {|fh|
+          fh.puts(@key_string)
+        }
+      else
+        File.open(@key_cache_path, 'r') {|fh|
+          @key_string = fh.read
+        }
+      end
+    else
+      open(url) {|fh|
+        @key_string = fh.read
+      }
+    end
+
+    tk_key = Hash.new
+
+    for pair in @key_string.strip.split(' ')
+      key, value = pair.split('=')
+      tk_key[key] = value.to_i
+    end
+
+    return tk_key
+  end
+
+  # Verify a DSA signature
+  def dsa_verify(message, sig, key)
+    r_sig, s_sig = sig.split(':')
+    r_sig = Base64.decode64(r_sig).unpack('H*')[0].hex
+    s_sig = Base64.decode64(s_sig).unpack('H*')[0].hex
+    sign = OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::Integer.new(r_sig),
+					 OpenSSL::ASN1::Integer.new(s_sig)]
+				       ).to_der
+    dsa = OpenSSL::PKey::DSA.new
+    dsa.p = key['p']
+    dsa.q = key['q']
+    dsa.g = key['g']
+    dsa.pub_key = key['pub_key']
+    dss1 = OpenSSL::Digest::DSS1.new
+    return dsa.verify(dss1, sign, message)
+  end
+end

data/vendor/qwik/util-basic.rb

@@ -0,0 +1,135 @@
+#
+# Copyright (C) 2002-2004 Satoru Takabayashi <satoru@namazu.org> 
+# 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 General Public License version 2.
+#
+
+$LOAD_PATH.unshift '..' unless $LOAD_PATH.include? '..'
+require 'qwik/util-string'
+
+class NilClass
+  def empty?
+    return true
+  end
+end
+
+class Integer
+  # 12345.commify => '12,345'
+  def commify
+    numstr = self.to_s
+    true while numstr.sub!(/^([-+]?\d+)(\d{3})/, '\1,\2')
+    return numstr
+  end
+
+  UNITS = ['Bytes','KB','MB','GB','TB','PB']
+  # 1024 => 1KB
+  def byte_format
+      n = self
+      UNITS.each {|unit|
+        t = n/1024
+        if t > 0
+          n = t
+        else
+          return n.to_s + unit
+        end
+      }
+      return n.to_s + _(unit)
+  end
+end
+
+# It preserves case information. but it accepts an
+# address case-insensitively for member management.
+class IcaseArray < Array
+  def include? (item)
+    if self.find {|x| x.downcase == item.downcase } 
+      return true
+    else
+      return false
+    end
+  end
+
+  def delete (item)
+    self.replace(self.find_all {|x| x.downcase != item.downcase })
+  end
+end
+
+class IcaseHash < Hash
+  def include? (key)
+    super(key.downcase)
+  end
+
+  def delete (key)
+    super(key.downcase)
+  end
+
+  def [] (key)
+    super(key.downcase)
+  end	
+
+  def []= (key, value)
+    super(key.downcase, value)
+  end	
+end
+
+class Hash
+  def to_query_string
+    ar = []
+    self.each {|k, v|
+      if k && v
+	ar << "#{k.to_s.escape}=#{v.to_s.escape}"
+      end
+    }
+    return ar.sort.join('&')
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestUtilBasic < Test::Unit::TestCase
+    def test_nil
+      assert_equal true, nil.empty?
+    end
+
+    def test_integer
+      assert_equal '12,345', 12345.commify
+      assert_equal '123,456,789', 123456789.commify
+
+      assert_equal '1KB', (1024+1).byte_format
+      assert_equal '2MB', (2*1024*1024+2).byte_format
+      assert_equal '3GB', (3*1024*1024*1024+3).byte_format
+      assert_equal '4TB', (4*1024*1024*1024*1024+4).byte_format
+    end
+
+    def test_iscase_array
+      iar = IcaseArray.new
+      iar << 'T'
+      assert_equal true, iar.include?('T')
+      assert_equal true, iar.include?('t')
+      iar.delete('t')
+      assert_equal false, iar.include?('t')
+    end
+
+    def test_icase_hash
+      ih = IcaseHash.new
+      ih['T'] = 1
+      assert_equal true, ih.include?('t')
+      assert_equal 1, ih['t']
+      ih.delete('t')
+      assert_equal false, ih.include?('t')
+    end
+
+    def test_hash
+      # test_hash_to_query_string
+      assert_equal 'k=v', {:k=>'v'}.to_query_string
+      assert_equal 'k1=v1&k2=v2', {:k1=>'v1', :k2=>'v2'}.to_query_string
+    end
+  end
+end

data/vendor/qwik/util-charset.rb

@@ -0,0 +1,332 @@
+#encoding: sjis
+# 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 'kconv'
+require 'iconv'
+
+$LOAD_PATH.unshift '..' unless $LOAD_PATH.include? '..'
+
+class String
+  # ============================== kconv
+  def sjistoeuc
+    self.kconv(Kconv::EUC, Kconv::SJIS).set_euc
+  end
+
+  def euctosjis
+    self.kconv(Kconv::SJIS, Kconv::EUC).set_sjis
+  end
+
+  def sjistojis
+    self.kconv(Kconv::JIS, Kconv::SJIS).set_jis
+  end
+
+  def jistosjis
+    self.kconv(Kconv::SJIS, Kconv::JIS).set_sjis
+  end
+
+  def euctojis
+    self.kconv(Kconv::JIS, Kconv::EUC).set_jis
+  end
+
+  def jistoeuc
+    self.kconv(Kconv::EUC, Kconv::JIS).set_euc
+  end
+
+  # ============================== iconv
+  def sjistou8;	Iconv.iconv_to_from('UTF-8', 'Shift_JIS', self)	end
+  def u8tosjis;	Iconv.iconv_to_from('Shift_JIS', 'UTF-8', self)	end
+  def euctou8;	Iconv.iconv_to_from('UTF-8', 'EUC-JP', self)	end
+  def u8toeuc;	Iconv.iconv_to_from('EUC-JP', 'UTF-8', self)	end
+  def jistou8;	Iconv.iconv_to_from('UTF-8', 'ISO-2022-JP', self)	end
+  def u8tojis
+    iconv = Iconv.new('ISO-2022-JP', 'UTF-8')
+    out = iconv.iconv(self)+iconv.close
+    out.set_charset('ISO-2022-JP')
+    out
+  end
+
+  # ============================== charset
+  def set_charset(charset)
+    @charset = charset
+    return self
+  end
+
+  def charset
+    return @charset if defined?(@charset)
+    return nil
+  end
+
+  def set_utf8;	set_charset('UTF-8')		end
+  def set_sjis;	set_charset('Shift_JIS')	end
+  def set_euc;	set_charset('EUC-JP')		end
+  def set_jis;	set_charset('ISO-2022-JP')	end
+
+  KCONV_TO_CHARSET = {
+   #Kconv::AUTO		=> '?',
+    Kconv::JIS		=> 'ISO-2022-JP',
+    Kconv::EUC		=> 'EUC-JP',
+    Kconv::SJIS		=> 'Shift_JIS',
+   #Kconv::BINARY	=> '?BINARY',
+   #Kconv::NOCONV	=> '?NOCONV',
+    Kconv::ASCII	=> 'ASCII',
+    Kconv::UTF8		=> 'UTF-8',
+    Kconv::UTF16	=> 'UTF-16',
+    Kconv::UTF32	=> 'UTF-32',
+   #Kconv::UNKNOWN	=> '?',
+  }
+
+  def guess_charset
+    kconv_charset = Kconv::guess(self)
+    charset = KCONV_TO_CHARSET[kconv_charset]
+    if /\A\?/ =~ charset
+      #p kconv_charset, charset
+    end
+    return charset
+  end
+
+  def guess_charset!
+    set_charset(self.guess_charset)
+    return self
+  end
+
+  # tosjis is used in kconv.rb
+  def to_sjis
+    raise 'Undefined charset.' if self.charset.nil?
+    case self.charset
+    when 'ASCII';	return self
+    when 'UTF-8';	return self.u8tosjis
+    when 'Shift_JIS';	return self
+    when 'EUC-JP';	return self.euctosjis
+    when 'ISO-2022-JP';	return self.jistosjis
+    end
+    raise 'Unknown charset.'
+  end
+
+  # toeuc is used in kconv.rb
+  def to_euc
+    raise 'Undefined charset.' if self.charset.nil?
+    case self.charset
+    when 'ASCII';	return self
+    when 'UTF-8';	return self.u8toeuc
+    when 'Shift_JIS';	return self.sjistoeuc
+    when 'EUC-JP';	return self
+    when 'ISO-2022-JP';	return self.jistoeuc
+    end
+    raise 'Unknown charset.'
+  end
+
+  # tojis is used in kconv.rb
+  def to_jis
+    raise 'Undefined charset.' if self.charset.nil?
+    case self.charset
+    when 'ASCII';	return self
+    when 'UTF-8';	return self.u8tojis
+    when 'Shift_JIS';	return self.sjistojis
+    when 'EUC-JP';	return self.euctojis
+    when 'ISO-2022-JP';	return self
+    end
+    raise 'Unknown charset.'
+  end
+
+  def to_utf8
+   #raise 'Undefined charset.' if self.charset.nil?
+    self.guess_charset! if self.charset.nil?
+    case self.charset
+    when 'ASCII';	return self
+    when 'UTF-8';	return self
+    when 'Shift_JIS';	return self.sjistou8
+    when 'EUC-JP';	return self.euctou8
+    when 'ISO-2022-JP';	return self.jistou8
+    end
+    raise 'Unknown charset.'
+  end
+
+  # Some use case.
+  alias set_mail_charset	set_jis
+  alias set_page_charset	set_sjis	# This can be changed.
+  alias set_sourcecode_charset	set_sjis	# This can be changed.
+  alias set_xml_charset		set_utf8
+  alias set_url_charset		set_utf8
+  alias set_filename_charset	set_utf8
+
+  alias to_mail_charset		to_jis
+  alias to_page_charset		to_sjis
+  alias to_xml_charset		to_utf8
+  alias to_url_charset		to_utf8
+  alias to_filename_charset	to_utf8
+
+  def page_to_xml
+    self.set_page_charset.to_xml_charset
+  end
+end
+
+class Iconv
+  UNKNOWN_CHARACTER = '?'
+
+  def self.iconv_to_from(to, from, str)
+    iconv = Iconv.new(to, from)
+    out = ''
+    begin
+      out << iconv.iconv(str)
+    rescue Iconv::IllegalSequence => e	# FIXME: Merge with InvalidCharacter
+      out << e.success
+      ch, str = e.failed.split(//u, 2)
+      out << UNKNOWN_CHARACTER
+      retry
+    rescue Iconv::InvalidCharacter => e
+      out << e.success
+      ch, str = e.failed.split(//u, 2)
+      out << UNKNOWN_CHARACTER
+      retry
+    end
+    out.set_charset(to)
+    return out
+  end
+
+  def self.iconv_to_utf8(from, str)
+    to = 'UTF-8'
+    iconv = Iconv.new(from, to)
+    out = ''
+    begin
+      out << iconv.iconv(str)
+    rescue Iconv::IllegalSequence => e
+      out << e.success
+      ch, str = e.failed.split(//u, 2)
+      if respond_to?(:unknown_unicode_handler)
+	u = ch.unpack('U').first
+	out << unknown_unicode_handler(u)
+      else
+	out << UNKNOWN_CHARACTER
+      end
+      retry
+    end
+    out.set_charset(to)
+    return out
+  end
+
+  def self.unknown_unicode_handler (u)
+    return sprintf("&#x%04x;", u)
+  end
+end
+
+module Charset
+  UTF8 = 'utf-8'
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestUtilCharset < Test::Unit::TestCase
+    def test_kconv
+      # test_sjistoeuc
+      assert_equal "\244\242", '��'.sjistoeuc
+      assert_equal 'EUC-JP', '��'.sjistoeuc.charset
+
+      # test_euctosjis
+      assert_equal '��', "\244\242".euctosjis
+      assert_equal 'Shift_JIS', "\244\242".euctosjis.charset
+
+      # test_sjistojis
+      assert_equal "\e$B$\"\e(B", '��'.sjistojis
+      assert_equal 'ISO-2022-JP', '��'.sjistojis.charset
+
+      # test_jistosjis
+      assert_equal '��', "\e$B$\"\e(B".jistosjis
+      assert_equal 'Shift_JIS', "\e$B$\"\e(B".jistosjis.charset
+
+      # test_euctojis
+      assert_equal "\e$B$\"\e(B", "\244\242".euctojis
+      assert_equal 'ISO-2022-JP', "\244\242".euctojis.charset
+
+      # test_jistoeuc
+      assert_equal "\244\242", "\e$B$\"\e(B".jistoeuc
+      assert_equal 'EUC-JP', "\e$B$\"\e(B".jistoeuc.charset
+
+      # test_some_characters
+      assert_equal "\e$B4A;z\e(B", '����'.sjistojis
+    end
+
+    def test_iconv
+      assert_equal '��', '��'.sjistou8.u8tosjis
+      assert_equal '��', '��'.sjistoeuc.euctou8.u8toeuc.euctosjis
+      assert_equal '��', '��'.sjistojis.jistou8.u8tojis.jistosjis
+
+      # test_sjistou8
+      assert_equal "\343\201\202", '��'.sjistou8
+      assert_equal 'UTF-8', '��'.sjistou8.charset
+
+      assert_equal "\342\200\276", '~'.sjistou8
+
+      # test_u8tosjis
+      assert_equal "\202\240", "\343\201\202".u8tosjis
+      assert_equal 'Shift_JIS', "\343\201\202".u8tosjis.charset
+
+      # test_sjistoeuc
+      assert_equal "\244\242", '��'.sjistoeuc
+      assert_equal 'EUC-JP', '��'.sjistoeuc.charset
+
+      # test_euctou8
+      assert_equal "\343\201\202", "\244\242".euctou8
+      assert_equal 'UTF-8', "\244\242".euctou8.charset
+
+      # test_u8toeuc
+      assert_equal "\244\242", "\343\201\202".u8toeuc
+      assert_equal 'EUC-JP', "\343\201\202".u8toeuc.charset
+
+      # test_sjistojis
+      assert_equal "\e$B$\"\e(B", "��".sjistojis
+      assert_equal 'ISO-2022-JP', "��".sjistojis.charset
+
+      # test_jistou8
+      assert_equal "\343\201\202", "\e$B$\"\e(B".jistou8
+      assert_equal 'UTF-8', "\e$B$\"\e(B".jistou8.charset
+
+      # test_u8tojis
+      assert_equal "\e$B$\"\e(B", "\343\201\202".u8tojis
+      assert_equal 'ISO-2022-JP', "\343\201\202".u8tojis.charset
+
+      # test_illegal_sequence
+      # last \202 is illegal
+      assert_equal "\202\240?", "\343\201\202\202".u8tosjis
+      # first \202 is illegal
+      assert_equal "?\202\240", "\202\343\201\202".u8tosjis
+
+      # test_annoying_character
+      assert_equal "\343\200\234", '�`'.sjistou8
+      assert_equal '�`', "\343\200\234".u8tosjis
+    end
+
+    def test_charset
+      s = "\202\240"
+      assert_equal nil, s.charset
+      assert_equal "\202\240", s.set_charset('Shift_JIS')
+      assert_equal 'Shift_JIS', s.charset
+
+      # test_guess
+      assert_equal 'UTF-8', "\343\201\202".guess_charset
+      assert_equal 'Shift_JIS', "\202\240".guess_charset	# ��
+#      assert_equal 'EUC-JP', "\244\242".guess_charset
+      assert_equal 'ISO-2022-JP', "\e$B$\"\e(B".guess_charset
+
+      # test_to
+      s = "\202\240".set_sjis
+      assert_equal "\343\201\202", s.to_utf8
+      assert_equal "\202\240", s.to_sjis
+      assert_equal "\244\242", s.to_euc
+      assert_equal "\e$B$\"\e(B", s.to_jis
+    end
+
+    def test_bug
+      # $KCODE = 'u'
+      assert_equal "~", "~".to_utf8
+      assert_equal "\342\200\276", "~".set_sjis.to_utf8	# annoying...
+      #assert_equal "\343\200\234", "�`".to_utf8
+      #assert_equal "\343\200\234", "�`".set_sjis.to_utf8
+    end
+  end
+end