drudge 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a8ec87116986aae788c0749caf6dac45b6472a1
+  data.tar.gz: eb37d215512ce79df1574add8a64f12525232dd4
+SHA512:
+  metadata.gz: 64a5c2ca69867c1d5d136b2d77e173b1b24cb5890074039775e1c22369f29aa1dc0cc7e9b7f20177aff79c5fca4f4aae7b6dcfb586bc9427dc5cf542fd90df82
+  data.tar.gz: a797072dc6182895e0ab116032eea9f93040599449ce1e36306221e00c374b48dcb6d85e068a423f04a6a1f0382aebb42966dd3c3c8f8c5ec964619589e735c2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in drudge.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    drudge (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aruba (0.5.4)
+      childprocess (>= 0.3.6)
+      cucumber (>= 1.1.1)
+      rspec-expectations (>= 2.7.0)
+    builder (3.2.2)
+    childprocess (0.5.1)
+      ffi (~> 1.0, >= 1.0.11)
+    coderay (1.1.0)
+    cucumber (1.3.10)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 2.12)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.0.2)
+    diff-lcs (1.2.5)
+    ffi (1.9.3)
+    gem-release (0.7.1)
+    gherkin (2.12.2)
+      multi_json (~> 1.3)
+    method_source (0.8.2)
+    multi_json (1.8.4)
+    multi_test (0.0.3)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.4.7)
+    yard (0.8.7.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aruba (>= 0.4.6)
+  bundler (~> 1.3)
+  cucumber
+  drudge!
+  gem-release
+  pry
+  rake
+  rspec (>= 2.14, < 3.0)
+  yard (>= 0.8.6.1)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013, 2014 Ognen Ivanovski
+
+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,107 @@
+# Drudge
+
+A gem that enables you to write command line automation tools using Ruby 2.0.
+
+
+## Usage
+
+Given a binary file called `cli`:
+
+```ruby
+#!/usr/bin/env ruby 
+
+require 'drudge'
+
+class Cli < Drudge
+
+  desc "Greets people"
+  def greet(from, opening = 'Hi', *messages,  to)
+    puts "#{from} says #{opening}, #{messages.join(', ')} to #{to}"
+  end
+end
+
+Cli.dispatch
+```
+
+Running:
+
+```
+$ ./cli greet Santa 'good day to you' Joe
+Santa says Hi, good day to you to Joe
+
+$ ./cli greet Santa Greetings 'how do you do?' Joe
+Santa says Greetings, how do you do? to Joe
+
+$ ./cli
+error: expected a command:
+
+  cli
+      ^
+
+
+$ ./cli great Santa Joe
+error: unknown command 'great':
+
+    cli great Santa Joe
+        ~~~~~
+
+$ ./cli greet
+error: expected a value for <from>:
+
+    cli greet
+              ^
+
+$ ./cli greet Santa
+error: expected a value for <to>:
+
+    cli greet Santa
+                    ^
+```
+
+## Approach
+
+The philosphy of **Drudge** is to provide a very thin layer over *glue* over normal
+Ruby constructs such as classes and methods that exposes them via a command
+line interface. 
+
+This layer interprets the command line instruction and invokes the identifed
+ruby method using a **very simple** resolution method. From then on, it's just
+normal Ruby! No special life-cycles etc.
+
+Even though this layer is simple, it is built to produce excellent error
+messages on wrong command line input.
+
+Drudge is built for Ruby 2.0 with keyword arguments in mind.
+
+## Why not Thor?
+
+Drudge was inspired by the great work folks did in **Thor**. 
+
+The problem with Thor is that it tries to be two things at once: a build tool
+(aimed on replacing rake) and an automation tool. 
+
+This introduces a number of unnecessary complexities:
+
+  - there are rake-like *namespaces* but also sub commands for automation. These two
+    concepts have a number of nasty interactions which result in many small but annoying bugs
+
+  - it is meant to be used a a stand-alone tool (by invoking `thor` which will look for a 
+    `Thorfile`) but also as a library for building your own tools. This too
+    produces complexities and unwanted interactions in the Thor codebase
+
+  - Thor skews the normal Ruby class/method model towards the command line
+    interface and introduces some 'suprises' for the user (e.g. the
+    Thor-subclass gets instantieated every time a method/command is called,
+    something that is not usually expected)
+
+In contrast, Drudge's aim is simple: a library for building command-line
+automation tools with the aim of transferring you (conceptionally) from the command line
+interface into Ruby and then letting you use build your tool in a familiar
+environement.
+
+## License
+
+Released under the MIT License.  See the [LICENSE][] file for further details.
+
+[license]: LICENSE.txt
+

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require "cucumber"
+require "cucumber/rake/task"
+require "rspec/core/rake_task"
+
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features"
+end
+
+namespace :spec do
+
+  default_opts = %w[-Ilib -Ispec --color]
+
+  desc "Runs specs with progress output"
+  RSpec::Core::RakeTask.new(:run) do |t|
+    t.rspec_opts = default_opts
+  end
+
+  desc "Runs specs in documentation mode" 
+  RSpec::Core::RakeTask.new(:pretty) do |t|
+    t.rspec_opts = default_opts + %w[--format documentation]
+  end
+end
+
+desc "Runs specs"
+task :spec => "spec:run"

data/drudge.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'drudge/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "drudge"
+  spec.version       = Drudge::VERSION
+  spec.authors       = ["Ognen Ivanovski"]
+  spec.email         = ["ognen.ivanovski@me.com"]
+  spec.description   = %q{A library for building command-line
+                          automation tools with the aim of transferring you (conceptionally) from the command line
+                          interface into Ruby and then letting you use build your tool in a familiar
+                          environement.}
+  spec.summary       = %q{A gem that enables you to write command line automation tools using Ruby 2.0.}
+  spec.homepage      = "https://github.com/ognen/drudge"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", ">= 2.14", "< 3.0"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba", ">= 0.4.6"
+  spec.add_development_dependency "yard", ">= 0.8.6.1"
+  spec.add_development_dependency "gem-release" 
+
+end

data/features/optional-arguments.feature

@@ -0,0 +1,64 @@
+Feature: Optional Arguments
+  Ruby supports optional (positional) arguments.
+  I want (again) a close mapping between method-optional arguments and 
+  the command line.
+
+  Scenario: Optonal argument at the end of the arg list
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "Greets people"
+      def greet(message, from = "Santa")
+        puts "#{from} says: #{message}" 
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet Hello` 
+    Then the output should contain "Santa says: Hello"
+
+  Scenario: Optional arguments in the middle of the arg list
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "Greets people"
+      def greet(message, from = "Santa", recipient)
+        puts "#{from} says to #{recipient}: #{message}" 
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet Hello Sam` 
+    Then the output should contain "Santa says to Sam: Hello"
+
+
+  Scenario: Providing value for an optional arguemnt overrides the default
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "Greets people"
+      def greet(message, from = "Santa", recipient)
+        puts "#{from} says to #{recipient}: #{message}" 
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet Hello Farmer Sam` 
+    Then the output should contain "Farmer says to Sam: Hello"
+
+

data/features/simple-commands.feature

@@ -0,0 +1,185 @@
+Feature: Simple Commands
+  In order to write command line tasks quickly and painlessly
+  I want to have a very close mapping between Ruby classes and methods
+  and command scripts / commands.
+
+
+  Scenario: A simple command with no arguments is just a method call 
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "verifies the project"
+      def verify
+        puts "Verified."
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli verify` 
+    Then the output should contain "Verified."
+
+
+  Scenario: A method with an argument maps to a command in a Ruby script with one required argument
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+    
+    class Cli < Drudge
+
+      desc "greets someone"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet Santa`
+    Then the output should contain "Hello Santa!"
+
+  Scenario: Too many arguments are reported as an error
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "greet someone someoneelse"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet Santa Clause`
+    Then the output should contain:
+    """
+    error: extra command line arguments provided:
+
+        cli greet Santa Clause
+                        ~~~~~~
+    """
+
+  Scenario: A required parameter must be provided
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "greets someone"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli greet`
+    Then the output should contain:
+    """
+    error: expected a value for <someone>:
+
+        cli greet
+                  ^
+    """
+
+  Scenario: The user is notified if a command is improperly entered
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "greets someone"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+
+      desc "says something"
+      def say(something)
+        puts "Saying #{something}!"
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli great`
+    Then the output should contain:
+    """
+    error: unknown command 'great':
+
+        cli great
+            ~~~~~
+    """
+
+  Scenario: The user is notified if a command is missing
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "greets someone"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+
+      desc "says something"
+      def say(something)
+        puts "Saying #{something}!"
+      end
+
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli`
+    Then the output should contain:
+    """
+    error: expected a command:
+
+        cli
+            ^
+    """
+
+  Scenario: The error reported relates to the command being executed
+    Given a Ruby script called "cli" with:
+    """
+    require 'drudge'
+
+    class Cli < Drudge
+
+      desc "greets someone"
+      def greet(someone)
+        puts "Hello #{someone}!"
+      end
+
+      desc "hello worlds"
+      def hello(world)
+        puts "Hello #{world}!"
+      end
+
+      desc "Third"
+      def third
+        puts "Hello"
+      end
+    end
+
+    Cli.dispatch
+    """
+    When I run `cli hello world err`
+    Then the output should contain:
+    """
+    error: extra command line arguments provided:
+    
+        cli hello world err
+                        ~~~
+    """