command_exec 0.0.1

data/.gitignore

@@ -0,0 +1,52 @@
+.$*$
+.*
+*.*~
+*.acn
+*.acr
+*.alg
+*.aux
+*.auxlock
+*.bak
+*.bbl
+*.blg
+.bundle
+coverage/
+doc/yardoc/
+*.dvi
+*.fdb_latexmk
+*.fls
+*.gem
+!.git*
+*.glg
+*.glo
+*.gls
+*.htm
+*.html
+*.idx
+*.ilg
+*.ind
+*.ist
+*.loc
+*.lof
+*.log
+*.log
+*.lol
+*.lot
+*.nlo
+*.nls
+nohup*
+*.old
+*.out
+pkg/
+pkg/*
+.rvmrc
+*.s??
+*.s*p
+*.synctex.gz*
+*.tex.meta
+*.toc
+.yardoc
+tmp/
+*.pdf
+!doc/*/*.pdf
+*.pid

data/Gemfile

@@ -0,0 +1,24 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ruby-pdflatex.gemspec
+gemspec
+
+group :development do
+  gem 'cucumber'
+  gem 'fakefs'
+  gem 'fuubar'
+  gem 'github-markup'
+  gem 'guard'
+  gem 'guard-cucumber'
+  gem 'guard-rspec'
+  gem 'guard-yard'
+  gem 'libnotify'
+  gem 'pry'
+  gem 'rb-inotify'
+  gem 'rb-readline'
+  gem 'redcarpet' , '~>1.17.2'
+  gem 'rspec'
+  gem 'simplecov'
+  gem 'terminal_multiplexer'
+  gem 'yard'
+end

data/Gemfile.lock

