scripted 0.0.1

data/features/formatters.feature

@@ -0,0 +1,142 @@
+Feature: Formatters
+
+  You can specify multiple formatters, similar to RSpec formatters.
+
+  This is done, either via the command line or via the configuration.
+
+  A formatter needs a name and optionally an output.
+
+  In the following example, the default output (the output of your commands)
+  will be written to the file `out.txt` but the announcer formatter will print
+  to the terminal.
+
+      $ scripted -f default -o out.txt -f announcer
+
+  To specify a formatter in the configuration:
+
+  ``` ruby
+  formatter "default", :out => "out.txt"
+  formatter "announcer"
+
+  run "bundle install"
+  ```
+
+  If you don't specify a format, only the default formatter will be used. If
+  you specify a formatter, the default won't be used, so you won't see any
+  output.
+
+  There are a couple of formatters included, such as `default`, `table`,
+  `announcer`, `websocket` and `stats`. If you want to add your own, just use
+  the complete class name as a formatter.
+
+      $ scripted -f MyAwesome::Formatter
+
+  Take a look at the included formatters to see how to make your own.
+
+  Scenario: Saving output to a file
+    Given the configuration:
+    """
+    run "echo Hi there"
+    """
+    When I run `scripted -f default -o output.txt`
+    Then the output should not contain "Hi there"
+    But the file "output.txt" should contain "Hi there"
+
+  Scenario: Multiple outputs
+    Given the configuration:
+    """
+    run "echo Hello there"
+    """
+    When I run `scripted -f default -o output.txt -f announcer -o announce.txt`
+    Then the file "output.txt" should contain "Hello there"
+    And the file "announce.txt" should contain:
+    
+    """
+    ┌────────────────────────────────────────────────┐
+    │                echo Hello there                │
+    └────────────────────────────────────────────────┘
+    """
+
+  Scenario: Status table formatter
+    Given the configuration:
+    """
+    run "true"
+    run "true"
+    run "false"
+    run "true"
+    """
+    When I run `scripted -f table`
+    Then it should fail with:
+    """
+    ┌─────────┬─────────┬─────────┐
+    │ Command │ Runtime │ Status  │
+    ├─────────┼─────────┼─────────┤
+    """
+
+  Scenario: Announcer formatter
+    Given the configuration:
+    """
+    run "echo hi there"
+    """
+    When I run `scripted -f announcer -f default`
+    Then the output should contain:
+    """
+    ┌────────────────────────────────────────────────┐
+    │                 echo hi there                  │
+    └────────────────────────────────────────────────┘
+
+    hi there
+    """
+
+  Scenario: Stats output
+    Given the configuration:
+    """
+    run "echo hi there"
+    """
+    When I run `scripted -f stats`
+    Then the output should contain:
+    """
+    name,runtime,status
+    """
+
+  Scenario: Custom formatter
+    Given a file named "my_awesome/formatter.rb" with:
+    """
+    require 'scripted/formatters/blank'
+    module MyAwesome
+      class Formatter < Scripted::Formatters::Blank
+
+        def execute(command)
+          puts "I am now starting #{command.name}"
+        end
+
+      end
+    end
+    """
+    And the configuration:
+    """
+    run "true"
+    """
+    When I run `scripted -f MyAwesome::Formatter -I .`
+    Then it should pass with:
+    """
+    I am now starting true
+    """
+
+  Scenario: Custom Formatter in the configuration
+    Given the configuration:
+    """
+    require 'scripted/formatters/blank'
+    class MyFormatter < Scripted::Formatters::Blank
+      def execute(command)
+        puts "I am now starting #{command.name}"
+      end
+    end
+    formatter MyFormatter
+    run "true"
+    """
+    When I run `scripted`
+    Then it should pass with:
+    """
+    I am now starting true
+    """

data/features/rake_integration.feature

