Module: HttpUtilities::Http::ProxySupport

Included in:
Mechanize::Client, Request
Defined in:
lib/http_utilities/http/proxy_support.rb

Instance Method Summary collapse

Instance Method Details

#generate_proxy_options ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/http_utilities/http/proxy_support.rb', line 112

def generate_proxy_options
  proxy_options                 =   {}
  
  if self.proxy && !self.proxy[:host].to_s.empty? && !self.proxy[:port].to_s.empty?
    proxy_options[:uri]         =   "http://#{self.proxy[:host]}:#{self.proxy[:port]}"
    proxy_options[:user]        =   self.proxy[:username] if !self.proxy[:username].to_s.empty?
    proxy_options[:password]    =   self.proxy[:password] if !self.proxy[:password].to_s.empty?
  end
  
  return proxy_options
end

#proxy_model_defined? ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
108
109
110
 
# File 'lib/http_utilities/http/proxy_support.rb', line 105

def proxy_model_defined?
  defined                       =   Module.const_get("Proxy").is_a?(Class) rescue false
  defined                       =   (defined && ::Proxy.respond_to?(:get_random_proxy))
  
  return defined
end

#set_credentials(username, password, credentials = {}) ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/http_utilities/http/proxy_support.rb', line 84

def set_credentials(username, password, credentials = {})
  if username && password
    self.proxy[:username]       =   username
    self.proxy[:password]       =   password

  elsif credentials
    if credentials.is_a?(Hash)
      self.proxy[:username]     =   credentials[:username]
      self.proxy[:password]     =   credentials[:password]

    elsif (credentials.is_a?(String))
      parts                     =   credentials.split(":")

      if parts && parts.any? && parts.size == 2
        self.proxy[:username]   =   parts.first
        self.proxy[:password]   =   parts.second
      end
    end
  end
end

#set_from_array(proxy_opts) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/http_utilities/http/proxy_support.rb', line 61

def set_from_array(proxy_opts)
  item                          =   proxy_opts.sample
  
  if item.is_a?(String)
    set_from_string(item)
  elsif item.is_a?(Hash) && !item.empty?
    set_from_hash(item)
  elsif proxy_model_defined? && item.is_a?(::Proxy)
    set_from_object(item)
  end
end

#set_from_hash(proxy_opts) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/http_utilities/http/proxy_support.rb', line 36

def set_from_hash(proxy_opts)
  host                          =   proxy_opts.fetch(:host, nil)
  port                          =   proxy_opts.fetch(:port, nil)
  
  username                      =   proxy_opts.fetch(:username, nil)
  password                      =   proxy_opts.fetch(:password, nil)
  credentials                   =   proxy_opts.fetch(:credentials, nil)
  
  randomize                     =   proxy_opts.fetch(:randomize, true)
  type                          =   proxy_opts.fetch(:type, :all)
  protocol                      =   proxy_opts.fetch(:protocol, :all)
  
  if randomize && proxy_model_defined?
    proxy_object                =   ::Proxy.get_random_proxy(protocol: protocol, proxy_type: type)
    set_from_object(proxy_object)
  else
    if host && port
      self.proxy[:host]         =   host
      self.proxy[:port]         =   port
      
      set_credentials(username, password)
    end
  end
end

#set_from_object(proxy_object) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/http_utilities/http/proxy_support.rb', line 73

def set_from_object(proxy_object)
  if proxy_object
    self.proxy[:host]           =   proxy_object.host
    self.proxy[:port]           =   proxy_object.port
    username                    =   !proxy_object.username.to_s.empty? ? proxy_object.username : nil
    password                    =   !proxy_object.password.to_s.empty? ? proxy_object.password : nil
    
    set_credentials(username, password)
  end
end

#set_from_string(proxy_opts) ⇒ Object 



26
27
28
29
30
31
32
33
34
 
# File 'lib/http_utilities/http/proxy_support.rb', line 26

def set_from_string(proxy_opts)
  proxy_opts                    =   proxy_opts.gsub(/^http(s)?:\/\//i, "")
  parts                         =   proxy_opts.split(":")

  if parts.size.eql?(2)
    self.proxy[:host]           =   parts.first
    self.proxy[:port]           =   parts.second.to_i
  end
end

#set_proxy_options(options = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/http_utilities/http/proxy_support.rb', line 5

def set_proxy_options(options = {})
  proxy_opts                    =   options.fetch(:proxy, nil)
  
  if proxy_opts
    self.proxy                ||=   {}
    
    if proxy_opts.is_a?(String)
      set_from_string(proxy_opts)
      
    elsif proxy_opts.is_a?(Hash) && !proxy_opts.empty?
      set_from_hash(proxy_opts)
    
    elsif proxy_opts.is_a?(Array) && proxy_opts.any?
      set_from_array(proxy_opts)
      
    elsif proxy_model_defined? && proxy_opts.is_a?(::Proxy)
      set_from_object(proxy_opts)
    end
  end
end