RubyGems - kanamei-kanamei-keystone - Versions diffs - 0.0.7 → 0.0.10 - Mend

kanamei-kanamei-keystone 0.0.7 → 0.0.10

Files changed (14) hide show

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'keystone'
+require 'keystone/batch_base'
+require 'keystone/mail'
+include Keystone::BatchBase
+if ARGV[0] == nil
+  puts "set mail addr"
+  exit
+end
+MAIL_FROM = ARGV[0]
+MAIL_TO = [ARGV[0]]
+MAIL_SUBJECT = 'テストメール~~'
+MAIL_BODY = <<BODY
+こんにちは
+どないでしょう？？
+〜〜〜
+#{Keystone::Environment.dump}
+BODY
+execute do
+  info "batch process01"
+  sleep 1.2
+  begin
+    raise 'error occur'
+  rescue => e
+    error e
+    Keystone::Mail::Send.new().send(MAIL_FROM,MAIL_TO,MAIL_SUBJECT,MAIL_BODY)
+    Keystone::Mail::Send.send(MAIL_FROM,MAIL_TO,MAIL_SUBJECT,MAIL_BODY)
+  end
+end

data/example/string_util.rb ADDED

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'keystone'
+st = %|test "test 02" 日本語 ﾆﾎﾝｺﾞﾊﾝｶｸ "にほ　んご　ですが　なにか"|
+st2 = Keystone::StringUtil.to_searchtext(st)
+p Keystone::StringUtil.serach_string_to_array(st)
+p Keystone::StringUtil.serach_string_to_array(st2)

data/lib/keystone.rb CHANGED

@@ -1,7 +1,25 @@
+$KCODE = 'u'
+require 'keystone/core_ext'
+require 'keystone/base'
+include Keystone::Base
+autoload :FlagSetMaker  , 'flag_set_maker'
+autoload :Moji          , 'moji'
 module Keystone
-  autoload :StringUtil , 'keystone/string_util'
+  VERSION = '0.0.10'
+  autoload :StringUtil  , 'keystone/string_util'
+  autoload :BatchUtil   , 'keystone/batch_util'
+  autoload :Environment , 'keystone/environment'
+  autoload :Mail        , 'keystone/mail'
   module Rails
     #autoload :ActiveSupportExt, 'keystone/rails/active_support_ext'
   end
-end
+end

data/lib/keystone/base.rb ADDED

@@ -0,0 +1,36 @@
+module Keystone
+  module Base
+    def log(log_type,message, is_base_info = true)
+      if is_base_info
+        puts "[#{Time.now.strftime("%Y/%m/%d %H:%M:%S")}][#{$$}][#{log_type.to_s}] #{message}"
+      else
+        puts "[#{log_type.to_s}] #{message}"
+      end
+    end
+    def info(message)
+      log(:INFO,message)
+    end
+    def error(message)
+      if message.is_a? Exception
+        log(:ERROR," #{message.message}")
+        message.backtrace.each_with_index {|line, i|
+          log(:ERROR," #{line})",false)
+        }
+      else
+        log(:ERROR,message.to_s)
+      end
+    end
+    def warn(message)
+      log(:WARN,message)
+    end
+    def debug(message)
+      if $DEBUG
+        log(:DEBUG,message)
+      end
+    end
+  end
+end

data/lib/keystone/batch_base.rb ADDED

@@ -0,0 +1,17 @@
+module Keystone
+  module BatchBase
+    def execute(&process)
+      info "start script"
+      script_started_at = Time.now
+      begin
+        return (yield process)
+      rescue => e
+        error e
+        Skutil::Mail.send_error(ERROR_MAIL_FROM,ERROR_MAIL_TO,ERROR_MAIL_SUBJECT,e)
+        return e
+      ensure
+        info "finish script (%1.3fsec)" % (Time.now - script_started_at)
+      end
+    end
+  end
+end

data/lib/keystone/core_ext.rb ADDED

@@ -0,0 +1,76 @@
+require 'tempfile'
+class Uri
+  #
+  def self.escape_raw(st)
+    st.gsub(/([^a-zA-Z0-9_\-\.~])/) { "%#{$1.unpack('H*')[0].scan(/../).join('%').upcase }" }
+  end
+  #
+  # usage
+  # @search_tag = Uri.unescape_raw(params[:tag]).toutf8
+  #
+  #
+  def self.unescape_raw(st)
+    st.tr('+',' ').gsub(/%([A-Fa-f0-9][A-Fa-f0-9])/) { [$1.hex].pack('C') }
+  end
+end
+class Tempfile
+  def self.open_with_block(name = nil, dir = nil)
+    name ||= (0..8).map{rand(36).to_s(36)}.join
+    args = dir ? [name, dir] : [name]
+    tmp = Tempfile.open *args
+    begin
+      yield tmp
+    ensure
+      tmp.close true
+    end
+  end
+end
+class Dir
+  def self.mkdir_r(dirPath)
+    folders = dirPath.split('/')
+    folderToCreate = ''
+    folders.each do |folder|
+      folderToCreate += folder + '/'
+      if !File.directory?(folderToCreate)
+        Dir.mkdir(folderToCreate)
+      end
+    end
+  end
+end
+class Object
+  # http://www.yohasebe.com/pages/trans-seeing-metaclasses-clearly/
+  def metaclass
+    class << self
+      self
+    end
+  end
+  # http://www.yohasebe.com/pages/trans-seeing-metaclasses-clearly/
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+  # http://www.yohasebe.com/pages/trans-seeing-metaclasses-clearly/
+  def meta_def(name, &blk)
+   meta_eval { define_method name, &blk }
+  end
+  # http://www.yohasebe.com/pages/trans-seeing-metaclasses-clearly/
+  def class_def(name, &blk)
+    class_eval { define_method name, &blk }
+  end
+  # 1.8.7  エミュレート
+  def tap
+    yield(self)
+    self
+  end
+end