@@ -0,0 +1,86 @@
+Feature: Rake Integration
+
+  Scripted has support for Rake.
+
+  You can either let it pick up your "scripted.rb" file, or define the commands
+  in place.
+
+  When you don't specify a block, it will pick up your "scripted.rb" file:
+
+  ``` ruby
+  require 'scripted/rake_task'
+  Scripted::RakeTask.new(:scripted)
+  ```
+
+  When you specify a block, it will use this block to execute:
+
+  ``` ruby
+  require 'scripted/rake_task'
+  Scripted::RakeTask.new(:scripted) do
+    run "echo from inside rakefile"
+  end
+  ```
+
+  The rake command will run the default group by default. To change this, specify the group:
+
+  ``` ruby
+  require 'scripted/rake_task'
+  Scripted::RakeTask.new(:install, :install)
+  ```
+
+  You can also specify Rake dependencies:
+
+  ``` ruby
+  require 'scripted/rake_task'
+  Scripted::RakeTask.new(:my_task => "db:migrate")
+  ```
+
+  Scenario: Picking up scripted.rb
+
+    Given a file named "scripted.rb" with:
+    """
+    run "echo command 1"
+    """
+
+    And a file named "Rakefile" with:
+    """
+    require 'scripted/rake_task'
+    Scripted::RakeTask.new(:scripted)
+    """
+
+    When I run `rake scripted`
+    Then the output should contain "command 1"
+
+  Scenario: Specifying different groups
+
+    Given a file named "scripted.rb" with:
+    """
+    run "echo command 1"
+    group :install do
+      run "echo install command"
+    end
+    """
+
+    And a file named "Rakefile" with:
+    """
+    require 'scripted/rake_task'
+    Scripted::RakeTask.new(:scripted, :install)
+    """
+
+    When I run `rake scripted`
+    Then the output should contain "install command"
+    But the output should not contain "command 1"
+
+
+  Scenario: Configuring in place
+
+    Given a file named "Rakefile" with:
+    """
+    require 'scripted/rake_task'
+    Scripted::RakeTask.new(:scripted) do
+      run "echo from inside rakefile"
+    end
+    """
+    And the file "scripted.rb" should not exist
+    When I run `rake scripted`
+    Then the output should contain "from inside rakefile"

data/features/running_commands_in_parallel.feature

@@ -0,0 +1,27 @@
+Feature: Running Commands in Parallel
+
+  Commands can be run in parallel. Simply put a `parallel` block around them.
+
+  ``` ruby
+  parallel do
+    run "rspec"
+    run "cucumber"
+  end
+  ```
+
+  Scenario: Parallel
+
+    Given the configuration:
+    """
+    parallel do
+      run "sleep 1"
+      run "sleep 1"
+    end
+    parallel do
+      run "sleep 1"
+      run "sleep 1"
+      run "sleep 1"
+    end
+    """
+    When I run `scripted -f table`
+    Then it should have taken about 2 seconds

data/features/running_from_command_line.feature

@@ -0,0 +1,56 @@
+Feature: Running from the Command Line
+
+  Scripted comes with a executable to run commands. This requires you to have
+  a configuration file somewhere. The default configuration file is
+  `scripted.rb`, allowing you to run scripted without passing any commands.
+
+      $ scripted
+
+  If you want to store your configuration file somewhere else,
+  you can specify it with the `-r` or `--require` option:
+
+      $ scripted -r foo.rb
+
+  To get more information, about the options, run:
+
+      $ scripted --help
+
+  Scenario: Running some commands
+
+    Given a file named "scripted.rb" with:
+    """
+    run "echo command 1"
+    run "echo command 2"
+    """
+    When I run `scripted`
+    Then it should pass
+    And the output should contain "command 1"
+    And the output should contain "command 2"
+
+  Scenario: By specifying another file
+
+    Given a file named "something_else.rb" with:
+    """
+    run "echo 1"
+    run "echo 2"
+    """
+    When I run `scripted -r something_else.rb`
+    Then it should pass
+
+  Scenario: With a non existing file
+    When I run `scripted -r nope.rb`
+    Then it should fail with regexp:
+    """
+    ^No such file -- .*nope.rb$
+    """
+
+  Scenario: Without `scripted.rb`
+    When I run `scripted`
+    Then it should fail with regexp:
+    """
+    ^No such file -- .*scripted.rb$
+    """
+    And the output should contain:
+    """
+    Either create a file called 'scripted.rb', or specify another file to load
+    """

data/features/running_from_ruby.feature

@@ -0,0 +1,38 @@
+Feature: Running from Ruby
+
+  If you want to use scripted from within your own Ruby application, you can
+  define and run your scripts in place.
+
+  Scenario: Configuring and running directly
+
+    Given a file named "app.rb" with:
+    """
+    require 'scripted'
+    Scripted.run do
+      run "echo welcome from shell within Ruby"
+    end
+    """
+
+    When I run `ruby app.rb`
+    Then the output should contain "welcome from shell within Ruby"
+
+  Scenario: Defining a configuration and running later
+    Given a file named "app.rb" with:
+    """
+    require 'scripted'
+
+    configuration = Scripted.configure do
+      run "echo welcome from shell within Ruby"
+    end
+
+    puts "Not running yet at this point"
+
+    Scripted.run(configuration)
+    """
+
+    When I run `ruby app.rb`
+    Then the output should contain:
+    """
+    Not running yet at this point
+    welcome from shell within Ruby
+    """

