Merge pull request #229 from fog/best-practices

Force Gem Best Practice

Author: geemus

lib/fog/core/provider.rb

@@ -21,11 +21,21 @@ def service(new_service, constant_string)
       Fog.services[new_service] ||= []
       Fog.services[new_service] |= [to_s.split("::").last.downcase.to_sym]
       @services_registry ||= {}
-      @services_registry[new_service] = [to_s, constant_string].join("::")
+      @services_registry[new_service] = service_klass(constant_string)
     end
 
     def services
       @services_registry.keys
     end
+
+    def service_klass(constant_string)
+      eval([to_s, constant_string].join("::"))
+      [to_s, constant_string].join("::")
+    rescue NameError
+      provider = to_s.split("::").last
+      Fog::Logger.deprecation("Unable to load #{[to_s, constant_string].join("::")}")
+      Fog::Logger.deprecation("The format #{['Fog', constant_string, provider].join("::")} is deprecated")
+      ['Fog', constant_string, provider].join("::")
+    end
   end
 end

lib/fog/core/services_mixin.rb

@@ -24,16 +24,24 @@ def providers
 
     private
 
+    # This method should be removed once all providers are extracted.
+    # Bundler will correctly require all dependencies automatically and thus
+    # fog-core wont need to know any specifics providers. Each provider will
+    # have to load its dependencies.
     def require_service_provider_library(service, provider)
       require "fog/#{provider}/#{service}"
     rescue LoadError  # Try to require the service provider in an alternate location
+      Fog::Logger.deprecation("Unable to require fog/#{provider}/#{service}")
+      Fog::Logger.deprecation("The format fog/#{service}/#{provider} is deprecated")
       require "fog/#{service}/#{provider}"
     end
 
     def service_provider_constant(service_name, provider_name)
-      Fog.const_get(service_name).const_get(*const_get_args(provider_name))
-    rescue NameError  # Try to find the constant from in an alternate location
       Fog.const_get(provider_name).const_get(*const_get_args(service_name))
+    rescue NameError  # Try to find the constant from in an alternate location
+      Fog::Logger.deprecation("Unable to load Fog::#{provider_name}::#{service_name}")
+      Fog::Logger.deprecation("The format Fog::#{service_name}::#{provider_name} is deprecated")
+      Fog.const_get(service_name).const_get(*const_get_args(provider_name))
     end
 
     def const_get_args(*args)

spec/compute_spec.rb

@@ -16,16 +16,16 @@ module TheRightWay
     end
 
     module Fog
-      module Compute
-        class TheRightWay
+      module TheRightWay
+        class Compute
           def initialize(_args); end
         end
       end
     end
 
     it "instantiates an instance of Fog::Compute::<Provider> from the :provider keyword arg" do
       compute = Fog::Compute.new(:provider => :therightway)
-      assert_instance_of(Fog::Compute::TheRightWay, compute)
+      assert_instance_of(Fog::TheRightWay::Compute, compute)
     end
 
     module Fog
@@ -36,16 +36,16 @@ module TheWrongWay
     end
 
     module Fog
-      module TheWrongWay
-        class Compute
+      module Compute
+        class TheWrongWay
           def initialize(_args); end
         end
       end
     end
 
     it "instantiates an instance of Fog::<Provider>::Compute from the :provider keyword arg" do
       compute = Fog::Compute.new(:provider => :thewrongway)
-      assert_instance_of(Fog::TheWrongWay::Compute, compute)
+      assert_instance_of(Fog::Compute::TheWrongWay, compute)
     end
 
     module Fog
@@ -58,26 +58,26 @@ module BothWays
     module Fog
       module BothWays
         class Compute
-          def initialize(_args); end
+          attr_reader :args
+          def initialize(args)
+            @args = args
+          end
         end
       end
     end
 
     module Fog
       module Compute
         class BothWays
-          attr_reader :args
-          def initialize(args)
-            @args = args
-          end
+          def initialize(_args); end
         end
       end
     end
 
     describe "when both Fog::Compute::<Provider> and Fog::<Provider>::Compute exist" do
-      it "prefers Fog::Compute::<Provider>" do
+      it "prefers Fog::<Provider>::Compute" do
         compute = Fog::Compute.new(:provider => :bothways)
