File: request.rb

package info (click to toggle)
hiki 1.0.0-2
  • links: PTS, VCS
  • area: main
  • in suites: buster, stretch
  • size: 1,812 kB
  • ctags: 2,033
  • sloc: ruby: 14,572; lisp: 926; sh: 19; makefile: 16
file content (199 lines) | stat: -rw-r--r-- 3,970 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
# -*- coding: utf-8 -*-

module Hiki
  if Object.const_defined?(:Rack)
    Request = ::Rack::Request
    class ::Rack::Request
      alias remote_addr ip
    end
  else
    raise RuntimeError, 'Do not use CGI class!' if Object.const_defined?(:Rack)
    # CGI を Rack::Request っぽいインターフェイスに変換する
    class Request
      attr_reader :env, :cgi
      def initialize(env)
        @cgi = CGI.new
        @env = env
      end

      def params
        return @params if @params
        @params = { }
        @cgi.params.each{|k, v|
          v = v.uniq
          case v.size
          when 0
            @params[k] = nil
          when 1
            @params[k] = v[0]
          else
            @params[k] = v
          end
        }
        @params
      end

      def [](key)
        params[key.to_s]
      end

      def []=(key, val)
        params[key.to_s] = val
      end

      def request_method
        @env['REQUEST_METHOD']
      end

      def header(header)
        @cgi.header(header)
      end

      def get?
        request_method == 'GET'
      end

      def head?
        request_method = 'HEAD'
      end

      def post?
        request_method == 'POST'
      end

      def put?
        request_method == 'PUT'
      end

      def delete?
        request_method == 'DELETE'
      end

      def xhr?
        raise NameError, 'not implemented : xhr?'
      end

      def accept_encoding
        raise NameError, 'not implemented : accept_encoding'
      end

      def body
        raise NameError, 'not implemented : body'
      end

      def content_charset
        @env['CONTENT_CHARSET']
      end

      def content_length
        @env['CONTENT_LENGTH']
      end

      def content_type
        @env['CONTENT_TYPE']
      end

      def remote_addr
        @env['REMOTE_ADDR']
      end

      def cookies
        return @cookies if @cookies
        @cookies = { }
        @cgi.cookies.each{|k, v|
          case v.size
          when 0
            @cookies[k] = nil
          when 1
            @cookies[k] = v[0]
          else
            @cookies[k] = v
          end
        }
        @cookies
      end

      def form_data?
        raise NameError, 'not implemented : form_data?'
      end

      def fullpath
        raise NameError, 'not implemented : fullpath'
      end

      def host
        # Remove port number.from Rack::Response
        (@env["HTTP_HOST"] || @env["SERVER_NAME"]).gsub(/:\d+\z/, '')
      end

      def ip
        raise NameError, 'not implemented : ip'
      end

      def media_type
        raise NameError, 'not implemented : madia_type'
      end

      def media_type_params
        raise NameError, 'not implemented : media_type_params'
      end

      def openid_request
        raise NameError, 'not implemented : openid_request'
      end

      def openid_response
        raise NameError, 'not implemented : openid_response'
      end

      def parseable_data?
        raise NameError, 'not implemented : parseable_data?'
      end

      def path
        raise NameError, 'not implemented : path'
      end

      def path_info
        @env['PATH_INFO'].to_s
      end

      def path_info=(s)
        raise NameError, 'not implemented : path_info='
      end

      def port
        raise NameError, 'not implemented : port'
      end

      def query_string
        raise NameError, 'not implemented : query_string'
      end

      def referer
        raise NameError, 'not implemented : referer'
      end
      alias referrer referer

      def schema
        raise NameError, 'not implemented : schema'
      end

      def script_name
        @env['SCRIPT_NAME']
      end

      def session_options
        raise NameError, 'not implemented : session_options'
      end

      def url
        raise NameError, 'not implemented : url'
      end

      def values_at(*keys)
        raise NameError, 'not implemented : values_at'
      end
    end
  end
end