runnable 0.2.4 → 0.3.0

data/README.markdown

@@ -5,10 +5,17 @@ A Ruby gem that allow programmer to control UNIX system commands as a Ruby class
 All you have to do is to create a class named exactly as command and make it 
 inherit from class Runnable.
 
-    class LS < Runnable
+    class LS
+      include Runnable
     end
 
 That gives you the basics to control the execution of ```ls``` command.
+You can overwrite the name of the command by using the ```executes``` macro:
+    class MyLs
+      include Runnable
+
+      executes :ls
+    end
 
 Now you can create an instance like this:
 
@@ -23,53 +30,51 @@ for some important information about the command and its process. Entire
 documentation of this gem can be generated using ```yardoc```. To do this use 
 ```rake doc```.
 
-## Return values
-Runnable has two special methods which are called at the end of a command execution.  
-```:finish``` if commands finalized in a correct way and ```:fail``` if an error 
-ocurred. In case something went wrong and a ```:fail``` method is called, Runnable 
-also provide an array containing the command return value as the parameter of a 
-SystemCallError exception and optionally others exceptions ocurred at runtime.
+## Custom output and exceptions
+Runnable parse a set of user defined regular expresion to set up the command return
+values.
 
 This is an example of how we can receive the return value of a command:
 
-    class LS < Runnable
+    class Nmap
+      include Runnable
+      
+      executes :nmap
 
-      def finish
-        puts "Everything went better than expected :)"
-      end
+      define_command( :scan, :blocking => true ) { |ip, subnet| "-sP #{ip}/#{subnet}" }
+      scan_processors(
+        :exceptions => { /^Illegal netmask value/ => ArgumentError },
+        :outputs => { /Nmap scan report for (.*)/ => :ip }
+      )
+    end
 
-      def failed( exceptions )
-        puts "Something went wrong :("
-        exceptions.each do |exception|
-          puts exception.message
-        end   
-      end
+    Nmap.new.scan("192.168.1.1", "24") # should return an array with the ips
 
-    end
+Runnable can also raise custom exceptions, using the previously Nmap defined class:
+    Nmap.new.scan("192.168.1.1", "1000")
+Will raise an ArgumentError exception.
+Note that Runnable will also raise an exception if the command returned value is not 0.
 
-    my_command = LS.new    
-    my_command.run
+## Background usage
+Runnable can be used with background process:
 
-## Custom exceptions
-As we saw in previous chapter, if a command execution does not ends 
-succesfully, Runnable fires a ```:fail``` event whit an exceptions array. We can
-add exceptions to that array based on the output of command. For example, we 
-can controll that parameters passed to a command are valids if we know the 
-command output for an invalid parameters.
+    class Ping
+      include Runnable
 
-First we have to do is override the method ```exceptions``` defined in runnable
-as follows
+      define_command( :goping, :blocking => false) { "-c5 www.google.es" }
 
-    class LS < Runnable
-      def exceptions
-        { /ls: (invalid option.*)/ => ArgumentError }
-      end
+      goping_processors(
+        :outputs => { /64 bytes from .* time=(.*) ms/ => :time  }
+      )
     end
 
