--- /dev/null
+module Faraday
+ # Subclasses Struct with some special helpers for converting from a Hash to
+ # a Struct.
+ class Options < Struct
+ # Public
+ def self.from(value)
+ value ? new.update(value) : new
+ end
+
+ # Public
+ def each
+ return to_enum(:each) unless block_given?
+ members.each do |key|
+ yield(key.to_sym, send(key))
+ end
+ end
+
+ # Public
+ def update(obj)
+ obj.each do |key, value|
+ if sub_options = self.class.options_for(key)
+ value = sub_options.from(value) if value
+ elsif Hash === value
+ hash = {}
+ value.each do |hash_key, hash_value|
+ hash[hash_key] = hash_value
+ end
+ value = hash
+ end
+
+ self.send("#{key}=", value) unless value.nil?
+ end
+ self
+ end
+
+ alias merge! update
+
+ # Public
+ def delete(key)
+ value = send(key)
+ send("#{key}=", nil)
+ value
+ end
+
+ # Public
+ def clear
+ members.each { |member| delete(member) }
+ end
+
+ # Public
+ def merge(value)
+ dup.update(value)
+ end
+
+ # Public
+ def fetch(key, *args)
+ unless symbolized_key_set.include?(key.to_sym)
+ key_setter = "#{key}="
+ if args.size > 0
+ send(key_setter, args.first)
+ elsif block_given?
+ send(key_setter, Proc.new.call(key))
+ else
+ raise self.class.fetch_error_class, "key not found: #{key.inspect}"
+ end
+ end
+ send(key)
+ end
+
+ # Public
+ def values_at(*keys)
+ keys.map { |key| send(key) }
+ end
+
+ # Public
+ def keys
+ members.reject { |member| send(member).nil? }
+ end
+
+ # Public
+ def empty?
+ keys.empty?
+ end
+
+ # Public
+ def each_key
+ return to_enum(:each_key) unless block_given?
+ keys.each do |key|
+ yield(key)
+ end
+ end
+
+ # Public
+ def key?(key)
+ keys.include?(key)
+ end
+
+ alias has_key? key?
+
+ # Public
+ def each_value
+ return to_enum(:each_value) unless block_given?
+ values.each do |value|
+ yield(value)
+ end
+ end
+
+ # Public
+ def value?(value)
+ values.include?(value)
+ end
+
+ alias has_value? value?
+
+ # Public
+ def to_hash
+ hash = {}
+ members.each do |key|
+ value = send(key)
+ hash[key.to_sym] = value unless value.nil?
+ end
+ hash
+ end
+
+ # Internal
+ def inspect
+ values = []
+ members.each do |member|
+ value = send(member)
+ values << "#{member}=#{value.inspect}" if value
+ end
+ values = values.empty? ? ' (empty)' : (' ' << values.join(", "))
+
+ %(#<#{self.class}#{values}>)
+ end
+
+ # Internal
+ def self.options(mapping)
+ attribute_options.update(mapping)
+ end
+
+ # Internal
+ def self.options_for(key)
+ attribute_options[key]
+ end
+
+ # Internal
+ def self.attribute_options
+ @attribute_options ||= {}
+ end
+
+ def self.memoized(key)
+ memoized_attributes[key.to_sym] = Proc.new
+ class_eval <<-RUBY, __FILE__, __LINE__ + 1
+ def #{key}() self[:#{key}]; end
+ RUBY
+ end
+
+ def self.memoized_attributes
+ @memoized_attributes ||= {}
+ end
+
+ def [](key)
+ key = key.to_sym
+ if method = self.class.memoized_attributes[key]
+ super(key) || (self[key] = instance_eval(&method))
+ else
+ super
+ end
+ end
+
+ def symbolized_key_set
+ @symbolized_key_set ||= Set.new(keys.map { |k| k.to_sym })
+ end
+
+ def self.inherited(subclass)
+ super
+ subclass.attribute_options.update(attribute_options)
+ subclass.memoized_attributes.update(memoized_attributes)
+ end
+
+ def self.fetch_error_class
+ @fetch_error_class ||= if Object.const_defined?(:KeyError)
+ ::KeyError
+ else
+ ::IndexError
+ end
+ end
+ end
+
+ class RequestOptions < Options.new(:params_encoder, :proxy, :bind,
+ :timeout, :open_timeout, :boundary,
+ :oauth)
+
+ def []=(key, value)
+ if key && key.to_sym == :proxy
+ super(key, value ? ProxyOptions.from(value) : nil)
+ else
+ super(key, value)
+ end
+ end
+ end
+
+ class SSLOptions < Options.new(:verify, :ca_file, :ca_path, :verify_mode,
+ :cert_store, :client_cert, :client_key, :certificate, :private_key, :verify_depth, :version)
+
+ def verify?
+ verify != false
+ end
+
+ def disable?
+ !verify?
+ end
+ end
+
+ class ProxyOptions < Options.new(:uri, :user, :password)
+ extend Forwardable
+ def_delegators :uri, :scheme, :scheme=, :host, :host=, :port, :port=, :path, :path=
+
+ def self.from(value)
+ case value
+ when String
+ value = {:uri => Utils.URI(value)}
+ when URI
+ value = {:uri => value}
+ when Hash, Options
+ if uri = value.delete(:uri)
+ value[:uri] = Utils.URI(uri)
+ end
+ end
+ super(value)
+ end
+
+ memoized(:user) { uri.user && Utils.unescape(uri.user) }
+ memoized(:password) { uri.password && Utils.unescape(uri.password) }
+ end
+
+ class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,
+ :parallel_manager, :params, :headers, :builder_class)
+
+ options :request => RequestOptions, :ssl => SSLOptions
+
+ memoized(:request) { self.class.options_for(:request).new }
+
+ memoized(:ssl) { self.class.options_for(:ssl).new }
+
+ memoized(:builder_class) { RackBuilder }
+
+ def new_builder(block)
+ builder_class.new(&block)
+ end
+ end
+
+ class Env < Options.new(:method, :body, :url, :request, :request_headers,
+ :ssl, :parallel_manager, :params, :response, :response_headers, :status)
+
+ ContentLength = 'Content-Length'.freeze
+ StatusesWithoutBody = Set.new [204, 304]
+ SuccessfulStatuses = 200..299
+
+ # A Set of HTTP verbs that typically send a body. If no body is set for
+ # these requests, the Content-Length header is set to 0.
+ MethodsWithBodies = Set.new [:post, :put, :patch, :options]
+
+ options :request => RequestOptions,
+ :request_headers => Utils::Headers, :response_headers => Utils::Headers
+
+ extend Forwardable
+
+ def_delegators :request, :params_encoder
+
+ # Public
+ def [](key)
+ if in_member_set?(key)
+ super(key)
+ else
+ custom_members[key]
+ end
+ end
+
+ # Public
+ def []=(key, value)
+ if in_member_set?(key)
+ super(key, value)
+ else
+ custom_members[key] = value
+ end
+ end
+
+ # Public
+ def success?
+ SuccessfulStatuses.include?(status)
+ end
+
+ # Public
+ def needs_body?
+ !body && MethodsWithBodies.include?(method)
+ end
+
+ # Public
+ def clear_body
+ request_headers[ContentLength] = '0'
+ self.body = ''
+ end
+
+ # Public
+ def parse_body?
+ !StatusesWithoutBody.include?(status)
+ end
+
+ # Public
+ def parallel?
+ !!parallel_manager
+ end
+
+ def inspect
+ attrs = [nil]
+ members.each do |mem|
+ if value = send(mem)
+ attrs << "@#{mem}=#{value.inspect}"
+ end
+ end
+ if !custom_members.empty?
+ attrs << "@custom=#{custom_members.inspect}"
+ end
+ %(#<#{self.class}#{attrs.join(" ")}>)
+ end
+
+ # Internal
+ def custom_members
+ @custom_members ||= {}
+ end
+
+ # Internal
+ if members.first.is_a?(Symbol)
+ def in_member_set?(key)
+ self.class.member_set.include?(key.to_sym)
+ end
+ else
+ def in_member_set?(key)
+ self.class.member_set.include?(key.to_s)
+ end
+ end
+
+ # Internal
+ def self.member_set
+ @member_set ||= Set.new(members)
+ end
+ end
+end
projects / dsa-puppet.git / blobdiff