3rdparty/modules/aviator/feature/aviator/core/request.rb

   1 module Aviator
   2
   3   class Request
   4
   5     class ApiVersionNotDefinedError < StandardError
   6       def initialize
   7         super "api_version is not defined."
   8       end
   9     end
  10
  11     class EndpointTypeNotDefinedError < StandardError
  12       def initialize
  13         super "endpoint_type is not defined."
  14       end
  15     end
  16
  17     class PathNotDefinedError < StandardError
  18       def initialize
  19         super "path is not defined."
  20       end
  21     end
  22
  23
  24     def initialize(session_data=nil)
  25       @session_data = session_data
  26
  27       params = self.class.params_class.new if self.class.params_class
  28
  29       if params
  30         yield(params) if block_given?
  31         validate_params(params)
  32       end
  33
  34       @params = params
  35     end
  36
  37
  38     def anonymous?
  39       self.class.anonymous?
  40     end
  41
  42
  43     def body?
  44       self.class.body?
  45     end
  46
  47
  48     def headers?
  49       self.class.headers?
  50     end
  51
  52
  53     def links
  54       self.class.links
  55     end
  56
  57
  58     def optional_params
  59       self.class.optional_params
  60     end
  61
  62
  63     def params
  64       @params.dup
  65     end
  66
  67
  68     def required_params
  69       self.class.required_params
  70     end
  71
  72
  73     def session_data
  74       @session_data
  75     end
  76
  77
  78     def session_data?
  79       !session_data.nil?
  80     end
  81
  82
  83     def querystring?
  84       self.class.querystring?
  85     end
  86
  87
  88     def url?
  89       self.class.url?
  90     end
  91
  92
  93     private
  94
  95
  96     def validate_params(params)
  97       required_params = self.class.required_params
  98
  99       required_params.each do |name|
 100         raise ArgumentError.new("Missing parameter #{ name }.") if params.send(name).nil?
 101       end
 102     end
 103
 104
 105     # NOTE that, because we are defining the following as class methods, when they
 106     # are called, all 'instance' variables are actually defined in the descendant class,
 107     # not in the instance/object. This is by design since we want to keep these attributes
 108     # within the class and because they don't change between instances anyway.
 109     class << self
 110
 111       def anonymous?
 112         respond_to?(:anonymous) && anonymous == true
 113       end
 114
 115
 116       def body?
 117         instance_methods.include? :body
 118       end
 119
 120
 121       def headers?
 122         instance_methods.include? :headers
 123       end
 124
 125
 126       def links
 127         @links ||= []
 128       end
 129
 130
 131       def param_aliases
 132         @param_aliases ||= {}
 133       end
 134
 135
 136       def params_class
 137         all_params = required_params + optional_params
 138
 139         if all_params.length > 0 && @params_class.nil?
 140           @params_class = build_params_class(all_params, self.param_aliases)
 141         end
 142
 143         @params_class
 144       end
 145
 146
 147       def optional_params
 148         @optional_params ||= []
 149       end
 150
 151
 152       def querystring?
 153         instance_methods.include? :querystring
 154       end
 155
 156
 157       def required_params
 158         @required_params ||= []
 159       end
 160
 161
 162       def url?
 163         instance_methods.include? :url
 164       end
 165
 166
 167       private
 168
 169
 170       def build_params_class(all_params, param_aliases)
 171         Struct.new(*all_params) do
 172           alias :param_getter :[]
 173           alias :param_setter :[]=
 174
 175           define_method :[] do |key|
 176             key = param_aliases[key.to_sym] if param_aliases.keys.include? key.to_sym
 177             param_getter(key)
 178           end
 179
 180           define_method :[]= do |key, value|
 181             key = param_aliases[key.to_sym] if param_aliases.keys.include? key.to_sym
 182             param_setter(key, value)
 183           end
 184
 185           param_aliases.each do |param_alias, param_name|
 186             define_method param_alias do
 187               param_getter(param_name)
 188             end
 189
 190             define_method "#{ param_alias }=" do |value|
 191               param_setter(param_name, value)
 192             end
 193           end
 194         end
 195       end
 196
 197
 198       def link(rel, href)
 199         links << { :rel => rel, :href => href }
 200       end
 201
 202
 203       def meta(attr_name, attr_value)
 204         eigenclass = class << self; self; end
 205         eigenclass.send(:define_method, attr_name) do
 206           attr_value
 207         end
 208
 209         define_method(attr_name) do
 210           self.class.send(attr_name)
 211         end
 212       end
 213
 214
 215       def param(param_name, opts={})
 216         opts  = Hashish.new(opts)
 217         list  = (opts[:required] == false ? optional_params : required_params)
 218         list << param_name unless optional_params.include?(param_name)
 219
 220         if opts[:alias]
 221           self.param_aliases[opts[:alias]] = param_name
 222         end
 223       end
 224
 225     end
 226
 227   end
 228
 229 end