data/lib/keystone/environment.rb ADDED

@@ -0,0 +1,47 @@
+module Keystone
+  class Environment
+    def self.ip_address
+      ifconfig = `/sbin/ifconfig`
+      ips = []
+      # TODO mac
+      ifconfig.gsub(/inet addr:(\d+\.\d+\.\d+\.\d+)/){|ip|
+        if $1 != '127.0.0.1'
+          ips << $1
+        end
+      }
+      return ips
+    end
+    def self.hostname
+      `/bin/hostname`.chomp
+    end
+    def self.df
+      `/bin/df -h`.chomp
+    end
+    def self.ps
+      `/bin/ps -ef`.chomp
+    end
+    def self.netstat
+      `/usr/sbin/netstat -an`.chomp
+    end
+    def self.execute(command)
+      `#{command}`.chomp
+    end
+    def self.dump
+      self_methods = self.methods - Class.methods
+      self_methods.delete("dump")
+      self_methods.delete("execute")
+      st = ""
+      self_methods.each do |method|
+        st << "#{method}:\n  #{self.__send__(method).to_s.split("\n").join("\n  ")}\n"
+      end
+      return st
+    end
+  end
+end

data/lib/keystone/mail.rb ADDED

@@ -0,0 +1,6 @@
+module Keystone
+  module Mail
+    autoload :Send , 'keystone/mail/send'
+    autoload :Receive , 'keystone/mail/receive'
+  end
+end

data/lib/keystone/mail/send.rb ADDED

