fog-core 1.24.0 → 1.25.0

data/lib/fog/core/collection.rb

@@ -9,19 +9,18 @@ module Fog
     attr_reader :service
 
     Array.public_instance_methods(false).each do |method|
-      unless [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
-        class_eval <<-EOS, __FILE__, __LINE__
-          def #{method}(*args)
-            unless @loaded
-              lazy_load
-            end
-            super
+      next if [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{method}(*args)
+          unless @loaded
+            lazy_load
           end
-        EOS
-      end
+          super
+        end
+      EOS
     end
 
-    %w[reject select slice].each do |method|
+    %w(reject select slice).each do |method|
       class_eval <<-EOS, __FILE__, __LINE__
         def #{method}(*args)
           unless @loaded
@@ -33,8 +32,8 @@ module Fog
       EOS
     end
 
-    def self.model(new_model=nil)
-      if new_model == nil
+    def self.model(new_model = nil)
+      if new_model.nil?
         @model
       else
         @model = new_model
@@ -70,21 +69,20 @@ module Fog
       merge_attributes(attributes)
     end
 
-
     def inspect
       Thread.current[:formatador] ||= Formatador.new
       data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
       Thread.current[:formatador].indent do
         unless self.class.attributes.empty?
           data << "#{Thread.current[:formatador].indentation}"
-          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+          data << self.class.attributes.map { |attribute| "#{attribute}=#{send(attribute).inspect}" }.join(",\n#{Thread.current[:formatador].indentation}")
           data << "\n"
         end
         data << "#{Thread.current[:formatador].indentation}["
         unless self.empty?
           data << "\n"
           Thread.current[:formatador].indent do
-            data << self.map {|member| member.inspect}.join(",\n")
+            data << map(&:inspect).join(", \n")
             data << "\n"
           end
           data << Thread.current[:formatador].indentation
@@ -97,19 +95,19 @@ module Fog
 
     def load(objects)
       clear
-      for object in objects
+      objects.each do |object|
         self << new(object)
       end
       self
     end
 
     def model
-      self.class.instance_variable_get('@model')
+      self.class.instance_variable_get("@model")
     end
 
     def new(attributes = {})
       unless attributes.is_a?(::Hash)
-        raise(ArgumentError.new("Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"))
+        raise ArgumentError, "Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"
       end
       model.new(
         {
@@ -126,29 +124,27 @@ module Fog
     end
 
     def table(attributes = nil)
-      Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
+      Formatador.display_table(map(&:attributes), attributes)
     end
 
-    def to_json(options = {})
-      Fog::JSON.encode(self.map {|member| member.attributes})
+    def to_json(_options = {})
+      Fog::JSON.encode(map(&:attributes))
     end
 
     private
 
     def lazy_load
-      self.all
+      all
     end
-
   end
 
   # Base class for collection classes whose 'all' method returns only a single page of results and passes the
   # 'Marker' option along as self.filters[:marker]
   class PagedCollection < Collection
-
-    def each(filters=filters)
+    def each(filters = filters)
       if block_given?
         begin
-          page = self.all(filters)
+          page = all(filters)
           # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
           base_each = Fog::Collection.instance_method(:each)
           base_each.bind(page).call { |item| yield item }
@@ -156,6 +152,5 @@ module Fog
       end
       self
     end
-
   end
 end

data/lib/fog/core/connection.rb

@@ -1,6 +1,5 @@
 module Fog
   module Core
-
     # Fog::Core::Connection is a generic class to contain a HTTP link to an API.
     #
     # It is intended to be subclassed by providers who can then add their own
@@ -24,7 +23,7 @@ module Fog
       # @option params [Fixnum] :retry_limit Set how many times we'll retry a failed request.  (Default 4)
       # @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
       # @option params [String] :instrumentor_name Name prefix for #instrument events.  Defaults to 'excon'
-      def initialize(url, persistent=false, params={})
+      def initialize(url, persistent = false, params = {})
         if params[:path_prefix]
           if params[:path]
             raise ArgumentError, "optional arg 'path' is invalid when 'path_prefix' is provided"
@@ -33,11 +32,11 @@ module Fog
           @path_prefix = params.delete(:path_prefix)
         end
 
-        unless params.has_key?(:debug_response)
-          params[:debug_response] = true
-        end
+        params[:debug_response] = true unless params.key?(:debug_response)
         params[:headers] ||= {}
-        params[:headers]['User-Agent'] ||= "fog/#{Fog::VERSION}"
+        user_agent = "fog-core/#{Fog::Core::VERSION}"
+        user_agent = "fog/#{Fog::VERSION} #{user_agent}" if defined?(Fog::VERSION)
+        params[:headers]["User-Agent"] ||= user_agent
         params.merge!(:persistent => params.fetch(:persistent, persistent))
         @excon = Excon.new(url, params)
       end

data/lib/fog/core/credentials.rb

@@ -1,7 +1,7 @@
-require 'yaml'
+require "yaml"
 
 module Fog
-  require 'fog/core/deprecation'
+  require "fog/core/deprecation"
 
   # Sets the global configuration up from a Hash rather than using background loading from a file
   #
@@ -19,8 +19,8 @@ module Fog
   #   }
   #
   # @return [Hash] The newly assigned credentials
-  def self.credentials=(new_credentials)
-    @credentials = new_credentials
+  class << self
+    attr_writer :credentials
   end
 
   # Assign a new credential to use from configuration file
@@ -38,7 +38,7 @@ module Fog
   #
   # @return [Symbol] The credential to use in Fog
   def self.credential
-    @credential ||= ( ENV["FOG_CREDENTIAL"] && ENV["FOG_CREDENTIAL"].to_sym ) || :default
+    @credential ||= (ENV["FOG_CREDENTIAL"] && ENV["FOG_CREDENTIAL"].to_sym) || :default
   end
 
   # This returns the path to the configuration file being used globally to look for sets of
@@ -49,7 +49,7 @@ module Fog
   # @return [String] The path for configuration_file
   def self.credentials_path
     @credential_path ||= begin
-      path = ENV["FOG_RC"] || (ENV['HOME'] && File.directory?(ENV['HOME']) && '~/.fog')
+      path = ENV["FOG_RC"] || (ENV["HOME"] && File.directory?(ENV["HOME"]) && "~/.fog")
       File.expand_path(path) if path
     rescue
       nil
@@ -66,7 +66,7 @@ module Fog
   # @raise [LoadError] Configuration unavailable in configuration file
   def self.credentials
     @credentials ||= begin
-      if credentials_path && File.exists?(credentials_path)
+      if credentials_path && File.exist?(credentials_path)
         credentials = Fog::Core::Utils.prepare_service_settings(YAML.load_file(credentials_path))
         (credentials && credentials[credential]) || Fog::Errors.missing_credentials
       else

data/lib/fog/core/current_machine.rb

@@ -1,12 +1,14 @@
-require 'thread'
+require "thread"
+
 module Fog
   class CurrentMachine
-    @@lock = Mutex.new
-    AMAZON_AWS_CHECK_IP = 'http://checkip.amazonaws.com'
+    @lock = Mutex.new
+
+    AMAZON_AWS_CHECK_IP = "http://checkip.amazonaws.com"
 
-    def self.ip_address= ip_address
-      @@lock.synchronize do
-        @@ip_address = ip_address
+    def self.ip_address=(ip_address)
+      @lock.synchronize do
+        @ip_address = ip_address
       end
     end
 
@@ -26,8 +28,8 @@ module Fog
     #
     # @raise [Excon::Errors::Error] if the net/http request fails.
     def self.ip_address
-      @@lock.synchronize do
-        @@ip_address ||= Excon.get(AMAZON_AWS_CHECK_IP).body.chomp
+      @lock.synchronize do
+        @ip_address ||= Excon.get(AMAZON_AWS_CHECK_IP).body.chomp
       end
     end
   end

data/lib/fog/core/deprecated_connection_accessors.rb

@@ -35,7 +35,6 @@ module Fog
       def prepare_service_value(attributes)
         @service = attributes[:service] || attributes[:connection]
       end
-
     end
   end
 end

data/lib/fog/core/deprecation.rb

@@ -1,6 +1,5 @@
 module Fog
   module Deprecation
-
     def deprecate(older, newer)
       module_eval <<-EOS, __FILE__, __LINE__
         def #{older}(*args)
@@ -18,6 +17,5 @@ module Fog
         end
       EOS
     end
-
   end
 end

data/lib/fog/core/errors.rb

@@ -1,6 +1,5 @@
 module Fog
   module Errors
-
     class Error < StandardError
       attr_accessor :verbose
 
@@ -16,9 +15,9 @@ module Fog
 
     class NotFound < Fog::Errors::Error; end
 
-    class LoadError < LoadError; end
+    class LoadError < Fog::Errors::Error; end
 
-    class TimeoutError< Fog::Errors::Error; end
+    class TimeoutError < Fog::Errors::Error; end
 
     class NotImplemented < Fog::Errors::Error; end
 
@@ -111,8 +110,7 @@ An alternate file may be used by placing its path in the FOG_RC environment vari
 #######################################################
 
     YML
-      raise(Fog::Errors::LoadError.new(missing_credentials_message))
+      raise Fog::Errors::LoadError, missing_credentials_message
     end
-
   end
 end

data/lib/fog/core/hmac.rb

@@ -1,12 +1,11 @@
 module Fog
   class HMAC
-
     def initialize(type, key)
       @key = key
       case type
-      when 'sha1'
+      when "sha1"
         setup_sha1
-      when 'sha256'
+      when "sha256"
         setup_sha256
       end
     end
@@ -18,18 +17,17 @@ module Fog
     private
 
     def setup_sha1
-      @digest = OpenSSL::Digest.new('sha1')
+      @digest = OpenSSL::Digest.new("sha1")
       @signer = lambda do |data|
         OpenSSL::HMAC.digest(@digest, @key, data)
       end
     end
 
     def setup_sha256
-      @digest = OpenSSL::Digest.new('sha256')
+      @digest = OpenSSL::Digest.new("sha256")
       @signer = lambda do |data|
         OpenSSL::HMAC.digest(@digest, @key, data)
       end
     end
-
   end
 end

data/lib/fog/core/logger.rb

@@ -1,12 +1,11 @@
 module Fog
   class Logger
-
     @channels = {
       :deprecation  => ::STDERR,
       :warning      => ::STDERR
     }
 
-    @channels[:debug] = ::STDERR if ENV['DEBUG']
+    @channels[:debug] = ::STDERR if ENV["DEBUG"]
 
     def self.[](channel)
       @channels[channel]
@@ -17,28 +16,28 @@ module Fog
     end
 
     def self.debug(message)
-      self.write(:debug, "[light_black][fog][DEBUG] #{message}[/]\n")
+      write(:debug, "[light_black][fog][DEBUG] #{message}[/]\n")
     end
 
     def self.deprecation(message)
-      self.write(:deprecation, "[yellow][fog][DEPRECATION] #{message}[/]\n")
+      write(:deprecation, "[yellow][fog][DEPRECATION] #{message}[/]\n")
     end
 
     def self.warning(message)
-      self.write(:warning, "[yellow][fog][WARNING] #{message}[/]\n")
+      write(:warning, "[yellow][fog][WARNING] #{message}[/]\n")
     end
 
     def self.write(key, value)
-      if channel = @channels[key]
+      channel = @channels[key]
+      if channel
         message = if channel.tty?
-          value.gsub(Formatador::PARSE_REGEX) { "\e[#{Formatador::STYLES[$1.to_sym]}m" }.gsub(Formatador::INDENT_REGEX, '')
-        else
-          value.gsub(Formatador::PARSE_REGEX, '').gsub(Formatador::INDENT_REGEX, '')
-        end
+                    value.gsub(Formatador::PARSE_REGEX) { "\e[#{Formatador::STYLES[$1.to_sym]}m" }.gsub(Formatador::INDENT_REGEX, "")
+                  else
+                    value.gsub(Formatador::PARSE_REGEX, "").gsub(Formatador::INDENT_REGEX, "")
+                  end
         channel.write(message)
       end
       nil
     end
-
   end
 end

data/lib/fog/core/mock.rb

@@ -1,5 +1,4 @@
 module Fog
-
   @mocking = false
 
   def self.mock!
@@ -10,19 +9,18 @@ module Fog
     @mocking = false
   end
 
-  def self.mock?
-    @mocking
-  end
+  class << self
+    attr_reader :mocking
 
-  def self.mocking?
-    @mocking
+    alias_method :mock?, :mocking
+    alias_method :mocking?, :mocking
   end
 
   module Mock
-
     @delay = 1
-    def self.delay
-      @delay
+
+    class << self
+      attr_reader :delay
     end
 
     def self.delay=(new_delay)
@@ -30,11 +28,11 @@ module Fog
       @delay = new_delay
     end
 
-    def self.not_implemented(message = 'Contributions welcome!')
-      raise Fog::Errors::MockNotImplemented.new(message)
+    def self.not_implemented(message = "Contributions welcome!")
+      raise Fog::Errors::MockNotImplemented, message
     end
 
-    def self.random_ip(opts = {:version => :v4})
+    def self.random_ip(opts = { :version => :v4 })
       version = opts[:version]
       if version == :v6
         bit_length = 128
@@ -46,7 +44,7 @@ module Fog
         raise ArgumentError, "Unknown IP version: #{version}"
       end
 
-      seed = 1 + rand((2**bit_length)-1)
+      seed = 1 + rand((2**bit_length) - 1)
       IPAddr.new(seed, family).to_s
     end
 
@@ -58,31 +56,31 @@ module Fog
     end
 
     def self.random_hex(length)
-      max = ('f' * length).to_i(16)
-      rand(max).to_s(16).rjust(length, '0')
+      max = ("f" * length).to_i(16)
+      rand(max).to_s(16).rjust(length, "0")
     end
 
     def self.random_letters(length)
       random_selection(
-        'abcdefghijklmnopqrstuvwxyz',
+        "abcdefghijklmnopqrstuvwxyz",
         length
       )
     end
 
     def self.random_numbers(length)
-      max = ('9' * length).to_i
+      max = ("9" * length).to_i
       rand(max).to_s
     end
 
     def self.random_letters_and_numbers(length)
       random_selection(
-        'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
         length
       )
     end
 
     def self.random_selection(characters, length)
-      selection = ''
+      selection = ""
       length.times do
         position = rand(characters.length)
         selection << characters[position..position]
@@ -97,19 +95,15 @@ module Fog
         x_const.respond_to?(:constants) && x_const.constants.map do |y|
           y_const = x_const.const_get(y)
           y_const.respond_to?(:constants) && y_const.constants.map do |z|
-            if z.to_sym == :Mock
-              mocked_services << y_const.const_get(z)
-            end
+            mocked_services << y_const.const_get(z) if z.to_sym == :Mock
           end
         end
       end
 
-      for mocked_service in mocked_services
+      mocked_services.each do |mocked_service|
         next unless mocked_service.respond_to?(:reset)
         mocked_service.reset
       end
     end
-
   end
-
 end