aruba 0.14.14 → 1.0.0.pre.alpha.1

data/lib/aruba/api/filesystem.rb

@@ -372,10 +372,25 @@ module Aruba
       #
       # @result [FileSize]
       #   Bytes on disk
+
       def disk_usage(*paths)
         expect(paths.flatten).to Aruba::Matchers.all be_an_existing_path
+        expanded = paths.flatten.map { |p| ArubaPath.new(expand_path(p)) }
+
+        # TODO: change the API so that you could set something like
+        # aruba.config.fs_allocation_unit_size directly
+
+        typical_fs_unit = 4096 # very typical, except for giant or embedded filesystems
+        typical_dev_bsize = 512 # google dev_bsize for more info
+
+        block_multiplier = typical_fs_unit / typical_dev_bsize
+        fs_unit_size = aruba.config.physical_block_size * block_multiplier
 
-        Aruba.platform.determine_disk_usage paths.flatten.map { |p| ArubaPath.new(expand_path(p)) }, aruba.config.physical_block_size
+        # TODO: the size argument here is unnecessary - ArubaPath should decide
+        # what the disk usage of a file is (even if Aruba.config needs to be
+        # read)
+        deprecated_block_count = fs_unit_size / block_multiplier
+        Aruba.platform.determine_disk_usage(expanded, deprecated_block_count)
       end
 
       # Get size of file
@@ -383,7 +398,7 @@ module Aruba
       # @return [Numeric]
       #   The size of the file
       def file_size(name)
-        raise ArgumentError, "#{name} does not exist" unless exist? name
+        expect(name).to be_an_existing_file
 
         Aruba.platform.determine_file_size expand_path(name)
       end

data/lib/aruba/api/rvm.rb

@@ -0,0 +1,44 @@
+require 'aruba/api/environment'
+require 'aruba/api/command'
+
+# Aruba
+module Aruba
+  # Api
+  module Api
+    # RVM
+    #
+    # @deprecated
+    module Rvm
+      # Use a clean rvm gemset
+      #
+      # Please make sure that you've got [rvm](http://rvm.io/) installed.
+      #
+      # @param [String] gemset
+      #   The name of the gemset to be used
+      def use_clean_gemset(gemset)
+        run_command_and_stop(%{rvm gemset create "#{gemset}"}, true)
+        if all_stdout =~ /'#{gemset}' gemset created \((.*)\)\./
+          gem_home = Regexp.last_match[1]
+          set_environment_variable('GEM_HOME', gem_home)
+          set_environment_variable('GEM_PATH', gem_home)
+          set_environment_variable('BUNDLE_PATH', gem_home)
+
+          paths = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+          paths.unshift(File.join(gem_home, 'bin'))
+          set_environment_variable('PATH', paths.uniq.join(File::PATH_SEPARATOR))
+
+          run_command_and_stop("gem install bundler", true)
+        else
+          raise "I didn't understand rvm's output: #{all_stdout}"
+        end
+      end
+
+      # Unset variables used by bundler
+      def unset_bundler_env_vars
+        %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE].each do |key|
+          set_environment_variable(key, nil)
+        end
+      end
+    end
+  end
+end

data/lib/aruba/aruba_path.rb

@@ -54,24 +54,6 @@ module Aruba
       @delegate_sd_obj.pop
     end
 
-    if RUBY_VERSION < '1.9'
-      def to_s
-        __getobj__.to_s
-      end
-
-      def relative?
-        !(%r{\A/} === to_s)
-      end
-
-      def absolute?
-        (%r{\A/} === to_s)
-      end
-
-      def to_ary
-        to_a
-      end
-    end
-
     # How many parts has the file name
     #
     # @return [Integer]
@@ -83,14 +65,7 @@ module Aruba
     # path.depth # => 3
     #
     def depth
-      if RUBY_VERSION < '1.9'
-        items = []
-        __getobj__.each_filename { |f| items << f }
-
-        items.size
-      else
-        __getobj__.each_filename.to_a.size
-      end
+      __getobj__.each_filename.to_a.size
     end
 
     # Path ends with string
@@ -113,11 +88,7 @@ module Aruba
     #
     # @param [Integer, Range] index
     def [](index)
-      if RUBY_VERSION < '1.9'
-        to_s.chars.to_a[index].to_a.join('')
-      else
-        to_s[index]
-      end
+      to_s[index]
     end
 
     # Report count of blocks allocated on disk
@@ -126,8 +97,61 @@ module Aruba
     #
     # @return [Integer]
     #   The count of blocks on disk
+    #
+    # @deprecated
     def blocks
