ame 0.1.1 → 1.0.1

data/lib/ame/methods.rb

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Methods
-  include Enumerable
-
-  def initialize
-    @methods = {}
-  end
-
-  def <<(method)
-    @methods[method.name] = method
-    self
-  end
-
-  def [](name)
-    @methods[name.to_sym] or
-      raise Ame::UnrecognizedMethod, 'unrecognized method: %s' % name
-  end
-
-  def include?(name)
-    @methods.include? name.to_sym
-  end
-
-  def each
-    @methods.each_value do |method|
-      yield method
-    end
-    self
-  end
-end

data/lib/ame/option.rb

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Option < Ame::Argument
-  def initialize(name, description, options = {}, &validate)
-    is_boolean_type = [TrueClass, FalseClass].include? options[:type]
-    options[:default] = false unless options.include? :default or options.include? :type
-    if is_boolean_type and not options.include? :default
-      options[:default] = options[:type] == FalseClass
-    end
-    is_boolean = [true, false].include? options[:default]
-    raise ArgumentError,
-      'optional arguments to options are only allowed for booleans' if
-        options[:optional] and not(is_boolean_type or is_boolean)
-    options[:optional] = is_boolean
-    raise ArgumentError,
-      'boolean options cannot have argument descriptions' if
-        is_boolean and options[:argument]
-    @argument_name = is_boolean ? "" : (options[:argument] || name).to_s
-    @aliases = Array(options[:alias]) + Array(options[:aliases])
-    @ignored = options[:ignore]
-    super
-  end
-
-  def to_s
-    (name.to_s.length > 1 ? '--%s' : '-%s') % name
-  end
-
-  attr_reader :argument_name, :aliases
-
-  def short
-    [name, *aliases].find{ |a| a.to_s.length == 1 }
-  end
-
-  def long
-    [name, *aliases].find{ |a| a.to_s.length > 1 }
-  end
-
-  def ignored?
-    @ignored
-  end
-
-private
-
-  def set_default(value, type)
-    saved_optional, @optional = @optional, true
-    super
-  ensure
-    @optional = saved_optional
-  end
-end

data/lib/ame/options.rb

@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Options
-  include Enumerable
-
-  def initialize
-    @options = {}
-    @ordered = []
-    @options_must_precede_arguments = ENV.include? 'POSIXLY_CORRECT'
-  end
-
-  def option(name, description, options = {}, &block)
-    option = Ame::Option.new(name, description, options, &block)
-    self[option.name] = option
-    option.aliases.each do |a|
-      self[a] = option
-    end
-    @ordered << option
-    self
-  end
-
-  def options_must_precede_arguments
-    @options_must_precede_arguments = true
-    self
-  end
-
-  def process(arguments)
-    process!(defaults, arguments.dup)
-  end
-
-  def each
-    @ordered.each do |option|
-      yield option
-    end
-    self
-  end
-
-  def include?(name)
-    @options.include? name.to_s
-  end
-
-private
-
-  def []=(name, option)
-    raise ArgumentError,
-      'option already defined: %s' % name if include? name
-    @options[name.to_s] = option
-  end
-
-  def [](name)
-    @options[name.to_s.sub(/^-+/, "")] or
-      raise Ame::UnrecognizedOption, 'unrecognized option: %s' % name
-  end
-
-  def defaults
-    @ordered.reduce({}){ |d, o| d[o.name] = o.default; d }
-  end
-
-  def process!(results, arguments)
-    remainder = []
-    until arguments.empty?
-      case first = arguments.shift
-      when '--'
-        break
-      when /^-([^=-]{2,})$/
-        process_combined results, arguments, $1
-      when /^(--[^=]+|-[^-])(?:=(.*))?$/
-        process1 results, arguments, self[$1], $2
-      else
-        remainder << first
-        break if @options_must_precede_arguments
-      end
-    end
-    [results.reject{ |n, _| self[n].ignored? }, remainder.concat(arguments)]
-  end
-
-  def process_combined(results, arguments, combined)
-    combined.each_char.with_index do |c, i|
-      option = self['-' + c]
-      if option.optional?
-        process1 results, [], option, nil
-      elsif i == combined.length - 1
-        process1 results, arguments, option, nil
-      else
-        process1 results, [], option, combined[i+1..-1]
-        break
-      end
-    end
-  end
-
-  def process1(results, arguments, option, arg)
-    results[option.name] = option.process(results, [], argument(arguments, option, arg))
-  end
-
-  def argument(arguments, option, argument)
-    case
-    when argument then argument
-    when option.optional? then (!option.default).to_s
-    else arguments.shift
-    end
-  end
-end

