ame 0.1.0

data/README

@@ -0,0 +1,4 @@
+# Ame #
+
+Ame is a simple command-line parser and build system.  Its aim is to replace
+the need for other command-line parsers and Rake.

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+require 'lookout/rake/tasks'
+require 'yard'
+
+Lookout::Rake::Tasks::Test.new
+Lookout::Rake::Tasks::Gem.new
+Lookout::Rake::Tasks::Tags.new
+YARD::Rake::YardocTask.new

data/lib/ame.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+module Ame
+  AbortAllProcessing = :AmeAbortAllProcessing
+  AbortProcessing = :AmeAbortProcessing
+
+  Error = Class.new(StandardError)
+  UnrecognizedMethod = Class.new(Error)
+  MalformedArgument = Class.new(Error)
+  MissingArgument = Class.new(Error)
+  SuperfluousArgument = Class.new(Error)
+  UnrecognizedOption = Class.new(Error)
+
+  autoload :Argument, 'ame/argument'
+  autoload :Arguments, 'ame/arguments'
+  autoload :Class, 'ame/class'
+  autoload :Help, 'ame/help'
+  autoload :Method, 'ame/method'
+  autoload :Methods, 'ame/methods'
+  autoload :Option, 'ame/option'
+  autoload :Options, 'ame/options'
+  autoload :Root, 'ame/root'
+  autoload :Splat, 'ame/splat'
+  autoload :Types, 'ame/types'
+  autoload :Version, 'ame/version'
+end

data/lib/ame/argument.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+class Ame::Argument
+  def initialize(name, description, options = {}, &validate)
+    @name, @description, @validate = name.to_sym, description, validate || DefaultValidate
+    @optional = options.fetch(:optional, false)
+    @type = Ame::Types[[options[:type], options[:default], String].find{ |o| !o.nil? }]
+    set_default options[:default], options[:type] if options.include? :default
+  end
+
+  def arity
+    1
+  end
+
+  def process(options, processed, argument)
+    raise Ame::MissingArgument, 'missing argument: %s' % self if required? and argument.nil?
+    validate(options, processed, argument)
+  end
+
+  attr_reader :name, :description, :default
+
+  def optional?
+    @optional
+  end
+
+  def required?
+    not optional?
+  end
+
+  def to_s
+    name.to_s.upcase
+  end
+
+private
+
+  DefaultValidate = proc{ |options, processed, argument| argument }
+
+  def set_default(value, type)
+    raise ArgumentError,
+      'default value can only be set if optional' unless optional?
+    raise ArgumentError,
+      'default value %s is not of type %s' %
+        [value, type] unless value.nil? or type.nil? or value.is_a? type
+    @default = value
+  end
+
+  def parse(argument)
+    argument.nil? ? default : @type.parse(argument)
+  end
+
+  def validate(options, processed, argument)
+    @validate.call(options, processed, parse(argument))
+  rescue Ame::MalformedArgument, ArgumentError, TypeError => e
+    raise Ame::MalformedArgument, '%s: %s' % [self, e]
+  end
+end

data/lib/ame/arguments.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+class Ame::Arguments
+  include Enumerable
+
+  def initialize
+    @arguments = []
+    @splat = nil
+  end
+
+  def argument(name, description, options = {}, &block)
+    argument = Ame::Argument.new(name, description, options, &block)
+    raise ArgumentError,
+      'argument %s must come before splat argument %s' %
+        [argument.name, splat.name] if @splat
+    raise ArgumentError,
+      'optional argument %s may not precede required argument %s' %
+        [first_optional.name, argument.name] if argument.required? and first_optional
+    @arguments << argument
+    self
+  end
+
+  def splat(name = nil, description = nil, options = {}, &validate)
+    return @splat unless name
+    splat = Ame::Splat.new(name, description, options, &validate)
+    raise ArgumentError,
+      'splat argument %s already defined: %s' % [@splat.name, splat.name] if @splat
+    raise ArgumentError,
+      'optional argument %s may not precede required splat argument %s' %
+        [first_optional.name, splat.name] if splat.required? and first_optional
+    @splat = splat
+    self
+  end
+
+  def arity
+    required = @arguments.select{ |a| a.required? }.size +
+               (@splat && @splat.required? ? 1 : 0)
+    @splat || first_optional ? -required - 1 : required
+  end
+
+  def process(options, arguments)
+    unprocessed = arguments.dup
+    reduce([]){ |processed, argument|
+      processed << argument.process(options, processed,
+                                    argument.arity < 0 ? unprocessed : unprocessed.shift)
+    }.tap{
+      raise Ame::SuperfluousArgument,
+        'superfluous arguments: %s' % unprocessed.join(' ') unless unprocessed.empty?
+    }
+  end
+
+  def each
+    @arguments.each do |argument|
+      yield argument
+    end
+    yield @splat if @splat
+    self
+  end
+
+private
+
+  def first_optional
+    @arguments.find{ |a| a.optional? }
+  end
+end

