jpmobile 1.0.0.pre.4 → 1.0.0.pre.5

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/emoticon/z_combine.rb

@@ -1,36 +0,0 @@
-unless Object.const_defined?(:Encoding)
-  $KCODE = 'u'
-end
-
-module Jpmobile
-  module Emoticon
-    GETA = 0x3013
-
-    SJIS_TO_UNICODE = {}
-    SJIS_TO_UNICODE.update(DOCOMO_SJIS_TO_UNICODE)
-    SJIS_TO_UNICODE.update(AU_SJIS_TO_UNICODE)
-    SJIS_TO_UNICODE.freeze
-    UNICODE_TO_SJIS = SJIS_TO_UNICODE.invert.freeze
-
-    # for au email
-    SJIS_TO_EMAIL_JIS = {0x81ac => 0x222E}
-    SJIS_TO_EMAIL_JIS.update(AU_SJIS_TO_EMAIL_JIS)
-    SJIS_TO_EMAIL_JIS.freeze
-
-    SJIS_REGEXP = Regexp.union(*SJIS_TO_UNICODE.keys.map{|s| Jpmobile::Util.sjis_regexp(s)})
-    SOFTBANK_WEBCODE_REGEXP = Regexp.union(*([/(?!)/n]+SOFTBANK_WEBCODE_TO_UNICODE.keys.map{|x| "\x1b\x24#{x}\x0f"}))
-
-    DOCOMO_SJIS_REGEXP      = Regexp.union(*DOCOMO_SJIS_TO_UNICODE.keys.map{|s| Jpmobile::Util.sjis_regexp(s)})
-    AU_SJIS_REGEXP          = Regexp.union(*AU_SJIS_TO_UNICODE.keys.map{|s| Jpmobile::Util.sjis_regexp(s)})
-    SOFTBANK_UNICODE_REGEXP = Regexp.union(*SOFTBANK_UNICODE_TO_WEBCODE.keys.map{|x| [x].pack('U')}).freeze
-
-    EMOTICON_UNICODES = UNICODE_TO_SJIS.keys|SOFTBANK_UNICODE_TO_WEBCODE.keys.map{|k|k+0x1000}
-    UTF8_REGEXP = Regexp.union(*EMOTICON_UNICODES.map{|x| [x].pack('U')}).freeze
-
-    # for PC conversion "GETA"
-    CONVERSION_TABLE_TO_PC_EMAIL = Hash[*(CONVERSION_TABLE_TO_SOFTBANK.keys|CONVERSION_TABLE_TO_DOCOMO.keys|CONVERSION_TABLE_TO_AU.keys).map{|k| [k, GETA]}.flatten]
-
-    SOFTBANK_SJIS_REGEXP = Regexp.union(*SOFTBANK_SJIS_TO_UNICODE.keys.map{|s| Jpmobile::Util.sjis_regexp(s)}).freeze
-    AU_EMAILJIS_REGEXP = Regexp.union(*AU_EMAILJIS_TO_UNICODE.keys.map{|s| Jpmobile::Util.jis_regexp(s)})
-  end
-end

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/encoding.rb

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-# params を UTF-8 にする拡張
-module Jpmobile
-  module Encoding
-    def self.included(base)
-      base.class_eval do
-        alias_method :parameters_without_jpmobile, :parameters
-
-        def parameters
-          return @parameters if @jpmobile_params_converted
-
-          # load params
-          @parameters = parameters_without_jpmobile
-          # 変換
-          @parameters = Jpmobile::Util.deep_convert(@parameters) do |value|
-            value = Jpmobile::Util.utf8(value)
-          end
-
-          @jpmobile_params_converted = true
-          if @parameters.respond_to?(:with_indifferent_access)
-            @parameters = @parameters.with_indifferent_access
-          end
-
-          @parameters
-        end
-      end
-    end
-  end
-end

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/filter.rb