-      File::Stat.new(to_s).blocks
+      min_bytes_used = minimum_disk_space_used
+      min_bytes_used / Aruba.config.physical_block_size
+    end
+
+    # 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
+      # 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(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

data/lib/aruba/basic_configuration.rb

@@ -57,6 +57,7 @@ module Aruba
       # @option [Object] default
       #   The default value
       #
+      # rubocop:disable Metrics/CyclomaticComplexity
       def option_accessor(name, opts = {})
         contract = opts[:contract]
         default  = opts[:default]
@@ -74,6 +75,7 @@ module Aruba
         # Add reader
         option_reader name, :contract => { None => contract.values.first }
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       private
 
@@ -215,11 +217,7 @@ module Aruba
 
     # Set if name is option
     def set_if_option(name, *args)
-      if RUBY_VERSION < '1.9'
-        send("#{name}=".to_sym, *args) if option? name
-      else
-        public_send("#{name}=".to_sym, *args) if option? name
-      end
+      public_send("#{name}=".to_sym, *args) if option? name
     end
 
     private

data/lib/aruba/colorizer.rb

@@ -1,19 +1,108 @@
-# Aruba
 module Aruba
-  # Simple colorizer class. Only supports the color cyan
-  class Colorizer
-    class << self
-      attr_accessor :coloring
+  # The ANSIColor module can be used for namespacing and mixed into your own
+  # classes.
+  module AnsiColor
+    # :stopdoc:
+    ATTRIBUTES = [
+      [ :clear        ,   0 ],
+      [ :reset        ,   0 ],     # synonym for :clear
+      [ :bold         ,   1 ],
+      [ :dark         ,   2 ],
+      [ :italic       ,   3 ],     # not widely implemented
+      [ :underline    ,   4 ],
+      [ :underscore   ,   4 ],     # synonym for :underline
+      [ :blink        ,   5 ],
+      [ :rapid_blink  ,   6 ],     # not widely implemented
+      [ :negative     ,   7 ],     # no reverse because of String#reverse
+      [ :concealed    ,   8 ],
+      [ :strikethrough,   9 ],     # not widely implemented
+      [ :black        ,  30 ],
+      [ :red          ,  31 ],
+      [ :green        ,  32 ],
+      [ :yellow       ,  33 ],
+      [ :blue         ,  34 ],
+      [ :magenta      ,  35 ],
+      [ :cyan         ,  36 ],
+      [ :white        ,  37 ],
+      [ :on_black     ,  40 ],
+      [ :on_red       ,  41 ],
+      [ :on_green     ,  42 ],
+      [ :on_yellow    ,  43 ],
+      [ :on_blue      ,  44 ],
+      [ :on_magenta   ,  45 ],
+      [ :on_cyan      ,  46 ],
+      [ :on_white     ,  47 ]
+    ].freeze
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+    # :startdoc:
+
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    def self.coloring?
+      @coloring
+    end
+
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
+    def self.coloring=(val)
+      @coloring = val
+    end
+    self.coloring = true
+
+    ATTRIBUTES.each do |c, v|
+      define_method(c) do |string|
+        result = ''
+        result << "\e[#{v}m" if Aruba::AnsiColor.coloring?
+        if block_given?
+          result << yield
+        elsif string
+          result << string
+        elsif respond_to?(:to_str)
+          result << to_str
+        else
+          return result #only switch on
+        end
+        result << "\e[0m" if Aruba::AnsiColor.coloring?
+        result
+      end
+    end
 
-      alias coloring? coloring
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+    def self.included(klass)
+      if klass == String
+        ATTRIBUTES.delete(:clear)
+        ATTRIBUTE_NAMES.delete(:clear)
+      end
     end
 
-    def cyan(string)
-      if self.class.coloring?
-        "\e[36m#{string}\e[0m"
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolored(string = nil) # :yields:
+      if block_given?
+        yield.gsub(COLORED_REGEXP, '')
+      elsif string
+        string.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
       else
-        string
+        ''
       end
     end
+
+    # Returns an array of all Aruba::Platforms::AnsiColor attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+  end
+end
+
+module Aruba
+  class Colorizer
+    include Aruba::AnsiColor
   end
 end

data/lib/aruba/command.rb

@@ -56,8 +56,6 @@ module Aruba
 
     # Terminate command
     def terminate(*)
-      return if __getobj__.stopped?
-
       __getobj__.terminate
       event_bus.notify Events::CommandStopped.new(self)
 

data/lib/aruba/config.rb

@@ -25,11 +25,7 @@ module Aruba
 
     option_accessor :working_directory, :contract => { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath }, :default => 'tmp/aruba'
 
