vagrant 0.7.8 → 0.8.1

data/lib/vagrant/util/plain_logger.rb

@@ -1,25 +0,0 @@
-require 'logger'
-
-module Vagrant
-  module Util
-    # Subclass of the standard library logger which has no format on
-    # its own. The message sent to the logger is outputted as-is.
-    class PlainLogger < ::Logger
-      # This is the method which is called for all debug, info, error,
-      # etc. methods by the logger. This is overriden to verify that
-      # the output is always flushed.
-      #
-      # Logger by default syncs all log devices but this just verifies
-      # it is truly flushed.
-      def add(*args)
-        super
-        @logdev.dev.flush if @logdev
-      end
-
-      def format_message(level, time, progname, msg)
-        # We do no formatting, its up to the user
-        "#{msg}\n"
-      end
-    end
-  end
-end

data/lib/vagrant/util/resource_logger.rb

@@ -1,63 +0,0 @@
-require 'thread'
-
-module Vagrant
-  module Util
-    # Represents a logger for a specific resource within Vagrant. Each
-    # logger should be initialized and set to represent a single
-    # resource. Each logged message will then appear in the following
-    # format:
-    #
-    #     [resource] message
-    #
-    # This class is thread safe. The backing class which actually does
-    # all the logging IO is protected.
-    class ResourceLogger
-      @@singleton_logger = nil
-      @@writer_lock = Mutex.new
-
-      # The resource which this logger represents.
-      attr_reader :resource
-
-      # The environment that this logger is part of
-      attr_reader :env
-
-      # The backing logger which actually handles the IO. This logger
-      # should be a subclass of the standard library Logger, in general.
-      # IMPORTANT: This logger must be thread-safe.
-      attr_reader :logger
-
-      class << self
-        # Returns a singleton logger. If one has not yet be
-        # instantiated, then the given environment will be used to
-        # create a new logger.
-        def singleton_logger(env=nil)
-          return PlainLogger.new(nil) if !env.loaded?
-
-          @@singleton_logger ||= begin
-            file = env.log_path.join("#{Time.now.to_i}.log")
-            PlainLogger.new(file)
-          end
-        end
-
-        # Resets the singleton logger (only used for testing).
-        def reset_singleton_logger!
-          @@singleton_logger = nil
-        end
-      end
-
-      def initialize(resource, env)
-        @resource = resource
-        @env = env
-        @logger = self.class.singleton_logger(env)
-      end
-
-      [:debug, :info, :error, :fatal].each do |method|
-        define_method(method) do |message|
-          @@writer_lock.synchronize do
-            logger.send(method, "[#{resource}] #{message}")
-          end
-        end
-      end
-    end
-  end
-end

data/test/vagrant/util/plain_logger_test.rb

@@ -1,17 +0,0 @@
-require "test_helper"
-
-class PlainLoggerUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Util::PlainLogger
-    @instance = @klass.new(nil)
-  end
-
-  should "inherit from the standard logger" do
-    assert @instance.is_a?(::Logger)
-  end
-
-  should "just add a newline to the message" do
-    msg = "foo bar baz"
-    assert_equal "#{msg}\n", @instance.format_message("1", "2", "3", msg)
-  end
-end

data/test/vagrant/util/resource_logger_test.rb

@@ -1,78 +0,0 @@
-require "test_helper"
-
-class ResourceLoggerUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Util::ResourceLogger
-  end
-
-  context "singleton logger" do
-    setup do
-      @klass.reset_singleton_logger!
-
-      @result = mock("result")
-    end
-
-    should "return a nil plain logger if the environment is not loaded" do
-      env = vagrant_env
-      env.stubs(:loaded?).returns(false)
-
-      Vagrant::Util::PlainLogger.expects(:new).with(nil).returns(@result)
-      assert_equal @result, @klass.singleton_logger(env)
-    end
-
-    should "return a logger with the output file set if environment is ready" do
-      env = vagrant_env
-
-      Vagrant::Util::PlainLogger.expects(:new).returns(@result).with() do |path|
-        assert path.to_s =~ /logs/
-        true
-      end
-
-      assert_equal @result, @klass.singleton_logger(env)
-    end
-
-    should "only load the logger once" do
-      env = vagrant_env
-
-      Vagrant::Util::PlainLogger.expects(:new).with(anything).returns(@result)
-      assert_equal @result, @klass.singleton_logger(env)
-      assert_equal @result, @klass.singleton_logger(env)
-      assert_equal @result, @klass.singleton_logger(env)
-    end
-  end
-
-  context "initialization" do
-    should "setup the logger and attributes" do
-      env = vagrant_env
-      resource = mock("resource")
-      result = mock("result")
-
-      @klass.expects(:singleton_logger).with(env).returns(result)
-      instance = @klass.new(resource, env)
-      assert_equal resource, instance.resource
-      assert_equal env, instance.env
-      assert_equal result, instance.logger
-    end
-  end
-
-  context "with an instance" do
-    setup do
-      @resource = "foo"
-      @env = vagrant_env
-      @logger = mock("logger")
-
-      @klass.stubs(:singleton_logger).returns(@logger)
-      @instance = @klass.new(@resource, @env)
-    end
-
-    context "logging methods" do
-      [:debug, :info, :error, :fatal].each do |method|
-        should "log with the proper format on #{method}" do
-          message = "bar"
-          @logger.expects(method).with("[#{@resource}] #{message}").once
-          @instance.send(method, message)
-        end
-      end
-    end
-  end
-end