-        assert_instance_of(Fog::Compute::BothWays, compute)
+        assert_instance_of(Fog::BothWays::Compute, compute)
       end
     end
 

spec/identity_spec.rb

@@ -16,36 +16,36 @@ module TheRightWay
     end
 
     module Fog
-      module Identity
-        class TheRightWay
+      module TheRightWay
+        class Identity
           def initialize(_args); end
         end
       end
     end
 
     it "instantiates an instance of Fog::Identity::<Provider> from the :provider keyword arg" do
       identity = Fog::Identity.new(:provider => :therightway)
-      assert_instance_of(Fog::Identity::TheRightWay, identity)
+      assert_instance_of(Fog::TheRightWay::Identity, identity)
     end
 
     module Fog
-      module Rackspace
+      module TheWrongWay
         extend Provider
         service(:identity, "Identity")
       end
     end
 
     module Fog
-      module Rackspace
-        class Identity
+      module Identity
+        class TheWrongWay
           def initialize(_args); end
         end
       end
     end
 
     it "instantiates an instance of Fog::<Provider>::Identity from the :provider keyword arg" do
-      identity = Fog::Identity.new(:provider => :rackspace)
-      assert_instance_of(Fog::Rackspace::Identity, identity)
+      identity = Fog::Identity.new(:provider => :thewrongway)
+      assert_instance_of(Fog::Identity::TheWrongWay, identity)
     end
 
     module Fog
@@ -58,26 +58,26 @@ module BothWays
     module Fog
       module BothWays
         class Identity
-          def initialize(_args); end
+          attr_reader :args
+          def initialize(args)
+            @args = args
+          end
         end
       end
     end
 
     module Fog
       module Identity
         class BothWays
-          attr_reader :args
-          def initialize(args)
-            @args = args
-          end
+          def initialize(_args); end
         end
       end
     end
 
     describe "when both Fog::Identity::<Provider> and Fog::<Provider>::Identity exist" do
       it "prefers Fog::Identity::<Provider>" do
         identity = Fog::Identity.new(:provider => :bothways)
-        assert_instance_of(Fog::Identity::BothWays, identity)
+        assert_instance_of(Fog::BothWays::Identity, identity)
       end
     end
 

spec/storage_spec.rb

@@ -16,36 +16,34 @@ module TheRightWay
     end
 
     module Fog
-      module Storage
-        class TheRightWay
+      module TheRightWay
+        class Storage
           def initialize(_args); end
         end
       end
     end
 
-    it "instantiates an instance of Fog::Storage::<Provider> from the :provider keyword arg" do
+    it "instantiates an instance of Fog::<Provider>::Storage from the :provider keyword arg" do
       compute = Fog::Storage.new(:provider => :therightway)
-      assert_instance_of(Fog::Storage::TheRightWay, compute)
+      assert_instance_of(Fog::TheRightWay::Storage, compute)
     end
 
     module Fog
       module TheWrongWay
         extend Provider
         service(:storage, "Storage")
       end
-    end
 
-    module Fog
-      module TheWrongWay
-        class Storage
+      module Storage
+        class TheWrongWay
           def initialize(_args); end
         end
       end
     end
 
-    it "instantiates an instance of Fog::<Provider>::Storage from the :provider keyword arg" do
+    it "instantiates an instance of Fog::Storage::<Provider> from the :provider keyword arg" do
       compute = Fog::Storage.new(:provider => :thewrongway)
-      assert_instance_of(Fog::TheWrongWay::Storage, compute)
+      assert_instance_of(Fog::Storage::TheWrongWay, compute)
     end
 
     module Fog
@@ -58,27 +56,27 @@ module BothWays
     module Fog
       module BothWays
         class Storage
-          def initialize(_args); end
+          attr_reader :args
+
+          def initialize(args)
+            @args = args
+          end
         end
       end
     end
 
     module Fog
       module Storage
         class BothWays
-          attr_reader :args
-
-          def initialize(args)
-            @args = args
-          end
+          def initialize(_args); end
         end
       end
     end
 
     describe "when both Fog::Storage::<Provider> and Fog::<Provider>::Storage exist" do
       it "prefers Fog::Storage::<Provider>" do
         compute = Fog::Storage.new(:provider => :bothways)
-        assert_instance_of(Fog::Storage::BothWays, compute)
+        assert_instance_of(Fog::BothWays::Storage, compute)
       end
     end