-    if RUBY_VERSION < '1.9'
-      option_reader :fixtures_path_prefix, :contract => { None => String }, :default => '%'
-    else
-      option_reader :fixtures_path_prefix, :contract => { None => String }, :default => ?%
-    end
+    option_reader :fixtures_path_prefix, :contract => { None => String }, :default => ?%
 
     option_accessor :exit_timeout, :contract => { Num => Num }, :default => 15
     option_accessor :stop_signal, :contract => { Maybe[String] => Maybe[String] }, :default => nil
@@ -46,6 +42,7 @@ module Aruba
     option_accessor :command_launcher, :contract => { Aruba::Contracts::Enum[:in_process, :spawn, :debug] => Aruba::Contracts::Enum[:in_process, :spawn, :debug] }, :default => :spawn
     # rubocop:enable Metrics/LineLength
     option_accessor :main_class, :contract => { Class => Maybe[Class] }, :default => nil
+    # rubocop:disable Metrics/LineLength
 
     # rubocop:disable Metrics/LineLength
     if Aruba::VERSION >= '1.0.0'
@@ -61,6 +58,9 @@ module Aruba
     option_accessor :log_level, :contract => { Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] => Aruba::Contracts::Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent] }, :default => :info
     # rubocop:enable Metrics/LineLength
 
+    # TODO: deprecate this value and replace with "filesystem allocation unit"
+    # equal to 4096 by default. "filesystem allocation unit" would represent
+    # the actual MINIMUM space taken in bytes by a 1-byte file
     option_accessor :physical_block_size, :contract => { Aruba::Contracts::IsPowerOfTwo => Aruba::Contracts::IsPowerOfTwo }, :default => 512
     option_accessor :console_history_file, :contract => { String => String }, :default => '~/.aruba_history'
 

data/lib/aruba/config/jruby.rb

@@ -2,26 +2,16 @@ require 'rbconfig'
 
 # ideas taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
 Aruba.configure do |config|
-  config.before :command do |command|
+  config.before :command do
     next unless RUBY_PLATFORM == 'java'
 
-    env = command.environment
-
-    jruby_opts = env['JRUBY_OPTS'] || ''
-
     # disable JIT since these processes are so short lived
-    jruby_opts = "-X-C #{jruby_opts}" unless jruby_opts.include? '-X-C'
+    ENV['JRUBY_OPTS'] = "-X-C #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '') .include? '-X-C'
 
     # Faster startup for jruby
-    jruby_opts = "--dev #{jruby_opts}" unless jruby_opts.include? '--dev'
-
-    env['JRUBY_OPTS'] = jruby_opts
-
-    if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i
-      java_opts = env['JAVA_OPTS'] || ''
+    ENV['JRUBY_OPTS'] = "--dev #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '').include? '--dev'
 
-      # force jRuby to use client JVM for faster startup times
-      env['JAVA_OPTS'] = "-d32 #{java_opts}" unless java_opts.include?('-d32')
-    end
+    # force jRuby to use client JVM for faster startup times
+    ENV['JAVA_OPTS'] = "-d32 #{ENV['JAVA_OPTS']}" if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i && !(ENV['JAVA_OPTS'] || '').include?('-d32')
   end
 end

data/lib/aruba/console.rb

@@ -35,6 +35,7 @@ module Aruba
       IRB.conf[:SAVE_HISTORY] = 1000
       IRB.conf[:HISTORY_FILE] = Aruba.config.console_history_file
 
+      # rubocop:disable Lint/NestedMethodDefinition
       context = Class.new do
         include Aruba::Api
         include Aruba::Console::Help
@@ -47,6 +48,7 @@ module Aruba
           'nil'
         end
       end
+      # rubocop:enable Lint/NestedMethodDefinition
 
       irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
       IRB.conf[:MAIN_CONTEXT] = irb.context

data/lib/aruba/console/help.rb

@@ -18,13 +18,7 @@ module Aruba
 
       # List available methods in aruba
       def aruba_methods
-        ms = if RUBY_VERSION < '1.9'
-               # rubocop:disable Style/EachWithObject
-               (Aruba::Api.instance_methods - Module.instance_methods).inject([]) { |a, e| a << format("* %s", e); a }.sort
-               # rubocop:enable Style/EachWithObject
-             else
-               (Aruba::Api.instance_methods - Module.instance_methods).each_with_object([]) { |e, a| a << format("* %s", e) }.sort
-             end
+        ms = (Aruba::Api.instance_methods - Module.instance_methods).each_with_object([]) { |e, a| a << format("* %s", e) }.sort
 
         puts "Available Methods:\n" + ms.join("\n")