Class: Miasma::Types::Api

41
42
43
44
45
46
47
48
49
50
51

# File 'lib/miasma/types/api.rb', line 41

def api_for(type)
  memoize(type) do
    Miasma.api(
      Smash.new(
        :type => type,
        :provider => provider,
        :credentials => attributes
      )
    )
  end
end

33
34
35

# File 'lib/miasma/types/api.rb', line 33

def connect
  self
end

54
55
56

# File 'lib/miasma/types/api.rb', line 54

def connection
  HTTP.with_headers('User-Agent' => "miasma/v#{Miasma::VERSION}")
end

59
60
61

# File 'lib/miasma/types/api.rb', line 59

def endpoint
  'http://api.example.com'
end

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

# File 'lib/miasma/types/api.rb', line 121

def format_response(result, extract_body=true)
  extracted_headers = Smash[result.headers.map{|k,v| [Utils.snake(k), v]}]
  if(extract_body)
    if(extracted_headers[:content_type].to_s.include?('json'))
      begin
        extracted_body = MultiJson.load(result.body.to_s)
        if(extracted_body.respond_to?(:to_smash))
          extracted_body = extracted_body.to_smash
        elsif(extracted_body.respond_to?(:map!))
          extracted_body.map! do |i|
            i.respond_to?(:to_smash) ? i.to_smash : i
          end
        end
      rescue MultiJson::ParseError
        extracted_body = result.body.to_s
      end
    elsif(extracted_headers[:content_type].to_s.include?('xml'))
      begin
        extracted_body = MultiXml.parse(result.body.to_s)
        if(extracted_body.respond_to?(:to_smash))
          extracted_body = extracted_body.to_smash
        elsif(extracted_body.respond_to?(:map!))
          extracted_body.map! do |i|
            i.respond_to?(:to_smash) ? i.to_smash : i
          end
        end
      rescue MultiXml::ParseError
        extracted_body = result.body.to_s
      end
    end
  end
  unless(extracted_body)
    # @note if body is over 100KB, do not extract
    if(extracted_headers[:content_length].to_i < 102400)
      extracted_body = result.body.to_s
    else
      extracted_body = result.body
    end
  end
  Smash.new(
    :response => result,
    :headers => extracted_headers,
    :body => extracted_body
  )
end

112
113
114

# File 'lib/miasma/types/api.rb', line 112

def make_request(connection, http_method, request_args)
  connection.send(http_method, *request_args)
end

26
27
28

# File 'lib/miasma/types/api.rb', line 26

def provider
  Utils.snake(self.class.to_s.split('::').last).to_sym
end

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

# File 'lib/miasma/types/api.rb', line 72

def request(args)
  args = args.to_smash
  http_method = args.fetch(:method, 'get').to_s.downcase.to_sym
  unless(HTTP::Request::METHODS.include?(http_method))
    raise ArgumentError.new 'Invalid request method provided!'
  end
  request_args = [].tap do |ary|
    _endpoint = args.delete(:endpoint) || endpoint
    ary.push(
      File.join(_endpoint, args[:path].to_s)
    )
    options = {}.tap do |opts|
      [:form, :params, :json, :body].each do |key|
        opts[key] = args[key] if args[key]
      end
    end
    ary.push(options) unless options.empty?
  end
  if(args[:headers])
    _connection = connection.with_headers(args[:headers])
    args.delete(:headers)
  else
    _connection = connection
  end
  result = make_request(_connection, http_method, request_args)
  unless([args.fetch(:expects, 200)].flatten.compact.map(&:to_i).include?(result.code))
    raise Error::ApiError::RequestError.new(result.reason, :response => result)
  end
  format_response(result, !args[:disable_body_extraction])
end