aruba-win-fix 0.14.2

data/lib/aruba/errors.rb

@@ -0,0 +1,37 @@
+module Aruba
+  # Standard error
+  class Error < StandardError; end
+
+  # An error because a user of the API did something wrong
+  class UserError < StandardError; end
+
+  # Raised on launch error
+  class LaunchError < Error; end
+
+  # Raised if one tries to use an unknown configuration option
+  class UnknownOptionError < ArgumentError; end
+
+  # Raised if command already died
+  class CommandAlreadyStoppedError < Error; end
+
+  # Raised if one tries to access last command started, but no command
+  # has been started
+  class NoCommandHasBeenStartedError < Error; end
+
+  # Raised if one tries to access last command stopped, but no command
+  # has been stopped
+  class NoCommandHasBeenStoppedError < Error; end
+
+  # Raised if one looked for a command, but no matching was found
+  class CommandNotFoundError < ArgumentError; end
+
+  # Raised if command was already started, otherwise aruba forgets about the
+  # previous pid and you've got hidden commands run
+  class CommandAlreadyStartedError < Error; end
+
+  # Raised if an event name cannot be resolved
+  class EventNameResolveError < StandardError; end
+
+  # Raised if given object is not an event
+  class NoEventError < StandardError; end
+end

data/lib/aruba/event_bus.rb

@@ -0,0 +1,59 @@
+require 'aruba/event_bus/name_resolver'
+require 'aruba/errors'
+
+module Aruba
+  # Event bus
+  #
+  # Implements and in-process pub-sub events broadcaster allowing multiple observers
+  # to subscribe to different events that fire as your tests are executed.
+  #
+  class EventBus
+    # Create EventBus
+    #
+    # @param [#transform] resolver
+    #   A resolver which transforms Symbol, String, Class into an event Class.
+    def initialize(resolver)
+      @resolver = resolver
+      @handlers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Register for an event
+    #
+    # @param [String, Symbol, Class, Array] event_ids
+    #   If Array, register multiple events witht the same handler. If String,
+    #   Symbol, Class register handler for given event.
+    #
+    # @param [#call] handler_object
+    #   The handler object, needs to have method `#call`. Either
+    #   `handler_object` or `block` can be defined. The handler object gets the
+    #   event passed to `#call`.
+    #
+    # @yield
+    #   Handler block which gets the event passed as parameter.
+    def register(event_ids, handler_object = nil, &handler_proc)
+      handler = handler_proc || handler_object
+
+      fail ArgumentError, 'Please pass either an object#call or a handler block' if handler.nil? || !handler.respond_to?(:call)
+
+      Array(event_ids).flatten.each do |id|
+        @handlers[
+          @resolver.transform(id).to_s
+        ] << handler
+      end
+
+      nil
+    end
+
+    # Broadcast an event
+    #
+    # @param [Object] event
+    #   An object of registered event class. This object is passed to the event
+    #   handler.
+    #
+    def notify(event)
+      fail NoEventError, 'Please pass an event object, not a class' if event.is_a?(Class)
+
+      @handlers[event.class.to_s].each { |handler| handler.call(event) }
+    end
+  end
+end

data/lib/aruba/event_bus/name_resolver.rb