@@ -0,0 +1,68 @@
+#
+# 普通なことをしたいならTMailを使いましょう
+#
+require 'net/smtp'
+require 'kconv'
+module Keystone
+  module Mail
+    class Send
+      def initialize(smtp_addr="127.0.0.1",smtp_port=25)
+        @smtp_addr,@smtp_port=smtp_addr,smtp_port
+      end
+      def self.send(from,to,title,body,smtp_addr="127.0.0.1",smtp_port=25)
+        from_addr,from_addr_4_header = create_addr_and_header(from)
+        title = Kconv.tojis(title)
+        title = title.split(//,1).pack('m'); title = title.chomp
+        if to.class.to_s == 'Array'
+          tomany = to.join(',')
+        else
+          tomany = to.to_s;
+        end
+        head = <<HEAD
+Subject: =?ISO-2022-JP?B?#{title}?=
+To: #{tomany}
+From: #{from_addr_4_header}
+Mime-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Type: Text/Plain; charset=iso-2022-jp
+HEAD
+        src = head + "\n" + Kconv.tojis(body)
+    #    puts src
+        m = Net::SMTPSession.new(smtp_addr, smtp_port)
+        m.start()
+        m.sendmail(src, from_addr, to)
+        m.finish
+      end
+      def send(from,to,title,body)
+        self.class.send(from,to,title,body,@smtp_addr,@smtp_port)
+      end
+      private
+      def self.create_addr_and_header(addr_data)
+        addr = ''
+        addr_4_header = ''
+        case addr_data.class.to_s
+          when 'String'
+            addr = addr_data.dup
+            addr_4_header = addr.dup
+          when 'Array'
+            addr = addr_data[1].dup
+            addr_4_header = addr_data[0].dup
+            addr_4_header = Kconv.tojis(addr_4_header)
+            addr_4_header = addr_4_header.split(//,1).pack('m'); addr_4_header = addr_4_header.chomp
+            addr_4_header = "=?ISO-2022-JP?B?#{addr_4_header}?=<#{addr}>"
+          else
+            # TODO exception
+            raise 'addr_data must be String or Array'
+        end
+        return addr,addr_4_header
+      end
+    end
+  end
+end

data/lib/keystone/string_util.rb CHANGED

@@ -2,8 +2,8 @@ module Keystone
   class StringUtil
     def self.int_to_splitted_path(i_value,value_length,base_folder,suffix="")
       file_name = Integer(i_value).to_s
-      raise "value_length must bigger than 0" if value_length < 1
-      raise 'i_value length is bigger than value_length' if file_name.size > value_length
+      raise RangeError,"value_length must bigger than 0" if value_length < 1
+      raise RangeError, 'i_value length is bigger than value_length' if file_name.size > value_length
       file_name = file_name.rjust(value_length, '0')
       new_path = base_folder.dup
       group_regex = ""
@@ -28,5 +28,47 @@ module Keystone
       new_path << suffix if suffix != ""
       return new_path
     end
+    def self.reverse_mail(mail)
+      if mail.index('@') == nil
+        return mail
+      end
+      user,dom = mail.split('@')
+      if dom == nil
+        return "@#{user}"
+      end
+      return dom.split('.').reverse.join(".") + "@" + user
+    end
+    MULTIBYTE_SPACE = [0x3000].pack("U")
+    PRESERVED_QUERY_WORDS_RE = /(AND|OR|ANDNOT)/
+    #
+    # adviced by Mr.morohashi
+    #
+    def self.serach_string_to_array(query)
+      tokens = query.scan(/'([^']*)'|"([^"]*)"|([^\s#{MULTIBYTE_SPACE}]*)/).flatten.reject{|i| i == nil || i == "" }
+      tokens.map do |token|
+        next unless token
+        #token.gsub!(PRESERVED_QUERY_WORDS_RE, $1.downcase) if token =~ PRESERVED_QUERY_WORDS_RE
+        token.gsub!(/\A['"]|['"]\z/, '') # strip quatos
+        token
+      end
+    end
+    #
+    #
+    # TODO
+    def self.downcase_roma_number(st)
+      st.tr("ⅠⅡⅢⅣ", "ⅰⅱⅲⅳ")
+    end
+    #
+    # making search text for indexing
+    #
+    def self.to_searchtext(str)
+      self.downcase_roma_number(Moji.han_to_zen(
+          Moji.zen_to_han(str,Moji::ZEN_ALNUM | Moji::ZEN_SYMBOL).downcase,Moji::HAN_KATA | Moji::HAN_JSYMBOL).tr("ｰ～／","ー~/")
+      )
+    end
   end
-end
+end

data/test/test_string_util.rb ADDED

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'redgreen'
+require 'lib/keystone'
+require 'lib/keystone/string_util'
+$KCODE='u'
+class TestStringUtilBase < Test::Unit::TestCase
+  def setup
+  end
+  def test_reverse_mail
+    assert_equal(Keystone::StringUtil::reverse_mail("testuser@softbank.ne.jp"),"jp.ne.softbank@testuser")
+    assert_equal(Keystone::StringUtil::reverse_mail("test.user@somedomain.com"),"com.somedomain@test.user")
+    assert_equal(Keystone::StringUtil::reverse_mail("a.b@c.d"),"d.c@a.b")
+    assert_equal(Keystone::StringUtil::reverse_mail("a.b@"),"@a.b")
+    assert_equal(Keystone::StringUtil::reverse_mail("@c.d"),"d.c@")
+    assert_equal(Keystone::StringUtil::reverse_mail("a.b"),"a.b")
+  end
+  def test_int_to_splitted_path
+    assert_equal(Keystone::StringUtil.int_to_splitted_path(113355,12,"/tmp",".jpg"),"/tmp/000/000/113/355.jpg")
+    assert_equal(Keystone::StringUtil.int_to_splitted_path(1234567890,10,"/temp",".png"),"/temp/1/234/567/890.png")
+    assert_equal(Keystone::StringUtil.int_to_splitted_path(1234567890,11,"/temp",".png"),"/temp/01/234/567/890.png")
+    assert_raise(RangeError){Keystone::StringUtil.int_to_splitted_path(12345678901,10,"/tmp")}
+    assert_equal(Keystone::StringUtil.int_to_splitted_path(00000000000000001,11,"/tmp",".gif"),"/tmp/00/000/000/001.gif")
+  end
+  def test_serach_string_to_array
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|test test2 test3|),%w|test test2 test3|)
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|test "test2" test3|),%w|test test2 test3|)
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|test "test 2" test3|),["test","test 2","test3"])
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|"test 1" "test 2" test3|),["test 1","test 2","test3"])
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|"日本語 1" "test 2" test3|),["日本語 1","test 2","test3"])
+    assert_equal(Keystone::StringUtil.serach_string_to_array(%|"日本語 1" "test 2" ﾊﾝｶｸ|),["日本語 1","test 2","ﾊﾝｶｸ"])
+    # TODO
+    # assert_equal(Keystone::StringUtil.serach_string_to_array(%|"日本語 1" "tes\"t 2" ﾊﾝｶｸ|),["日本語 1","test 2","ﾊﾝｶｸ"])
+  end
+  def test_to_searchtext
+    assert_equal(Keystone::StringUtil.to_searchtext("日本語"),"日本語")
+    assert_equal(Keystone::StringUtil.to_searchtext("カタカナ"),"カタカナ")
+    assert_equal(Keystone::StringUtil.to_searchtext("ﾊﾝｶｸ"),"ハンカク")
+    assert_equal(Keystone::StringUtil.to_searchtext("A"),"a")
+    assert_equal(Keystone::StringUtil.to_searchtext("１"),"1")
+    assert_equal(Keystone::StringUtil.to_searchtext("ａｂＣＤ１２３４"),"abcd1234")
+    assert_equal(Keystone::StringUtil.to_searchtext("スープ"),"スープ")
+    assert_equal(Keystone::StringUtil.to_searchtext("ｽｰﾌﾟ"),"スープ")  # ハンカク半濁点
+    assert_equal(Keystone::StringUtil.to_searchtext("ｺｽﾞﾐｯｸﾗﾅｳｪｲ"),"コズミックラナウェイ")  # ハンカク濁点
+    assert_equal(Keystone::StringUtil.to_searchtext("句読点。、・／"),"句読点。、・／") # ??? ここおかしくない？？
+    # TODO
+    assert_equal(Keystone::StringUtil.to_searchtext("！”＄％＆￥’（）＊＋，－．／：；＜＝＞？＠［￥］＾＿‘｛｜｝～＃"),"!\"$%&\\'()*+,-./:;<=>?@[\\]^_`{|}~#") # 半角全角変換可能記号
+    assert_equal(Keystone::StringUtil.to_searchtext("｡｢｣､ｰﾞﾟ･"),"。「」、ー゛゜・")
+    assert_equal(Keystone::StringUtil.to_searchtext("ⅠⅡⅢⅣ"),"ⅰⅱⅲⅳ")
+  end
+end

