Class: Artifactory::Resource::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/artifactory/resources/base.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes = {}) ⇒ Base

Create a new instance



248
249
250
251
252
 
# File 'lib/artifactory/resources/base.rb', line 248

def initialize(attributes = {})
  attributes.each do |key, value|
    set(key, value)
  end
end

Class Method Details

.attribute(key, default = nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/artifactory/resources/base.rb', line 45

def attribute(key, default = nil)
  key = key.to_sym unless key.is_a?(Symbol)

  # Set this attribute in the top-level hash
  attributes[key] = nil

  define_method(key) do
    value = attributes[key]
    return value unless value.nil?

    if default.nil?
      value
    elsif default.is_a?(Proc)
      default.call
    else
      default
    end
  end

  define_method("#{key}?") do
    !!attributes[key]
  end

  define_method("#{key}=") do |value|
    set(key, value)
  end
end

.attributes ⇒ Array<Symbol>

The list of attributes defined by this class.

Returns:

  • (Array<Symbol>) 


78
79
80
 
# File 'lib/artifactory/resources/base.rb', line 78

def attributes
  @attributes ||= {}
end

.extract_client!(options) ⇒ Object

Get the client (connection) object from the given options. If the :client key is preset in the hash, it is assumed to contain the connection object to use for the request. If the :client key is not present, the default Artifactory.client is used.

Warning, the value of Artifactory.client is not threadsafe! If multiple threads or processes are modifying the connection information, the same request could use a different client object. If you use the Client proxy methods, this is handled for you.

Warning, this method will remove the :client key from the hash if it exists.

Parameters:

  • options (Hash) —

    the list of options passed to the method

Options Hash (options):



210
211
212
 
# File 'lib/artifactory/resources/base.rb', line 210

def extract_client!(options)
  options.delete(:client) || Artifactory.client
end

.find_from_config(xpath, config, options = {}) ⇒ Object

Find the text elements matching a giving xpath

Parameters:

  • xpath (String) —

    xpath expression

  • config (REXML) —

    Artifactory configuration file as an REXML doc

  • options (Hash) (defaults to: {}) —

    the list of options



151
152
153
154
155
156
157
158
159
160
 
# File 'lib/artifactory/resources/base.rb', line 151

def find_from_config(xpath, config, options = {})
  name_node = REXML::XPath.match(config, xpath)
  return nil if name_node.empty?
  properties = {}
  name_node[0].parent.each_element_with_text do |e|
    properties[e.name] = Util.to_type(e.text)
  end

  from_hash(properties, options)
end

.format_repos!(options) ⇒ Object

Format the repos list from the given options. This method will modify the given Hash parameter!

Warning, this method will modify the given hash if it exists.

Parameters:

  • options (Hash) —

    the list of options to extract the repos from



223
224
225
226
227
 
# File 'lib/artifactory/resources/base.rb', line 223

def format_repos!(options)
  return options if options[:repos].nil? || options[:repos].empty?
  options[:repos] = Array(options[:repos]).compact.join(',')
  options
end

.from_hash(hash, options = {}) ⇒ ~Resource::Base

Construct a new object from the hash.

Parameters:

  • hash (Hash) —

    the hash to create the object with

  • options (Hash) (defaults to: {}) —

    the list options

Options Hash (options):

Returns:



175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/artifactory/resources/base.rb', line 175

def from_hash(hash, options = {})
  instance = new
  instance.client = extract_client!(options)

  hash.inject(instance) do |instance, (key, value)|
    method = :"#{Util.underscore(key)}="

    if instance.respond_to?(method)
      instance.send(method, value)
    end

    instance
  end
end

.from_url(url, options = {}) ⇒ ~Resource::Base

Construct a new object from the given URL.

Parameters:

  • url (String) —

    the URL to find the user from

  • options (Hash) (defaults to: {}) —

    the list of options

Options Hash (options):

Returns:



107
108
109
110
111
112
113
 
# File 'lib/artifactory/resources/base.rb', line 107

def from_url(url, options = {})
  # Parse the URL and only use the path so the configured
  # endpoint/proxy/SSL settings are used in the GET request.
  path = URI.parse(url).path
  client = extract_client!(options)
  from_hash(client.get(path), client: client)
end

.has_attribute?(key) ⇒ true, false

Determine if this class has a given attribute.

Parameters:

  • key (#to_sym) —

    the key to check as an attribute

Returns:

  • (true, false) 


90
91
92
 
# File 'lib/artifactory/resources/base.rb', line 90

def has_attribute?(key)
  attributes.has_key?(key.to_sym)
end

.list_from_config(xpath, config, options = {}) ⇒ Object

List all the child text elements in the Artifactory configuration file of a node matching the specified xpath

Parameters:

  • xpath (String) —

    xpath expression for the parent element whose children are to be listed

  • config (REXML) —

    Artifactory config as an REXML file

  • options (Hash) (defaults to: {}) —

    the list of options



128
129
130
131
132
133
134
135
136
137
 
# File 'lib/artifactory/resources/base.rb', line 128

def list_from_config(xpath, config, options = {})
  REXML::XPath.match(config, xpath).map do |r|
    hash = {}

    r.each_element_with_text do |l|
      hash[l.name] = l.get_text
    end
    from_hash(hash, options)
  end
end

.url_safe(value) ⇒ String

Generate a URL-safe string from the given value.

Parameters:

  • value (#to_s) —

    the value to sanitize

Returns:

  • (String) —

    the URL-safe version of the string



238
239
240
 
# File 'lib/artifactory/resources/base.rb', line 238

def url_safe(value)
  URI.escape(value.to_s)
end

Instance Method Details

#attributes ⇒ hash

The list of attributes for this resource.

Returns:

  • (hash) 


259
260
261
 
# File 'lib/artifactory/resources/base.rb', line 259

def attributes
  @attributes ||= self.class.attributes.dup
end

#client ⇒ Object

Return this object’s client

Returns:

  • (Object) 


243
 
# File 'lib/artifactory/resources/base.rb', line 243

attribute :client, ->{ Artifactory.client }

#client=(value) ⇒ Object

Set this object’s client

Parameters:

  • value (Object) —

    the value to set for client

  • default (Object) —

    the default value for this attribute



243
 
# File 'lib/artifactory/resources/base.rb', line 243

attribute :client, ->{ Artifactory.client }

#client? ⇒ Boolean

Determines if the client value exists and is truthy

Returns:

  • (Boolean) 


243
 
# File 'lib/artifactory/resources/base.rb', line 243

attribute :client, ->{ Artifactory.client }

#extract_client!(options) ⇒ Object

See Also:



279
280
281
 
# File 'lib/artifactory/resources/base.rb', line 279

def extract_client!(options)
  self.class.extract_client!(options)
end

#format_repos!(options) ⇒ Object

See Also:



284
285
286
 
# File 'lib/artifactory/resources/base.rb', line 284

def format_repos!(options)
  self.class.format_repos!(options)
end

#inspect ⇒ Object 



368
369
370
371
372
373
374
375
376
 
# File 'lib/artifactory/resources/base.rb', line 368

def inspect
  list = attributes.collect do |key, value|
    unless Resource::Base.has_attribute?(key)
      "#{key}: #{value.inspect}"
    end
  end.compact

  "#<#{short_classname} #{list.join(', ')}>"
end

#set(key, value) ⇒ Object

Set a given attribute on this resource.

Parameters:

  • key (#to_sym) —

    the attribute to set

  • value (Object) —

    the value to set

Returns:

  • (Object) —

    the set value



274
275
276
 
# File 'lib/artifactory/resources/base.rb', line 274

def set(key, value)
  attributes[key.to_sym] = value
end

#to_hash ⇒ Hash

The hash representation

Examples:

An example hash response

{ 'key' => 'local-repo1', 'includesPattern' => '**/*' }

Returns:

  • (Hash) 


301
302
303
304
305
306
307
308
309
 
# File 'lib/artifactory/resources/base.rb', line 301

def to_hash
  attributes.inject({}) do |hash, (key, value)|
    unless Resource::Base.has_attribute?(key)
      hash[Util.camelize(key, true)] = send(key.to_sym)
    end

    hash
  end
end

#to_json ⇒ String

The JSON representation of this object.

Returns:

  • (String)

See Also:



318
319
320
 
# File 'lib/artifactory/resources/base.rb', line 318

def to_json
  JSON.fast_generate(to_hash)
end

#to_matrix_properties(hash = {}) ⇒ Object

Create CGI-escaped string from matrix properties

See Also:



327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/artifactory/resources/base.rb', line 327

def to_matrix_properties(hash = {})
  properties = hash.map do |k, v|
    key   = CGI.escape(k.to_s)
    value = CGI.escape(v.to_s)

    "#{key}=#{value}"
  end

  if properties.empty?
    nil
  else
    ";#{properties.join(';')}"
  end
end

#to_query_string_parameters(hash = {}) ⇒ Object

Create URI-escaped querystring parameters

See Also:



347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/artifactory/resources/base.rb', line 347

def to_query_string_parameters(hash = {})
  properties = hash.map do |k, v|
    key   = URI.escape(k.to_s)
    value = URI.escape(v.to_s)

    "#{key}=#{value}"
  end

  if properties.empty?
    nil
  else
    properties.join('&')
  end
end

#to_s ⇒ Object 



363
364
365
 
# File 'lib/artifactory/resources/base.rb', line 363

def to_s
  "#<#{short_classname}>"
end

#url_safe(value) ⇒ Object

See Also:



289
290
291
 
# File 'lib/artifactory/resources/base.rb', line 289

def url_safe(value)
  self.class.url_safe(value)
end