data/lib/ame/root.rb

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Root < Ame::Class
-  class << self
-    def basename
-      ''
-    end
-
-    def process(method = File.basename($0), arguments = ARGV)
-      new.process(method, arguments)
-    rescue => e
-      help_for_error method, e
-    end
-
-    def help(help = nil)
-      return @help = help if help
-      @help ||= Ame::Help::Console.new
-    end
-
-    def help_for_dispatch(method, subclass)
-      help.for_dispatch method, subclass
-    end
-
-    def help_for_method(method)
-      help.for_method method
-    end
-
-  private
-
-    def help_for_error(method, error)
-      help.for_error method, error
-    end
-
-    def method_added(name)
-      m = method
-      option :version, 'Display version information', :ignore => true do
-        help.version self, m
-        throw Ame::AbortAllProcessing
-      end unless method.options.include? :version
-      super
-    end
-  end
-
-  def process(name, arguments = [])
-    catch Ame::AbortAllProcessing do
-      super
-    end
-    self
-  end
-
-  def call(name, arguments = nil, options = nil)
-    catch Ame::AbortAllProcessing do
-      super
-    end
-    self
-  end
-end

data/lib/ame/splat.rb

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Splat < Ame::Argument
-  def arity
-    -1
-  end
-
-  def process(options, processed, arguments)
-    super options, processed, nil if required? and arguments.empty?
-    arguments.map{ |argument| super(options, processed, argument) }.tap{ arguments.clear }
-  end
-end

data/lib/ame/types.rb

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Ame::Types
-  class << self
-    def register(type, *classes)
-      classes.each do |c|
-        types[c] = type
-      end
-    end
-
-    def [](class_or_value)
-      type = types[class_or_value] and return type
-      pair = types.find{ |c, t| class_or_value.is_a? c } and return pair.last
-      class_or_value.respond_to? :parse and return class_or_value
-      raise ArgumentError, 'unknown type: %p' % class_or_value
-    end
-
-  private
-
-    def types
-      @types ||= {}
-    end
-  end
-
-  autoload :Array, 'ame/types/array'
-  require 'ame/types/boolean'
-  require 'ame/types/integer'
-  require 'ame/types/string'
-end

data/lib/ame/types/array.rb

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Ame::Types::Array
-  class << self
-    alias_method :[], :new
-  end
-
-  def initialize(type)
-    @type = Ame::Types[type]
-    @contents = []
-  end
-
-  def parse(value)
-    @contents << @type.parse(value)
-  end
-end

data/lib/ame/types/boolean.rb

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Ame::Types::Boolean
-  Ame::Types.register self, TrueClass, FalseClass
-
-  def self.parse(value)
-    case value
-    when 'true', 'yes', 'on'
-      true
-    when 'false', 'no', 'off'
-      false
-    else
-      raise Ame::MalformedArgument, 'not a boolean: %s' % value
-    end
-  end
-end

data/lib/ame/version.rb

@@ -1,5 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Ame
-  Version = '0.1.1'
-end

data/test/ame/types/array.rb

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect Ame::Types::Array do Ame::Types::Array[String] end
-  expect [''] do Ame::Types::Array[String].parse('') end
-  expect [1] do Ame::Types::Array[Integer].parse('1') end
-  expect [1, 2, 3] do
-    ary = Ame::Types::Array[Integer]
-    ary.parse('1')
-    ary.parse('2')
-    ary.parse('3')
-  end
-end

data/test/unit/ame/argument.rb

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect :a do Ame::Argument.new(:a, 'd').name end
-
-  expect 'd' do Ame::Argument.new(:a, 'd').description end
-
-  expect 1 do Ame::Argument.new(:a, 'd').arity end
-
-  expect Ame::Argument.new(:a, 'd').not.to.be.optional?
-  expect Ame::Argument.new(:a, 'd', :optional => true).to.be.optional?
-
-  expect Ame::Argument.new(:a, 'd').to.be.required?
-  expect Ame::Argument.new(:a, 'd', :optional => true).not.to.be.required?
-
-  expect 'A' do Ame::Argument.new(:a, 'd').to_s end
-
-  expect ArgumentError do Ame::Argument.new(:a, 'd', :default => 1) end
-  expect 1 do Ame::Argument.new(:a, 'd', :optional => true, :default => 1).default end
-
-  expect ArgumentError do Ame::Argument.new(:a, 'd', :optional => true, :type => String, :default => 1) end
-  expect 1 do Ame::Argument.new(:a, 'd', :optional => true, :type => Integer, :default => 1).default end
-  expect ArgumentError do Ame::Argument.new(:a, 'd', :optional => true, :type => TrueClass, :default => false) end
-
-  expect Ame::MissingArgument do Ame::Argument.new(:a, 'd').process({}, [], nil) end
-  expect nil do Ame::Argument.new(:a, 'd', :optional => true).process({}, [], nil) end
-  expect 'default' do Ame::Argument.new(:a, 'd', :optional => true, :default => 'default').process({}, [], nil) end
-  expect 'string' do Ame::Argument.new(:a, 'd').process({}, [], 'string') end
-
-  expect 1 do Ame::Argument.new(:a, 'd', :type => Integer).process({}, [], '1') end
-  expect 2 do Ame::Argument.new(:a, 'd', :optional => true, :default => 1).process({}, [], '2') end
-  expect Ame::MalformedArgument.new('A: not an integer: junk') do
-    Ame::Argument.new(:a, 'd', :type => Integer).process({}, [], 'junk')
-  end
-
-  expect TrueClass do Ame::Argument.new(:a, 'd', :type => TrueClass).process({}, [], 'true') end
-  expect TrueClass do Ame::Argument.new(:a, 'd', :optional => true, :default => true).process({}, [], nil) end
-  expect Ame::MalformedArgument.new('A: not a boolean: junk') do
-    Ame::Argument.new(:a, 'd', :type => TrueClass).process({}, [], 'junk')
-  end
-
-  expect FalseClass do Ame::Argument.new(:a, 'd', :type => FalseClass).process({}, [], 'false') end
-  expect FalseClass do Ame::Argument.new(:a, 'd', :optional => true, :default => false).process({}, [], nil) end
-  expect Ame::MalformedArgument.new('A: not a boolean: junk') do
-    Ame::Argument.new(:a, 'd', :type => FalseClass).process({}, [], 'junk')
-  end
-
-  expect :a => 1 do
-    options = nil
-    Ame::Argument.new(:a, 'd', :type => Integer){ |o, p, a| options = o }.process({:a => 1}, [1], '2')
-    options
-  end
-  expect [1] do
-    processed = nil
-    Ame::Argument.new(:a, 'd', :type => Integer){ |o, p, a| processed = p }.process({:a => 1}, [1], '2')
-    processed
-  end
-  expect 2 do
-    argument = nil
-    Ame::Argument.new(:a, 'd', :type => Integer){ |o, p, a| argument = a }.process({:a => 1}, [1], '2')
-    argument
-  end
-  expect 3 do
-    Ame::Argument.new(:a, 'd', :type => Integer){ |o, p, a| 3 }.process({:a => 1}, [1], '2')
-  end
-end

