qwik2md 0.1.0

data/vendor/qwik/lib/qwik/group-config.rb

@@ -0,0 +1,247 @@
+#
+# 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/group-db'
+
+module QuickML
+  class Group
+    def forward?
+      return @group_config.forward?
+    end
+
+    def group_config_check_exist
+      @group_config.check_exist
+    end
+
+    def get_max_members
+      return @group_config[:max_members]
+    end
+
+    private
+
+    def init_group_config
+      @group_config = GroupConfig.new(@db)
+      group_config = GroupConfig.get_group_config(@config)
+      @group_config.set_default(group_config)
+      @group_config.write
+    end
+  end
+
+  class GroupConfig
+    DefaultConfig = {
+      :auto_unsubscribe_count	=> nil,
+      :max_mail_length		=> nil,
+      :max_members		=> nil,
+      :ml_alert_time		=> nil,
+      :ml_life_time		=> nil,
+      :forward			=> false,
+      :permanent		=> false,
+      :unlimited		=> false,
+    }
+
+    KEYS = DefaultConfig.keys.map {|s| s.to_s }.sort.map {|k| k.intern }
+
+    def initialize(db)
+      @db = db
+      @default = nil
+      @group_config = {}
+      @group_config.update(DefaultConfig)
+      @content = nil
+      read
+    end
+
+    def set_default(default)
+      @default = default
+    end
+
+    def check_exist
+      write if ! exist?
+    end
+
+    def exist?
+      return @db.exist?(:Config)
+    end
+
+    def [](key)
+      read
+      return @group_config[key]
+    end
+
+    def forward?
+      return true if @db.exist?(:Forward)
+      return true if self[:forward]
+      return false
+    end
+
+    def permanent?
+      return true if @db.exist?(:Permanent)
+      return true if self[:permanent]
+      return false
+    end
+
+    def unlimited?
+      return true if @db.exist?(:Unlimited)
+      return true if self[:unlimited]
+      return false
+    end
+
+    def write
+      raise 'must have default' if @default.nil?
+      GroupConfig.set_default(@default, @group_config)
+      content = GroupConfig.generate(@group_config)
+      return if content == @content	# Do nothing.
+      @db.put(:Config, content)
+      @content = content
+    end
+
+    private
+
+    def read
+      content = @db.get(:Config)
+      return if content && content == @content	# Do nothing.
+      @content = content
+      config = GroupConfig.parse_hash(@content)
+      @group_config.update(config)
+      return
+    end
+
+    def self.parse_hash(str)
+      config = {}
+      return config if str.nil?
+      str.each {|line|
+	k = v = nil
+	line.chomp!
+	if /\A\s+:([a-z_]+) => (\d+),\z/ =~ line
+	  k = $1.intern
+	  v = $2.to_i
+	  config[k] = v
+	elsif /\A:([a-z_]+):(\d+)\z/ =~ line
+	  k = $1.intern
+	  v = $2.to_i
+	  config[k] = v
+	elsif /\A:([a-z_]+):([a-z]+)\z/ =~ line
+	  k = $1.intern
+	  v = $2
+	  v = true  if v == 'true'
+	  v = false if v == 'false'
+	  config[k] = v
+	end
+      }
+      return config
+    end
+
+    def self.set_default(default, group_config)
+      default.each {|k, v|
+	group_config[k] ||= v
+      }
+    end
+
+    def self.generate(config)
+      return KEYS.map {|k|
+	":#{k}:#{config[k]}\n"
+      }.join
+    end
+
+    def self.get_group_config(config)
+      return {
+	:auto_unsubscribe_count	=> config[:auto_unsubscribe_count],
+	:max_mail_length	=> config[:max_ml_mail_length] ||
+				   config[:max_mail_length],
+	:max_members		=> config[:max_members],
+	:ml_alert_time		=> config[:ml_alert_time],
+	:ml_life_time		=> config[:ml_life_time],
+      }
+    end
+
+  end
+end
+
+if $0 == __FILE__
+  require 'qwik/farm'
+  require 'qwik/server-memory'
+  require 'qwik/test-module-session'
+  require 'qwik/config'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestGroupConfig < Test::Unit::TestCase
+    include TestSession
+
+    def test_class_method
+      c = QuickML::GroupConfig
+
+      # test_parse_hash
+      ok_eq({}, c.parse_hash(''))
+      ok_eq({:max_members=>20}, c.parse_hash('{
+  :max_members => 20,
+}'))
+      m = c.parse_hash(':max_members:20')
+      ok_eq({:max_members=>20}, m)
+      m = c.parse_hash(':forward:true')
+      ok_eq({:forward=>true}, m)
+
+      # test_generate
+      ok_eq(":auto_unsubscribe_count:\n:forward:\n:max_mail_length:\n:max_members:\n:ml_alert_time:\n:ml_life_time:\n:permanent:\n:unlimited:\n", c.generate({}))
+    end
+
+    def test_all
+      sites_dir = '.test/data/'
+      group_name = 'test'
+      db = QuickML::GroupDB.new(sites_dir, group_name)
+      db.set_site(@site)
+
+      config = Qwik::Config.new
+      group_config = QuickML::GroupConfig.new(db)
+      default = QuickML::GroupConfig.get_group_config(config)
+      group_config.set_default(default)
+      group_config.write
+
+      # ==================== GroupConfig
+      # test_exist?
+      ok_eq(true, group_config.exist?)
+
+      # test_[]
+      ok_eq(100, group_config[:max_members])
+
+      # test_forward?
+      ok_eq(false, group_config.forward?)
+
+      # test_permanent?
+      ok_eq(false, group_config.permanent?)
+
+      # test_unlimited?
+      ok_eq(false, group_config.unlimited?)
+
+      # test_write
+      group_config.instance_eval {
+	@group_config[:max_members] = 10
+      }
+      ok_eq(10, group_config[:max_members])
+      group_config.write
+
+      # test_read
+      t_make_public(QuickML::GroupConfig, :read)
+      group_config.read
+      ok_eq(10, group_config[:max_members])
+      
+      str = db.get(:Config)
+      ok_eq(":auto_unsubscribe_count:5\n:forward:false\n:max_mail_length:102400\n:max_members:10\n:ml_alert_time:2073600\n:ml_life_time:2678400\n:permanent:false\n:unlimited:false\n", str)
+
+      # test_forward?
+      ok_eq(false, group_config.forward?)
+
+      page = @site['_GroupConfig']
+      page.put_with_time(':forward:true', Time.at(Time.now.to_i+10))
+      ok_eq(true, group_config.forward?)
+    end
+  end
+end

data/vendor/qwik/lib/qwik/group-confirm.rb

@@ -0,0 +1,147 @@
+#
+# 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/group'
+require 'qwik/group-db'
+
+module QuickML
+  class Group
+    # ml-processor.rb:115:        ml.prepare_confirmation(@mail)
+    def prepare_confirmation (mail)
+      # Create empty ML files.
+      @members.save
+
+      waiting_message_put(mail.bare)
+      str = waiting_message_get		# FIXME: Why?
+
+      add_waiting_member(mail.from)
+      mail.collect_cc.each {|address| 
+        add_waiting_member(address)
+      }
+      send_confirmation(mail.from)
+    end
+
+    def validate_confirmation(time)
+      return waiting_message_exist? && waiting_message_mtime.to_i == time.to_i
+    end
+
+    # ml-processor.rb:98:        ml.accept_confirmation
+    def accept_confirmation
+      # Add suspended members.
+      waiting_members = (waiting_members_get || '').to_a.map {|line|
+        line.chomp
+      }
+      waiting_members.each {|address|
+        begin
+          add_member(address)
+        rescue TooManyMembers
+        end
+      }
+
+      # Read suspended message.
+      waiting_message = waiting_message_get || ''
+      mail = Mail.create { waiting_message }
+
+      submit(mail)	# Send it.
+
+      waiting_members_delete
+      waiting_message_delete
+      @logger.log "[#{@name}]: Accept confirmation:  #{@address}"
+    end
+
+    private
+
+    def confirmation_address
+      t = waiting_message_mtime.to_i
+      return "confirm+#{t}+#{@address}"
+    end
+
+    # waiting_message
+    def waiting_message_exist?
+      return @db.exist?(:WaitingMessage)
+    end
+    def waiting_message_mtime
+      return @db.mtime(:WaitingMessage)
+    end
+    def waiting_message_put(content)
+      @db.put(:WaitingMessage, content)
+    end
+    def waiting_message_get
+      return @db.get(:WaitingMessage)
+    end
+    def waiting_message_delete
+      @db.delete(:WaitingMessage)
+    end
+
+    # waiting_member
+    def add_waiting_member (address)
+      waiting_members_add(address+"\n")
+    end
+    def waiting_members_exist?
+      return @db.exist?(:WaitingMembers)
+    end
+    def waiting_members_get
+      return @db.get(:WaitingMembers)
+    end
+    def waiting_members_add(content)
+      @db.add(:WaitingMembers, content)
+    end
+    def waiting_members_delete
+      @db.delete(:WaitingMembers)
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'qwik/test-module-ml'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestGroupConfirmation < Test::Unit::TestCase
+    include TestModuleML
+
+    def setup_group
+      return QuickML::Group.new(@ml_config, 'test@example.com')
+    end
+
+    def test_all
+      group = setup_group
+
+      t_make_readable(QuickML::Group, :db)
+
+      # test_prepare_confirmation
+      message =
+'Date: Mon, 3 Feb 2001 12:34:56 +0900
+From: user@e.com
+To: test@example.com
+Subject: create
+
+Create a new mailing list.
+'
+      mail = QuickML::Mail.generate { message }
+      group.prepare_confirmation(mail)
+      ok_eq(message, group.db.get(:WaitingMessage))
+      ok_eq("user@e.com\n", group.db.get(:WaitingMembers))
+
+      # test_validate_confirmation
+      t_make_public(QuickML::Group, :waiting_message_mtime)
+      time = group.waiting_message_mtime
+      ok_eq(true, group.validate_confirmation(time))
+
+      # test_accept_confirmation
+      t_make_public(QuickML::Group, :get_active_members)
+      ok_eq([], group.get_active_members)
+      group.accept_confirmation
+      ok_eq(['user@e.com'], group.get_active_members)
+    end
+  end
+end

data/vendor/qwik/lib/qwik/group-db.rb

@@ -0,0 +1,326 @@
+# 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 QuickML
+  class GroupDB
+=begin
+    FILENAME = {
+      :Members		=> ',members',
+      :Count		=> ',count',
+      :Config		=> ',config',
+      :Charset		=> ',charset',
+      :Alerted		=> ',alerted',
+      :Forward		=> ',forward',
+      :Permanent	=> ',permanent',
+      :Unlimited	=> ',unlimited',
+      :WaitingMembers	=> ',waiting-members',
+      :WaitingMessage	=> ',waiting-message',
+    }
+=end
+
+    PAGENAME = {
+      :Members		=> '_GroupMembers',
+      :Count		=> '_GroupCount',
+      :Config		=> '_GroupConfig',
+      :Charset		=> '_GroupCharset',
+      :Alerted		=> '_GroupAlerted',
+      :Forward		=> '_GroupForward',
+      :Permanent	=> '_GroupPermanent',
+      :Unlimited	=> '_GroupUnlimited',
+      :WaitingMembers	=> '_GroupWaitingMembers',
+      :WaitingMessage	=> '_GroupWaitingMessage',
+    }
+
+    def initialize(sites_dir, group_name)
+      @sites_dir = sites_dir
+      @group_name = group_name
+      @site = nil
+      get_dirpath.mkpath	# Make a new directory here.
+    end
+
+    def set_site(site)
+      @site = site
+    end
+
+=begin
+    def update_files
+      if false
+	FILENAME.keys.each {|s|
+	  sync(s)
+	}
+      end
+    end
+=end
+
+    # read
+    def exist?(s)
+      #sync(s)
+
+#      f = get_filpath(s)
+#      return true if f.exist?
+
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      return true if page
+
+      return false
+    end
+
+    def mtime(s)
+#      return [file_mtime(s), page_mtime(s)].max
+      return page_mtime(s)
+    end
+
+    def get(s)	# with sync.
+      #sync(s)
+
+#      file_content = nil
+#      f = get_filepath(s)
+#      file_content = f.read if f.exist?
+
+      page_content = nil
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      page_content = page.get if page
+      return page_content
+
+      # Both is nil.
+#      return nil if file_content.nil? && page_content.nil?	# Do nothing.
+
+#      fmt = file_mtime(s)
+#      pmt = page_mtime(s)
+
+      # File is exist, but the page is not exist.
+#      if file_content && page_content.nil?
+#	page = @site.create(pagename)
+#	page.put_with_time(file_content, fmt)
+#	# FIXME: delete file?
+#	return file_content
+#      end
+
+      # File is not exist, but page is exist.
+#      if file_content.nil? && page_content
+#	# Do not create file.
+#	#f.put(page_content)
+#	#f.utime(pmt, pmt)
+#	return page_content
+#      end
+
+      # Both exist.
+#      if file_content == page_content
+#	return page_content
+#      end
+
+#      if fmt < pmt	# The page is new.
+#	f.put(page_content)
+#	begin
+#	  f.utime(pmt, pmt)
+#	rescue
+#	  p 'error to set time'
+#	end
+#	return page_content
+#      end
+
+#      page.put_with_time(file_content, fmt)
+#      return file_content
+    end
+
+    # write
+    def put(s, content)
+#      f = get_filepath(s)
+#      f.put(content)
+
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      page = @site.create(pagename) if page.nil?
+      page.put(content)
+    end
+
+    def add(s, content)
+#      f = get_filepath(s)
+#      f.add(content)
+
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      page = @site.create(pagename) if page.nil?
+      page.add(content)
+    end
+
+    def delete(s)
+      return if ! exist?(s)
+#      f = get_filepath(s)
+#      f.unlink
+
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      @site.delete(pagename) if page
+    end
+
+    # the mtime of the newest file in the directory
+    def last_article_time
+      max = nil
+      dir = get_dirpath
+      dir.each_entry {|f|
+	fs = f.to_s
+
+	next if /\A\./ =~ fs ||
+#	  /,config/ =~ fs ||
+	  /_GroupConfig.txt/ =~ fs ||
+#	  /,charset/ =~ fs ||
+	  /_GroupCharset.txt/ =~ fs
+
+	file = dir+f
+	mt = file.mtime
+	if max.nil? || max < mt
+	  max = mt 
+	end
+      }
+      return max || Time.now
+    end
+
+    private
+
+    def get_pagename(symbol)
+      return PAGENAME[symbol]
+    end
+
+    def get_dirpath
+      return "#{@sites_dir}/#{@group_name}".path
+    end
+
+=begin
+    def get_filepath(symbol)
+      dir = get_dirpath
+      base = FILENAME[symbol]
+      return nil if base.nil?
+      return dir+base
+    end
+
+    def file_mtime(s)
+      f = get_filepath(s)
+      return f.mtime if f.exist?
+      return Time.at(0)
+    end
+=end
+
+    def page_mtime(s)
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      return page.mtime if page
+      return Time.at(0)
+    end
+
+=begin
+    def sync(s)
+      file_content = nil
+      f = get_filepath(s)
+      file_content = f.read if f.exist?
+
+      page_content = nil
+      pagename = get_pagename(s)
+      page = @site[pagename]
+      page_content = page.get if page
+
+      # Both is nil.
+      return if file_content.nil? && page_content.nil?	# Do nothing.
+
+      fmt = file_mtime(s)
+      pmt = page_mtime(s)
+
+      # File is exist, but the page is not exist.
+      if file_content && page_content.nil?
+	page = @site.create(pagename)
+	page.put_with_time(file_content, fmt)
+	# FIXME: delete file?
+	return
+      end
+
+      # File is not exist, but page is exist.
+      if file_content.nil? && page_content
+	f.put(page_content)
+	f.utime(pmt, pmt)
+	return
+      end
+
+      # Both exist.
+      if file_content == page_content
+	return	# The two contents are already synced.
+      end
+      
+      if fmt < pmt	# The page is new.
+	f.put(page_content)
+	f.utime(pmt, pmt)
+	return
+      end
+
+      page.put_with_time(file_content, fmt)
+      return
+    end
+=end
+  end
+end
+
+if $0 == __FILE__
+  require 'qwik/farm'
+  require 'qwik/server-memory'
+  require 'qwik/test-module-session'
+  $test = true
+end
+
+if defined?($test) && $test
+  class TestGroupDB < Test::Unit::TestCase
+    include TestSession
+
+    def test_db
+      sites_dir = './.test/data'
+      group_name = 'test'
+
+      db = QuickML::GroupDB.new(sites_dir, group_name)
+
+      ok_eq(true, './.test/data/test'.path.exist?)
+
+      db.set_site(@site)
+
+      t_make_public(QuickML::GroupDB, :get_dirpath)
+      ok_eq('./.test/data/test', db.get_dirpath.to_s)
+
+      # test_put
+      db.put(:Count, 'v')
+
+      # test_exist?
+      ok_eq(true, db.exist?(:Count))
+
+      # test_get
+      ok_eq('v', db.get(:Count))
+
+      # test_add
+      db.add(:Count, 'w')
+      #ok_eq('vw', db.get(:Count))
+      ok_eq("v\nw\n", db.get(:Count))
+
+      # test_last_article_time
+      t = db.last_article_time
+      assert_instance_of(Time, t)
+
+      # test_delete
+      db.delete(:Count)
+      ok_eq(false, db.exist?(:Count))
+
+      # test_use_site
+      site = @site
+      page = site['_GroupCount']
+      ok_eq(nil, page)
+
+      db.put(:Count, 'v2')
+      page = site['_GroupCount']
+      ok_eq('v2', page.get)
+
+      page.put_with_time('v3', Time.at(Time.now.to_i+10))
+      ok_eq('v3', db.get(:Count))
+
+    end
+  end
+end