@@ -0,0 +1,101 @@
+PATH
+  remote: .
+  specs:
+    command_exec (0.0.1)
+      POpen4
+      colored
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    POpen4 (0.1.4)
+      Platform (>= 0.4.0)
+      open4
+    Platform (0.4.0)
+    builder (3.0.0)
+    coderay (1.0.5)
+    colored (1.2)
+    cucumber (1.1.9)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.9.0)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    fakefs (0.4.0)
+    ffi (1.0.11)
+    fuubar (1.0.0)
+      rspec (~> 2.0)
+      rspec-instafail (~> 0.2.0)
+      ruby-progressbar (~> 0.0.10)
+    gherkin (2.9.1)
+      json (>= 1.4.6)
+    github-markup (0.7.1)
+    guard (1.0.1)
+      ffi (>= 0.5.0)
+      thor (~> 0.14.6)
+    guard-cucumber (0.7.5)
+      cucumber (>= 0.10)
+      guard (>= 0.8.3)
+    guard-rspec (0.6.0)
+      guard (>= 0.10.0)
+    guard-yard (1.0.2)
+      guard (>= 0.2.2)
+      yard (>= 0.7.0)
+    highline (1.6.11)
+    json (1.6.5)
+    libnotify (0.7.2)
+    method_source (0.7.1)
+    multi_json (1.1.0)
+    open4 (1.3.0)
+    pry (0.9.8.4)
+      coderay (~> 1.0.5)
+      method_source (~> 0.7.1)
+      slop (>= 2.4.4, < 3)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rb-readline (0.4.2)
+    redcarpet (1.17.2)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.0)
+      diff-lcs (~> 1.1.3)
+    rspec-instafail (0.2.2)
+    rspec-mocks (2.9.0)
+    ruby-progressbar (0.0.10)
+    simplecov (0.6.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    slop (2.4.4)
+    term-ansicolor (1.0.7)
+    terminal_multiplexer (1.0.2)
+      highline
+    thor (0.14.6)
+    yard (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  command_exec!
+  cucumber
+  fakefs
+  fuubar
+  github-markup
+  guard
+  guard-cucumber
+  guard-rspec
+  guard-yard
+  libnotify
+  pry
+  rb-inotify
+  rb-readline
+  redcarpet (~> 1.17.2)
+  rspec
+  simplecov
+  terminal_multiplexer
+  yard

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,6 @@
+command-exec(1) -- execute shell commands with ease
+===================================================
+
+## DESCRIPTION
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/command_exec.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "command_exec/version"
+
+Gem::Specification.new do |s|
+  s.name        = "command_exec"
+  s.version     = CommandExec::VERSION
+  s.authors     = ["Max Meyer"]
+  s.email       = ["dev@fedux.org"]
+  s.homepage    = ""
+  s.summary     = %q{Helper gem to exectue arbitrary shell commands}
+  s.description = %q{This adds bells and whistles to ease shell command execution}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency 'POpen4'
+  s.add_runtime_dependency 'colored'
+end

data/lib/command_exec/command.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+
+require 'popen4'
+require 'colored'
+require 'logger'
+
+# Classes concerning command execution
+module CommandExec
+  # Run commands
+  class Command
+
+    attr_accessor :logfile, :options , :parameter, :error_keywords
+    attr_reader :result, :path, :working_directory
+
+    # Create a new command to execute
+    #
+    # @param [Symbol] name name of command
+    # @param [optional,Hash] opts options for the command
+    # @option opts [String] :options options for binary
+    # @option opts [String] :parameter parameter for binary
+    # @option opts [String] :error_keywords keyword indicating an error on stdout
+    # @option opts [String] :working_directory working directory where the process should run in
+    # @option opts [String] :logfile file path to log file of process
+    def initialize(name,opts={})
+
+      @name = name
+      @opts = {
+        :logger => Logger.new($stderr),
+        :options => '',
+        :parameter => '',
+        :error_keywords => [],
+        :working_directory => Dir.pwd,
+        :logfile => '',
+        :debug => false,
+      }.update opts
+
+      @logger = @opts[:logger] 
+      @options = @opts[:options]
+      @parameter = @opts[:parameter]
+      @path = resolve_cmd_name(name)
+      @error_keywords = @opts[:error_keywords]
+      @logfile = @opts[:logfile]
+
+      @working_directory = @opts[:working_directory] 
+      Dir.chdir(working_directory)
+
+    end
+
+    private
+
+    # Find utility path
+    #
+    # @param [Symbol] name Name of utility
+    # @return [Path] Returns the path to the binary of the binary
+    def resolve_cmd_name(name)
+      path=''
+      path = %x[which #{name} 2>/dev/null].chomp
+
+      if path.empty?
+        @logger.fatal("Command not found #{name}")
+        raise Exceptions::CommandNotFound 
+      end
+
+      return path
+    end
+
+    # Build string to execute command
+    #
+    # @return [String] Returns to whole command with parameters and options
+    def build_cmd_string
+      cmd = ''
+      cmd += path
+      cmd += options.empty? ? "" : " #{options}"
+      cmd += parameter.empty? ? "" : " #{parameter}"
+
+      return cmd
+    end
+
+    # Checks for errors
+    #
+    # @raise [String] 
+
+    public
+
+    # Output the textual representation of a command
+    #
+    # @return [String] command in text form
+    def to_txt
+      return build_cmd_string
+    end
+
+    # Run the program
+    #
+    def run
+
+      _stdout = ''
+      _stderr = ''
+
+      status = POpen4::popen4(build_cmd_string) do |stdout, stderr, stdin, pid|
+        _stdout = stdout.read.strip
+        _stderr = stderr.read.strip
+      end
+
+
+      error_in_stdout_found = error_in_string_found?(error_keywords,_stdout)
+      @result = run_successful?( status.success? ,  error_in_stdout_found ) 
+
+      if @result == false
+        msg = message(
+          @result, 
+          help_output(
+            { 
+              :error_in_exec => not(status.success?), 
+              :error_in_stdout => error_in_stdout_found 
+            }, {
+              :stdout => StringIO.new(_stdout),
+              :stderr => StringIO.new(_stderr),
+              :logfile => read_logfile(logfile),
+            }
+          )
+        )
+      else
+        msg =  message(@result)
+      end
+
+      @logger.info "#{@name.to_s}: #{msg}"
+
+      return @result
+
+    end
+
+    # Read the content of the logfile
+    #
+    # @param [Path] file path to logfile
+    # @param [Integer num_of_lines the number of lines which should be read -- e.g. 30 lines = -30
+    def read_logfile(file, num_of_lines=-30)
+      content = StringIO.new
+
+      unless file.empty? 
+        begin
+          content << File.readlines(logfile)[num_of_lines..-1].join("")
+        rescue Errno::ENOENT
+          @logger.warn "Warning: logfile not found!"
+        end
+      end
+
+      return content
+    end
+
+    # Decide if a program run was successful
+    #
+    # @return [Boolean] Returns the decision
+    def run_successful?(success,error_in_stdout)
+      if success == false or error_in_stdout == true 
+        return false
+      else 
+        return true 
+      end
+    end
+
+    # Decide which output to return to the user
+    # to help him with debugging
+    #
+    # @return [Array] Returns lines of log/stdout/stderr
+    def help_output(error_indicators={},output={})
+      error_in_exec = error_indicators[:error_in_exec]
+      error_in_stdout = error_indicators[:error_in_stdout]
+
+      logfile = output[:logfile].string
+      stdout = output[:stdout].string
+      stderr = output[:stderr].string
+
+      result = []
+
+      if error_in_exec == true
+        result << '================== LOGFILE ================== '
+        result << logfile if logfile.empty? == false 
+        result << '================== STDOUT ================== '
+        result << stdout if stdout.empty? == false
+        result << '================== STDERR ================== '
+        result << stderr if stderr.empty? == false
+      elsif error_in_stdout == true
+        result << '================== STDOUT ================== '
+        result << stdout 
+      end
+
+      return result
+
+    end
+
+    # Find error in stdout
+    # 
+    # @return [Boolean] Returns true if it finds an error
+    def error_in_string_found? (keywords=[], string )
+      return false if keywords.empty? or not keywords.is_a? Array 
+      return false if string.nil? or not string.is_a? String
+
+      error_found = false
+      keywords.each do |word|
+        if string.include? word
+          error_found = true
+          break
+        end
+      end
+
+      return error_found
+
+    end
+
+    # Generate the message which is return to the user
+    # 
+    # @param [Boolean] run_successful true if a positive message should be returned
+    # @param [Array] msg Message which should be returned
+    def message(run_successful, *msg)
+
+      message = []
+      if run_successful
+        message << 'OK'.green.bold
+      else
+        message << 'FAILED'.red.bold
+        message.concat msg.flatten
+      end
+
+      return message.join("\n")
+    end
+
+    # Constructur to initiate a new command and run it later
+    #
+    # @see #initialize
+    def Command.execute(name,opts={})
+      command = new(name,opts)
+      command.run
+
+      return command
+    end
+
+  end
+end

data/lib/command_exec/exceptions.rb

@@ -0,0 +1,20 @@
+# Main
+module CommandExec
+  # Classed concerning pdflatex exceptions
+  module Exceptions
+    # Class used to indicate that a command 
+    # could not be found in file system
+    class CommandNotFound < RuntimeError
+    end
+    
+    # Class used to indicate that a command run
+    # ended with a failure 
+    class ExecuteCommandFailed < RuntimeError
+    end
+    
+    # Class used to indicate that a logfile
+    # could not be found in file system
+    class LogfileNotFound < RuntimeError
+    end
+  end
+end

data/lib/command_exec/spec_helper_module.rb

@@ -0,0 +1,19 @@
+module CommandExec
+  module SpecHelper
+    def capture_stderr(&block)
+      previous_stderr, $stderr = $stderr, StringIO.new
+      block.call
+      return $stderr.string
+    ensure
+      $stderr = previous_stderr
+    end
+
+    def capture_stdout(&block)
+      previous_stdout, $stdout = $stdout, StringIO.new
+      block.call
+      return $stdout.string
+    ensure
+      $stdout = previous_stdout
+    end
+  end
+end

data/lib/command_exec/version.rb

@@ -0,0 +1,3 @@
+module CommandExec
+    VERSION = "0.0.1"
+end

data/lib/command_exec.rb

@@ -0,0 +1,6 @@
+require 'command_exec/version'
+require 'command_exec/exceptions'
+require 'command_exec/command'
+
+module CommandExec
+end

data/spec/command/command_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Command do
+  let(:logger) {Logger.new('/dev/null')}
+  #let(:logger) {Logger.new($stdout)}
+  let(:debug) {false}
+  #let(:debug) {true}
+  let(:command) { Command.new(:echo , :debug=>debug, :logger => logger, :parameter => "hello world" , :error_keywords => %q[abc def], :working_directory => '/tmp' ) }
+
+
+  it "has a path" do
+    command.path.should == '/bin/echo'
+  end
+
+  it "has parameter" do
+    command.parameter.should == 'hello world'
+  end
+
+  it "has options" do
+    command.options.should == ''
+  end
+
+  it "offers the possibility to change the working directory of the process" do
+    command.working_directory.should == '/tmp'
+    Dir.pwd.should == '/tmp'
+  end
+
+  it "has special keywords indicating errors in stdout" do
+    command.error_keywords.should == %q[abc def]
+  end
+
+  it "can be used to construct a command string, which can be executed" do
+    command = Command.new(:pdflatex, :debug => debug, :logger => logger, :parameter => "index.tex blub.tex", :options => "-a -b")
+    command.send(:build_cmd_string).should == "/usr/bin/pdflatex -a -b index.tex blub.tex"
+  end
+
+  it "runs programms" do
+    command.run
+    command.result.should == true
+  end
+
+  it "returns the textual rep of a command" do
+    command.to_txt.should == '/bin/echo hello world'
+  end
+
+  it "execute existing programs" do
+    command = Command.execute(:echo, :debug => debug, :logger => logger ,:parameter => "index.tex blub.tex", :options => "-- -a -b")
+    command.result.should == true
+  end
+  
+  it "does not execute non-existing programs" do
+    command = Command.execute(:grep, :debug => debug, :logger => logger, :parameter => "index.tex blub.tex", :options => "-- -a -b")
+    command.result.should == false
+  end
+
+  it "checks if errors have happend during execution" do
+    lambda { Command.new(:echo1, :debug => debug, :logger => logger, :parameter => "index.tex blub.tex", :options => "-- -a -b") }.should raise_error CommandNotFound
+  end
+
+  it "decides which output should be returned to the user" do
+    logfile = StringIO.new
+    logfile << 'Error in ... found'
+
+    stderr = StringIO.new
+    stderr << 'Error found'
+
+    stdout = StringIO.new
+    stdout << 'Error found'
+
+    #result = command.send(:help_logger)({ :error_in_exec => true , :error_in_stdout => false} , { :logfile => logfile, :stderr => stderr , :stdout => stdout })
+    result = command.send(:help_output, { :error_in_exec => true , :error_in_stdout => false} , { :logfile => logfile, :stderr => stderr , :stdout => stdout })
+    result.should == ["================== LOGFILE ================== ", "Error in ... found", "================== STDOUT ================== ", "Error found", "================== STDERR ================== ", "Error found"]
+
+    result = command.send(:help_output, { :error_in_exec => false , :error_in_stdout => true} , { :logfile => logfile, :stderr => stderr , :stdout => stdout })
+    result.should == ["================== STDOUT ================== ", "Error found"]
+
+    result = command.send(:help_output, { :error_in_exec => true , :error_in_stdout => true} , { :logfile => logfile, :stderr => stderr , :stdout => stdout })
+    result.should == ["================== LOGFILE ================== ", "Error in ... found", "================== STDOUT ================== ", "Error found", "================== STDERR ================== ", "Error found"]
+
+
+    result = command.send(:help_output, { :error_in_exec => false , :error_in_stdout => false} , { :logfile => logfile, :stderr => stderr , :stdout => stdout })
+    result.should == []
+
+  end
+
+  it "finds errors in stdout" do
+    command.send(:error_in_string_found?, ['error'] , 'long string witherror inside' ).should == true
+    command.send(:error_in_string_found?, ['long', 'inside'] , 'long string witherror inside' ).should == true
+    command.send(:error_in_string_found?, ['error'] , 'long string with erro inside' ).should == false
+  end
+
+  it "output a message" do
+    command.send(:message, false, 'Hello_world').should == "\e[1m\e[31mFAILED\e[0m\e[0m\nHello_world"
+    command.send(:message, true, 'Hello_world').should == "\e[1m\e[32mOK\e[0m\e[0m"
+    command.send(:message, true ).should == "\e[1m\e[32mOK\e[0m\e[0m"
+  end
+
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+#encoding: utf-8
+$LOAD_PATH << File.expand_path('../lib' , File.dirname(__FILE__))
+
+require 'pry'
+require 'stringio'
+
+require 'simplecov'
+SimpleCov.start
+
+require 'command_exec'
+require 'command_exec/spec_helper_module'
+
+include CommandExec
+include CommandExec::Exceptions
+
+RSpec.configure do |c|
+  c.include CommandExec::SpecHelper
+end
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: command_exec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Max Meyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: POpen4
+  requirement: &21841820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21841820
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: &21889840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21889840
+description: This adds bells and whistles to ease shell command execution
+email:
+- dev@fedux.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- command_exec.gemspec
+- lib/command_exec.rb
+- lib/command_exec/command.rb
+- lib/command_exec/exceptions.rb
+- lib/command_exec/spec_helper_module.rb
+- lib/command_exec/version.rb
+- spec/command/command_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Helper gem to exectue arbitrary shell commands
+test_files:
+- spec/command/command_spec.rb
+- spec/spec_helper.rb
+has_rdoc: