go_run 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9988225c09ce3743832a8caf4fdd6aee87159150
+  data.tar.gz: b9eff09dc56eeceb496ca0192728fcca5a9a9c10
+SHA512:
+  metadata.gz: 153fd74b86a8a62f6ef7a0d111c44b98c837dc1b112541db278aaa3d52d3529f6f9b826fd323c2dca3ff061599558fc5f74c01e5d273771c43559fe0a46b4fab
+  data.tar.gz: f3baf4092391b8be45f7bfe3958e542b3e1ff47c1d405b6a3de9e712ad36c6e18d5e067ca71f69b88515931d759ba0f2d6a23c86aac3fbf1a09fa4f6b30ae6e2

data/bin/run

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../lib/go_run"
+
+GoRun.new(ARGV)

data/lib/go_run/parser.rb

@@ -0,0 +1,115 @@
+require 'yaml'
+
+class Parser
+  attr_reader :config
+
+  def initialize(config_file_path)
+    @config = {}
+    parse(YAML.load_file(config_file_path))
+  end
+
+  def parse(config)
+    if config.is_a? Hash
+      config.each { |target, lines|
+        initialise_target(target)
+        if lines.is_a? Array
+          lines.each { |line|
+            if line.is_a? String
+              parse_line(target, line)
+            else
+              raise "Configuration error: each line of a target should be a string"
+            end
+          }
+        else
+          raise "Configuration error: each target should be an array of strings"
+        end
+      }
+    else
+      raise "Configuration error: config is not a hash"
+    end
+  end
+
+  def parse_line(target, line)
+    match = /^(GROUP|SET|REQUIRE|CALL|RUN)(.*)/.match line
+    if not match.nil?
+      capture = match.captures[1].strip
+      case match.captures[0]
+      when 'GROUP'
+        add_group(target, capture)
+      when 'SET'
+        add_set(target, capture)
+      when 'REQUIRE'
+        add_require(target, capture)
+      when 'CALL'
+        add_call(target, capture)
+      when 'RUN'
+        add_run(target, capture)
+      end
+    else
+      raise "Configuration error: target lines should match /^(GROUP|SET|REQUIRE|CALL|RUN)/"
+    end
+  end
+
+  def add_group(target, groups)
+    initialise_action(target, "group")
+    @config[target]["group"] += groups.split(' ')
+  end
+
+  def add_set(target, capture)
+    initialise_action(target, "set")
+    @config[target]["set"] << parse_set(capture)
+  end
+
+  def add_require(target, capture)
+    initialise_action(target, "requires")
+    @config[target]["requires"] << parse_require(capture)
+  end
+
+  def add_call(target, call)
+    initialise_action(target, "call")
+    c = {"target" => call}
+    @config[target]["call"] << c
+  end
+
+  def add_run(target, command)
+    initialise_action(target, "commands")
+    @config[target]["commands"] << command
+  end
+
+  def parse_set(set)
+    match = /^([a-zA-Z][a-zA-Z0-9_]*) (.*)$/.match set
+    if not match.nil?
+      s = {"key" => match.captures[0], "value" => match.captures[1]}
+    else
+      raise "Configuration error: SET syntax is 'SET KEY value'"
+    end
+    return s
+  end
+
+  def parse_require(requirement)
+    match = /^([a-zA-Z][a-zA-Z0-9_]*)$/.match requirement
+    if not match.nil?
+      r = {"key" => match.captures[0]}
+    else
+      match = /^([a-zA-Z][a-zA-Z0-9_]*) default (.*)$/.match requirement
+      if not match.nil?
+        r = {"key" => match.captures[0], "default" => match.captures[1]}
+      else
+        raise "Configuration error: REQUIRE syntax is 'REQUIRE KEY' or 'REQUIRE KEY default value'"
+      end
+    end
+    return r
+  end
+
+  def initialise_target(target)
+    if not @config.has_key? target
+      @config[target] = {}
+    end
+  end
+
+  def initialise_action(target, action)
+    if not @config[target].has_key? action
+      @config[target][action] = []
+    end
+  end
+end

data/lib/go_run/runner.rb

@@ -0,0 +1,80 @@
+class Runner
+  attr_reader :commands
+
+  def initialize(config)
+    @config = config
+    @commands = []
+    @output = ""
+  end
+
+  def run(targets)
+    targets.each do |target|
+      run_target(target)
+    end
+    @output
+  end
+
+  def run_target(target)
+    raise "Target '#{target}' not found in configuration" if not @config.has_key? target
+    if @config[target].has_key? "group"
+      @config[target]["group"].each do |group|
+        run_target(group)
+      end
+    end
+    if @config[target].has_key? "set"
+      @config[target]["set"].each do |env_var|
+        ENV[env_var["key"]] = env_var["value"]
+      end
+    end
+    if @config[target].has_key? "requires"
+      @config[target]["requires"].each do |requirement|
+        if not requirement_fulfilled?(requirement)
+          @output << "Failed to fulfill requirements for target '#{target}'\n"
+          return
+        end
+      end
+    end
+    if @config[target].has_key? "call"
+      @config[target]["call"].each do |call|
+        run_target(call["target"])
+      end
+    end
+    if @config[target].has_key? "commands"
+      @config[target]["commands"].each do |command|
+        if run_command(command) != 0
+          @output << "Failed to run command '#{command}'\n"
+          return
+        end
+      end
+    end
+  end
+
+  def run_command(command)
+    system(command)
+    @commands << {
+      "command" => command,
+      "exit_code" => $?.exitstatus
+    }
+    $?.exitstatus
+  end
+
+  def requirement_fulfilled?(requirement)
+    if ENV.has_key? requirement["key"]
+      return true
+    elsif requirement.has_key? "default"
+      ENV[requirement["key"]] = requirement["default"]
+      return true
+    else
+      @output << "Environment variable #{requirement["key"]} not set\n"
+    end
+    return false
+  end
+
+  def exit_status
+    non_zero_exit_status = @commands.find { |c| c["exit_code"] != 0 }
+    if non_zero_exit_status.nil?
+      return 0
+    end
+    return non_zero_exit_status["exit_code"]
+  end
+end

data/lib/go_run.rb

@@ -0,0 +1,57 @@
+require_relative "go_run/parser"
+require_relative "go_run/runner"
+require 'optparse'
+require 'ostruct'
+
+class GoRun
+  def initialize(args)
+    @options = parse_args(args)
+    validate_runfile
+    validate_args
+    run
+  end
+
+  def parse_args(args)
+    options = OpenStruct.new
+    options.runfile = File.expand_path("./Runfile.yml", `pwd`.strip)
+    opt_parser = OptionParser.new do |opts|
+      opts.on("-r", "--runfile RUNFILE_PATH",
+              "Set the location of the Runfile") do |runfile|
+        options.runfile = runfile
+      end
+    end
+    opt_parser.parse!(args)
+    options
+  end
+
+  def validate_runfile
+    if not runfile_exists?
+      puts "Runfile not found: #{@options.runfile}"
+      exit 1
+    end
+  end
+
+  def runfile_exists?
+    File.file? @options.runfile
+  end
+
+  def validate_args
+    if ARGV.length == 0
+      print_usage
+      exit 1
+    end
+  end
+
+  def print_usage
+    puts "You must choose at least one target"
+    puts
+    puts "Example usage:"
+    puts "#{$0} <target> [targets]..."
+  end
+
+  def run
+    runner = Runner.new(Parser.new(@options.runfile).config)
+    runner.run(ARGV)
+    exit runner.exit_status
+  end
+end

data/spec/fixtures/parser/array.yml

@@ -0,0 +1,2 @@
+---
+- RUN ./some-script.sh

data/spec/fixtures/parser/calls.yml

@@ -0,0 +1,5 @@
+---
+some-other-target:
+- RUN ./script.sh
+dev:
+- CALL some-other-target

data/spec/fixtures/parser/commands.yml

@@ -0,0 +1,4 @@
+---
+deploy:
+- RUN echo "deploying..."
+- RUN date

data/spec/fixtures/parser/env-vars.yml

@@ -0,0 +1,4 @@
+---
+dev:
+- REQUIRE ENVIRONMENT
+- REQUIRE REGION default eu-west-1

data/spec/fixtures/parser/group.yml