data/features/running_groups.feature

@@ -0,0 +1,39 @@
+Feature: Running Groups
+
+  You can specify multiple groups and use the command line option "--group" or
+  "-g" to run only that group.
+
+  If you don't specify a group, it will run the default group. And if you don't
+  specify which group a command is in, it will be in the default group.
+
+  Example:
+
+  ``` ruby
+  group :install do
+    run "bundle install"
+  end
+  ```
+
+  Background:
+    Given the configuration:
+    """
+    run "echo from the default group"
+    group :install do
+      run "echo from the install group"
+    end
+    """
+
+  Scenario: Running the default group.
+    When I run `scripted`
+    Then the output should contain "from the default group"
+    But the output should not contain "from the install group"
+
+  Scenario: Running another group
+    When I run `scripted -g install`
+    Then the output should contain "from the install group"
+    But the output should not contain "from the default group"
+
+  Scenario: Running multiple groups
+    When I run `scripted -g install,default`
+    Then the output should contain "from the install group"
+    And the output should contain "from the default group"

data/features/specifying_which_commands_to_run.feature

@@ -0,0 +1,122 @@
+Feature: Specifying which Command to Run
+
+  By default the name of the command is the shell command to be run.
+
+  There are a number of different runners.
+
+  * Shell commands (the default)
+  * Rake commands
+  * Ruby commands
+
+  Shell commands can be specified by using backticks, or the `sh` method:
+
+  ``` ruby
+  run "javascript tests" do
+    `cucumber --tags @javascript`
+  end
+  ```
+
+  Rake commands will try to run in the same process if you also happen to use
+  Rake integration. Otherwise it will just shell out.
+
+  ``` ruby
+  run "migrations" do
+    rake "db:migrate"
+  end
+  ```
+
+  Ruby commands will just execute a block. If you want to fail a ruby command,
+  just raise an exception.
+
+  ``` ruby
+  run "version check" do
+    ruby do
+      fail "incorrect version" if Scripted::VERSION != "1.0"
+    end
+  end
+  ```
+
+  Scenario: Choosing a different shell command
+
+    Given the configuration:
+    """
+    run "the name" do
+      sh "echo the command output"
+    end
+    """
+    When I run `scripted`
+    Then the output should contain "the command output"
+
+  Scenario: Choosing a different shell command with backticks
+
+    Given the configuration:
+    """
+    run "the name" do
+      `echo the command output`
+    end
+    """
+    When I run `scripted`
+    Then the output should contain "the command output"
+
+
+
+  Scenario: Running a rake command outside rake
+    Given a file named "Rakefile" with:
+    """
+    namespace :db do
+      task :migrate do
+        puts "the rake task ran"
+      end
+    end
+    """
+    And the configuration:
+    """
+    run "rake" do
+      rake "db:migrate"
+    end
+    """
+    When I run `scripted`
+    Then it should pass
+    And the output should contain "the rake task ran"
+
+  Scenario: Running a rake command from within Rake
+
+    If you are running rake inside rake, it will use the normal invocation
+    pattern, so dependencies will not be run again.
+
+    Given a file named "Rakefile" with:
+    """
+    task :setup do
+      raise "setup ran again" if File.exist?("foo")
+      `touch foo`
+    end
+    task :migrate => :setup do
+      puts "the rake task ran"
+    end
+    require 'scripted/rake_task'
+    Scripted::RakeTask.new(:scripted => [:setup]) do
+      run "migrate" do
+        rake "migrate"
+      end
+    end
+    task :both => [:setup, :scripted]
+    """
+    When I run `rake both`
+    Then it should pass
+    Then the output should contain "the rake task ran"
+
+  Scenario: Running pure ruby
+
+    Given the configuration:
+    """
+    run "some ruby code" do
+      ruby { puts "the command" }
+    end
+    run "some failing ruby code" do
+      ruby { raise "this command failed" }
+    end
+    """
+    When I run `scripted`
+    Then it should fail
+    And the output should contain "the command"
+    And the output should contain "this command failed"