Module: RestCore::Client

Includes:
RestCore
Defined in:
lib/rest-core/client.rb

Constant Summary

Unserializable =
[Proc, Method, IO]

Constants included from RestCore

ASYNC, CLIENT, DRY, FAIL, HIJACK, LOG, PROMISE, REQUEST_HEADERS, REQUEST_METHOD, REQUEST_PATH, REQUEST_PAYLOAD, REQUEST_QUERY, REQUEST_URI, RESPONSE_BODY, RESPONSE_HEADERS, RESPONSE_KEY, RESPONSE_SOCKET, RESPONSE_STATUS, TIMER, Universal, VERSION

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from RestCore

eagerload, id

Instance Attribute Details

- (Object) app (readonly)

Returns the value of attribute app



43
44
45
# File 'lib/rest-core/client.rb', line 43

def app
  @app
end

- (Object) dry (readonly)

Returns the value of attribute dry



43
44
45
# File 'lib/rest-core/client.rb', line 43

def dry
  @dry
end

- (Object) promises (readonly)

Returns the value of attribute promises



43
44
45
# File 'lib/rest-core/client.rb', line 43

def promises
  @promises
end

Class Method Details

+ (Object) included(mod)



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
# File 'lib/rest-core/client.rb', line 11

def self.included mod
  # honor default attributes
  src = mod.members.map{ |name|
    <<-RUBY
      def #{name}
        if (r = super).nil?
          self.#{name} = default_#{name}
        else
          r
        end
      end

      def default_#{name} app=app
        if self.class.respond_to?("default_#{name}")
          self.class.default_#{name}      # old class default style
        elsif app.respond_to?(:#{name})
          app.#{name}({})                 # middleware instance value
        elsif app.respond_to?(:app)
          default_#{name}(app.app)        # walk into next app
        else
          nil
        end
      end
      private :default_#{name}
    RUBY
  }
  accessor = Module.new
  accessor.module_eval(src.join("\n"), __FILE__, __LINE__)
  mod.const_set('Accessor', accessor)
  mod.send(:include, accessor)
end

Instance Method Details

- (Object) attributes



53
54
55
# File 'lib/rest-core/client.rb', line 53

def attributes
  Hash[each_pair.map{ |k, v| [k, send(k)] }]
end

- (Object) build_env(env = {})



183
184
185
186
# File 'lib/rest-core/client.rb', line 183

def build_env env={}
  default_env.merge(
    Middleware.string_keys(attributes).merge(Middleware.string_keys(env)))
end

- (Object) default_env



188
189
190
191
192
193
194
195
196
197
# File 'lib/rest-core/client.rb', line 188

def default_env
  {REQUEST_METHOD  => :get,
   REQUEST_PATH    => '/' ,
   REQUEST_QUERY   => {}  ,
   REQUEST_PAYLOAD => {}  ,
   REQUEST_HEADERS => {}  ,
   FAIL            => []  ,
   LOG             => []  ,
   CLIENT          => self}
end

- (Object) delete(path, query = {}, opts = {}, &cb)



104
105
106
107
108
109
# File 'lib/rest-core/client.rb', line 104

def delete path, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :delete,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  }.merge(opts), &cb)
end

- (Object) event_source(path, query = {}, opts = {})



151
152
153
# File 'lib/rest-core/client.rb', line 151

def event_source path, query={}, opts={}
  self.class.event_source_class.new(self, path, query, opts)
end

- (Object) get(path, query = {}, opts = {}, &cb)



97
98
99
100
101
102
# File 'lib/rest-core/client.rb', line 97

def get    path, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :get   ,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  }.merge(opts), &cb)
end

- (Object) head(path, query = {}, opts = {}, &cb)



111
112
113
114
115
116
117
# File 'lib/rest-core/client.rb', line 111

def head path, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :head  ,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  ,
     RESPONSE_KEY    => RESPONSE_HEADERS}.merge(opts), &cb)
end

- (Object) initialize(o = {})



44
45
46
47
48
49
50
51
# File 'lib/rest-core/client.rb', line 44