@@ -0,0 +1,9 @@
+---
+dev:
+- REQUIRE ENVIRONMENT
+
+deploy:
+- RUN ./deploy.sh
+
+dev-deploy:
+- GROUP dev deploy

data/spec/fixtures/parser/set-env-vars.yml

@@ -0,0 +1,3 @@
+---
+dev:
+- SET ENVIRONMENT dev

data/spec/fixtures/parser/target-line-invalid.yml

@@ -0,0 +1,3 @@
+---
+dev:
+- run script.sh

data/spec/fixtures/parser/target-not-an-array-of-strings.yml

@@ -0,0 +1,3 @@
+---
+dev:
+- run: ./script.sh

data/spec/fixtures/parser/target-not-an-array.yml

@@ -0,0 +1,2 @@
+---
+dev: ./run-script.sh

data/spec/fixtures/runfiles/Runfile-with-failures.yml

@@ -0,0 +1,6 @@
+---
+dev:
+- SET AWS_DEFAULT_REGION eu-west-1
+
+deploy:
+- RUN echo $AWS_DEFAULT_REGION; exit 1

data/spec/fixtures/runfiles/Runfile.yml

@@ -0,0 +1,6 @@
+---
+dev:
+- SET AWS_DEFAULT_REGION eu-west-1
+
+deploy:
+- RUN echo $AWS_DEFAULT_REGION

data/spec/go_run_spec.rb

