ame 0.1.1 → 1.0.1

data/lib/ame.rb

@@ -1,26 +0,0 @@
-# -*- 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

@@ -1,56 +0,0 @@
-# -*- 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

@@ -1,65 +0,0 @@
-# -*- 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

@@ -1,117 +0,0 @@
-# -*- 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/console.rb

@@ -1,96 +0,0 @@
-# -*- 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.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

@@ -1,94 +0,0 @@
-# -*- 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, _ = 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