shellany 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68dc8a476d023b6991ff72a15f075abfc03ed915
+  data.tar.gz: 56aa1c504f9fce4486a246188b24122910129fe6
+SHA512:
+  metadata.gz: 195ad943cf64c1c16071ebc9ec28f58fca1d5aaf88f7b0f672ee2d1f0a7863147c31abaa67b1ae1bcc6e28c6843e02cacf7dcea39adbe7231fd318bc8d02f512
+  data.tar.gz: 896b8ff16cb676c696e173fbe2bf950004b6fd44a51aa1d97e974401e5195742d8b034adcfeae7b8c82e936362428aa8c5046a1827f5350d3f098ebc5190d3cf

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - ruby-head
+  - jruby
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: rbx
+    - rvm: jruby

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shellany.gemspec
+gemspec development_group: :gem_build_tools
+
+gem "rake", "~> 10.0"
+gem 'nenv', "~> 0.1"
+
+group :test do
+  gem "rspec", "~> 3.1"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Cezary Baginski
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Shellany
+
+Shellany captures command output.
+
+## Features:
+
+- portability (should work on recent JRuby versions)
+- capturing stdout, stderr in a convenient way
+- returning the result in a convenient way
+- detecting if a shell is needed (though incomplete/primitive implementation)
+- prevents running the same command multiple times
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shellany'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shellany
+
+## Usage
+
+Basic usage:
+
+```ruby
+require 'shellany/sheller'
+
+Shellany::Sheller.stdout("echo abc") # => "abc"
+Shellany::Sheller.stderr("touch /foo") # => "touch: cannot touch  ‘/aef’: Permission denied
+Shellany::Sheller.run("false") # => false
+Shellany::Sheller.system("clear") # => clears screen (no capture done)
+```
+
+Using Sheller object:
+
+```ruby
+require 'shellany/sheller'
+
+sh = Shellany::Sheller.new('grep /etc/passed|tail -n 1') # does nothing
+
+sh.stdout # shows output (runs the command since it wasn't run)
+sh.stderr # shows stderr (does not run the command)
+sh.ok? # returns true if exit code was zero (does not run the command)
+```
+
+## Project status
+
+Only developed enough for Guard to run, though pull requests are more than welcome.
+
+Especially for:
+
+- better API
+- better shell detection code
+- better support for various system() arguments
+- better support for redireciton handling
+- better support for shell detection (e.g. Windows)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/shellany/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'nenv'
+
+default_tasks = []
+
+require 'rspec/core/rake_task'
+default_tasks  << RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = Nenv.ci?
+end
+
+task default: default_tasks.map(&:name)
+

data/lib/shellany.rb

@@ -0,0 +1,5 @@
+require "shellany/version"
+
+module Shellany
+  # Your code goes here...
+end

data/lib/shellany/sheller.rb

@@ -0,0 +1,144 @@
+require "open3"
+
+module Shellany
+  # The Guard sheller abstract the actual subshell
+  # calls and allow easier stubbing.
+  #
+  class Sheller
+    attr_reader :status
+
+    # Creates a new Guard::Sheller object.
+    #
+    # @param [String] args a command to run in a subshell
+    # @param [Array<String>] args an array of command parts to run in a subshell
+    # @param [*String] args a list of command parts to run in a subshell
+    #
+    def initialize(*args)
+      fail ArgumentError, "no command given" if args.empty?
+      @command = args
+      @ran = false
+    end
+
+    # Shortcut for new(command).run
+    #
+    def self.run(*args)
+      new(*args).run
+    end
+
+    # Shortcut for new(command).run.stdout
+    #
+    def self.stdout(*args)
+      new(*args).stdout
+    end
+
+    # Shortcut for new(command).run.stderr
+    #
+    def self.stderr(*args)
+      new(*args).stderr
+    end
+
+    # Runs the command.
+    #
+    # @return [Boolean] whether or not the command succeeded.
+    #
+    def run
+      unless ran?
+        status, output, errors = self.class._system_with_capture(*@command)
+        @ran = true
+        @stdout = output
+        @stderr = errors
+        @status = status
+      end
+
+      ok?
+    end
+
+    # Returns true if the command has already been run, false otherwise.
+    #
+    # @return [Boolean] whether or not the command has already been run
+    #
+    def ran?
+      @ran
+    end
+
+    # Returns true if the command succeeded, false otherwise.
+    #
+    # @return [Boolean] whether or not the command succeeded
+    #
+    def ok?
+      run unless ran?
+
+      @status && @status.success?
+    end
+
+    # Returns the command's output.
+    #
+    # @return [String] the command output
+    #
+    def stdout
+      run unless ran?
+
+      @stdout
+    end
+
+    # Returns the command's error output.
+    #
+    # @return [String] the command output
+    #
+    def stderr
+      run unless ran?
+
+      @stderr
+    end
+
+    # No output capturing
+    #
+    # NOTE: `$stdout.puts system('cls')` on Windows won't work like
+    # it does for on systems with ansi terminals, so we need to be
+    # able to call Kernel.system directly.
+    def self.system(*args)
+      _system_with_no_capture(*args)
+    end
+
+    def self._system_with_no_capture(*args)
+      Kernel.system(*args)
+      result = $?
+      errors = (result == 0) || "Guard failed to run: #{args.inspect}"
+      [result, nil, errors]
+    end
+
+    def self._system_with_capture(*args)
+      # We use popen3, because it started working on recent versions
+      # of JRuby, while JRuby doesn't handle options to Kernel.system
+      args = _shellize_if_needed(args)
+
+      stdout, stderr, status = nil
+      Open3.popen3(*args) do |_stdin, _stdout, _stderr, _thr|
+        stdout = _stdout.read
+        stderr = _stderr.read
+        status = _thr.value
+      end
+
+      [status, stdout, stderr]
+    rescue Errno::ENOENT, IOError => e
+      [nil, nil, "Guard::Sheller failed (#{e.inspect})"]
+    end
+
+    # Only needed on JRUBY, because MRI properly detects ';' and metachars
+    def self._shellize_if_needed(args)
+      return args unless RUBY_PLATFORM == "java"
+      return args unless args.size == 1
+      return args unless /[;<>]/ =~ args.first
+
+      # NOTE: Sheller was originally meant for Guard (which basically only uses
+      # UNIX commands anyway) and JRuby doesn't support options to
+      # Kernel.system (and doesn't automatically shell when there's a
+      # metacharacter in the command).
+      #
+      # So ... I'm assuming /bin/sh exists - if not, PRs are welcome,
+      # because I have no clue what to do if /bin/sh doesn't exist.
+      # (use ENV["RUBYSHELL"] ? Detect cmd.exe ?)
+      ["/bin/sh", "-c", args.first]
+    end
+  end
+end