@@ -1,113 +0,0 @@
-# -*- coding: utf-8 -*-
-# = 半角変換フィルター
-# thanks to masuidrive <masuidrive (at) masuidrive.jp>
-
-class ActionController::Base #:nodoc:
-  def self.hankaku_filter(options={})
-    options = {:input => false}.update(options)
-
-    before_filter lambda {|controller| Jpmobile::HankakuFilter.before(controller, options)}
-    after_filter  lambda {|controller| Jpmobile::HankakuFilter.after(controller, options)}
-  end
-
-  def self.mobile_filter(options={})
-    STDERR.puts "Method mobile_filter is now deprecated. Use hankaku_filter instead for Hankaku-conversion."
-
-    self.hankaku_filter(options)
-  end
-end
-
-module Jpmobile
-  module HankakuFilter
-    module_function
-
-    # 入出力フィルタの適用条件
-    def apply_incoming?(controller)
-      controller.request.mobile?
-    end
-    def apply_outgoing?(controller)
-      controller.request.mobile? and
-        [nil, "text/html", "application/xhtml+xml"].include?(controller.response.content_type)
-    end
-
-    def before(controller, options = {})
-      if apply_incoming?(controller)
-        Util.deep_apply(controller.params) do |value|
-          value = to_internal(value, options)
-        end
-      end
-    end
-    # 内部コードから外部コードに変換
-    def after(controller, options = {})
-      if apply_outgoing?(controller) and controller.response.body.is_a?(String)
-        controller.response.body = to_external(controller.response.body, options)
-      end
-    end
-
-    @@internal = %w(ガ ギ グ ゲ ゴ ザ ジ ズ ゼ ゾ ダ ヂ ヅ デ ド バ ビ ブ ベ ボ パ ピ プ ペ ポ ヴ ア イ ウ エ オ カ キ ク ケ コ サ シ ス セ ソ タ チ ツ テ ト ナ ニ ヌ ネ ノ ハ ヒ フ ヘ ホ マ ミ ム メ モ ヤ ユ ヨ ラ リ ル レ ロ ワ ヲ ン ャ ュ ョ ァ ィ ゥ ェ ォ ッ ゛ ゜ ー 。 「 」 、 ・ ！ ？).freeze
-    @@external = %w(ｶﾞ ｷﾞ ｸﾞ ｹﾞ ｺﾞ ｻﾞ ｼﾞ ｽﾞ ｾﾞ ｿﾞ ﾀﾞ ﾁﾞ ﾂﾞ ﾃﾞ ﾄﾞ ﾊﾞ ﾋﾞ ﾌﾞ ﾍﾞ ﾎﾞ ﾊﾟ ﾋﾟ ﾌﾟ ﾍﾟ ﾎﾟ ｳﾞ ｱ ｲ ｳ ｴ ｵ ｶ ｷ ｸ ｹ ｺ ｻ ｼ ｽ ｾ ｿ ﾀ ﾁ ﾂ ﾃ ﾄ ﾅ ﾆ ﾇ ﾈ ﾉ ﾊ ﾋ ﾌ ﾍ ﾎ ﾏ ﾐ ﾑ ﾒ ﾓ ﾔ ﾕ ﾖ ﾗ ﾘ ﾙ ﾚ ﾛ ﾜ ｦ ﾝ ｬ ｭ ｮ ｧ ｨ ｩ ｪ ｫ ｯ ﾞ ﾟ ｰ ｡ ｢ ｣ ､ ･ ! ?).freeze
-    def to_internal(str, options = {})
-      filter(str, @@external, @@internal)
-    end
-    def to_external(str, options = {})
-      unless options[:input]
-        filter(str, @@internal, @@external)
-      else
-        encoding = (str =~ /^\s*<[^Hh>]*html/) and str.respond_to?(:encoding)
-        nokogiri_klass =
-          (str =~ /^\s*<[^Hh>]*html/) ? Nokogiri::HTML::Document : Nokogiri::HTML::DocumentFragment
-        doc = if encoding
-                nokogiri_klass.parse(str, nil, "UTF-8")
-              else
-                nokogiri_klass.parse(str)
-              end
-
-        doc = convert_text_content(doc)
-
-        doc.to_html
-      end
-    end
-
-    def filter(str, from, to)
-      str = str.clone
-
-      # 一度UTF-8に変換
-      before_encoding = nil
-      if str.respond_to?(:force_encoding)
-        before_encoding = str.encoding
-        str.force_encoding("UTF-8")
-      end
-
-      from.each_with_index do |int, i|
-        str.gsub!(int, to[i])
-      end
-
-      # 元に戻す
-      if before_encoding
-        str.force_encoding(before_encoding)
-      end
-
-      str
-    end
-
-    # 再帰的に探す
-    def convert_text_content(document)
-      document.children.each do |element|
-        if element.kind_of?(Nokogiri::XML::Text)
-          unless element.parent.node_name == "textarea"
-            # textarea 以外のテキストなら content を変換
-            element.content = filter(element.content, @@internal, @@external)
-          end
-        elsif element.node_name == "input" and ["submit", "reset", "button"].include?(element["type"])
-          # テキスト以外でもボタンの value は変換
-          element["value"] = filter(element["value"], @@internal, @@external)
-        elsif element.children.any?
-          # 子要素があれば再帰的に変換
-          element = convert_text_content(element)
-        end
-      end
-
-      document
-    end
-  end
-end

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/helpers.rb