data/vendor/flag_set_maker.rb ADDED

@@ -0,0 +1,121 @@
+require "forwardable"
+module FlagSetMaker
+  class FlagSet
+    def initialize(mod, names, zero= nil)
+      @module= mod
+      @flag_names= names.to_a()
+      @zero_name= zero
+      for i in 0...@flag_names.size
+        mod.const_set(@flag_names[i], Flags.new(1 << i, self))
+      end
+      mod.const_set(@zero_name, Flags.new(0, self)) if @zero_name
+    end
+    def to_s(v)
+      names= []
+      @flag_names.each_with_index(){ |name, i| names.push(name) if v[i]==1 }
+      if names.empty?()
+        return (@zero_name.to_s() || "0")
+      elsif names.size==1
+        return names[0].to_s()
+      else
+        return "("+names.join("|")+")"
+      end
+    end
+    def inspect(v= nil)
+      return v ? format("%p::%s", @module, to_s(v)) : super()
+    end
+    def validate(v)
+      return v&((1 << @flag_names.size)-1)
+    end
+  end
+  class Flags
+    extend(Forwardable)
+    def initialize(v, fs)
+      @value= fs.validate(v)
+      @flag_set= fs
+    end
+    def to_i()
+      return @value
+    end
+    def to_s()
+      return @flag_set.to_s(@value)
+    end
+    def inspect()
+      return @flag_set.inspect(@value)
+    end
+    def ==(rhs)
+      return rhs.is_a?(Flags) && @flag_set==rhs.flag_set && @value==rhs.to_i()
+    end
+    alias :eql? :==
+    def_delegators(:to_i, :hash)
+    def &(rhs)
+      return new_flag(@value&rhs.to_i())
+    end
+    def |(rhs)
+      return new_flag(@value|rhs.to_i())
+    end
+    def ~()
+      return new_flag(~@value)
+    end
+    def include?(flags)
+      return (@value&flags.to_i())==flags.to_i()
+    end
+    def empty?()
+      return @value!=0
+    end
+  protected
+    attr_reader(:flag_set)
+  private
+    def new_flag(v)
+      return Flags.new(v, @flag_set)
+    end
+  end
+  def make_flag_set(*args)
+    FlagSet.new(self, *args)
+  end
+end
+if __FILE__==$0
+  class Hoge
+    extend(FlagSetMaker)
+    make_flag_set([:FOO, :BAR, :HOGE], :NONE)
+  end
+end

data/vendor/moji.rb ADDED