@@ -0,0 +1,44 @@
+require 'go_run'
+require 'open3'
+
+describe GoRun do
+  before(:each) do
+    @binary = File.expand_path("../../bin/run", __FILE__)
+
+    # Make sure no local Runfiles interfere with tests
+    pwd_runfile = File.expand_path("./Runfile.yml", `pwd`.strip)
+    expect(File.file? pwd_runfile).to be(false)
+  end
+
+  context "when no Runfile is provided" do
+    it "should print an error" do
+      stdout, status = Open3.capture2(@binary)
+      expect(stdout).to include("Runfile not found")
+    end
+  end
+
+  context "when no arguments are provided" do
+    it "should print an error" do
+      runfile_path = File.expand_path("spec/fixtures/runfiles/Runfile.yml")
+      stdout, status = Open3.capture2(@binary, "-r", runfile_path)
+      expect(stdout).to include("You must choose at least one target")
+    end
+  end
+
+  context "when arguments are provided" do
+    it "should run the targets" do
+      runfile_path = File.expand_path("spec/fixtures/runfiles/Runfile.yml")
+      stdout, status = Open3.capture2(@binary, "-r", runfile_path, "dev", "deploy")
+      expect(stdout).to include("eu-west-1")
+    end
+  end
+
+  context "when the targeted commands fail" do
+    it "should exit with a non-zero code" do
+      runfile_path = File.expand_path("spec/fixtures/runfiles/Runfile-with-failures.yml")
+      stdout, status = Open3.capture2(@binary, "-r", runfile_path, "dev", "deploy")
+      expect(stdout).to include("eu-west-1")
+      expect(status.exitstatus).to be(1)
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,73 @@
+require 'go_run/parser'
+
+describe Parser do
+  it "should raise an error if it is not a hash" do
+    file_path = File.expand_path("../../spec/fixtures/parser/array.yml", __FILE__)
+    expect{Parser.new(file_path)}.to raise_error(RuntimeError, "Configuration error: config is not a hash")
+  end
+
+  it "should raise an error if a target is not an array" do
+    file_path = File.expand_path("../../spec/fixtures/parser/target-not-an-array.yml", __FILE__)
+    expect{Parser.new(file_path)}.to raise_error(RuntimeError, "Configuration error: each target should be an array of strings")
+  end
+
+  it "should raise an error if a target is not an array of strings" do
+    file_path = File.expand_path("../../spec/fixtures/parser/target-not-an-array-of-strings.yml", __FILE__)
+    expect{Parser.new(file_path)}.to raise_error(RuntimeError, "Configuration error: each line of a target should be a string")
+  end
+
+  it "should raise an error if a target line does not start with a keyword" do
+    file_path = File.expand_path("../../spec/fixtures/parser/target-line-invalid.yml", __FILE__)
+    expect{Parser.new(file_path)}.to raise_error(RuntimeError, "Configuration error: target lines should match /^(GROUP|SET|REQUIRE|CALL|RUN)/")
+  end
+
+  it "should build an array of commands" do
+    file_path = File.expand_path("../../spec/fixtures/parser/commands.yml", __FILE__)
+    config = Parser.new(file_path).config
+    expect(config["deploy"].has_key? "commands").to be(true)
+
+    commands = config["deploy"]["commands"]
+    expect(commands.length).to be(2)
+    expect(commands[0]).to eq('echo "deploying..."')
+    expect(commands[1]).to eq('date')
+  end
+
+  it "should build an array of required env vars and their defaults" do
+    file_path = File.expand_path("../../spec/fixtures/parser/env-vars.yml", __FILE__)
+    config = Parser.new(file_path).config
+    expect(config["dev"].has_key? "requires").to be(true)
+    expect(config["dev"]["requires"].length).to be(2)
+    expect(config["dev"]["requires"][0].has_key? "key").to be(true)
+    expect(config["dev"]["requires"][1].has_key? "default").to be(true)
+    expect(config["dev"]["requires"][1]["default"]).to eq('eu-west-1')
+  end
+
+  it "should build an array of env var key-value pairs to set" do
+    file_path = File.expand_path("../../spec/fixtures/parser/set-env-vars.yml", __FILE__)
+    config = Parser.new(file_path).config
+    expect(config["dev"].has_key? "set").to be(true)
+    expect(config["dev"]["set"].length).to be(1)
+    expect(config["dev"]["set"][0].has_key? "key").to be(true)
+    expect(config["dev"]["set"][0].has_key? "value").to be(true)
+    expect(config["dev"]["set"][0]["key"]).to eq('ENVIRONMENT')
+    expect(config["dev"]["set"][0]["value"]).to eq('dev')
+  end
+
+  it "should build an array of calls to other targets" do
+    file_path = File.expand_path("../../spec/fixtures/parser/calls.yml", __FILE__)
+    config = Parser.new(file_path).config
+    expect(config["dev"].has_key? "call").to be(true)
+    expect(config["dev"]["call"].length).to be(1)
+    expect(config["dev"]["call"][0].has_key? "target").to be(true)
+    expect(config["dev"]["call"][0]["target"]).to eq('some-other-target')
+  end
+
+  it "should build a group of other targets to call" do
+    file_path = File.expand_path("../../spec/fixtures/parser/group.yml", __FILE__)
+    config = Parser.new(file_path).config
+    expect(config["dev-deploy"].has_key? "group").to be(true)
+    expect(config["dev-deploy"]["group"].length).to be(2)
+    expect(config["dev-deploy"]["group"][0]).to eq('dev')
+    expect(config["dev-deploy"]["group"][1]).to eq('deploy')
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,113 @@
+require 'go_run/runner'
+require 'climate_control'
+
+describe Runner do
+  it "runs all commands and records their exit code" do
+    config = {
+      "some_commands" => { "commands" => ["echo 'command 1'", "echo 'command 2'"] }
+    }
+    @runner = Runner.new(config)
+    @runner.run(["some_commands"])
+    expect(@runner.commands.length).to be(2)
+    expect(@runner.commands[0]["exit_code"]).to be(0)
+    expect(@runner.commands[1]["exit_code"]).to be(0)
+  end
+
+  it "stops running commands when a command fails" do
+    config = {
+      "some_commands" => { "commands" => ["echo 'command 1'", "echo 'command 2'; exit 1", "echo 'command 3'"] }
+    }
+    @runner = Runner.new(config)
+    output = @runner.run(["some_commands"])
+    expect(@runner.commands.length).to be(2)
+    expect(@runner.commands[0]["exit_code"]).to be(0)
+    expect(@runner.commands[1]["exit_code"]).to be(1)
+    expect(output).to include("Failed to run command 'echo 'command 2'; exit 1'")
+  end
+
+  it "does not run commands if required environment variables are not set" do
+    config = {
+      "deploy" => {
+        "requires" => [{"key" => "ENVIRONMENT"}],
+        "commands" => ['echo "deploying $ENVIRONMENT"']
+      }
+    }
+    @runner = Runner.new(config)
+    ClimateControl.modify ENVIRONMENT: nil do
+      output = @runner.run(["deploy"])
+      expect(@runner.commands.length).to be(0)
+      expect(output).to include("Environment variable ENVIRONMENT not set")
+    end
+  end
+
+  it "can set environment variables to a default value" do
+    config = {
+      "deploy" => {
+        "requires" => [{"key" => "ENVIRONMENT", "default" => "some value"}],
+        "commands" => ['echo "deploying $ENVIRONMENT"']
+      }
+    }
+    @runner = Runner.new(config)
+    ClimateControl.modify ENVIRONMENT: nil do
+      output = @runner.run(["deploy"])
+      expect(@runner.commands.length).to be(1)
+      expect(ENV['ENVIRONMENT']).to eq("some value")
+    end
+  end
+
+  it "can set environment variables" do
+    config = {
+      "deploy" => {
+        "set" => [{"key" => "ENVIRONMENT", "value" => "dev"}],
+        "commands" => ['echo "deploying $ENVIRONMENT"']
+      }
+    }
+    @runner = Runner.new(config)
+    ClimateControl.modify ENVIRONMENT: nil do
+      output = @runner.run(["deploy"])
+      expect(@runner.commands.length).to be(1)
+      expect(ENV['ENVIRONMENT']).to eq("dev")
+    end
+  end
+
+  it "can call other targets" do
+    config = {
+      "dev" => {
+        "set" => [{"key" => "ENVIRONMENT", "value" => "dev"}]
+      },
+      "deploy" => {
+        "call" => [{"target" => "dev"}],
+        "commands" => ['echo "deploying $ENVIRONMENT"']
+      }
+    }
+    @runner = Runner.new(config)
+    ClimateControl.modify [ENVIRONMENT: nil] do
+      output = @runner.run(["deploy"])
+      expect(ENV['ENVIRONMENT']).to eq("dev")
+      expect(@runner.commands.length).to be(1)
+      expect(@runner.commands[0]["exit_code"]).to be(0)
+    end
+  end
+
+  it "can run groups of targets" do
+    config = {
+      "dev" => {
+        "set" => [{"key" => "ENVIRONMENT", "value" => "dev"}]
+      },
+      "deploy" => {
+        "call" => [{"target" => "dev"}],
+        "commands" => ['echo "deploying $ENVIRONMENT"']
+      },
+      "dev-deploy" => {
+        "group" => ["dev", "deploy"]
+      }
+    }
+    @runner = Runner.new(config)
+    ClimateControl.modify [ENVIRONMENT: nil] do
+      output = @runner.run(["dev-deploy"])
+      expect(ENV['ENVIRONMENT']).to eq("dev")
+      expect(@runner.commands.length).to be(1)
+      expect(@runner.commands[0]["exit_code"]).to be(0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: go_run
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Henry Knott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-29 00:00:00.000000000 Z
+dependencies: []
+description: |
+  GoRun aims to provide a way of configuring commands, scripts, and environment
+  variables for systems administration. Many people use the C compile tool `make`
+  to create hierachical targets which set environment variables and run certain
+  scripts, but without actually using it to compile anything. GoRun is designed
+  specifically for that purpose, with a flexible way of defining your configuration
+  in 'Runfiles', which is analogous to the 'Makefiles' used by `make`.
+email: henrytknott@gmail.com
+executables:
+- run
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/run
+- lib/go_run.rb
+- lib/go_run/parser.rb
+- lib/go_run/runner.rb
+- spec/fixtures/parser/array.yml
+- spec/fixtures/parser/calls.yml
+- spec/fixtures/parser/commands.yml
+- spec/fixtures/parser/env-vars.yml
+- spec/fixtures/parser/group.yml
+- spec/fixtures/parser/set-env-vars.yml
+- spec/fixtures/parser/target-line-invalid.yml
+- spec/fixtures/parser/target-not-an-array-of-strings.yml
+- spec/fixtures/parser/target-not-an-array.yml
+- spec/fixtures/runfiles/Runfile-with-failures.yml
+- spec/fixtures/runfiles/Runfile.yml
+- spec/go_run_spec.rb
+- spec/parser_spec.rb
+- spec/runner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/henrytk/go_run
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A way of not using `make` for running scripts
+test_files: []