ame 0.1.0

data/lib/ame/methods.rb

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+# -*- 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/types/integer.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+module Ame::Types::Integer
+  Ame::Types.register self, Integer
+
+  def self.parse(value)
+    Integer(value)
+  rescue ArgumentError
+    raise Ame::MalformedArgument, 'not an integer: %s' % value
+  end
+end

data/lib/ame/types/string.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+module Ame::Types::String
+  Ame::Types.register self, String
+
+  def self.parse(value)
+    value
+  end
+end

data/lib/ame/version.rb

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

data/test/ame/types/array.rb

@@ -0,0 +1,13 @@
+# -*- 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/ame/types/boolean.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect TrueClass do Ame::Types::Boolean.parse('true') end
+  expect TrueClass do Ame::Types::Boolean.parse('yes') end
+  expect TrueClass do Ame::Types::Boolean.parse('on') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('1') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('junk') end
+
+  expect FalseClass do Ame::Types::Boolean.parse('false') end
+  expect FalseClass do Ame::Types::Boolean.parse('no') end
+  expect FalseClass do Ame::Types::Boolean.parse('off') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('0') end
+  expect Ame::MalformedArgument do Ame::Types::Boolean.parse('junk') end
+end

data/test/ame/types/integer.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 1 do Ame::Types::Integer.parse('1') end
+  expect Ame::MalformedArgument do Ame::Types::Integer.parse('') end
+  expect Ame::MalformedArgument do Ame::Types::Integer.parse('junk') end
+end

data/test/ame/types/string.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '' do Ame::Types::String.parse('') end
+  expect 'junk' do Ame::Types::String.parse('junk') end
+end

data/test/unit/ame/argument.rb

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