aruba 1.0.0.pre.alpha.2 → 1.0.1

data/lib/aruba/platforms/aruba_fixed_size_file_creator.rb

@@ -19,14 +19,19 @@ module Aruba
       # @param [Numeric] size
       #   The size of the file
       #
-      # @param [TrueClass, FalseClass] check_presence (false)
+      # @param [Boolean] check_presence (false)
       #   Check if file exist
       def call(path, size, check_presence)
-        fail "Expected #{path} to be present" if check_presence && !Aruba.platform.file?(path)
+        if check_presence && !Aruba.platform.file?(path)
+          raise "Expected #{path} to be present"
+        end
 
         Aruba.platform.mkdir(File.dirname(path))
 
-        File.open(path, "wb"){ |f| f.seek(size - 1); f.write("\0") }
+        File.open(path, 'wb') do |f|
+          f.seek(size - 1)
+          f.write("\0")
+        end
 
         self
       end

data/lib/aruba/platforms/aruba_logger.rb

@@ -10,12 +10,32 @@ module Aruba
 
     # Create logger
     #
-    # @param [Logger] logger (::Logger.new( $stderr ))
-    #   The logger with should be used to output data
+    # @param [Hash] opts
+    #   Options
+    #
+    # @option opts [Symbol] :default_mode Log level
     def initialize(opts = {})
       @mode = opts.fetch(:default_mode, :info)
     end
 
+    # @!method fatal(msg)
+    # Log a fatal level log message
+
+    # @!method warn(msg)
+    # Log a warn level log message
+
+    # @!method debug(msg)
+    # Log a debug level log message
+
+    # @!method info(msg)
+    # Log an info level log message
+
+    # @!method error(msg)
+    # Log an error level log message
+
+    # @!method unknown(msg)
+    # Log an unknown level log message
+
     [:fatal, :warn, :debug, :info, :error, :unknown].each do |m|
       define_method m do |msg|
         logger.public_send m, msg

data/lib/aruba/platforms/command_monitor.rb

@@ -20,7 +20,11 @@ module Aruba
       end
 
       def method_missing(*)
-        fail NoCommandHasBeenStoppedError, 'No last command stopped available'
+        raise NoCommandHasBeenStoppedError, 'No last command stopped available'
+      end
+
+      def respond_to_missing?(*)
+        true
       end
     end
 
@@ -30,7 +34,11 @@ module Aruba
       end
 
       def method_missing(*)
-        fail NoCommandHasBeenStartedError, 'No last command started available'
+        raise NoCommandHasBeenStartedError, 'No last command started available'
+      end
+
+      def respond_to_missing?(*)
+        true
       end
     end
 
@@ -40,23 +48,11 @@ module Aruba
 
       @last_command_stopped = DefaultLastCommandStopped.new
       @last_command_started = DefaultLastCommandStarted.new
-
     rescue KeyError => e
       raise ArgumentError, e.message
     end
 
-    if Aruba::VERSION < '1'
-      # Return the last command stopped
-      def last_command_stopped
-        return @last_command_stopped unless @last_command_stopped.nil?
-
-        registered_commands.each(&:stop)
-
-        @last_command_stopped
-      end
-    else
-      attr_reader :last_command_stopped
-    end
+    attr_reader :last_command_stopped
 
     # Set last command started
     #
@@ -66,7 +62,7 @@ module Aruba
       @last_command_started = find(cmd)
     end
 
-    # Set last command started
+    # Set last command stopped
     #
     # @param [String] cmd
     #   The commandline of the command
@@ -82,7 +78,7 @@ module Aruba
       cmd = cmd.commandline if cmd.respond_to? :commandline
       command = registered_commands.reverse.find { |c| c.commandline == cmd }
 
-      fail CommandNotFoundError, "No command named '#{cmd}' has been started" if command.nil?
+      raise CommandNotFoundError, "No command named '#{cmd}' has been started" if command.nil?
 
       command
     end
@@ -95,37 +91,6 @@ module Aruba
       self
     end
 
-    # @deprecated
-    # Fetch output (stdout, stderr) from command
-    #
-    # @param [String] cmd
-    #   The command
-    def output_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      find(cmd).output
-    end
-
-    # @deprecated
-    # Fetch stdout from command
-    #
-    # @param [String] cmd
-    #   The command
-    def stdout_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      find(cmd).stdout
-    end
-
-    # @deprecated
-    # Fetch stderr from command
-    #
-    # @param [String] cmd
-    #   The command
-    def stderr_from(cmd)
-      cmd = Aruba.platform.detect_ruby(cmd)
-      find(cmd).stderr
-    end
-
-    # @deprecated
     # Get stdout of all commands
     #
     # @return [String]
@@ -133,10 +98,9 @@ module Aruba
     def all_stdout
       registered_commands.each(&:stop)
 
-      registered_commands.each_with_object("".dup) { |e, a| a << e.stdout }
+      registered_commands.each_with_object('') { |e, a| a << e.stdout }
     end
 
-    # @deprecated
     # Get stderr of all commands
     #
     # @return [String]
@@ -144,10 +108,9 @@ module Aruba
     def all_stderr
       registered_commands.each(&:stop)
 