@@ -0,0 +1,501 @@
+#このファイルの文字コードはUTF-8です。
+#このファイルをUnicode非対応のエディタで編集してはいけません（〜が文字化ける）。
+=begin
+=Moji モジュール
+日本語の文字種判定、文字種変換(半角→全角、ひらがな→カタカナなど)を行います。
+==インストール:
+解凍してできた moji ディレクトリの中で以下のコマンドを実行してください。
+  # ruby setup.rb
+または、 moji/lib の中の moji.rb と flag_set_maker.rb を lib/ruby/site_ruby/1.8 にコピーしてください。
+==使い方:
+(({$KCODE})) を指定してから (({require "moji"})) してください。
+Moji モジュールの関数に渡す文字列の文字コードは (({$KCODE})) と一致させてください。
+  $KCODE= "UTF8"
+  require "moji"
+  #文字種判定。
+  p Moji.type("漢")                                    # => Moji::ZEN_KANJI
+  p Moji.type?("Ａ", Moji::ZEN)                        # => true
+  #文字種変換。
+  p Moji.zen_to_han("Ｒｕｂｙ")                        # => "Ruby"
+  p Moji.upcase("Ｒｕｂｙ")                            # => "ＲＵＢＹ"
+  p Moji.kata_to_hira("ルビー")                        # => "るびー"
+  #文字種による正規表現。
+  p /#{Moji.kata}+#{Moji.hira}+/ =~ "ぼくドラえもん"   # => 6
+  p Regexp.last_match.to_s                             # => "ドラえもん"
+==定数:
+以下の定数は、文字種の一番細かい分類です。
+(({Moji.type})) が返すのは、以下の定数のうちの1つです。
+--- HAN_CONTROL
+    制御文字。
+--- HAN_ASYMBOL
+    ASCIIに含まれる半角記号。
+--- HAN_JSYMBOL
+    JISに含まれるがASCIIには含まれない半角記号。
+--- HAN_NUMBER
+    半角数字。
+--- HAN_UPPER
+    半角アルファベット大文字。
+--- HAN_LOWER
+    半角アルファベット小文字。
+--- HAN_KATA
+    半角カタカナ。
+--- ZEN_ASYMBOL
+    JISの全角記号のうち、ASCIIに対応する半角記号があるもの。
+--- ZEN_JSYMBOL
+    JISの全角記号のうち、ASCIIに対応する半角記号がないもの。
+--- ZEN_NUMBER
+    全角数字。
+--- ZEN_UPPER
+    全角アルファベット大文字。
+--- ZEN_LOWER
+    全角アルファベット小文字。
+--- ZEN_HIRA
+    ひらがな。
+--- ZEN_KATA
+    全角カタカナ。
+--- ZEN_GREEK
+    ギリシャ文字。
+--- ZEN_CYRILLIC
+    キリル文字。
+--- ZEN_LINE
+    罫線のかけら。
+--- ZEN_KANJI
+    漢字。
+以下の定数は、上の文字種の組み合わせと別名です。
+--- HAN_SYMBOL
+    JISに含まれる半角記号。(({HAN_ASYMBOL | HAN_JSYMBOL}))
+--- HAN_ALPHA
+    半角アルファベット。(({HAN_UPPER | HAN_LOWER}))
+--- HAN_ALNUM
+    半角英数字。(({HAN_ALPHA | HAN_NUMBER}))
+--- HAN
+    全ての半角文字。(({HAN_CONTROL | HAN_SYMBOL | HAN_ALNUM | HAN_KATA}))
+--- ZEN_SYMBOL
+    JISに含まれる全角記号。(({ZEN_ASYMBOL | ZEN_JSYMBOL}))
+--- ZEN_ALPHA
+    全角アルファベット。(({ZEN_UPPER | ZEN_LOWER}))
+--- ZEN_ALNUM
+    全角英数字。(({ZEN_ALPHA | ZEN_NUMBER}))
+--- ZEN_KANA
+    全角かな/カナ。(({ZEN_KATA | ZEN_HIRA}))
+--- ZEN
+    JISに含まれる全ての全角文字。(({ZEN_SYMBOL | ZEN_ALNUM | ZEN_KANA | ZEN_GREEK | ZEN_CYRILLIC | ZEN_LINE | ZEN_KANJI}))
+--- ASYMBOL
+    ASCIIに含まれる半角記号とその全角版。(({HAN_ASYMBOL | ZEN_ASYMBOL}))
+--- JSYMBOL
+    JISに含まれるが (({ASYMBOL})) には含まれない全角/半角記号。(({HAN_JSYMBOL | ZEN_JSYMBOL}))
+--- SYMBOL
+    JISに含まれる全ての全角/半角記号。(({HAN_SYMBOL | ZEN_SYMBOL}))
+--- NUMBER
+    全角/半角数字。(({HAN_NUMBER | ZEN_NUMBER}))
+--- UPPER
+    全角/半角アルファベット大文字。(({HAN_UPPER | ZEN_UPPER}))
+--- LOWER
+    全角/半角アルファベット小文字。(({HAN_LOWER | ZEN_LOWER}))
+--- ALPHA
+    全角/半角アルファベット。(({HAN_ALPHA | ZEN_ALPHA}))
+--- ALNUM
+    全角/半角英数字。(({HAN_ALNUM | ZEN_ALNUM}))
+--- HIRA
+    (({ZEN_HIRA})) の別名。
+--- KATA
+    全角/半角カタカナ。(({HAN_KATA | ZEN_KATA}))
+--- KANA
+    全角/半角 かな/カナ。(({KATA | ZEN_HIRA}))
+--- GREEK
+    (({ZEN_GREEK})) の別名。
+--- CYRILLIC
+    (({ZEN_CYRILLIC})) の別名。
+--- LINE
+    (({ZEN_LINE})) の別名。
+--- KANJI
+    (({ZEN_KANJI})) の別名。
+--- ALL
+    上記全ての文字。
+==モジュール関数:
+--- Moji.type(ch)
+    文字 ((|ch|)) の文字種を返します。
+    「一番細かい分類」の((<定数|定数:>))のうち1つを返します。
+    上の分類に当てはまらない文字(Unicodeのハングルなど)に対しては (({nil})) を返します。
+    また、UnicodeのB面以降の文字に対しても (({nil})) を返します。
+    文字が割り当てられていない文字コードに対する結果は不定です( (({nil})) を返す事もあります)。
+      p Moji.type("漢")   # => Moji::ZEN_KANJI
+--- Moji.type?(ch, type)
+    文字 ((|ch|)) が文字種 ((|type|)) に含まれれば、 (({true})) を返します。
+    ((|type|)) には全ての((<定数|定数:>))と、それらを (({|}))
+    で結んだものを使えます。
+      p Moji.type?("Ａ", Moji::ZEN)   # => true
+--- Moji.regexp(type)
+    文字種 ((|type|)) の1文字を表す正規表現を返します。
+    ((|type|)) には全ての((<定数|定数:>))と、それらを (({|}))
+    で結んだものを使えます。
+      p Moji.regexp(Moji::HIRA)   # => /[ぁ-ん]/
+--- Moji.zen_to_han(str[, type])
+    文字列 ((|str|)) の全角を半角に変換して返します。
+    ((|type|)) には、変換対象とする文字種を((<定数|定数:>))で指定します。
+    デフォルトは (({ALL})) (全て)です。
+      p Moji.zen_to_han("Ｒｕｂｙ！？")                # => "Ruby!?"
+      p Moji.zen_to_han("Ｒｕｂｙ！？", Moji::ALPHA)   # => "Ruby！？"
+--- Moji.han_to_zen(str[, type])
+    文字列 ((|str|)) の半角を全角に変換して返します。
+    ((|type|)) には、変換対象とする文字種を((<定数|定数:>))で指定します。
+    デフォルトは (({ALL})) (全て)です。
+      p Moji.han_to_zen("Ruby!?")                 # => "Ｒｕｂｙ！？"
+      p Moji.han_to_zen("Ruby!?", Moji::SYMBOL)   # => "Ruby！？"
+--- Moji.normalize_zen_han(str)
+    文字列 ((|str|)) の大文字、小文字を一般的なものに統一します。
+    具体的には、ASCIIに含まれる記号と英数字( (({ALNUM|ASYMBOL}))
+    )を半角に、それ以外の記号とカタカナ( (({JSYMBOL|HAN_KATA})) )を全角に変換します。
+--- Moji.upcase(str[, type])
+    文字列 ((|str|)) の小文字を大文字に変換して返します。
+    ((|type|)) には、変換対象とする文字種を((<定数|定数:>))で指定します。
+    デフォルトは (({LOWER})) (全角/半角のアルファベット)です。
+    ギリシャ文字、キリル文字には対応していません。
+      p Moji.upcase("Ｒｕｂｙ")   # => "ＲＵＢＹ"
+--- Moji.downcase(str[, type])
+    文字列 ((|str|)) の小文字を大文字に変換して返します。
+    ((|type|)) には、変換対象とする文字種を((<定数|定数:>))で指定します。
+    デフォルトは (({UPPER})) (全角/半角のアルファベット)です。
+    ギリシャ文字、キリル文字には対応していません。
+      p Moji.downcase("Ｒｕｂｙ")   # => "ｒｕｂｙ"
+--- Moji.kata_to_hira(str)
+    文字列 ((|str|)) の全角カタカナをひらがなに変換して返します。
+    半角カタカナは直接変換できません。 (({han_to_zen})) で全角にしてから変換してください。
+      p Moji.kata_to_hira("ルビー")   # => "るびー"
+--- Moji.hira_to_kata(str)
+    文字列 ((|str|)) のひらがなを全角カタカナに変換して返します。
+      p Moji.hira_to_kata("るびー")   # => "ルビー"
+--- Moji.han_control
+--- Moji.han_asymbol
+--- ...
+--- Moji.kana
+--- ...
+    ((<定数|定数:>))それぞれに対応するメソッドが有り、
+    それぞれの文字種の1文字を表す正規表現を返します。
+    例えば、 (({Moji.kana})) は (({Moji.regexp(Moji::KANA)})) と同じです。
+    以下の例のように、文字クラスっぽく使えます。
+      p /#{Moji.kata}+#{Moji.hira}+/ =~ "ぼくドラえもん"   # => 6
+      p Regexp.last_match.to_s                             # => "ドラえもん"
+==動作環境:
+たぶんRuby 1.8以降。
+FreeBSD Ruby 1.8.5にて動作確認しました。
+==置き場所/連絡先:
+置き場所: ((<URL:http://gimite.ddo.jp/pukiwiki/index.php?Ruby%BE%AE%CA%AA%BD%B8>))
+作者: Gimite 市川 (連絡先: ((<URL:http://gimite.ddo.jp/bbs/tnote.cgi>)) )
+==ライセンス:
+Public Domainです。煮るなり焼くなりご自由に。
+==更新履歴:
+2006/7/23 Ver.1.3
+*半角中黒(･)の字種判別、全角中黒との相互変換ができていなかったのを修正。(thanks to xyzzyさん)
+2006/10/5 Ver.1.2
+*EUC 以外の文字コードにも対応し、ライブラリ名を Moji に変更。
+*han_to_zen, zen_to_han の対象文字種のデフォルトを全て( (({ALL})) )に。
+*normalize_zen_han 追加。
+2005/1/3 Ver.1.1
+*(({$KCODE})) が指定されていないとEUCUtil.typeが正常動作しない問題を修正。
+*定数に (({ASYMBOL})) と (({JSYMBOL})) を追加。
+2004/11/16 Ver.1.0
+*EUCUtil 公開。
+=end
+if $KCODE=="NONE"
+  warn("Warning: Set $KCODE before requiring 'moji' (UTF8 assumed)")
+  $KCODE= "u"
+end
+require "nkf"
+require "jcode"
+require "enumerator"
+require "flag_set_maker"
+nkf_kcode= {"SJIS" => "s", "EUC" => "e"}[$KCODE]
+script= <<'EOS'
+module Moji
+  extend(FlagSetMaker)
+  module Detail
+    HAN_ASYMBOL_LIST= ' !"#$%&\'()*+,-./:;<=>?@[\]^_`{|}~'
+    ZEN_ASYMBOL_LIST= '　！”＃＄％＆’（）＊＋，－．／：；＜＝＞？＠［￥］＾＿‘｛｜｝￣'
+    HAN_JSYMBOL1_LIST= '｡｢｣､ｰﾞﾟ･'
+    ZEN_JSYMBOL1_LIST= '。「」、ー゛゜・'
+    ZEN_JSYMBOL_LIST= '、。・゛゜´｀¨ヽヾゝゞ〃仝々〆〇ー―‐＼～〜∥…‥“〔〕〈〉《》「」『』【】'+
+      '±×÷≠≦≧∞∴♂♀°′″℃￠￡§☆★○●◎◇◇◆□■△▲▽▼※〒→←↑↓〓'
+    HAN_KATA_LIST= 'ﾊﾋﾌﾍﾎｳｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄｱｲｴｵﾅﾆﾇﾈﾉﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜｦﾝｧｨｩｪｫｬｭｮｯ'.split(//)
+    HAN_VSYMBOLS= ['', 'ﾞ', 'ﾟ']
+    ZEN_KATA_LISTS= [
+      'ハヒフヘホウカキクケコサシスセソタチツテトアイエオ'+
+        'ナニヌネノマミムメモヤユヨラリルレロワヲンァィゥェォャュョッ',
+      'バビブベボヴガギグゲゴザジズゼゾダヂヅデド',
+      'パピプペポ',
+    ].map(){ |s| s.split(//) }
+  end
+  def self.uni_range(*args)
+    if $KCODE=="UTF8"
+      str= args.map(){ |n| NKF.nkf("-wW160x", [n].pack("n")) }.
+        enum_slice(2).map(){ |f, e| "#{f}-#{e}" }.to_s()
+      return /[#{str}]/u
+    else
+      return nil
+    end
+  end
+  make_flag_set([
+    :HAN_CONTROL, :HAN_ASYMBOL, :HAN_JSYMBOL, :HAN_NUMBER, :HAN_UPPER, :HAN_LOWER, :HAN_KATA,
+    :ZEN_ASYMBOL, :ZEN_JSYMBOL, :ZEN_NUMBER, :ZEN_UPPER, :ZEN_LOWER, :ZEN_HIRA, :ZEN_KATA,
+    :ZEN_GREEK, :ZEN_CYRILLIC, :ZEN_LINE, :ZEN_KANJI,
+  ])
+  HAN_SYMBOL= HAN_ASYMBOL | HAN_JSYMBOL
+  HAN_ALPHA= HAN_UPPER | HAN_LOWER
+  HAN_ALNUM= HAN_ALPHA | HAN_NUMBER
+  HAN= HAN_CONTROL | HAN_SYMBOL | HAN_ALNUM | HAN_KATA
+  ZEN_SYMBOL= ZEN_ASYMBOL | ZEN_JSYMBOL
+  ZEN_ALPHA= ZEN_UPPER | ZEN_LOWER
+  ZEN_ALNUM= ZEN_ALPHA | ZEN_NUMBER
+  ZEN_KANA= ZEN_KATA | ZEN_HIRA
+  ZEN= ZEN_SYMBOL | ZEN_ALNUM | ZEN_KANA | ZEN_GREEK | ZEN_CYRILLIC | ZEN_LINE | ZEN_KANJI
+  ASYMBOL= HAN_ASYMBOL | ZEN_ASYMBOL
+  JSYMBOL= HAN_JSYMBOL | ZEN_JSYMBOL
+  SYMBOL= HAN_SYMBOL | ZEN_SYMBOL
+  NUMBER= HAN_NUMBER | ZEN_NUMBER
+  UPPER= HAN_UPPER | ZEN_UPPER
+  LOWER= HAN_LOWER | ZEN_LOWER
+  ALPHA= HAN_ALPHA | ZEN_ALPHA
+  ALNUM= HAN_ALNUM | ZEN_ALNUM
+  HIRA= ZEN_HIRA
+  KATA= HAN_KATA | ZEN_KATA
+  KANA= KATA | ZEN_HIRA
+  GREEK= ZEN_GREEK
+  CYRILLIC= ZEN_CYRILLIC
+  LINE= ZEN_LINE
+  KANJI= ZEN_KANJI
+  ALL= HAN | ZEN
+  CHAR_REGEXPS= {
+    HAN_CONTROL => /[\x00-\x1f\x7f]/,
+    HAN_ASYMBOL =>
+      Regexp.new("["+Detail::HAN_ASYMBOL_LIST.gsub(/[\[\]\-\^\\]/){ "\\"+$& }+"]"),
+    HAN_JSYMBOL => Regexp.new("["+Detail::HAN_JSYMBOL1_LIST+"]"),
+    HAN_NUMBER => /[0-9]/,
+    HAN_UPPER => /[A-Z]/,
+    HAN_LOWER => /[a-z]/,
+    HAN_KATA => /[ｦ-ｯｱ-ﾝ]/,
+    ZEN_ASYMBOL => Regexp.new("["+Detail::ZEN_ASYMBOL_LIST+"]"),
+    ZEN_JSYMBOL => Regexp.new("["+Detail::ZEN_JSYMBOL_LIST+"]"),
+    ZEN_NUMBER => /[０-９]/,
+    ZEN_UPPER => /[Ａ-Ｚ]/,
+    ZEN_LOWER => /[ａ-ｚ]/,
+    ZEN_HIRA => /[ぁ-ん]/,
+    ZEN_KATA => /[ァ-ヶ]/,
+    ZEN_GREEK => /[Α-Ωα-ω]/,
+    ZEN_CYRILLIC => /[А-Яа-я]/,
+    ZEN_LINE => uni_range(0x2570, 0x25ff) || /[─-╂]/,
+    ZEN_KANJI => uni_range(0x3400, 0x9fff, 0xf900, 0xfaff) || /[亜-瑤]/,
+  }
+  def type(ch)
+    ch=~/^./
+    ch= $&
+    for tp, reg in CHAR_REGEXPS
+      return tp if ch=~reg
+    end
+    return nil
+  end
+  def type?(ch, tp)
+    return tp.include?(type(ch))
+  end
+  def regexp(tp)
+    regs= []
+    for tp2, reg in CHAR_REGEXPS
+      regs.push(reg) if tp.include?(tp2)
+    end
+    return regs.size==1 ? regs[0] : Regexp.new(regs.join("|"))
+  end
+  def zen_to_han(str, tp= ALL)
+    if tp.include?(ZEN_KATA)
+      reg= Regexp.new("["+Detail::ZEN_KATA_LISTS.to_s()+"]")
+      str= str.gsub(reg) do
+        for i in 0...3
+          pos= Detail::ZEN_KATA_LISTS[i].index($&)
+          break Detail::HAN_KATA_LIST[pos]+Detail::HAN_VSYMBOLS[i] if pos
+        end
+      end
+    end
+    str= str.tr("ａ-ｚ", "a-z") if tp.include?(ZEN_LOWER)
+    str= str.tr("Ａ-Ｚ", "A-Z") if tp.include?(ZEN_UPPER)
+    str= str.tr("０-９", "0-9") if tp.include?(ZEN_NUMBER)
+    str= str.tr(Detail::ZEN_ASYMBOL_LIST,
+      Detail::HAN_ASYMBOL_LIST.gsub(/[\-\^\\]/){ "\\"+$& }) if tp.include?(ZEN_ASYMBOL)
+    str= str.tr(Detail::ZEN_JSYMBOL1_LIST,
+      Detail::HAN_JSYMBOL1_LIST) if tp.include?(ZEN_JSYMBOL)
+    return str
+  end
+  def han_to_zen(str, tp= ALL)
+    #[半]濁音記号がJSYMBOLに含まれるので、KATAの変換をJSYMBOLより前にやる必要あり。
+    if tp.include?(HAN_KATA)
+      str= str.gsub(/(#{han_kata})([ﾞﾟ]?)/) do
+        i= {""=>0, "ﾞ"=>1, "ﾟ"=>2}[$2]
+        pos= Detail::HAN_KATA_LIST.index($1)
+        s= Detail::ZEN_KATA_LISTS[i][pos]
+        (!s || s=="") ? Detail::ZEN_KATA_LISTS[0][pos]+$2 : s
+      end
+    end
+    str= str.tr("a-z", "ａ-ｚ") if tp.include?(HAN_LOWER)
+    str= str.tr("A-Z", "Ａ-Ｚ") if tp.include?(HAN_UPPER)
+    str= str.tr("0-9", "０-９") if tp.include?(HAN_NUMBER)
+    str= str.tr(Detail::HAN_ASYMBOL_LIST.gsub(/[\-\^\\]/){ "\\"+$& },
+      Detail::ZEN_ASYMBOL_LIST) if tp.include?(HAN_ASYMBOL)
+    str= str.tr(Detail::HAN_JSYMBOL1_LIST,
+      Detail::ZEN_JSYMBOL1_LIST) if tp.include?(HAN_JSYMBOL)
+    return str
+  end
+  def normalize_zen_han(str)
+    return zen_to_han(han_to_zen(str, HAN_JSYMBOL|HAN_KATA), ZEN_ALNUM|ZEN_ASYMBOL)
+  end
+  def upcase(str, tp= LOWER)
+    str= str.tr("a-z", "A-Z") if tp.include?(HAN_LOWER)
+    str= str.tr("ａ-ｚ", "Ａ-Ｚ") if tp.include?(ZEN_LOWER)
+  end
+  def downcase(str, tp= UPPER)
+    str= str.tr("A-Z", "a-z") if tp.include?(HAN_UPPER)
+    str= str.tr("Ａ-Ｚ", "ａ-ｚ") if tp.include?(ZEN_UPPER)
+  end
+  def kata_to_hira(str)
+    return str.tr("ァ-ン", "ぁ-ん")
+  end
+  def hira_to_kata(str)
+    return str.tr("ぁ-ん", "ァ-ン")
+  end
+  module_function(
+    :type, :type?, :regexp, :zen_to_han, :han_to_zen, :normalize_zen_han, :upcase, :downcase,
+    :kata_to_hira, :hira_to_kata
+  )
+  def self.define_regexp_method(name, tp)
+    define_method(name){ regexp(tp) }
+    module_function(name)
+  end
+  #han_control, han_asymbol, …などのモジュール関数を定義。
+  for cons in constants
+    val= const_get(cons)
+    define_regexp_method(cons.downcase(), val) if val.is_a?(FlagSetMaker::Flags)
+  end
+  def self.test()
+    str= "ドラえもん(Doraemon)は、日本で1番有名な漫画だ。"
+    str.each_char() do |ch|
+      printf("%2s  %s\n", ch, Moji.type(ch))
+    end
+    str= Moji.zen_to_han(str, Moji::ALL)
+    puts(str)
+    str= Moji.han_to_zen(str, Moji::ALL)
+    puts(str)
+  end
+end
+EOS
+script= NKF.nkf("-#{nkf_kcode}Wx", script) if nkf_kcode
+  #UTF-8の場合、nkfしてはいけない（～が〜になるので）。
+eval(script, TOPLEVEL_BINDING)
+if __FILE__==$0
+  Moji.test()
+end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kanamei-kanamei-keystone
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.10
 platform: ruby
 authors:
 - kanamei
@@ -22,9 +22,21 @@ extensions: []
 extra_rdoc_files: []
 files:
+- example/batch_sample.rb
+- example/string_util.rb
+- test/test_string_util.rb
 - lib/keystone
+- lib/keystone/base.rb
+- lib/keystone/batch_base.rb
+- lib/keystone/core_ext.rb
+- lib/keystone/environment.rb
+- lib/keystone/mail
+- lib/keystone/mail/send.rb
+- lib/keystone/mail.rb
 - lib/keystone/string_util.rb
 - lib/keystone.rb
+- vendor/flag_set_maker.rb
+- vendor/moji.rb
 has_rdoc: false
 homepage: http://github.com/kanamei/keystone/tree/master
 post_install_message:
@@ -32,6 +44,9 @@ rdoc_options: []
 require_paths:
 - lib
+- vendor
+- example
+- test
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="