data/lib/shellany/version.rb

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

data/shellany.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shellany/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shellany"
+  spec.version       = Shellany::VERSION
+  spec.authors       = ["Cezary Baginski"]
+  spec.email         = ["cezary@chronomantic.net"]
+  spec.summary       = %q{Simple, somewhat portable command capturing}
+  spec.description   = %q{MRI+JRuby compatible command output capturing}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+end

data/spec/lib/shellany/sheller_spec.rb

@@ -0,0 +1,141 @@
+require "shellany/sheller"
+
+RSpec.describe Shellany::Sheller, :sheller_specs do
+  before do
+    allow(Kernel).to receive(:system) do |args|
+      fail "Stub called with: #{args.inspect}"
+    end
+  end
+
+  subject { described_class }
+
+  context "without a command" do
+    [:new, :run, :stdout, :stderr].each do |meth|
+      describe ".#{meth}" do
+        specify do
+          expect { subject.send(meth) }.
+            to raise_error ArgumentError, "no command given"
+        end
+      end
+    end
+  end
+
+  context "with shell (string) cmd returning success" do
+    let(:cmd) { "ls -l" }
+    let(:output) { "foo.rb\n" }
+    let(:errors) { "" }
+    let(:result) do
+      [instance_double(Process::Status, success?: true), output, errors]
+    end
+
+    context "when constructed with a cmd" do
+      subject { described_class.new(cmd) }
+
+      describe "#run" do
+        it "runs the command given to constructor" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(cmd).and_return(result)
+          subject.run
+        end
+      end
+    end
+  end
+
+  context "with array cmd returning success" do
+    let(:cmd) { %w(ls -l) }
+    let(:output) { "foo.rb\n" }
+    let(:errors) { "" }
+    let(:result) do
+      [instance_double(Process::Status, success?: true), output, errors]
+    end
+
+    describe "when used as class" do
+      describe ".run" do
+        it "runs the given command" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+          subject.run(*cmd)
+        end
+      end
+
+      describe ".new" do
+        it "does not run anything" do
+          expect(described_class).to_not receive(:_system_with_capture)
+          subject
+        end
+      end
+
+      describe ".stdout" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stdout(*cmd)).to eq "foo.rb\n"
+        end
+      end
+
+      describe ".stderr" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns errors" do
+          expect(subject.stderr(*cmd)).to eq ""
+        end
+      end
+    end
+
+    context "when constructed with a cmd" do
+      subject { described_class.new(*cmd) }
+
+      it "does not run anything" do
+        expect(described_class).to_not receive(:_system_with_capture)
+        subject
+      end
+
+      describe "#run" do
+        it "runs the command given to constructor" do
+          expect(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+          subject.run
+        end
+      end
+
+      describe "#stdout" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stdout).to eq "foo.rb\n"
+        end
+      end
+
+      describe "#stderr" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject.stderr).to eq ""
+        end
+      end
+
+      describe "#ok?" do
+        before do
+          allow(described_class).to receive(:_system_with_capture).
+            with(*cmd) { result }
+        end
+
+        it "runs command and returns output" do
+          expect(subject).to be_ok
+        end
+      end
+    end
+  end
+end

data/spec/shellany_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Shellany do
+  it 'has a version number' do
+    expect(Shellany::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  # config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: shellany
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cezary Baginski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: MRI+JRuby compatible command output capturing
+email:
+- cezary@chronomantic.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shellany.rb
+- lib/shellany/sheller.rb
+- lib/shellany/version.rb
+- shellany.gemspec
+- spec/lib/shellany/sheller_spec.rb
+- spec/shellany_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Simple, somewhat portable command capturing
+test_files:
+- spec/lib/shellany/sheller_spec.rb
+- spec/shellany_spec.rb
+- spec/spec_helper.rb