-      registered_commands.each_with_object("".dup) { |e, a| a << e.stderr }
+      registered_commands.each_with_object('') { |e, a| a << e.stderr }
     end
 
-    # @deprecated
     # Get stderr and stdout of all commands
     #
     # @return [String]
@@ -156,56 +119,6 @@ module Aruba
       all_stdout << all_stderr
     end
 
-    # @deprecated
-    def last_exit_status
-      Aruba.platform.deprecated('The use of "#last_exit_status" is deprecated. Use "last_command_(started|stopped).exit_status" instead')
-
-      return @last_exit_status if @last_exit_status
-      registered_commands.each(&:stop)
-      @last_exit_status
-    end
-
-    # @deprecated
-    def stop_process(process)
-      @last_command_stopped = process
-      @last_exit_status     = process.stop(announcer)
-    end
-
-    # @deprecated
-    def terminate_process!(process)
-      process.terminate
-    end
-
-    # @deprecated
-    def stop_processes!
-      Aruba.platform.deprecated('The use of "#stop_processes!" is deprecated.')
-
-      registered_commands.each(&:stop)
-    end
-
-    # @deprecated
-    # Terminate all running processes
-    def terminate_processes
-      Aruba.platform.deprecated('The use of "#terminate_processes" is deprecated.')
-
-      registered_commands.each(&:terminate)
-    end
-
-    # @deprecated
-    def only_processes
-      Aruba.platform.deprecated('The use of "#only_processes" is deprecated.')
-
-      registered_commands
-    end
-
-    # @deprecated
-    def get_process(wanted)
-      command = find(wanted)
-      raise ArgumentError.new("No process named '#{wanted}' has been started") unless command
-
-      command
-    end
-
     # Register command to monitor
     def register_command(cmd)
       registered_commands << cmd

data/lib/aruba/platforms/determine_disk_usage.rb

@@ -1,33 +1,70 @@
-require 'aruba/platforms/disk_usage_calculator'
+require 'aruba/file_size'
 
-# Aruba
 module Aruba
-  # Platforms
   module Platforms
     # Determinate disk usage
     #
     # @private
     class DetermineDiskUsage
-      def call(*args)
-        args = args.flatten
-
-        deprecated_block_size = args.pop
-        paths = args
-
-        size = paths.flatten.map do |p|
-          # TODO: replace the `call` methods signature so that you can use just
-          # p.minimum_disk_space_used
-          #
-          # (Same result, since the values are multiplied, so
-          # deprecated_block_size is canceled out
-          DiskUsageCalculator.new.call(
-            (p.minimum_disk_space_used / deprecated_block_size),
-            deprecated_block_size
-          )
+      def call(paths)
+        size = paths.flatten.map do |path|
+          minimum_disk_space_used path
         end.inject(0, &:+)
 
         FileSize.new(size)
       end
+
+      private
+
+      # TODO: Aruba.config.physical_block_size could be allowed to be nil
+      # (So the unit size can be autodetected)
+
+      # Report minimum disk space used
+      #
+      # This estimates the minimum bytes allocated by the path.
+      #
+      # E.g. a 1-byte text file on a typical EXT-3 filesystem takes up 4096 bytes
+      # (could be more if it was truncated or less for sparse files).
+      #
+      # Both `File::Stat` and the `stat()` system call will report 8 `blocks`
+      # (each "usually" represents 512 bytes). So 8 * 512 is exactly 4096 bytes.
+      #
+      # (The "magic" 512 bye implied makes the value of "blocks" so confusing).
+      #
+      # Currently Aruba allows you to set what's called the `physical_block_size`,
+      # which is a bit misleading - it's the "512" value. So if you somehow have a
+      # "filesystem unit size" of 8192 (instead of a typical 4KB), set the
+      # `physical_block_size` to 1024 (yes, divide by 8: 8192/8 = 1024).
+      #
+      # Ideally, Aruba should provide e.g. `Aruba.config.fs_allocation_unit`
+      # (with 4096 as the default), so you wouldn't have to "divide by 8".
+      #
+      # (typical_fs_unit / typical_dev_bsize = 4096 / 512 = 8)
+      #
+      #
+      # @return [Integer]
+      #   Total bytes allocate
+      #
+      # TODO: this is recommended over the above "blocks"
+      def minimum_disk_space_used(path)
+        # TODO: replace Aruba.config.physical_block_size
+        # with something like Aruba.config.fs_allocation_unit
+        dev_bsize = Aruba.config.physical_block_size
+
+        stat = File::Stat.new(path.to_s)
+
+        blocks = stat.blocks
+        return (blocks * dev_bsize) if blocks
+
+        typical_fs_unit = 4096
+        typical_dev_bsize = 512 # google dev_bsize for more info
+
+        block_multiplier = typical_fs_unit / typical_dev_bsize
+        fs_unit_size = dev_bsize * block_multiplier
+        fs_units = (stat.size + fs_unit_size - 1) / fs_unit_size
+        fs_units = 1 if fs_units.zero?
+        fs_units * fs_unit_size
+      end
     end
   end
 end

data/lib/aruba/platforms/filesystem_status.rb