data/lib/ame/class.rb

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+
+class Ame::Class
+  class << self
+    def basename(basename = nil)
+      @basename = basename if basename
+      return @basename if defined? @basename
+      name.split('::').last.scan(/[[:upper:]][[:lower:]]*/).join('-').downcase
+    end
+
+    def fullname
+      [].tap{ |names|
+        klass = self
+        until klass.nil? or klass.basename.empty?
+          names << klass.basename
+          klass = klass.parent
+        end
+      }.reverse.join(' ')
+    end
+
+    def description(description = nil)
+      return method.description(description) if description
+      defined?(@description) ? @description : ''
+    end
+
+    def help_for_dispatch(method, subclass)
+      parent.help_for_dispatch(method, subclass)
+    end
+
+    def help_for_method(method)
+      parent.help_for_method(method)
+    end
+
+    def methods
+      @methods ||= Ame::Methods.new
+    end
+
+    def dispatch(klass, options = {})
+      klass.parent = self
+      description klass.description
+      options_must_precede_arguments
+      dispatch = method
+      option :help, 'Display help for this method', :ignore => true do
+        help_for_dispatch dispatch, klass
+        throw Ame::AbortAllProcessing
+      end unless method.options.include? :help
+      method.arguments.arity.zero? or
+        raise ArgumentError,
+          'arguments may not be defined for a dispatch: %s' % klass
+      argument :method, 'Method to run', options.include?(:default) ?
+        {:optional => true, :default => options[:default]} :
+        {}
+      splat :arguments, 'Arguments to pass to METHOD', :optional => true
+      define_method Ame::Method.ruby_name(klass.basename) do |method, arguments|
+        klass.new.process method, arguments
+      end
+    end
+
+  protected
+
+    attr_accessor :parent
+
+  private
+
+    def options_must_precede_arguments
+      method.options_must_precede_arguments
+      self
+    end
+
+    def option(name, description, options = {}, &validate)
+      method.option name, description, options, &validate
+      self
+    end
+
+    def argument(name, description, options = {}, &validate)
+      method.argument name, description, options, &validate
+      self
+    end
+
+    def splat(name, description, options = {}, &validate)
+      method.splat name, description, options, &validate
+      self
+    end
+
+    def method
+      @method ||= Ame::Method.new(self)
+    end
+
+    def method_added(name)
+      if name == :initialize
+        @description = method.define(name).description
+      elsif [:process, :call].include? name
+        method.valid? and
+          raise NameError, 'method name reserved by Ame: %s' % name
+      elsif public_method_defined? name
+        methods << method.define(name)
+      elsif method.valid?
+        raise ArgumentError, 'non-public method cannot be used by Ame: %s' % name
+      end
+      @method = Ame::Method.new(self)
+    end
+  end
+
+  def process(name, arguments = [])
+    catch Ame::AbortProcessing do
+      self.class.methods[name].process self, arguments
+    end
+    self
+  end
+
+  def call(name, arguments = nil, options = nil)
+    catch Ame::AbortProcessing do
+      self.class.methods[name].call self, arguments, options
+    end
+    self
+  end
+end

data/lib/ame/help.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module Ame::Help
+  autoload :Console, 'ame/help/console'
+end