data/test/unit/ame/arguments.rb

@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect Enumerable do Ame::Arguments.new end
-
-  expect 0 do
-    Ame::Arguments.new.arity
-  end
-  expect 1 do
-    Ame::Arguments.new.argument(:a, 'd').arity
-  end
-  expect(-1) do
-    Ame::Arguments.new.argument(:a, 'd', :optional => true).arity
-  end
-  expect 2 do
-    Ame::Arguments.new.argument(:a, 'd').argument(:b, 'd').arity
-  end
-  expect(-2) do
-    Ame::Arguments.new.argument(:a, 'd').
-                       argument(:b, 'd', :optional => true).arity
-  end
-  expect(-3) do
-    Ame::Arguments.new.argument(:a, 'd').
-                       argument(:b, 'd').
-                       argument(:c, 'd', :optional => true).arity
-  end
-  expect(-4) do
-    Ame::Arguments.new.argument(:a, 'd').
-                       argument(:b, 'd').
-                       splat(:c, 'd').arity
-  end
-  expect(-3) do
-    Ame::Arguments.new.argument(:a, 'd').
-                       argument(:b, 'd').
-                       splat(:c, 'd', :optional => true).arity
-  end
-  expect(-3) do
-    Ame::Arguments.new.argument(:a, 'd').
-                       argument(:b, 'd').
-                       argument(:c, 'd', :optional => true).
-                       argument(:d, 'd', :optional => true).arity
-  end
-  expect(-3) do
-    Ame::Arguments.new.argument(:a, 'd').splat(:b, 'd').arity
-  end
-
-  expect ArgumentError.new('argument b must come before splat argument a') do
-    Ame::Arguments.new.splat(:a, 'd').argument(:b, 'd')
-  end
-
-  expect ArgumentError.new('optional argument a may not precede required argument b') do
-    Ame::Arguments.new.argument(:a, 'd', :optional => true).argument(:b, 'd')
-  end
-
-  expect ArgumentError.new('splat argument a already defined: b') do
-    Ame::Arguments.new.splat(:a, 'd').splat(:b, 'd')
-  end
-
-  expect ArgumentError.new('optional argument a may not precede required splat argument b') do
-    Ame::Arguments.new.argument(:a, 'd', :optional => true).splat(:b, 'd')
-  end
-
-  expect Ame::MissingArgument do
-    Ame::Arguments.new.argument(:a, 'd').process({}, [])
-  end
-
-  expect [] do
-    Ame::Arguments.new.process({}, [])
-  end
-
-  expect [1] do
-    Ame::Arguments.new.argument(:a, 'd', :type => Integer).process({}, %w[1])
-  end
-
-  expect [1, TrueClass] do
-    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
-                       argument(:b, 'd', :type => FalseClass).
-                       process({}, %w[1 true])
-  end
-
-  expect Ame::MissingArgument do
-    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
-                       splat(:b, 'd').
-                       process({}, %w[1])
-  end
-
-  expect [1, []] do
-    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
-                       splat(:b, 'd', :optional => true).
-                       process({}, %w[1])
-  end
-
-  expect [1, [2, 3]] do
-    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
-                       splat(:b, 'd', :type => Integer).
-                       process({}, %w[1 2 3])
-  end
-
-  expect Ame::Splat do
-    Ame::Arguments.new.splat(:a, 'd').splat
-  end
-
-  expect Ame::SuperfluousArgument do
-    Ame::Arguments.new.process({}, %w[1])
-  end
-end