@@ -30,7 +30,7 @@ module Aruba
 
       # Return permissions
       def mode
-        format("%o", status.mode)[-4,4].gsub(/^0*/, '')
+        format('%o', status.mode)[-4, 4].gsub(/^0*/, '')
       end
 
       # Return owner
@@ -49,14 +49,14 @@ module Aruba
       #   A hash of values
       def to_h
         {
-          :owner      => owner,
-          :group      => group,
-          :mode       => mode,
-          :executable => executable?,
-          :ctime      => ctime,
-          :atime      => atime,
-          :mtime      => mtime,
-          :size       => size
+          owner: owner,
+          group: group,
+          mode: mode,
+          executable: executable?,
+          ctime: ctime,
+          atime: atime,
+          mtime: mtime,
+          size: size
         }
       end
     end

data/lib/aruba/platforms/local_environment.rb

@@ -13,8 +13,8 @@ module Aruba
       #
       # @yield
       #   The block of code which should with local ENV
-      def call(env, &block)
-        old_env = ENV.to_hash.dup
+      def call(env)
+        old_env = Aruba.platform.environment_variables.hash_from_env
 
         ENV.clear
         ENV.update env

data/lib/aruba/platforms/simple_table.rb

@@ -17,7 +17,7 @@ module Aruba
       def initialize(hash, opts)
         @hash = hash
         @opts = {
-          :sort => true
+          sort: true
         }.merge opts
       end
 
@@ -31,16 +31,8 @@ module Aruba
 
         name_size = longest_key.length
 
-        if RUBY_VERSION < '2'
-          rows = []
-
-          hash.each do |k,v|
-            rows << format("# %-#{name_size}s => %s", k, v)
-          end
-        else
-          rows = hash.each_with_object([]) do |(k,v), a|
-            a << format("# %-#{name_size}s => %s", k, v)
-          end
+        rows = hash.each_with_object([]) do |(k, v), a|
+          a << format("# %-#{name_size}s => %s", k, v)
         end
 
         if opts[:sort] == true

data/lib/aruba/platforms/unix_command_string.rb

@@ -6,14 +6,17 @@ module Aruba
   # Platforms
   module Platforms
     # This is a command which should be run
-    class UnixCommandString < SimpleDelegator
-      def initialize(cmd)
-        __setobj__ cmd
+    #
+    # @private
+    class UnixCommandString
+      def initialize(command, *arguments)
+        @command = command
+        @arguments = arguments
       end
 
       # Convert to array
       def to_a
-        Shellwords.split __getobj__
+        [@command, *@arguments]
       end
     end
   end

data/lib/aruba/platforms/unix_environment_variables.rb

@@ -9,15 +9,9 @@ module Aruba
         attr_reader :other_env, :block
 
         def initialize(other_env, &block)
-          @other_env = other_env
+          @other_env = other_env.to_h.transform_values(&:to_s)
 
-          to_hash = RUBY_VERSION >= '2' ? :to_h : :to_hash
-
-          @other_env = @other_env.public_send(to_hash).each_with_object({}) { |(k, v), a| a[k] = v.to_s }
-
-          @block = if block_given?
-                     block
-                   end
+          @block = (block if block_given?)
         end
 
         def call(env)
@@ -56,11 +50,7 @@ module Aruba
       def initialize(env = ENV)
         @actions = []
 
-        @env = if RUBY_VERSION < '2.0'
-                 env.to_hash
-               else
-                 env.to_h
-               end
+        @env = env.to_h
       end
 
       # Update environment with other en
@@ -73,7 +63,7 @@ module Aruba
       def update(other_env)
         actions << UpdateAction.new(other_env)
 
-        UnixEnvironmentVariables.new(to_h)
+        self
       end
 
       # Fetch variable from environment
@@ -133,7 +123,7 @@ module Aruba
         name  = name.to_s
         value = self[name].to_s + value.to_s
 
-        actions << UpdateAction.new(name => value )
+        actions << UpdateAction.new(name => value)
 
         value
       end
@@ -184,11 +174,7 @@ module Aruba
       # @return [Hash]
       #   A new hash from environment
       def to_h
-        if RUBY_VERSION < '2.0'
-          Marshal.load(Marshal.dump(prepared_environment.to_hash))
-        else
-          Marshal.load(Marshal.dump(prepared_environment.to_h))
-        end
+        actions.inject(hash_from_env.merge(env)) { |a, e| e.call(a) }
       end
 
       # Reset environment
@@ -200,14 +186,21 @@ module Aruba
         value
       end
 
+      def nest
+        old_actions = @actions.dup
+        yield(self)
+      ensure
+        @actions = old_actions
+      end
+
+      def self.hash_from_env
+        ENV.to_hash
+      end
+
       private
 
-      def prepared_environment
-        if RUBY_VERSION == '1.9.3'
-          actions.inject(ENV.to_hash.merge(env)) { |a, e| e.call(a) }
-        else
-          actions.each_with_object(ENV.to_hash.merge(env)) { |e, a| a = e.call(a) }
-        end
+      def hash_from_env
+        self.class.hash_from_env
       end
     end
   end