data/lib/ame/help/console.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+class Ame::Help::Console
+  def initialize(io = $stdout, exit_on_error = true)
+    @io, @exit_on_error = io, exit_on_error
+  end
+
+  def for_dispatch(method, subclass)
+    @io.puts for_method_s(method).tap{ |result|
+      append_group result, 'Methods', :method, subclass.methods.sort_by{ |m| method(m) }
+    }
+  end
+
+  def for_method(method)
+    @io.puts for_method_s(method)
+  end
+
+  def version(klass, method)
+    @io.puts '%s %s' % [method.name, klass.const_get(:Version)]
+  end
+
+  def for_error(method, error)
+    (@io == $stdout ? $stderr : @io).puts '%s: %s' % [method, error]
+    if @exit_on_error
+      exit 1
+    else
+      raise error
+    end
+  end
+
+private
+
+  def for_method_s(method)
+    ['Usage:'].tap{ |result|
+      append result, ' ', method.qualified_name
+      append result, ' ', options_usage(method.options)
+      append result, ' ', arguments_usage(method.arguments)
+      result << "\n"
+      append result, '  ', method.description
+      append_group result, 'Arguments', :argument, method.arguments
+      append_group result, 'Options', :option, method.options.sort_by{ |o| (o.short or o.long).to_s }
+    }.join('')
+  end
+
+  def append(result, prefix, string)
+    result << prefix << string unless string.empty?
+  end
+
+  def append_group(result, heading, display, objects)
+    longest = objects.map{ |o| send(display, o).length }.max
+    append result, "\n\n%s:\n" % heading,
+      objects.map{ |o| '  %-*s  %s' % [longest, send(display, o), o.description] }.join("\n")
+  end
+
+  def options_usage(options)
+    options.count > 0 ? '[OPTIONS]...' : ''
+  end
+
+  def arguments_usage(arguments)
+    arguments.map{ |a| 
+      if a.optional? and a.arity < 0 then '[%s]...'
+      elsif a.optional? then '[%s]'
+      elsif a.arity < 0 then '%s...'
+      else '%s'
+      end % a
+    }.join(' ')
+  end
+
+  def argument(argument)
+    result = argument.to_s
+    result << '=%s' % argument.default if argument.default
+    result = '[%s]' % result if argument.optional?
+    result << '...' if argument.arity < 0
+    result
+  end
+
+  def option(option)
+    if not option.long and option.argument_name.empty?
+      '-%s' % option.short
+    elsif not option.long
+      '-%s=%s' % [option.short, option.argument_name.upcase]
+    elsif option.short and option.argument_name.empty?
+      '-%s, --%s' % [option.short, option.long]
+    elsif option.short
+      '-%s, --%s=%s' % [option.short, option.long, option.argument_name.upcase]
+    elsif option.argument_name.empty?
+      '    --%s' % option.long
+    else
+      '    --%s=%s' % [option.long, option.argument_name.upcase]
+    end
+  end
+
+  def method(method)
+    method.name.to_s
+  end
+end

data/lib/ame/method.rb

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+class Ame::Method
+  class << self
+    def ruby_name(name)
+      name.to_s.gsub('-', '_').to_sym
+    end
+
+    def name(name)
+      name.to_s.gsub('_', '-').to_sym
+    end
+  end
+
+  def initialize(klass)
+    @class = klass
+    @description = nil
+  end
+
+  def description(description = nil)
+    return @description unless description
+    @description = description
+    self
+  end
+
+  def options_must_precede_arguments
+    self.options.options_must_precede_arguments
+    self
+  end
+
+  def option(name, description, options = {}, &validate)
+    self.options.option name, description, options, &validate
+    self
+  end
+
+  def argument(name, description, options = {}, &validate)
+    arguments.argument name, description, options, &validate
+    self
+  end
+
+  def splat(name, description, options = {}, &validate)
+    arguments.splat name, description, options, &validate
+    self
+  end
+
+  def arity
+    arguments.arity
+  end
+
+  def define(name)
+    self.name = name
+    option :help, 'Display help for this method', :ignore => true do
+      @class.help_for_method self
+      throw Ame::AbortAllProcessing
+    end unless options.include? :help
+    self
+  end
+
+  def valid?
+    not description.nil?
+  end
+
+  def process(instance, arguments)
+    options, remainder = self.options.process(arguments)
+    call(instance, self.arguments.process(options, remainder), options)
+  end
+
+  def call(instance, arguments = nil, options = nil)
+    options, remainder = self.options.process([]) unless options
+    arguments ||= self.arguments.process(options, [])
+    instance.send ruby_name, *(arguments + (options.empty? ? [] : [options]))
+    self
+  end
+
+  attr_reader :name, :ruby_name
+
+  def qualified_name
+    [@class.fullname, name.to_s].reject{ |n| n.empty? }.join(' ')
+  end
+
+  def options
+    @options ||= Ame::Options.new
+  end
+
+  def arguments
+    @arguments ||= Ame::Arguments.new
+  end
+
+private
+
+  def name=(name)
+    @ruby_name = name
+    @name = self.class.name(name)
+  end
+end