@@ -1,174 +0,0 @@
-# -*- coding: utf-8 -*-
-# =位置情報等を要求するヘルパー
-module Jpmobile
-  # 携帯電話端末に位置情報を要求するための、特殊なリンクを出力するヘルパー群。
-  # 多くのキャリアでは特殊なFORMでも位置情報を要求できる。
-  module Helpers
-    # 位置情報(緯度経度がとれるもの。オープンiエリアをのぞく)要求するリンクを作成する。
-    # 位置情報を受け取るページを +url_for+ に渡す引数の形式で +options+ に指定する。
-    # :show_all => +true+ とするとキャリア判別を行わず全てキャリアのリンクを返す。
-    # 第1引数に文字列を与えるとその文字列をアンカーテキストにする。
-    # 第1引数がHashの場合はデフォルトのアンカーテキストを出力する。
-    def get_position_link_to(str=nil, options={})
-      if str.is_a?(Hash)
-        options = str
-        str = nil
-      end
-      show_all = nil
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        show_all = options.delete(:show_all)
-      end
-
-      # TODO: コード汚い
-      s = []
-      if show_all || request.mobile.instance_of?(Mobile::Docomo)
-        s << docomo_foma_gps_link_to(str||"DoCoMo FOMA(GPS)", options)
-      end
-      if show_all || request.mobile.instance_of?(Mobile::Au)
-        if show_all || request.mobile.supports_gps?
-          s << au_gps_link_to(str||"au(GPS)", options)
-        end
-        if show_all || (!(request.mobile.supports_gps?) && request.mobile.supports_location?)
-          s << au_location_link_to(str||"au(antenna)", options)
-        end
-      end
-      if show_all || request.mobile.instance_of?(Mobile::Vodafone) || request.mobile.instance_of?(Mobile::Softbank)
-        s << softbank_location_link_to(str||"Softbank 3G(GPS)", options)
-      end
-      if show_all || request.mobile.instance_of?(Mobile::Willcom)
-        s << willcom_location_link_to(str||"Willcom", options)
-      end
-      return s.join("<br>\n").html_safe
-    end
-
-    # DoCoMo FOMAでGPS位置情報を取得するためのリンクを返す。
-    def docomo_foma_gps_link_to(str, options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        url = url_for(options)
-      end
-      return %{<a href="#{url}" lcs>#{str}</a>}.html_safe
-    end
-
-    # DoCoMoでオープンiエリアを取得するためのURLを返す。
-    def docomo_openiarea_url_for(options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        posinfo = options.delete(:posinfo) || "1" # 基地局情報を元に測位した緯度経度情報を要求
-        url = url_for(options)
-      else
-        posinfo = "1"
-      end
-      return "http://w1m.docomo.ne.jp/cp/iarea?ecode=OPENAREACODE&msn=OPENAREAKEY&posinfo=#{posinfo}&nl=#{CGI.escape(url)}"
-    end
-
-    # DoCoMoでオープンiエリアを取得するためのリンクを返す。
-    def docomo_openiarea_link_to(str, options={})
-      link_to_url(str, docomo_openiarea_url_for(options))
-    end
-
-    # DoCoMoで端末製造番号等を取得するためのリンクを返す。
-    def docomo_utn_link_to(str, options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        url = url_for(options)
-      end
-      return %{<a href="#{url}" utn>#{str}</a>}.html_safe
-    end
-
-    # DoCoMoでiモードIDを取得するためのリンクを返す。
-    def docomo_guid_link_to(str, options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:guid] = "ON"
-        url = url_for(options)
-      end
-      return link_to_url(str, url)
-    end
-
-    # au GPS位置情報を取得するためのURLを返す。
-    def au_gps_url_for(options={})
-      url = options
-      datum = 0 # 0:wgs84, 1:tokyo
-      unit = 0 # 0:dms, 1:deg
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        datum = (options.delete(:datum) || 0 ).to_i # 0:wgs84, 1:tokyo
-        unit = (options.delete(:unit) || 0 ).to_i # 0:dms, 1:deg
-        url = url_for(options)
-      end
-      return "device:gpsone?url=#{CGI.escape(url)}&ver=1&datum=#{datum}&unit=#{unit}&acry=0&number=0"
-    end
-
-    # au GPS位置情報を取得するためのリンクを返す。
-    def au_gps_link_to(str, options={})
-      link_to_url(str, au_gps_url_for(options))
-    end
-
-    # au 簡易位置情報を取得するためのURLを返す。
-    def au_location_url_for(options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        url = url_for(options)
-      end
-      return "device:location?url=#{CGI.escape(url)}"
-    end
-
-    # au 簡易位置情報を取得するためのリンクを返す。
-    def au_location_link_to(str, options={})
-      link_to_url(str, au_location_url_for(options))
-    end
-
-    # Softbank(含むVodafone 3G)で位置情報を取得するためのURLを返す。
-    def softbank_location_url_for(options={})
-      url = options
-      mode = "auto"
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        mode = options.delete(:mode) || "auto"
-        options[:only_path] = false
-        url = url_for(options)
-      end
-      url.sub!(/\?/, '&')
-      return "location:#{mode}?url=#{url}"
-    end
-
-    # Softbank(含むVodafone 3G)で位置情報を取得するためのリンクを返す。
-    def softbank_location_link_to(str,options={})
-      link_to_url(str,softbank_location_url_for(options))
-    end
-
-    # Willcom 基地局位置情報を取得するためのURLを返す。
-    def willcom_location_url_for(options={})
-      url = options
-      if options.is_a?(Hash)
-        options = options.symbolize_keys
-        options[:only_path] = false
-        url = url_for(options)
-      end
-      return "http://location.request/dummy.cgi?my=#{url}&pos=$location"
-    end
-
-    # Willcom 基地局位置情報を取得するためのリンクを返す。
-    def willcom_location_link_to(str,options={})
-      link_to_url(str, willcom_location_url_for(options))
-    end
-
-    private
-    # 外部へのリンク
-    def link_to_url(str, url)
-      %{<a href="#{html_escape(url)}">#{html_escape(str)}</a>}.html_safe
-    end
-  end
-end

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/hook_action_controller.rb

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'jpmobile/lookup_context'
-
-module ActionController
-  class Base
-    include Jpmobile::Helpers
-    before_filter :gettext_force_ja_for_mobile
-    # gettextが組み込まれている場合、携帯電話からのアクセスをjaロケールに強制する。
-    def gettext_force_ja_for_mobile
-      if Object.const_defined?(:GetText) and request.mobile?
-        begin
-          ::GetText.locale = 'ja'
-        rescue NameError
-        end
-      end
-    end
-  end
-end

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/hook_action_dispatch.rb

@@ -1,2 +0,0 @@
-# -*- coding: utf-8 -*-
-ActionDispatch::Request.send :include, Jpmobile::Encoding

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/hook_action_view.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-#:stopdoc:
-# helperを追加
-ActionView::Base.class_eval { include Jpmobile::Helpers }
-#:startdoc:
-
-# :stopdoc:
-# accept-charset に charset を変更できるようにする
-# ActionView で trans_sid を有効にする
-module ActionView
-  module Helpers
-    module FormTagHelper
-      private
-      def html_options_for_form(url_for_options, options, *parameters_for_url)
-        accept_charset = (Rails.application.config.jpmobile.form_accept_charset_conversion && request && request.mobile && request.mobile.default_charset) || "UTF-8"
-
-        options.stringify_keys.tap do |html_options|
-          html_options["enctype"] = "multipart/form-data" if html_options.delete("multipart")
-          # The following URL is unescaped, this is just a hash of options, and it is the
-          # responsability of the caller to escape all the values.
-          html_options["action"]  = url_for(url_for_options, *parameters_for_url)
-          html_options["accept-charset"] = accept_charset
-          html_options["data-remote"] = true if html_options.delete("remote")
-        end
-      end
-    end
-  end
-
-  class Base
-    delegate :default_url_options, :to => :controller unless respond_to?(:default_url_options)
-  end
-end
-#:startdoc:

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/lookup_context.rb

@@ -1,2 +0,0 @@
-# -*- coding: utf-8 -*-
-ActionView::LookupContext.register_detail(:mobile) {nil}

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/mail.rb

@@ -1,330 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'mail'
-
-module Jpmobile
-  module Mail
-    module_function
-  end
-end
-
-module Mail
-  # encoding patch
-  if self.const_defined?(:Ruby19)
-    Ruby19.class_eval do
-      def self.b_value_decode(str)
-        match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
-        if match
-          encoding = match[1]
-          str = self.decode_base64(match[2])
-          str.force_encoding(fix_encoding(encoding))
-        end
-        # if str contains some emoticon, the following line raises Encoding error
-        str.encode("utf-8", :invalid => :replace, :replace => "") rescue Jpmobile::Util.ascii_8bit(str)
-      end
-    end
-  elsif self.const_defined?(:Ruby18)
-    Ruby18.class_eval do
-      def self.b_value_decode(str)
-        match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
-        if match
-          encoding = match[1]
-          str = Ruby18.decode_base64(match[2])
-        end
-        str
-      end
-    end
-  end
-
-  class Message
-    attr_accessor :mobile
-
-    def mobile=(m)
-      @mobile  = m
-      @charset = m.mail_charset(@charset)
-
-      if @body
-        @body.charset = @charset
-        @body.mobile = m
-      end
-    end
-
-    def encoded_with_jpmobile
-      if @mobile
-        header['subject'].mobile = @mobile if header['subject']
-        self.charset             = @mobile.mail_charset(@charset)
-
-        ready_to_send!
-
-        self.body.charset = @charset
-        self.body.mobile  = @mobile
-        self.header['Content-Transfer-Encoding'] = '8bit'
-
-        buffer = header.encoded
-        buffer << "\r\n"
-        buffer = @mobile.utf8_to_mail_encode(buffer)
-        buffer << body.encoded(content_transfer_encoding)
-        buffer
-      else
-        encoded_without_jpmobile
-      end
-    end
-
-    def parse_message_with_jpmobile
-      header_part, body_part = raw_source.split(/#{CRLF}#{WSP}*#{CRLF}/m, 2)
-
-      self.header = header_part
-
-      @body_part_jpmobile = body_part
-      convert_encoding_jpmobile
-      body_part = @body_part_jpmobile
-
-      self.body   = body_part
-    end
-
-    def init_with_string(string)
-      # convert to ASCII-8BIT for ascii incompatible encodings
-      s = Jpmobile::Util.ascii_8bit(string)
-      self.raw_source = s
-      set_envelope_header
-      parse_message
-      @separate_parts = multipart?
-    end
-
-    def process_body_raw_with_jpmobile
-      process_body_raw_without_jpmobile
-
-      @body.charset = @charset
-      @body.mobile = @mobile
-
-      if has_content_transfer_encoding? and
-          ["base64", "quoted-printable"].include?(content_transfer_encoding) and
-          ["text", nil].include?(@mobile_main_type)
-        @body.decode_transfer_encoding
-      end
-
-      if @body.multipart?
-        @body.parts.each do |p|
-          p.charset = @charset
-          p.mobile = @mobile
-        end
-      end
-    end
-
-    def body_lazy_with_jpmobile(value, index)
-      body_lazy_without_jpmobile(value, index)
-    end
-
-    alias_method :encoded_without_jpmobile, :encoded
-    alias_method :encoded, :encoded_with_jpmobile
-
-    alias_method :parse_message_without_jpmobile, :parse_message
-    alias_method :parse_message, :parse_message_with_jpmobile
-
-    alias_method :process_body_raw_without_jpmobile, :process_body_raw
-    alias_method :process_body_raw, :process_body_raw_with_jpmobile
-
-    alias_method :body_lazy_without_jpmobile, :body_lazy
-    alias_method :body_lazy, :body_lazy_with_jpmobile
-
-    private
-    def convert_encoding_jpmobile
-      # decide mobile carrier
-      if self.header['From']
-        mobile_class = Jpmobile::Email.detect_from_mail_header(self.header['From'].value)
-        @mobile ||= (mobile_class || Jpmobile::Mobile::AbstractMobile ).new(nil, nil)
-      end
-
-      # override charset
-      if self.header['Content-Type']
-        @charset = Jpmobile::Util.extract_charset(self.header['Content-Type'].value)
-        self.header['Content-Type'].parameters[:charset] = @charset
-        @mobile_main_type = self.header['Content-Type'].main_type
-      end
-
-      # convert header(s)
-      if self.header['Subject']
-        subject_charset = Jpmobile::Util.extract_charset(self.header['Subject'].value)
-
-        # override subject encoding if @charset is blank
-        @charset = subject_charset if !subject_charset.blank? and @charset.blank?
-
-        self.header['Subject'].charset = subject_charset
-
-        if @mobile
-          v = @mobile.to_mail_internal(
-            Encodings.value_decode(self.header['Subject'].value), subject_charset)
-          self.header['Subject'].value = Jpmobile::Util.force_encode(v, @mobile.mail_charset(@charset), Jpmobile::Util::UTF8)
-        end
-      end
-
-      if @body_part_jpmobile and @mobile
-        @body_part_jpmobile = @mobile.decode_transfer_encoding(@body_part_jpmobile, @charset)
-      end
-    end
-  end
-
-  class Part
-    def init_with_string(string)
-      self.raw_source = string
-      set_envelope_header
-      parse_message
-      @separate_parts = multipart?
-    end
-
-    def parse_message_with_jpmobile
-      header_part, body_part = raw_source.split(/#{CRLF}#{WSP}*#{CRLF}/m, 2)
-
-      if header_part =~ HEADER_LINE
-        self.header = header_part
-      else
-        self.header = "Content-Type: text/plain\r\n"
-      end
-
-      @body_part_jpmobile = body_part
-      convert_encoding_jpmobile
-      body_part = @body_part_jpmobile
-
-      self.body   = body_part
-    end
-
-    alias_method :parse_message_without_jpmobile, :parse_message
-    alias_method :parse_message, :parse_message_with_jpmobile
-  end
-
-  class Body
-    attr_accessor :mobile
-
-    # convert encoding
-    def encoded_with_jpmobile(transfer_encoding = '8bit')
-      if @mobile and !multipart?
-        if @mobile.to_mail_body_encoded?(@raw_source)
-          @raw_source
-        else
-          @mobile.to_mail_body(Jpmobile::Util.force_encode(@raw_source, @charset, Jpmobile::Util::UTF8))
-        end
-      else
-        encoded_without_jpmobile(transfer_encoding)
-      end
-    end
-
-    def decoded_with_jpmobile
-      decoded_without_jpmobile
-    end
-
-    # fix charset
-    def set_charset_with_jpmobile
-      @charset ||= only_us_ascii? ? 'US-ASCII' : nil
-    end
-
-    def mobile=(m)
-      @mobile = m
-
-      if self.multipart?
-        self.parts.each do |part|
-          part.charset      = @charset
-          part.mobile       = @mobile
-          part.body.charset = @charset
-          part.body.mobile  = @mobile
-        end
-      end
-    end
-
-    def decode_transfer_encoding
-      _raw_source = Encodings.get_encoding(encoding).decode(@raw_source)
-      _raw_source = Jpmobile::Util.set_encoding(_raw_source, @charset)
-
-      @raw_source = @mobile.decode_transfer_encoding(_raw_source, @charset)
-    end
-
-    def preamble_with_jpmobile
-      if @mobile
-        Jpmobile::Util.encode(@preamble, @charset)
-      else
-        preamble_without_jpmobile
-      end
-    end
-
-    def epilogue_with_jpmobile
-      if @mobile
-        Jpmobile::Util.encode(@epilogue, @charset)
-      else
-        epilogue_without_jpmobile
-      end
-    end
-
-    def crlf_boundary_with_jpmobile
-      if @mobile
-        Jpmobile::Util.encode(crlf_boundary_without_jpmobile, @charset)
-      else
-        epilogue_without_jpmobile
-      end
-    end
-
-    def end_boundary_with_jpmobile
-      if @mobile
-        Jpmobile::Util.encode(end_boundary_without_jpmobile, @charset)
-      else
-        epilogue_without_jpmobile
-      end
-    end
-
-    alias_method :encoded_without_jpmobile, :encoded
-    alias_method :encoded, :encoded_with_jpmobile
-
-    alias_method :decoded_without_jpmobile, :decoded
-    alias_method :decoded, :decoded_with_jpmobile
-
-    alias_method :set_charset_without_jpmobile, :set_charset
-    alias_method :set_charset, :set_charset_with_jpmobile
-
-    alias_method :preamble_without_jpmobile, :preamble
-    alias_method :preamble, :preamble_with_jpmobile
-
-    alias_method :crlf_boundary_without_jpmobile, :crlf_boundary
-    alias_method :crlf_boundary, :crlf_boundary_with_jpmobile
-
-    alias_method :end_boundary_without_jpmobile, :end_boundary
-    alias_method :end_boundary, :end_boundary_with_jpmobile
-
-    alias_method :epilogue_without_jpmobile, :epilogue
-    alias_method :epilogue, :epilogue_with_jpmobile
-  end
-
-  class UnstructuredField
-    attr_accessor :mobile
-  end
-
-  # for subject
-  class SubjectField < UnstructuredField
-    # FIXME: not folding subject -> folding
-    def encoded_with_jpmobile
-      if @mobile
-        if @mobile.to_mail_subject_encoded?(value)
-          "#{name}: #{value}\r\n"
-        else
-          # convert encoding
-          "#{name}: " + @mobile.to_mail_subject(value) + "\r\n"
-        end
-      else
-        encoded_without_jpmobile
-      end
-    end
-
-    alias_method :encoded_without_jpmobile, :encoded
-    alias_method :encoded, :encoded_with_jpmobile
-  end
-
-  class Sendmail
-    def Sendmail.call(path, arguments, destinations, mail)
-      encoded_mail = mail.encoded
-      if Jpmobile::Util.jis?(encoded_mail)
-        encoded_mail = Jpmobile::Util.ascii_8bit(encoded_mail)
-      end
-
-      IO.popen("#{path} #{arguments} #{destinations}", "w+") do |io|
-        io.puts encoded_mail.gsub(/\r\r\n/, "\n").to_lf
-        io.flush
-      end
-    end
-  end
-end