-```exceptions``` method should return a hash containing a regular expression 
-which will be match against the command output, and a value which will be the
-exception added to exception array. This means that if the command output match
-the regular expression, a new exception will be include in ```:fail``` event parameter.
+    p = Ping.new
+    p.goping
+
+    while p.running?
+      p p.output[:time]
+      sleep 1
+    end
 
 # About
 Runnable is a gem developed by [NoSoloSoftware](http://nosolosoftware.biz).

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/lib/runnable.rb

@@ -24,14 +24,97 @@ require 'fileutils'
 # you are able to start, define params and send signals (like kill, or stop)
 #
 # @example Usage:
-#   class LS < Runnable
+#   class LS 
+#     include Runnable
+#
+#     executes :ls
 #     command_style :extended
 #   end
 #
 #   ls = LS.new
 #   ls.alh
 #   ls.run
-class Runnable  
+module Runnable  
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    # Define the command to be executed
+    # @return [nil]
+    # @param [Symbol] command Command to be executed
+    def executes( cmd )
+      define_method( :command ) { cmd }
+    end
+ 
+    # Define the parameter style to be used.
+    # @return [nil]
+    def command_style( style )
+      define_method( :command_style ) { style }
+    end
+ 
+    # Create a user definde command
+    # @return [nil]
+    # @param [Symbol] name The user defined command name
+    # @param [Hash] options Options.
+    # @option options :blocking (false) Describe if the execution is blocking or non-blocking
+    # @option options :log_path (false) Path used to store logs # (dont store logs if no path specified)
+    def define_command( name, opts = {}, &block )
+      blocking = opts[:blocking] || false
+      log_path = opts[:log_path] || false
+
+      commands[name] = { :blocking => blocking }
+
+      define_method( name ) do |*args|
+        run name, block.call(*args), log_path
+        join if blocking
+      end
+    end
+ 
+    # Generic command processor. It allows to define generic processors used in all the
+    # user defined commands
+    # @param [Hash] opts Processing options
+    # @option opts :outputs (nil) Output processing Hash (regexp => output)
+    # @option opts :exceptions (nil) Exceptions processing Hash (regexp => exception)
+    def processors( opts = nil )
+      if opts.is_a? Hash
+        @processors = opts
+      else
+        @processors ||= Hash.new
+      end
+    end
+
+    # Method missing processing for the command processors
+    def method_missing( name, *opts )
+      raise NoMethodError.new( name.to_s ) unless name.to_s =~ /([a-z]*)_([a-z]*)/
+ 
+      # command_processors
+      if $2 == "processors"
+        commands[$1.to_sym][:outputs] = opts.first[:outputs]
+        commands[$1.to_sym][:exceptions] = opts.first[:exceptions]
+      end
+    end
+
+    # @group Accessors for the module class variables
+ 
+    # Returns the user defined commands
+    # @return [Hash] commands User defined commands
+    def commands
+      @commands ||= Hash.new
+    end
+ 
+    # Returns the list of runnable instances by pid
+    # @return [Hash] list of runnable instances by pid
+    def processes
+      @processes ||= Hash.new
+    end
+
+    # Processes writer
+    def processes=( value )
+      @processes = value
+    end
+  end
+  
   # Process id.
   attr_reader :pid
   # Process owner.
@@ -41,137 +124,54 @@ class Runnable
   # Directory where process was called from.
   attr_reader :pwd
 
-  # Input file
-  attr_accessor :input
+  # Process output
+  attr_reader :output
 
-  # Set the output file
-  attr_accessor :output
+  # Process options
+  attr_accessor :options
+  # Process log output
+  attr_accessor :log_path
 
   # Metaprogramming part of the class
-  
-  # Define the parameter style to be used.
-  # @return [nil]
-  def self.command_style( style )
-    define_method( :command_style ) do
-      style
-    end
-  end
-  
+
   # Parameter style used for the command.
   # @return [Symbol] Command style.
   def command_style
     :gnu
   end
 
-  # List of runnable instances running on the system order by pid.
-  @@processes = Hash.new
+  # Default command to be executed
+  # @return [String] Command to be executed
+  def command
+    self.class.to_s.split( "::" ).last.downcase
+  end
 
   # Constant to calculate cpu usage.
   HERTZ = 100
 
-  # Create a new instance of a runnable command.
-  # @param [Hash] option_hash Options.
-  # @option option_hash :delete_log (true) Delete the log after execution.
-  # @option option_hash :command_options ("") Command options.
-  # @option option_hash :log_path ("/var/log/runnable") Path for the log files.
-  def initialize( option_hash = {} )
-    # keys :delete_log
-    #      :command_options
-    #      :log_path
-    
-    # If we have the command class in a namespace, we need to remove
-    # the namespace name
-    @command = self.class.to_s.split( "::" ).last.downcase
-    
-    # Set the default command option
-    # Empty by default
-    option_hash[:command_options] ||= ""
-    @options = option_hash[:command_options]
-    
-    # Set the log path
-    # Default path is "/var/log/runnable"
-    option_hash[:log_path] ||= "/var/log/runnable/"
-    @log_path = option_hash[:log_path]
-
-    # Set the delete_log option
-    # true by default
-    if option_hash[:delete_log] == nil
-      @delete_log = true
-    else 
-      @delete_log = option_hash[:delete_log]
-    end
-
-    # Store input options
-    @input = String.new
-
-    # Store output options
-    @output = String.new
-
-    # Standar Outputs
-    @std_output = {
-      :out => "",
-      :err => ""
-      }
-
-    # @todo: checks that command is in the PATH
-    # ...
-    
-    # we dont set the pid, because we dont know until run
-    @pid = nil
-    @excep_array = []
-    
-
-    # Metaprogramming part  
-    # Create a new instance of the parser class
-    @command_line_interface = Object.const_get( command_style.to_s.capitalize.to_sym ).new
-    # End Metaprogramming part
-   
-    #End of initialize instance variables
-   
-    create_log_directory
-  end
-  
   # Start the execution of the command.
   # @return [nil]
-  def run
+  def run(name = nil, opts = nil, log_path = nil)
+    return false if @pid
     # Create a new mutex
     @pid_mutex = Mutex.new
+    
+    # Log path should be an instance variable to avoid a mess
+    @log_path = log_path || @log_path
 
     # Create pipes to redirect Standar I/O
     out_rd, out_wr = IO.pipe
     # Redirect Error I/O
     err_rd, err_wr = IO.pipe
-   
+
     # Reset exceptions array to not store exceptions for
     # past executions
-    @excep_array = []
-
-    # Set up the command line
-    command = []          
-    #command << @command
-    command << @input.to_s
-    command << @options.to_s
-    command << @command_line_interface.parse
-    command << @output.to_s
-    #command = command.join( " " )
-    command.flatten!
-    
-    command = command.select do |value| 
-      !value.to_s.strip.empty?
-    end
-=begin
-    # Debugging purpose
-    puts "I: #{@input}"
-    puts "OP: #{@options}"
-    puts "CLI: #{@command_line_interface.parse}"
-    puts "O: #{@output}"
-    puts "C: #{command}"
-=end
-    #@pid = Process.spawn( command, { :out => out_wr, :err => err_wr } )
-    @pid = Process.spawn( @command, *command, { :out => out_wr, :err => err_wr } )
+    command_argument = opts ? opts.split(" ") : compose_command
+
+    @pid = Process.spawn( command.to_s, *command_argument, { :out => out_wr, :err => err_wr } )
 
     # Include instance in class variable
-    @@processes[@pid] = self
+    self.class.processes[@pid] = self
 
     # Prepare the process info file to be read
     file_status = File.open( "/proc/#{@pid}/status" ).read.split( "\n" )
@@ -179,46 +179,36 @@ class Runnable
     @owner = file_status[6].split( " " )[1]
     # Group: Read the Group owner from /proc/@pid/status
     @group = file_status[7].split( " " )[1]
-   
+
     # Set @output_thread with new threads
     # wich execute the input/ouput loop
-    create_logs(:out => [out_wr, out_rd], :err => [err_wr, err_rd])
-    
-    # Create a new thread to avoid blocked processes
-    @run_thread = Thread.new do
-      # Wait to get the pid process even if it has finished
-      Process.wait( @pid, Process::WUNTRACED )
+    stream_info = {
+      :out => [out_wr, out_rd],
+      :err => [err_wr, err_rd]
+    }
+
+    if name
+      cmd_info = self.class.commands[name]
+      stream_processors = {
+        :outputs => cmd_info[:outputs],
+        :exceptions => cmd_info[:exceptions]
+      }
+    end
 
-      # Wait each I/O thread
-      @output_threads.each { |thread| thread.join }
-      # Delete log if its necesary
-      delete_log
+    output_threads = process_streams( stream_info, stream_processors )
+
+    # Create a new thread to avoid blocked processes
+    @run_thread = threaded_process(@pid, output_threads)
 
-      # Get the exit code from command
-      exit_status = $?.exitstatus
-      
-      # In case of error add an Exception to the @excep_array
-      @excep_array << SystemCallError.new( exit_status ) if exit_status != 0
-      
-      # Call methods according to the exit code
-      if @excep_array.empty?
-        finish
-      else
-        failed( @excep_array )
-      end
-      
-      # This instance is finished and we remove it
-      @@processes.delete( @pid )
-    end
-    
     # Satuts Variables
     # PWD: Current Working Directory get by /proc/@pid/cwd
     # @rescue If a fast process is runned there isn't time to get
     # the correct PWD. If the readlink fails, we retry, if the process still alive
     # until the process finish.
+
     begin
-      @pwd = File.readlink( "/proc/#{@pid}/cwd" )
-    rescue
+      @pwd ||= File.readlink( "/proc/#{@pid}/cwd" )
+    rescue Errno::ENOENT
       # If cwd is not available rerun @run_thread
       if @run_thread.alive?
         #If it is alive, we retry to get cwd
@@ -228,6 +218,8 @@ class Runnable
         #If process has terminated, we set pwd to current working directory of ruby
         @pwd = Dir.getwd
       end
+    rescue #Errno::EACCESS
+      @pwd = Dir.getwd
     end
   end
   
@@ -257,6 +249,7 @@ class Runnable
   # @return [nil]
   def join
     @run_thread.join if @run_thread.alive?
+    @output unless @output.empty?
   end
 
   # Check if prcess is running on the system.
@@ -268,13 +261,25 @@ class Runnable
   # Standar output of command
   # @return [String] Standar output
   def std_out
-    @std_output[:out]
+    @std_out ||= ""
   end
 
   # Standar error output of the command
   # @return [String] Standar error output
   def std_err
-    @std_output[:err]
+    @std_err ||= ""
+  end
+
+  # Sets the command input to be passed to the command execution
+  # @param [String] opt Command input
+  def input=( opt )
+    @command_input = opt
+  end
+
+  # Sets the command output to be passed to the command execution
+  # @param [String] opt Command output
+  def output=( opt )
+    @command_output = opt
   end
 
   # Calculate the estimated memory usage in Kb.
@@ -315,7 +320,6 @@ class Runnable
       # Seconds is Zero!
       0
     end
-
   end
 
   # Estimated bandwidth in kb/s.
@@ -354,6 +358,8 @@ class Runnable
   # @param [Block] block Block code in method
   # @return [nil]
   def method_missing( method, *params, &block )
+    @command_line_interface ||= Object.const_get( command_style.to_s.capitalize.to_sym ).new
+
     if params.length > 1
       super( method, params, block )
     else
@@ -363,8 +369,7 @@ class Runnable
         # @see parse_hash for more information
 				parse_hash( params[0] )
       else
-        @command_line_interface.add_param( method.to_s,
-                                          params != nil ? params.join(",") : nil )
+        @command_line_interface.add_param( method.to_s, params != nil ? params.join(",") : nil )
       end
     end
   end
@@ -375,39 +380,6 @@ class Runnable
     @@processes
   end
  
-  # @abstract 
-  # Returns a hash of regular expressions and exceptions associated to them.
-  # Command output is match against those regular expressions, if it does match
-  # an appropiate exception is included in the return value of execution. 
-  # @note This method should be overwritten in child classes.
-  # @example Usage:
-  #   class ls < Runnable
-  #     def exceptions
-  #       { /ls: (invalid option.*)/ => ArgumentError }
-  #     end
-  #   end
-  #
-  # @return [Hash] Using regular expressions as keys and exceptions that should
-  #   be raised as values.
-	def exceptions
-    {}
-  end
-  
-  # @abstract
-  # Method called when command ends with no erros.
-  # This method is a hook so it should be overwritten in child classes.
-  # @return [nil]
-  def finish
-  end
-
-  # @abstract
-  # Method called when command executions fail.
-  # This method is a hook so it should be overwritten in child classes.
-  # @param [Array] exceptions Array containing exceptions raised during the command execution.
-  # @return [nil]
-  def failed( exceptions )
-  end
-  
   # Send the desired signal to the command.
   # @param [Symbol] Signal to be send to the command.
   # @todo raise ESRCH if pid is not in system
@@ -437,50 +409,24 @@ class Runnable
   end
 
   protected
-  # Redirect command I/O to log files.
+  # Process the command I/O.
   # These files are located in /var/log/runnable.
   # @param [Hash] Outputs options.
   # @option outputs stream [Symbol] Stream name.
   # @option outputs pipes [IO] I/O stream to be redirected.
-  # @return [nil]
-  def create_logs( outputs = {} )
-    # Create an empty file for logging
-    FileUtils.touch "#{@log_path}#{@command}_#{@pid}.log"
+  # @return [Array] output_threads Array containing the output processing threads
+  def process_streams( output_streams = {}, stream_processors = nil )
+    @output = Hash.new
+    @std_output = Hash.new
 
-    @output_threads = []
+    output_threads = []
     # for each io stream we create a thread wich read that 
     # stream and write it in a log file
-    outputs.each do |output_name, pipes|
-      @output_threads << Thread.new do
-        pipes[0].close
-
-        @std_output[output_name] = ""
-
-        pipes[1].each_line do |line|
-          @std_output[output_name] << line
-
-          File.open("#{@log_path}#{@command}_#{@pid}.log", "a") do |log_file|
-            log_file.puts( "[#{Time.new.inspect} || [STD#{output_name.to_s.upcase} || [#{@pid}]] #{line}" )
-          end
-          # Match custom exceptions
-          # if we get a positive match, add it to the exception array
-          # in order to inform the user of what had happen
-          exceptions.each do | reg_expr, value |
-  					@excep_array<< value.new( $1 ) if reg_expr =~ line
-          end
-        end
-      end
+    output_streams.collect do |output_name, pipes|
+      threaded_output_processor(output_name, pipes, stream_processors)
     end
   end
   
-  def create_log_directory
-    Dir.mkdir( @log_path ) unless Dir.exist?( @log_path )
-  end
-  
-  def delete_log
-    File.delete( "#{@log_path}#{@command}_#{@pid}.log" ) if @delete_log == true
-  end
-
   # Expand a parameter hash calling each key as method and value as param
   # forcing method misssing to be called.
   # @param [Hash] hash Parameters to be expand and included in command execution
@@ -488,10 +434,82 @@ class Runnable
   def parse_hash( hash )
     hash.each do |key, value|
       # Add the param parsed to command_line_interface
-      @command_line_interface.add_param( 
-        key.to_s,
-        value != nil ? value.to_s : nil 
-        )
+      @command_line_interface.add_param( key.to_s, value != nil ? value.to_s : nil )
     end
   end
+
+  private
+
+  def save_log(output_name, line)
+    Dir.mkdir( @log_path ) unless Dir.exist?( @log_path )
+
+    File.open("#{@log_path}/#{self.command}_#{@pid}.log", "a") do |log_file|
+      log_file.puts( "[#{Time.new.inspect} || [STD#{output_name.to_s.upcase} || [#{@pid}]] #{line}" )
+    end
+  end
+
+  def compose_command
+    @command_line_interface ||= Object.const_get( command_style.to_s.capitalize.to_sym ).new
+
+    [ @command_input.to_s, 
+      @options.to_s, 
+      @command_line_interface.parse, 
+      @command_output.to_s 
+    ].select do |value|
+      !value.to_s.strip.empty?
+    end.flatten.select{|x| !x.empty?}
+  end
+
+  def threaded_process(pid, output_threads)
+    Thread.new do
+      # Wait to get the pid process even if it has finished
+      Process.wait( pid, Process::WUNTRACED )
+
+      # Wait each I/O thread
+      output_threads.each { |thread| thread.join }
+
+      # Get the exit code from command
+      exit_status = $?.exitstatus
+
+      # This instance is finished and we remove it
+      self.class.processes.delete( pid )
+      @pid = nil
+
+      # In case of error add an Exception to the @excep_array
+      raise SystemCallError.new( exit_status ) if exit_status != 0
+    end
+  end
+
+  def threaded_output_processor(output_name, pipes, stream_processors)
+    exception_processors = stream_processors.is_a?(Hash) ? stream_processors[:exceptions] : {}
+    exception_processors.merge!(self.class.processors[:exceptions] || {})
+
+    output_processors = stream_processors.is_a?(Hash) ? stream_processors[:outputs] : {}
+    output_processors.merge!(self.class.processors[:output] || {})
+        
+    Thread.new do
+      pipes[0].close
+
+      pipes[1].each_line do |line|
+        ( output_name == :err ? self.std_err : self.std_out ) << line
+
+        save_log(output_name, line) if @log_path
+        
+        # Match custom exceptions
+        # if we get a positive match, raise the exception
+        exception_processors.each do | reg_expr, value |
+          raise value.new( line ) if reg_expr =~ line
+        end
+         
+        # Match custom outputs
+        # if we get a positive match, add it to the outputs array
+        output_processors.each do | reg_expr, value |
+          @output[value] ||= Array.new
+          @output[value] << $1 if reg_expr =~ line
+        end
+
+      end
+    end
+  end
+  
 end

data/runnable.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{runnable}
-  s.version = "0.2.4"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rafael García", "Luis Ciudad", "Pedro Navajas", "Javier Aranda"]
-  s.date = %q{2011-10-27}
+  s.date = %q{2012-01-17}
   s.description = %q{Convert a executable command in a Ruby-like class you are able to start, define params and send signals (like kill, or stop)}
   s.email = ["rgarcia@nosolosoftware.biz", "lciudad@nosolosoftware.biz", "pnavajas@nosolosoftware.biz", "jaranda@nosolosoftware.biz"]
   s.extra_rdoc_files = [
@@ -28,10 +28,11 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/nosolosoftware/runnable}
   s.licenses = ["GPL-3"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{A Ruby gem for execute and control system commands}
 
   if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

metadata

@@ -1,86 +1,121 @@
 --- !ruby/object:Gem::Specification
 name: runnable
 version: !ruby/object:Gem::Version
-  version: 0.2.4
-  prerelease: 
+  version: 0.3.0
+  segments:
+  - 0
+  - 3
+  - 0
+  prerelease: false
+  segments_generated: true
 platform: ruby
 authors:
 - Rafael García
 - Luis Ciudad
 - Pedro Navajas
 - Javier Aranda
-autorequire: 
+autorequire: !!null 
 bindir: bin
 cert_chain: []
-date: 2011-10-27 00:00:00.000000000 +02:00
-default_executable: 
+date: 2012-01-17 00:00:00.000000000 +01:00
+default_executable: !!null 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &21080560 !ruby/object:Gem::Requirement
+  requirement: &32400380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.8.7
+        segments:
+        - 0
+        - 8
+        - 7
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21080560
+  version_requirements: *32400380
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &21079240 !ruby/object:Gem::Requirement
+  requirement: &32398960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.6.8
+        segments:
+        - 0
+        - 6
+        - 8
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21079240
+  version_requirements: *32398960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &21076920 !ruby/object:Gem::Requirement
+  requirement: &32397820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.5.0
+        segments:
+        - 2
+        - 5
+        - 0
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21076920
+  version_requirements: *32397820
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &21075340 !ruby/object:Gem::Requirement
+  requirement: &32396420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.10.2
+        segments:
+        - 0
+        - 10
+        - 2
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21075340
+  version_requirements: *32396420
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &21070000 !ruby/object:Gem::Requirement
+  requirement: &32388060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.6.0
+        segments:
+        - 1
+        - 6
+        - 0
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21070000
+  version_requirements: *32388060
 - !ruby/object:Gem::Dependency
   name: bluecloth
-  requirement: &21067180 !ruby/object:Gem::Requirement
+  requirement: &32386220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.1.0
+        segments:
+        - 2
+        - 1
+        - 0
+        segments_generated: true
   type: :development
   prerelease: false
-  version_requirements: *21067180
+  version_requirements: *32386220
 description: Convert a executable command in a Ruby-like class you are able to start,
   define params and send signals (like kill, or stop)
 email:
@@ -105,7 +140,7 @@ has_rdoc: true
 homepage: http://github.com/nosolosoftware/runnable
 licenses:
 - GPL-3
-post_install_message: 
+post_install_message: !!null 
 rdoc_options: []
 require_paths:
 - lib
@@ -117,17 +152,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -599557484973593353
+      segments_generated: true
+      hash: -3646317310813273179
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      segments_generated: true
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.6.2
-signing_key: 
+rubyforge_project: !!null 
+rubygems_version: 1.3.7
+signing_key: !!null 
 specification_version: 3
 summary: A Ruby gem for execute and control system commands
 test_files: []