@@ -0,0 +1,168 @@
+require 'aruba/errors'
+
+# Event notification library
+module Aruba
+  # EventBus
+  class EventBus
+    # Resolve name to Event name
+    class NameResolver
+      # @private
+      # Helpers for Resolvers
+      module ResolveHelpers
+        def camel_case(underscored_name)
+          if RUBY_VERSION < '1.9.3'
+            underscored_name.to_s.split('_').map { |word| word.upcase.chars.to_a[0] + word.chars.to_a[1..-1].join }.join
+          else
+            underscored_name.to_s.split('_').map { |word| word.upcase[0] + word[1..-1] }.join
+          end
+        end
+
+        # Thanks ActiveSupport
+        # (Only needed to support Ruby 1.9.3 and JRuby)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(camel_cased_word) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+
+              if RUBY_VERSION < '1.9.3'
+                next candidate if constant.const_defined?(name)
+              else
+                next candidate if constant.const_defined?(name, false)
+              end
+
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              # rubocop:disable Style/EachWithObject
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+              # rubocop:enable Style/EachWithObject
+
+              # owner is in Object, so raise
+              constant.const_get(name, false)
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      # @private
+      # Convert a class in to an event class
+      class ClassResolver
+        class << self
+          def match?(event_id)
+            event_id.is_a? Class
+          end
+
+          # Which types are supported
+          def supports
+            [Class]
+          end
+        end
+
+        def transform(_, event_id)
+          event_id
+        end
+      end
+
+      # @private
+      # Convert a string in to an event class
+      class StringResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? String
+          end
+
+          # Which types are supported
+          def supports
+            [String]
+          end
+        end
+
+        def transform(_, event_id)
+          constantize(event_id)
+        end
+      end
+
+      # @private
+      # Convert a symbol in to an event class
+      class SymbolResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? Symbol
+          end
+
+          # Which types are supported
+          def supports
+            [Symbol]
+          end
+        end
+
+        def transform(default_namespace, event_id)
+          constantize("#{default_namespace}::#{camel_case(event_id)}")
+        end
+      end
+
+      # @private
+      # Default failing resolver
+      #
+      # This comes into play if the user passes an invalid event type
+      class FailingResolver
+        class << self
+          def match?(event_id)
+            fail ArgumentError, %(Input type "#{event_id.class}" of event_id "#{event_id}" is invalid)
+          end
+
+          def supports
+            []
+          end
+        end
+      end
+
+      protected
+
+      attr_reader :resolvers, :default_namespace
+
+      public
+
+      def initialize(default_namespace)
+        @default_namespace = default_namespace
+
+        @resolvers = []
+        @resolvers << ClassResolver
+        @resolvers << StringResolver
+        @resolvers << SymbolResolver
+        @resolvers << FailingResolver
+      end
+
+      def transform(event_id)
+        resolvers.find { |r| r.match? event_id }.new.transform(default_namespace, event_id)
+      rescue => e
+        # rubocop:disable Metrics/LineLength
+        raise EventNameResolveError, %(Transforming "#{event_id}" into an event class failed. Supported types are: #{@resolvers.map(&:supports).flatten.join(', ')}. #{e.message}.\n\n#{e.backtrace.join("\n")})
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+  end
+end

data/lib/aruba/events.rb

@@ -0,0 +1,39 @@
+# Aruba
+module Aruba
+  # Events
+  module Events
+    # Basic event
+    #
+    # This is not meant for direct use - BasicEvent.new - by users. It is inherited by normal events
+    #
+    # @private
+    class BasicEvent
+      attr_reader :entity
+
+      def initialize(entity)
+        @entity = entity
+      end
+    end
+
+    # Command was stopped
+    class CommandStopped < BasicEvent; end
+
+    # Command was started
+    class CommandStarted < BasicEvent; end
+
+    # An environment variable was changed
+    class ChangedEnvironmentVariable < BasicEvent; end
+
+    # An environment variable was added
+    class AddedEnvironmentVariable < BasicEvent; end
+
+    # An environment variable was deleted
+    class DeletedEnvironmentVariable < BasicEvent; end
+
+    # The working directory has changed
+    class ChangedWorkingDirectory < BasicEvent; end
+
+    # The configuration was changed
+    class ChangedConfiguration < BasicEvent; end
+  end
+end

data/lib/aruba/extensions/string/strip.rb

@@ -0,0 +1,25 @@
+# String
+class String
+  # Strips indentation in heredocs.
+  #
+  # For example in
+  #
+  #   if options[:usage]
+  #     puts <<-USAGE.strip_heredoc
+  #       This command does such and such.
+  #
+  #       Supported options are:
+  #         -h         This message
+  #         ...
+  #     USAGE
+  #   end
+  #
+  # the user would see the usage message aligned against the left margin.
+  #
+  # Technically, it looks for the least indented line in the whole string, and removes
+  # that amount of leading whitespace.
+  def strip_heredoc
+    indent = scan(/^[ \t]*(?=\S)/).min.to_s.size
+    gsub(/^[ \t]{#{indent}}/, '')
+  end
+end

data/lib/aruba/file_size.rb

@@ -0,0 +1,63 @@
+require 'delegate'
+
+# Aruba
+module Aruba
+  # File Size
+  class FileSize
+    include Comparable
+
+    private
+
+    attr_reader :bytes, :divisor
+
+    public
+
+    # Create file size object
+    def initialize(bytes)
+      @bytes   = bytes
+      @divisor = 1024
+    end
+
+    # Convert to bytes
+    def to_byte
+      bytes
+    end
+    alias to_i to_byte
+
+    # Convert to float
+    def to_f
+      to_i.to_f
+    end
+
+    # Convert to string
+    def to_s
+      to_i.to_s
+    end
+    alias inspect to_s
+
+    # Move to other
+    def coerce(other)
+      [bytes, other]
+    end
+
+    # Convert to kibi byte
+    def to_kibi_byte
+      to_byte.to_f / divisor
+    end
+
+    # Convert to mebi byte
+    def to_mebi_byte
+      to_kibi_byte.to_f / divisor
+    end
+
+    # Convert to gibi byte
+    def to_gibi_byte
+      to_mebi_byte.to_f / divisor
+    end
+
+    # Compare size with other size
+    def <=>(other)
+      to_i <=> other.to_i
+    end
+  end
+end

data/lib/aruba/generators/script_file.rb

@@ -0,0 +1,46 @@
+# Aruba
+module Aruba
+  # Generate script files on command line
+  class ScriptFile
+    private
+
+    attr_reader :path, :content, :interpreter
+
+    public
+
+    def initialize(opts = {})
+      @path        = opts[:path]
+      @content     = opts[:content]
+      @interpreter = opts[:interpreter]
+    end
+
+    def call
+      Aruba.platform.write_file(path, "#{header}#{content}")
+      Aruba.platform.chmod(0755, path, {})
+    end
+
+    private
+
+    def header
+      if script_starts_with_shebang?
+        ''
+      elsif interpreter_is_absolute_path?
+        format("#!%s\n", interpreter)
+      elsif interpreter_is_just_the_name_of_shell?
+        format("#!/usr/bin/env %s\n", interpreter)
+      end
+    end
+
+    def interpreter_is_absolute_path?
+      Aruba.platform.absolute_path? interpreter
+    end
+
+    def interpreter_is_just_the_name_of_shell?
+      interpreter =~ /^[-_a-zA-Z.]+$/
+    end
+
+    def script_starts_with_shebang?
+      content.start_with? '#!'
+    end
+  end
+end

data/lib/aruba/hooks.rb

@@ -0,0 +1,56 @@
+# Aruba
+module Aruba
+  # Aruba Hooks
+  class Hooks
+    private
+
+    attr_reader :store
+
+    public
+
+    # Create store
+    def initialize
+      @store = {}
+    end
+
+    # Add new hook
+    #
+    # @param [String, Symbol] label
+    #   The name of the hook
+    #
+    # @para [Proc] block
+    #   The block which should be run for the hook
+    def append(label, block)
+      if store.key?(label.to_sym) && store[label.to_sym].respond_to?(:<<)
+        store[label.to_sym] << block
+      else
+        store[label.to_sym] = []
+        store[label.to_sym] << block
+      end
+    end
+
+    # Run hook
+    #
+    # @param [String, Symbol] label
+    #   The name of the hook
+    #
+    # @param [Object] context
+    #   The context in which the hook is run
+    #
+    # @param [Array] args
+    #   Other arguments
+    def execute(label, context, *args)
+      Array(store[label.to_sym]).each do |block|
+        context.instance_exec(*args, &block)
+      end
+    end
+
+    # Check if hook exist
+    #
+    # @param [String, Symbol] label
+    #   The name of the hook
+    def exist?(label)
+      store.key? label.to_sym
+    end
+  end
+end