def initialize o={}
  @app ||= self.class.builder.to_app # lighten! would reinitialize anyway
  @dry ||= self.class.builder.to_app(Dry)
  @promises = []  # don't record any promises in lighten!
  @mutex    = nil # for locking promises, lazily initialized
                  # for serialization
  o.each{ |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
end

- (Object) inspect



57
58
59
60
61
62
63
64
65
66
# File 'lib/rest-core/client.rb', line 57

def inspect
  fields = if size > 0
             ' ' + attributes.map{ |k, v|
               "#{k}=#{v.inspect.sub(/(?<=.{12}).{4,}/u, '...')}"
             }.join(', ')
           else
             ''
           end
  "#<struct #{self.class.name}#{fields}>"
end

- (Object) lighten(o = {})



81
82
83
# File 'lib/rest-core/client.rb', line 81

def lighten o={}
  dup.lighten!(o)
end

- (Object) lighten!(o = {})



68
69
70
71
72
73
74
75
76
77
78
79
# File 'lib/rest-core/client.rb', line 68

def lighten! o={}
  attributes.each{ |k, v| vv = case v;
                                 when  Hash; lighten_hash(v)
                                 when Array; lighten_array(v)
                                 when *Unserializable; nil
                                 else v
                               end
                          send("#{k}=", vv)}
  initialize(o)
  @app, @dry = lighten_app(app), lighten_app(dry)
  self
end

- (Object) options(path, query = {}, opts = {}, &cb)



119
120
121
122
123
124
125
# File 'lib/rest-core/client.rb', line 119

def options path, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :options,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  ,
     RESPONSE_KEY    => RESPONSE_HEADERS}.merge(opts), &cb)
end

- (Object) patch(path, payload = {}, query = {}, opts = {}, &cb)



143
144
145
146
147
148
149
# File 'lib/rest-core/client.rb', line 143

def patch  path, payload={}, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :patch ,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  ,
     REQUEST_PAYLOAD => payload}.merge(opts), &cb)
end

- (Object) post(path, payload = {}, query = {}, opts = {}, &cb)



127
128
129
130
131
132
133
# File 'lib/rest-core/client.rb', line 127

def post   path, payload={}, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :post  ,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  ,
     REQUEST_PAYLOAD => payload}.merge(opts), &cb)
end

- (Object) put(path, payload = {}, query = {}, opts = {}, &cb)



135
136
137
138
139
140
141
# File 'lib/rest-core/client.rb', line 135

def put    path, payload={}, query={}, opts={}, &cb
  request(
    {REQUEST_METHOD  => :put   ,
     REQUEST_PATH    => path   ,
     REQUEST_QUERY   => query  ,
     REQUEST_PAYLOAD => payload}.merge(opts), &cb)
end

- (Object) request(env, app = app)



155
156
157
158
159
160
161
# File 'lib/rest-core/client.rb', line 155

def request env, app=app
  if block_given?
    request_full(env, app){ |response| yield(response[response_key(env)]) }
  else
    request_full(env, app)[response_key(env)]
  end
end

- (Object) request_full(env, app = app, &k)



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
# File 'lib/rest-core/client.rb', line 163

def request_full env, app=app, &k
  response = app.call(build_env({ASYNC => !!k}.merge(env)),
                      &(k || RC.id))

  # under ASYNC callback, response might not be a response hash
  # in that case (maybe in a user created engine), Client#wait
  # won't work because we have no way to track the promise.
  if response.kind_of?(Hash) && response[PROMISE].kind_of?(Promise)
    weak_promise = WeakRef.new(response[PROMISE])
    self.class.give_promise(weak_promise)
    self.class.give_promise(weak_promise, promises, mutex)
  end

  if block_given?
    self
  else
    response
  end
end

- (Object) url(path, query = {}, opts = {})



90
91
92
93
94
95
# File 'lib/rest-core/client.rb', line 90

def url path, query={}, opts={}
  dry.call(build_env({
    REQUEST_PATH  => path,
    REQUEST_QUERY => query,
    DRY           => true}.merge(opts)), &Middleware.method(:request_uri))
end

- (Object) wait



85
86
87
88
# File 'lib/rest-core/client.rb', line 85

def wait
  self.class.wait(promises, mutex)
  self
end