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

data/test/rails/rails_root/vendor/plugins/jpmobile/lib/jpmobile/rack/params_filter.rb

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-# リクエストパラメータの変換
-module Jpmobile
-  module Rack
-    class ParamsFilter
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        # 入力
-        if @mobile = env['rack.jpmobile']
-          # パラメータをkey, valueに分解
-          # form_params
-          if env['REQUEST_METHOD'] == 'POST'
-            env['rack.input'] = StringIO.new(parse_query(env['rack.input'].read))
-          end
-
-          # query_params
-          env['QUERY_STRING'] = parse_query(env['QUERY_STRING'])
-        end
-
-        status, env, body = @app.call(env)
-
-        [status, env, body]
-      end
-
-      private
-      def to_internal(str)
-        ::Rack::Utils.escape(@mobile.to_internal(::Rack::Utils.unescape(str)))
-      end
-      def parse_query(str)
-        return nil unless str
-
-        new_array = []
-        str.split("&").each do |param_pair|
-          k, v = param_pair.split("=")
-          k = to_internal(k) if k
-          v = to_internal(v) if v
-          new_array << "#{k}=#{v}" if k
-        end
-
-        new_array.join("&")
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-ActiveSupport.on_load(:action_controller) do
-  require 'jpmobile/docomo_guid'
-  require 'jpmobile/filter'
-  require 'jpmobile/helpers'
-  require 'jpmobile/hook_action_controller'
-  require 'jpmobile/hook_action_view'
-  require 'jpmobile/trans_sid'
-end
-ActiveSupport.on_load(:action_dispatch) do
-  require 'jpmobile/hook_action_dispatch'
-end
-
-ActiveSupport.on_load(:before_configuration) do
-  # MobileCarrierのみデフォルトで有効
-  ::Rails.application.middleware.insert_before('ActionDispatch::ParamsParser', Jpmobile::Rack::MobileCarrier)
-  module Rails
-    class Application
-      class Configuration
-        def jpmobile
-          @jpmobile ||= ::Jpmobile::Configuration.new
-        end
-      end
-    end
-  end
-end
-
-module Jpmobile
-  module ViewSelector
-    def self.included(base)
-      base.class_eval do
-        before_filter :register_mobile
-
-        self._view_paths = self._view_paths.dup
-        self.view_paths.unshift(Jpmobile::Resolver.new(File.join(Rails.root, "app/views")))
-      end
-    end
-
-    def register_mobile
-      if request.mobile
-        # register mobile
-        self.lookup_context.mobile = request.mobile.variants
-      end
-    end
-
-    def disable_mobile_view!
-      self.lookup_context.mobile = nil
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# jpmobile の各機能を提供するモジュール
-# envメソッドが実装されている必要がある。
-
-module Jpmobile
-  module RequestWithMobile
-    # 環境変数 HTTP_USER_AGENT を返す。
-    def user_agent
-      env['HTTP_USER_AGENT']
-    end
-
-    # for reverse proxy.
-    def remote_addr
-      if respond_to?(:remote_ip)
-        return __send__(:remote_ip)  # for Rails
-      elsif respond_to?(:ip)
-        return __send__(:ip)         # for Rack
-      else
-        return ( env["HTTP_X_FORWARDED_FOR"] ? env["HTTP_X_FORWARDED_FOR"].split(',').pop : env["REMOTE_ADDR"] )
-      end
-    end
-
-    # 環境変数 HTTP_USER_AGENT を設定する。
-    def user_agent=(str)
-      self.env["HTTP_USER_AGENT"] = str
-    end
-
-    # 携帯電話からであれば +true+を、そうでなければ +false+ を返す。
-    def mobile?
-      mobile and not mobile.smart_phone?
-    end
-
-    # viewの切り替えをするかどうか
-    def smart_phone?
-      mobile and mobile.smart_phone?
-    end
-
-    # 携帯電話の機種に応じて Mobile::xxx を返す。
-    # 携帯電話でない場合はnilを返す。
-    def mobile
-      env['rack.jpmobile']
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Jpmobile
-  class Resolver < ActionView::FileSystemResolver
-    # EXTENSION_ORDER = [:variants, :locale, :formats, :handlers]
-
-    def find_templates(name, prefix, partial, details)
-      path = build_path(name, prefix, partial, details)
-      query(path, EXTENSION_ORDER.map { |ext| details[ext] }, details[:formats], details[:mobile])
-    end
-
-    def build_path(name, prefix, partial, details)
-      path = ""
-      path << "#{prefix}/" unless prefix.empty?
-      path << (partial ? "_#{name}" : name)
-      path
-    end
-
-    def query(path, exts, formats, mobile)
-      query = File.join(@path, path)
-      query << '{' << mobile.map {|v| "_#{v}"}.join(',') << ',}' if mobile and mobile.respond_to?(:map)
-
-      exts.each do |ext|
-        query << '{' << ext.map {|e| e && ".#{e}" }.join(',') << ',}'
-      end
-
-      query.gsub!(/\{\.html,/, "{.html,.text.html,")
-      query.gsub!(/\{\.text,/, "{.text,.text.plain,")
-
-      Dir[query].reject { |p| File.directory?(p) }.map do |p|
-        handler, format = extract_handler_and_format(p, formats)
-
-        contents = File.open(p, "rb") {|io| io.read }
-
-        ActionView::Template.new(contents, File.expand_path(p), handler,
-          :virtual_path => path, :format => format)
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-# -*- coding: utf-8 -*-
-# = セッションIDの付与
-require 'active_support/version'
-
-module ParamsOverCookie
-  def self.included(base)
-    base.class_eval do
-      # cookie よりも params を先に見るパッチ
-      def extract_session_id_with_jpmobile(env)
-        request = ActionDispatch::Request.new(env.dup)
-        if request.params[@key] and !@cookie_only
-          sid = request.params[@key]
-        end
-        sid ||= request.cookies[@key]
-        sid
-      end
-      alias_method_chain :extract_session_id, :jpmobile
-    end
-  end
-end
-
-module ActionDispatch
-  module Session
-    class AbstractStore
-      include ParamsOverCookie
-    end
-  end
-end
-
-module ActionController
-  module Redirecting
-    def redirect_to_with_jpmobile(options = {}, response_status = {})
-      if apply_trans_sid? and jpmobile_session_id
-        case options
-        when %r{^\w[\w+.-]*:.*}
-          # nothing to do
-        when String
-          unless options.match(/#{session_key}/)
-            url = URI.parse(options)
-            if url.query
-              url.query += "&#{session_key}=#{jpmobile_session_id}"
-            else
-              url.query = "#{session_key}=#{jpmobile_session_id}"
-            end
-            options = url.to_s
-          end
-        when :back
-          # nothing to do
-        when Hash
-          unless options[session_key.to_sym]
-            options[session_key.to_sym] = jpmobile_session_id
-          end
-        else
-          # nothing to do
-        end
-      end
-
-      redirect_to_without_jpmobile(options, response_status)
-    end
-
-    alias_method_chain :redirect_to, :jpmobile
-  end
-
-  class Metal #:nodoc:
-    class_inheritable_accessor :trans_sid_mode
-
-    class << self
-      def trans_sid(mode = :mobile)
-        include Jpmobile::TransSid
-        self.trans_sid_mode = mode
-      end
-    end
-
-    private
-    # trans_sidを適用すべきかを返す。
-    def apply_trans_sid?
-      # session_id が blank の場合は適用しない
-      return false if trans_sid_mode and jpmobile_session_id.blank?
-
-      case trans_sid_mode
-      when :always
-        session.inspect
-        return true
-      when :mobile
-        if request.mobile? and !request.mobile.supports_cookie?
-          session.inspect
-          return true
-        end
-      end
-
-      return false
-    end
-  end
-end
-
-module Jpmobile::TransSid #:nodoc:
-  def self.included(controller)
-    controller.after_filter(:append_session_id_parameter)
-  end
-
-  protected
-  # URLにsession_idを追加する。
-  def default_url_options
-    result = super || {}
-    return result unless request # for test process
-    return result unless apply_trans_sid?
-    return result.merge({session_key => jpmobile_session_id})
-  end
-
-  private
-  # session_keyを返す。
-  def session_key
-    unless key = Rails.application.config.session_options.merge(request.session_options || {})[:key]
-      key = ActionDispatch::Session::AbstractStore::DEFAULT_OPTIONS[:key]
-    end
-    key
-  end
-  # session_idを返す
-  def jpmobile_session_id
-    request.session_options[:id] rescue session.session_id
-  end
-  # session_idを埋め込むためのhidden fieldを出力する。
-  def sid_hidden_field_tag
-    "<input type=\"hidden\" name=\"#{CGI::escapeHTML session_key}\" value=\"#{CGI::escapeHTML jpmobile_session_id}\" />"
-  end
-  # formにsession_idを追加する。
-  def append_session_id_parameter
-    return unless request # for test process
-    return unless apply_trans_sid?
-    return unless jpmobile_session_id
-    response.body = response.body.gsub(%r{(</form>)}i, sid_hidden_field_tag+'\1')
-  end
-end

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

@@ -1,370 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'tempfile'
-module Jpmobile
-  module Util
-    # SJIS   = "Shift_JIS"
-    SJIS   = "Windows-31J"
-    UTF8   = "UTF-8"
-    JIS    = "ISO-2022-JP"
-    BINARY = "ASCII-8BIT"
-
-    WAVE_DASH = [0x301c].pack("U")
-    FULLWIDTH_TILDE = [0xff5e].pack("U")
-
-    OVERLINE = [0x203e].pack("U")
-    FULLWIDTH_MACRON = [0xffe3].pack("U")
-
-    EM_DASH = [0x2014].pack("U")
-    HORIZONTAL_BAR = [0x2015].pack("U")
-
-    MINUS_SIGN = [0x2212].pack("U")
-    FULLWIDTH_HYPHEN_MINUS = [0xFF0D].pack("U")
-
-    module_function
-    def deep_apply(obj, &proc)
-      case obj
-      when Hash
-        obj.each_pair do |key, value|
-          obj[key] = deep_apply(value, &proc)
-        end
-      when Array
-        obj.collect!{|value| deep_apply(value, &proc)}
-      when String
-        obj = obj.to_param if obj.respond_to?(:to_param)
-        proc.call(obj)
-      else
-        # NilClass, TrueClass, FalseClass, Tempfile, StringIO, etc...
-        return obj
-      end
-    end
-
-    def deep_convert(obj, &proc)
-      case obj
-      when Hash
-        new_obj = {}
-        obj.each_pair do |key, value|
-          new_obj[deep_convert(key.dup, &proc)] = deep_convert(value, &proc)
-        end
-        new_obj
-      when Array
-        new_obj = obj.map do |value|
-          deep_convert(value, &proc)
-        end
-      when Symbol
-        new_obj = proc.call(obj.to_s).to_sym
-      when String
-        obj = obj.to_param if obj.respond_to?(:to_param)
-        new_obj = proc.call(obj)
-      else
-        # NilClass, TrueClass, FalseClass, Tempfile, StringIO, etc...
-        new_obj = obj
-      end
-
-      new_obj
-    end
-
-    def sjis(str)
-      if str.respond_to?(:force_encoding) and !shift_jis?(str)
-        str.force_encoding(SJIS)
-      end
-      str
-    end
-
-    def utf8(str)
-      if str.respond_to?(:force_encoding) and !utf8?(str)
-        str.force_encoding(UTF8)
-      end
-      str
-    end
-
-    def jis(str)
-      if str.respond_to?(:force_encoding) and !jis?(str)
-        str.force_encoding(JIS)
-      end
-      str
-    end
-
-    def ascii_8bit(str)
-      if str.respond_to?(:force_encoding) and !ascii_8bit?(str)
-        str.force_encoding(BINARY)
-      end
-      str
-    end
-
-    def utf8_to_sjis(utf8_str)
-      # 波ダッシュ対策
-      utf8_str = wavedash_to_fullwidth_tilde(utf8_str)
-      # オーバーライン対策(不可逆的)
-      utf8_str = overline_to_fullwidth_macron(utf8_str)
-      # ダッシュ対策（不可逆的）
-      utf8_str = emdash_to_horizontal_bar(utf8_str)
-      # マイナス対策（不可逆的）
-      utf8_str = minus_sign_to_fullwidth_pyphen_minus(utf8_str)
-
-      if utf8_str.respond_to?(:encode)
-        utf8_str.encode(SJIS, :crlf_newline => true)
-      else
-        NKF.nkf("-m0 -x -W --oc=cp932", utf8_str).gsub(/\n/, "\r\n")
-      end
-    end
-
-    def sjis_to_utf8(sjis_str)
-      utf8_str = if sjis_str.respond_to?(:encode)
-                   sjis_str.encode("UTF-8", :universal_newline => true)
-                 else
-                   NKF.nkf("-m0 -x -w --ic=cp932", sjis_str).gsub(/\r\n/, "\n")
-                 end
-
-      # 波ダッシュ対策
-      fullwidth_tilde_to_wavedash(utf8_str)
-    end
-
-    def utf8_to_jis(utf8_str)
-      if utf8_str.respond_to?(:encode)
-        utf8_str.encode(JIS, :crlf_newline => true)
-      else
-        NKF.nkf("-m0 -x -Wj", utf8_str).gsub(/\n/, "\r\n")
-      end
-    end
-
-    def jis_to_utf8(jis_str)
-      if jis_str.respond_to?(:encode)
-        jis_str.encode(UTF8, :universal_newline => true)
-      else
-        NKF.nkf("-m0 -x -Jw", jis_str).gsub(/\r\n/, "\n")
-      end
-    end
-
-    def regexp_utf8_to_sjis(utf8_str)
-      if Object.const_defined?(:Encoding)
-        Regexp.compile(Regexp.escape(utf8_to_sjis(utf8_str)))
-      else
-        Regexp.compile(Regexp.escape(utf8_to_sjis(utf8_str),"s"),nil,'s')
-      end
-    end
-
-    def regexp_to_sjis(sjis_str)
-      if Object.const_defined?(:Encoding)
-        Regexp.compile(Regexp.escape(sjis(sjis_str)))
-      else
-        Regexp.compile(Regexp.escape(sjis_str,"s"),nil,'s')
-      end
-    end
-
-    def hash_to_utf8(hash)
-      new_hash = {}
-      hash.each do |keu, value|
-        new_hash[utf8(key)] = utf8(value)
-      end
-    end
-
-    def sjis_regexp(sjis)
-      sjis_str = sjis.kind_of?(Numeric) ? [sjis].pack('n') : sjis
-
-      if Object.const_defined?(:Encoding)
-        Regexp.compile(Regexp.escape(sjis_str.force_encoding(SJIS)))
-      else
-        Regexp.compile(Regexp.escape(sjis_str,"s"),nil,'s')
-      end
-    end
-
-    def jis_regexp(jis)
-      jis_str = jis.kind_of?(Numeric) ? [jis].pack('n') : jis
-
-      if Object.const_defined?(:Encoding)
-        # Regexp.compile(Regexp.escape(jis_str.force_encoding("stateless-ISO-2022-JP-KDDI"))) # for au only
-        Regexp.compile(Regexp.escape(jis_str.force_encoding(BINARY))) # for au only
-      else
-        Regexp.compile(Regexp.escape(jis_str,"j"),nil,'j')
-      end
-    end
-
-    def jis_string_regexp
-      Regexp.compile(Regexp.escape(ascii_8bit("\x1b\x24\x42")) + "(.+)" + Regexp.escape(ascii_8bit("\x1b\x28\x42")))
-    end
-
-    def encode(str, charset)
-      if Object.const_defined?(:Encoding)
-        (charset.nil? or charset == "" or str.nil? or str == "") ? str : str.encode(charset)
-      else
-        if str.nil?
-          str
-        else
-          case charset
-          when /iso-2022-jp/i
-            NKF.nkf("-j", str)
-          when /shift_jis/i
-            NKF.nkf("-s", str)
-          when /utf-8/i
-            NKF.nkf("-w", str)
-          else
-            str
-          end
-        end
-      end
-    end
-
-    def wavedash_to_fullwidth_tilde(utf8_str)
-      utf8_str.gsub(WAVE_DASH, FULLWIDTH_TILDE)
-    end
-
-    def fullwidth_tilde_to_wavedash(utf8_str)
-      utf8_str.gsub(FULLWIDTH_TILDE, WAVE_DASH)
-    end
-
-    def overline_to_fullwidth_macron(utf8_str)
-      utf8_str.gsub(OVERLINE, FULLWIDTH_MACRON)
-    end
-
-    def fullwidth_macron_to_overline(utf8_str)
-      utf8_str.gsub(FULLWIDTH_MACRON, OVERLINE)
-    end
-
-    def emdash_to_horizontal_bar(utf8_str)
-      utf8_str.gsub(EM_DASH, HORIZONTAL_BAR)
-    end
-
-    def minus_sign_to_fullwidth_pyphen_minus(utf8_str)
-      utf8_str.gsub(MINUS_SIGN, FULLWIDTH_HYPHEN_MINUS)
-    end
-
-    def fullwidth_pyphen_minus_to_minus_sign(utf8_str)
-      utf8_str.gsub(FULLWIDTH_HYPHEN_MINUS, MINUS_SIGN)
-    end
-
-    def force_encode(str, from, to)
-      s = str.dup
-      return str if detect_encoding(str) == to
-
-      if Object.const_defined?(:Encoding)
-        to = SJIS if to =~ /shift_jis/i
-
-        to_enc = ::Encoding.find(to)
-        return str if s.encoding == to_enc
-
-        if from
-          from_enc = ::Encoding.find(from)
-          s.force_encoding(from) unless s.encoding == from_enc
-        end
-
-        s.encode(to)
-      else
-        opt = []
-        opt << case from
-               when /iso-2022-jp/i
-                 "-Jx"
-               when /shift_jis/i
-                 "-Sx"
-               when /utf-8/i
-                 "-Wx"
-               else
-                 ""
-               end
-        opt << case to
-               when /iso-2022-jp/i
-                 "-j"
-               when /shift_jis/i, /windows_31j/i
-                 "-s"
-               when /utf-8/i
-                 "-w"
-               else
-                 ""
-               end
-        NKF.nkf(opt.join(" "), str)
-      end
-    end
-
-    def set_encoding(str, encoding)
-      if encoding and Object.const_defined?(:Encoding)
-        encoding = SJIS if encoding =~ /shift_jis/i
-
-        str.force_encoding(encoding)
-      end
-
-      str
-    end
-
-    def extract_charset(str)
-      case str
-      when /iso-2022-jp/i
-        "ISO-2022-JP"
-      when /shift_jis/i
-        "Shift_JIS"
-      when /utf-8/i
-        "UTF-8"
-      else
-        ""
-      end
-    end
-
-    def detect_encoding(str)
-      if Object.const_defined?(:Encoding)
-        case str.encoding
-        when ::Encoding::ISO2022_JP
-          JIS
-        when ::Encoding::Shift_JIS, ::Encoding::Windows_31J, ::Encoding::CP932
-          SJIS
-        when ::Encoding::UTF_8
-          UTF8
-        when ::Encoding::ASCII_8BIT
-          BINARY
-        else
-          BINARY
-        end
-      else
-        case NKF.guess(str)
-        when NKF::SJIS
-          SJIS
-        when NKF::JIS
-          JIS
-        when NKF::UTF8
-          UTF8
-        when NKF::BINARY
-          BINARY
-        else
-          BINARY
-        end
-      end
-    end
-
-    def ascii_8bit?(str)
-      detect_encoding(str) == BINARY
-    end
-    def utf8?(str)
-      detect_encoding(str) == UTF8
-    end
-    def shift_jis?(str)
-      detect_encoding(str) == SJIS
-    end
-    def jis?(str)
-      detect_encoding(str) == JIS
-    end
-
-    def fold_text(str, size = 15)
-      folded_texts = []
-
-      while texts = split_text(str, size) and texts.first.size != 0
-        folded_texts << texts.first
-        str = texts.last
-      end
-
-      folded_texts
-    end
-
-    def split_text(str, size = 15)
-      return nil if str.nil? or str == ''
-
-      if Object.const_defined?(:Encoding)
-        [str[0..(size-1)], str[size..-1]]
-      else
-        str    = str.split(//u)
-        text   = str[0..(size-1)]
-        text   = text.join if text
-        remain = str[size..-1]
-        remain = remain.join if remain
-        [text, remain]
-      end
-
-    end
-  end
-end