shebang 0.1

data/.gems

@@ -0,0 +1,3 @@
+bacon
+yard
+rdiscount

data/.gitignore

@@ -0,0 +1,10 @@
+# Ignore build related files
+doc
+pkg/*.gem
+
+# Ignore common crap
+.DS_Store
+Thumbs.db
+
+# Keep those funky gitkeep files
+!.gitkeep

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.2@shebang

data/.travis.yml

@@ -0,0 +1,16 @@
+script: "rvm gemset import .gems; rake test"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree
+  - rbx
+  - rbx-2.0
+  - jruby
+
+notifications:
+  email: false
+
+branches:
+  only:
+    - master

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011, Yorick Peterse
+
+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,154 @@
+# README
+
+Shebang is a nice wrapper around OptionParser that makes it easier to write
+commandline executables. I wrote it after getting fed up of having to re-invent
+the same wheel every time I wanted to write a commandline executable. For
+example, a relatively simple command using OptionParser directly may look like
+the following:
+
+    require 'optparse'
+
+    @options = {:force => false, :f => false, :name => nil, :n => nil}
+    parser   = OptionParser.new do |opt|
+      opt.banner = <<-TXT.strip
+    Runs an example command.
+
+    Usage:
+      $ foobar.rb [OPTIONS]
+      TXT
+
+      opt.summary_indent = '  '
+
+      opt.separator "\nOptions:\n"
+
+      opt.on('-h', '--help', 'Shows this help message') do
+        puts parser
+        exit
+      end
+
+      opt.on('-v', '--version', 'Shows the current version') do
+        puts '0.1'
+        exit
+      end
+
+      opt.on('-f', '--force', 'Forces the command to run') do
+        @options[:force] = @options[:f] = true
+      end
+
+      opt.on('-n', '--name NAME', 'A person\'s name') do |name|
+        @options[:name] = @options[:n] = name
+      end
+    end
+
+    parser.parse!
+
+    puts "Your name is #{@options[:name]}"
+
+Using Shebang this can be done as following:
+
+    require 'shebang'
+
+    class Greet < Shebang::Command
+      command :default
+      banner  'Runs an example command.'
+      usage   '$ foobar.rb [OPTIONS]'
+
+      o :h, :help   , 'Shows this help message'  , :method => :help
+      o :v, :version, 'Shows the current version', :method => :version
+      o :f, :force  , 'Forces the command to run'
+      o :n, :name   , 'A person\'s name', :type => String
+
+      def version
+        puts '0.1'
+        exit
+      end
+
+      def index
+        puts "Your name is #{@options[:n]}"
+      end
+    end
+
+    Shebang.run
+
+## Usage
+
+As shown in the example above commands can be created by extending the class
+``Shebang::Command`` and calling the class method ``command()``. Each command
+required an instance method called ``index()`` to be defined, this method is
+called once OptionParser has been set up and the commandline arguments have
+been parsed:
+
+    require 'shebang'
+
+    class Greet < Shebang::Command
+      command :default
+
+      def index
+
+      end
+    end
+
+Options can be retrieved using the method ``option()`` which takes either the
+short or long name of an option, in both cases it will result in the same value
+(given the option names belong to the same option):
+
+    option(:h) === option(:help) # => true
+
+Options can be added using the class method ``option()`` or it's alias ``o()``.
+Besides the features offered by OptionParser options can specify a method to
+execute in case that particular option has been specified. This can be done by
+passing the ``:method`` key to the option method:
+
+    option :f, :foobar, 'Calls a method', :method => :foobar
+
+Now whenever the ``-f`` of ``--foobar`` option is set the method ``foobar()``
+will be executed **without** stopping the rest of the command. This means that
+you'll have to manually call ``Kernel.exit()`` if you want to stop the execution
+process if a certain option is specified.
+
+Shebang comes with support for defining sub commands. Sub commands are nothing
+more than different methods than the default one. Say you have a class
+``Git::Submodule``, to run the command itself you'd invoke the default method on
+this class (index by default):
+
+    cmd = Git::Submodule.new
+
+    cmd.parse([...])
+    cmd.index
+
+To show the status of a submodule you'd invoke ``git submodule status``, this
+translates to the following code:
+
+    cmd = Git::Submodule.new
+
+    cmd.parse([...])
+    cmd.status
+
+Shebang takes care of this using ``Shebang.run()``. The first commandline
+argument that does not start with ``-`` (and this isn't an option) is considered
+the command name. If there's another argument that's not a switch following that
+one will be used as the method name. This means that in order to invoke
+``Git::Submodule#index`` you'd type the following into your terminal:
+
+    git.rb submodule
+
+If you want to invoke a method other than the default one you'd do the
+following:
+
+    git.rb submodule status
+
+In other words, the syntax of a Shebang command is the following:
+
+    script [COMMAND] [METHOD] [ARGS] [OPTIONS]
+
+## Configuration
+
+Various options of Shebang can be configured by modifying the hash
+``Shebang::Config``. For example, if you want to change the format of all the
+headers in the help message you can do so as following:
+
+    Shebang::Config[:heading] = "\n== %s:\n"
+
+You can also change the name of the default command:
+
+    Shebang::Config[:default_command] = :my_default_command

data/Rakefile

@@ -0,0 +1,11 @@
+require File.expand_path('../lib/shebang', __FILE__)
+
+module Shebang
+  Gemspec = Gem::Specification::load(File.expand_path('../shebang.gemspec', __FILE__))
+end
+
+task_dir = File.expand_path('../task', __FILE__)
+
+Dir.glob("#{task_dir}/*.rake").each do |f|
+  import(f)
+end

data/example/basic.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../lib/shebang', __FILE__)
+
+class Greet < Shebang::Command
+  command :default
+  banner  'Runs an example command.'
+  usage   '$ ruby example/basic.rb [OPTIONS]'
+
+  o :h, :help   , 'Shows this help message'  , :method => :help
+  o :v, :version, 'Shows the current version', :method => :version
+  o :f, :force  , 'Forces the command to run'
+  o :n, :name   , 'A person\'s name', :type => String,
+    :required => true, :default => 'Shebang'
+
+  # $ ruby example/basic.rb
+  # $ ruby example/basic.rb default
+  # $ ruby example/basic.rb default index
+  def index
+    puts "Your name is #{option(:n)}"
+  end
+
+  # $ ruby example/basic.rb test
+  # $ ruby example/basic.rb default test
+  def test
+    puts 'This is a test method'
+  end
+
+  protected
+
+  def version
+    puts Shebang::Version
+    exit
+  end
+end
+
+Shebang.run

data/lib/shebang.rb

@@ -0,0 +1,104 @@
+require 'rubygems'
+require 'optparse'
+require File.expand_path('../shebang/version', __FILE__)
+require File.expand_path('../shebang/command', __FILE__)
+require File.expand_path('../shebang/option' , __FILE__)
+
+##
+# Shebang is a nice wrapper around OptionParser that makes it easier to write
+# commandline executables.
+#
+# @author Yorick Peterse
+# @since  0.1
+#
+module Shebang
+  #:nodoc:
+  class Error < StandardError; end
+
+  # Hash containing various configuration options.
+  Config = {
+    # The name of the default command to invoke when no command is specified.
+    :default_command => :default,
+
+    # The name of the default method to invoke.
+    :default_method => :index,
+
+    # The amount of spaces to insert before each option.
+    :indent => '  ',
+
+    # The format for each header for help topics, options, etc.
+    :heading => "\n%s:\n",
+
+    # When set to true Shebang will raise an exception for errors instead of
+    # just printing a message.
+    :raise => true
+  }
+
+  # Hash containing the names of all commands and their classes.
+  Commands = {}
+
+  class << self
+    ##
+    # Runs a command based on the command line arguments. If no command is given
+    # this method will try to invoke the default command.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @param  [Array] argv Array containing the command line arguments to parse.
+    #
+    def run(argv = ARGV)
+      self.error("No commands have been registered") if Commands.empty?
+
+      command = Config[:default_command].to_sym
+      method  = Config[:default_method].to_sym
+
+      if !argv.empty?
+        # Get the command name
+        if argv[0][0] != '-' and Commands.key?(argv[0].to_sym)
+          command = argv.delete_at(0).to_sym
+        end
+      end
+
+      if Commands.key?(command)
+        klass = Commands[command].new
+
+        # Get the method to call.
+        if argv[0] and argv[0][0] != '-' and klass.respond_to?(argv[0].to_sym)
+          method = argv.delete_at(0).to_sym
+        end
+
+        # Parse the arguments and prepare all the options.
+        argv = klass.parse(argv)
+
+        # Call the method and pass the commandline arguments to it.
+        if klass.respond_to?(method)
+          if klass.class.instance_method(method).arity != 0
+            klass.send(method, argv)
+          else
+            klass.send(method)
+          end
+        else
+          error("The command #{command} does not have a #{method}() method")
+        end
+      else
+        error("The command #{command} does not exist")
+      end
+    end
+
+    ##
+    # Raises an exception or prints a regular error message to STDERR based on
+    # the :raise configuration option.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @param  [String] message The message to display.
+    #
+    def error(message)
+      if Config[:raise] === true
+        raise(Error, message)
+      else
+        abort "\e[0;31mError:\e[0m #{message}"
+      end
+    end
+  end # class << self
+end # Shebang

data/lib/shebang/command.rb

@@ -0,0 +1,274 @@
+module Shebang
+  ##
+  # Shebang::Command is where the party really starts. By extending this class
+  # other classes can become fully fledged commands with their own options,
+  # banners, callbacks, and so on. In it's most basic form a command looks like
+  # the following:
+  #
+  #     class MyCommand < Shebang::Command
+  #       command 'my-command'
+  #
+  #       def index
+  #
+  #       end
+  #     end
+  #
+  # The class method command() is used to register the class to the specified
+  # name, without this Shebang would be unable to call it.
+  #
+  # Defining options can be done by calling the class method option() or it's
+  # alias o():
+  #
+  #     class MyCommand < Shebang::Command
+  #       command 'my-command'
+  #
+  #       o :h, :help, 'Shows this help message', :method => :help
+  #
+  #       def index
+  #
+  #       end
+  #     end
+  #
+  # If you're going to define a help option, and you most likely will, you don't
+  # have to manually add a method that shows the message as the Command class
+  # already comes with an instance method for this, simply called help().
+  #
+  # For more information on options see Shebang::Option#initialize().
+  #
+  # @author Yorick Peterse
+  # @since  0.1
+  #
+  class Command
+    # Several methods that become available as class methods once
+    # Shebang::Command is extended by another class.
+    module ClassMethods
+      ##
+      # Binds a class to the specified command name.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [#to_sym] name The name of the command.
+      # @param  [Hash] options Hash containing various options for the command.
+      # @option options :parent The name of the parent command.
+      #
+      def command(name, options = {})
+        name = name.to_sym
+
+        if Shebang::Commands.key?(name)
+          Shebang.error("The command #{name} has already been registered")
+        end
+
+        Shebang::Commands[name] = self
+      end
+
+      ##
+      # Sets the banner for the command, trailing or leading newlines will
+      # be removed.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [String] text The content of the banner.
+      #
+      def banner(text)
+        @__banner = text.strip
+      end
+
+      ##
+      # A small shortcut for defining the syntax of a command. This method is
+      # just a shortcut for the following:
+      #
+      #  help('Usage', 'foobar [OPTIONS]'
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [String] text The content of the usage block.
+      #
+      def usage(text)
+        help('Usage', text)
+      end
+
+      ##
+      # Sets a general "help topic" with a custom title and content.
+      #
+      # @example
+      #  help('License', 'MIT License')
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [String] title The title of the topic.
+      # @param  [String] text The content of the topic.
+      #
+      def help(title, text)
+        @__help_topics      ||= {}
+        @__help_topics[title] = text.strip
+      end
+
+      ##
+      # Creates a new option for a command.
+      #
+      # @example
+      #  o :h, :help, 'Shows this help message', :method => :help
+      #  o :l, :list, 'A list of numbers'      , :type   => Array
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @see    Shebang::Option#initialize
+      #
+      def option(short, long, desc = nil, options = {})
+        @__options ||= []
+        option       = Shebang::Option.new(short, long, desc, options)
+
+        @__options.push(option)
+      end
+      alias :o :option
+    end # ClassMethods
+
+    ##
+    # Modifies the class that inherits this class so that the module
+    # Shebang::Comand::ClassMethods extends the class.
+    #
+    # @author Yorick Peterse
+    # @since  09-08-2011
+    # @param  [Class] by The class that inherits from Shebang::Command.
+    #
+    def self.inherited(by)
+      by.extend(Shebang::Command::ClassMethods)
+    end
+
+    ##
+    # Creates a new instance of the command and sets up OptionParser.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    def initialize
+      @option_parser = OptionParser.new do |opt|
+        opt.banner         = banner
+        opt.summary_indent = Shebang::Config[:indent]
+
+        # Process each help topic
+        help_topics.each do |title, text|
+          opt.separator "#{Shebang::Config[:heading]}#{
+            Shebang::Config[:indent]}#{text}" % title
+        end
+
+        opt.separator "#{Shebang::Config[:heading]}" % 'Options'
+
+        # Add all the options
+        options.each do |option|
+          opt.on(*option.option_parser) do |value|
+            option.value = value
+
+            # Run a method?
+            if !option.options[:method].nil? \
+            and respond_to?(option.options[:method])
+              # Pass the value to the method?
+              if self.class.instance_method(option.options[:method]).arity != 0
+                send(option.options[:method], value)
+              else
+                send(option.options[:method])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # Parses the command line arguments using OptionParser.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @param  [Array] argv Array containing the command line arguments to parse.
+    # @return [Array] argv Array containing all the command line arguments after
+    #  it has been processed.
+    #
+    def parse(argv = [])
+      @option_parser.parse!(argv)
+
+      options.each do |option|
+        if option.required? and !option.has_value?
+          Shebang.error("The -#{option.short} option is required")
+        end
+      end
+
+      return argv
+    end
+
+    ##
+    # Returns the banner of the current class.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [String]
+    #
+    def banner
+      self.class.instance_variable_get(:@__banner)
+    end
+
+    ##
+    # Returns all help topics for the current class.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [Hash]
+    #
+    def help_topics
+      self.class.instance_variable_get(:@__help_topics) || {}
+    end
+
+    ##
+    # Returns an array of all the options for the current class.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [Array]
+    #
+    def options
+      self.class.instance_variable_get(:@__options) || []
+    end
+
+    ##
+    # Method that is called whenever a command has to be executed.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    def index
+      raise(NotImplementedError, "You need to define your own index() method")
+    end
+
+    ##
+    # Returns the value of a given option. The option can be specified using
+    # either the short or long name.
+    #
+    # @example
+    #  puts "Hello #{option(:name)}
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @param  [#to_sym] opt The name of the option.
+    # @return [Mixed]
+    #
+    def option(opt)
+      opt = opt.to_sym
+
+      options.each do |op|
+        if op.short === opt or op.long === opt
+          return op.value
+        end
+      end
+    end
+
+    ##
+    # Shows the help message for the current class.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    def help
+      puts @option_parser
+      exit
+    end
+  end # Command
+end # Shebang

data/lib/shebang/option.rb

@@ -0,0 +1,95 @@
+module Shebang
+  ##
+  # Class that represents a single option that's passed to OptionParser.
+  #
+  # @author Yorick Peterse
+  # @since  0.1
+  #
+  class Option
+    attr_reader   :short, :long, :description, :options
+    attr_accessor :value
+
+    ##
+    # Creates a new instance of the Option class.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @param  [#to_sym] short The short option name such as :h.
+    # @param  [#to_sym] long The long option name such as :help.
+    # @param  [String] desc The description of the option.
+    # @param  [Hash] options Hash containing various configuration options for
+    #  the OptionParser option.
+    # @option options :type The type of value for the option, set to TrueClass
+    #  by default.
+    # @option options :key The key to use to indicate a value whenever the type
+    #  of an option is something else than TrueClass or FalseClass. This option
+    #  is set to "VALUE" by default.
+    # @option options :method A symbol that refers to a method that should be
+    #  called whenever the option is specified.
+    # @option options :required Indicates that the option has to be specified.
+    # @option options :default The default value of the option.
+    #
+    def initialize(short, long, desc = nil, options = {})
+      @short, @long = short.to_sym, long.to_sym
+      @description  = desc
+      @options      = {
+        :type     => TrueClass,
+        :key      => 'VALUE',
+        :method   => nil,
+        :required => false,
+        :default  => nil
+      }.merge(options)
+
+      @value = @options[:default]
+    end
+
+    ##
+    # Builds an array containing all the required parameters for
+    # OptionParser#on().
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [Array]
+    #
+    def option_parser
+      params = ["-#{@short}", "--#{@long}", nil, @options[:type]]
+
+      if !@description.nil? and !@description.empty?
+        params[2] = @description
+      end
+
+      # Set the correct format for the long/short option based on the type.
+      if ![TrueClass, FalseClass].include?(@options[:type])
+        params[1] += " #{@options[:key]}"
+      end
+
+      return params
+    end
+
+    ##
+    # Checks if the value of an option is not nil and not empty.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [TrueClass|FalseClass]
+    #
+    def has_value?
+      if !@value.nil? and !@value.empty?
+        return true
+      else
+        return false
+      end
+    end
+
+    ##
+    # Indicates whether or not the option requires a value.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @return [TrueClass|FalseClass]
+    #
+    def required?
+      return @options[:required]
+    end
+  end # Option
+end # Shebang

data/lib/shebang/spec/bacon/color_output.rb

@@ -0,0 +1,39 @@
+#:nodoc:
+module Bacon
+  #:nodoc:
+  module ColorOutput
+    #:nodoc:
+    def handle_specification(name)
+      puts spaces + name
+      yield
+      puts if Counter[:context_depth] == 1
+    end
+
+    #:nodoc:
+    def handle_requirement(description)
+      error = yield
+
+      if !error.empty?
+        puts "#{spaces} \e[31m- #{description} [FAILED]\e[0m"
+      else
+        puts "#{spaces} \e[32m- #{description}\e[0m"
+      end
+    end
+
+    #:nodoc:
+    def handle_summary
+      print ErrorLog  if Backtraces
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+
+    #:nodoc:
+    def spaces
+      if Counter[:context_depth] === 0
+        Counter[:context_depth] = 1
+      end
+
+      return ' ' * (Counter[:context_depth] - 1)
+    end
+  end # ColorOutput
+end # Bacon

data/lib/shebang/spec/helper.rb

@@ -0,0 +1,65 @@
+require 'bacon'
+require 'stringio'
+require File.expand_path('../bacon/color_output', __FILE__)
+
+Bacon.extend(Bacon::ColorOutput)
+Bacon.summary_on_exit
+
+##
+# Runs the block in a new thread and redirects $stdout and $stderr. The output
+# normally stored in these variables is stored in an instance of StringIO which
+# is returned as a hash.
+#
+# @example
+#  out = catch_output do
+#    puts 'hello'
+#  end
+#
+#  puts out # => {:stdout => "hello\n", :stderr => ""}
+#
+# @author Yorick Peterse
+# @return [Hash]
+#
+def catch_output
+  data = {
+    :stdout => nil,
+    :stderr => nil
+  }
+
+  Thread.new do
+    $stdout, $stderr = StringIO.new, StringIO.new
+
+    yield
+
+    $stdout.rewind
+    $stderr.rewind
+
+    data[:stdout], data[:stderr] = $stdout.read, $stderr.read
+
+    $stdout, $stderr = STDOUT, STDERR
+  end.join
+
+  return data
+end
+
+##
+# Allows developers to create stubbed objects similar to Mocha's stub() method.
+#
+# @example
+#  obj = stub(:language => 'Ruby')
+#  puts obj.language # => "Ruby"
+#
+# @author Yorick Peterse
+# @param  [Hash] attributes A hash containing all the attributes to set and
+# their values.
+# @return [Class]
+#
+def stub(attributes)
+  obj = Struct.new(*attributes.keys).new
+
+  attributes.each do |k, v|
+    obj.send("#{k}=", v)
+  end
+
+  return obj
+end

data/lib/shebang/version.rb

@@ -0,0 +1,4 @@
+module Shebang
+  #:nodoc:
+  Version = '0.1'
+end

data/shebang.gemspec

@@ -0,0 +1,21 @@
+require File.expand_path('../lib/shebang/version', __FILE__)
+
+path = File.expand_path('../', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'shebang'
+  s.version     = Shebang::Version
+  s.date        = '09-08-2011'
+  s.authors     = ['Yorick Peterse']
+  s.email       = 'yorickpeterse@gmail.com'
+  s.summary     = 'Shebang is a nice wrapper around OptionParser that makes it
+easier to write commandline executables.'
+  s.homepage    = 'https://github.com/yorickpeterse/shebang'
+  s.description = s.summary
+  s.files       = `cd #{path}; git ls-files`.split("\n").sort
+  s.has_rdoc    = 'yard'
+
+  s.add_development_dependency('rake' , ['~> 0.9.2'])
+  s.add_development_dependency('yard' , ['~> 0.7.2'])
+  s.add_development_dependency('bacon', ['~> 1.1.0'])
+end

data/spec/fixtures/command.rb

@@ -0,0 +1,21 @@
+class SpecCommand < Shebang::Command
+  command :default
+  banner  'The default command.'
+  usage   'shebang.rb [COMMAND] [OPTIONS]'
+
+  o :v, :version, 'Shows the current version', :method => :version
+
+  def index
+    puts 'index method'
+  end
+
+  def test
+    puts 'test method'
+  end
+
+  protected
+
+  def version
+    puts '0.1'
+  end
+end # SpecCommand

data/spec/helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../../lib/shebang', __FILE__)
+require File.expand_path('../../lib/shebang/spec/helper', __FILE__)

data/spec/shebang/command.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../helper', __FILE__)
+require File.expand_path('../../fixtures/command', __FILE__)
+
+describe('Shebang::Command') do
+  it('The name should be registered') do
+    Shebang::Commands[:default].should == SpecCommand
+  end
+
+  it('The banner should be set') do
+    Shebang::Commands[:default].instance_variable_get(:@__banner).should \
+      === 'The default command.'
+
+    Shebang::Commands[:default].new.banner.should === 'The default command.'
+  end
+
+  it('A help topic should be set') do
+    Shebang::Commands[:default].instance_variable_get(
+      :@__help_topics
+    )['Usage'].should === 'shebang.rb [COMMAND] [OPTIONS]'
+
+    Shebang::Commands[:default].new.help_topics['Usage'].should \
+      === 'shebang.rb [COMMAND] [OPTIONS]'
+  end
+
+  it('An option should be set') do
+    option = Shebang::Commands[:default].instance_variable_get(:@__options)[0]
+
+    option.short.should            === :v
+    option.long.should             === :version
+    option.description.should      === 'Shows the current version'
+    option.options[:method].should === :version
+    option.value                   = '0.1'
+
+    Shebang::Commands[:default].new.options[0].short.should === option.short
+
+    Shebang::Commands[:default].new.option(:v).should       === option.value
+    Shebang::Commands[:default].new.option(:version).should === option.value
+  end
+end

data/spec/shebang/option.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../helper', __FILE__)
+
+describe('Shebang::Option') do
+  it('Create a new option') do
+    option = Shebang::Option.new(:h, :help, 'help message', :method => :test)
+
+    option.short.should       === :h
+    option.long.should        === :help
+    option.description.should === 'help message'
+
+    option.options[:method].should === :test
+    option.options[:type].should   == TrueClass
+
+    option.required?.should  === false
+    option.has_value?.should === false
+  end
+
+  it('Convert to OptionParser arguments') do
+    option = Shebang::Option.new(:h, :help, 'help message', :method => :test)
+
+    option.option_parser.should === ['-h', '--help', 'help message', TrueClass]
+  end
+end

data/spec/shebang/shebang.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../../helper', __FILE__)
+require File.expand_path('../../fixtures/command', __FILE__)
+
+module Kernel
+  def abort(*args)
+    $stderr.puts(*args)
+  end
+
+  def exit(*args); end
+end
+
+describe('Shebang') do
+  it('Raise an error message') do
+    should.raise?(Shebang::Error) do
+      Shebang.error('test')
+    end
+  end
+
+  it('Display an error message') do
+    Shebang::Config[:raise] = false
+
+    output = catch_output do
+      Shebang.error('test')
+    end
+
+    output[:stderr].include?('test').should === true
+  end
+
+  it('Invoke the default command') do
+    [[], ['default'], ['default', 'index']].each do |argv|
+      output = catch_output do
+        Shebang.run(argv)
+      end
+
+      output[:stdout].strip.should === 'index method'
+    end
+  end
+
+  it('Invoke the default command with an alternative method') do
+    [['test'], ['default', 'test']].each do |argv|
+      output = catch_output do
+        Shebang.run(argv)
+      end
+
+      output[:stdout].strip.should === 'test method'
+    end
+  end
+
+  it('Show a help message') do
+    output = catch_output do
+      Shebang.run(['--help'])
+    end
+
+    output[:stdout].include?('The default command').should            === true
+    output[:stdout].include?('shebang.rb [COMMAND] [OPTIONS]').should === true
+    output[:stdout].include?('Options').should                        === true
+  end
+
+  it('Shows the current version') do
+    output = catch_output do
+      Shebang.run(['--version'])
+    end
+
+    output[:stdout].include?('0.1').should === true
+  end
+end # describe

data/task/build.rake

@@ -0,0 +1,33 @@
+# Task group used for building various elements such as the Gem and the
+# documentation.
+namespace :build do
+  desc 'Builds the documentation using YARD'
+  task :doc do
+    gem_path = File.expand_path('../../', __FILE__)
+    command  = "yard doc #{gem_path}/lib -m markdown -M rdiscount -o #{gem_path}/doc "
+    command += "-r #{gem_path}/README.md --private --protected"
+
+    sh(command)
+  end
+
+  desc 'Builds a new Gem'
+  task :gem do
+    gem_path     = File.expand_path('../../', __FILE__)
+    gemspec_path = File.join(
+      gem_path,
+      "#{Shebang::Gemspec.name}-#{Shebang::Gemspec.version.version}.gem"
+    )
+
+    pkg_path = File.join(
+      gem_path,
+      'pkg',
+      "#{Shebang::Gemspec.name}-#{Shebang::Gemspec.version.version}.gem"
+    )
+
+    # Build and install the gem
+    sh('gem', 'build'     , File.join(gem_path, 'shebang.gemspec'))
+    sh('mv' , gemspec_path, pkg_path)
+    sh('gem', 'install'   , pkg_path)
+  end
+end # namespace :build
+

data/task/test.rake

@@ -0,0 +1,6 @@
+desc 'Runs all the tests'
+task :test do
+  Dir.glob(File.expand_path('../../spec/shebang/*.rb', __FILE__)).each do |f|
+    require(f)
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: shebang
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+- Yorick Peterse
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.7.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :development
+  version_requirements: *id003
+description: Shebang is a nice wrapper around OptionParser that makes it easier to write commandline executables.
+email: yorickpeterse@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gems
+- .gitignore
+- .rvmrc
+- .travis.yml
+- LICENSE
+- README.md
+- Rakefile
+- example/basic.rb
+- lib/.gitkeep
+- lib/shebang.rb
+- lib/shebang/.gitkeep
+- lib/shebang/command.rb
+- lib/shebang/option.rb
+- lib/shebang/spec/bacon/color_output.rb
+- lib/shebang/spec/helper.rb
+- lib/shebang/version.rb
+- pkg/.gitkeep
+- shebang.gemspec
+- spec/.gitkeep
+- spec/fixtures/command.rb
+- spec/helper.rb
+- spec/shebang/command.rb
+- spec/shebang/option.rb
+- spec/shebang/shebang.rb
+- task/build.rake
+- task/test.rake
+has_rdoc: yard
+homepage: https://github.com/yorickpeterse/shebang
+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.6.2
+signing_key: 
+specification_version: 3
+summary: Shebang is a nice wrapper around OptionParser that makes it easier to write commandline executables.
+test_files: []
+