choosy 0.2.5 → 0.3.0

data/lib/choosy/printing/manpage.rb

@@ -0,0 +1,235 @@
+require 'choosy/errors'
+
+module Choosy::Printing
+  class ManpageFormatter
+    def bold(line=nil)
+      if line.nil?
+        '\\fB'
+      else
+        "\\fB#{line}\\fP"
+      end
+    end
+
+    def italics(line=nil)
+      if line.nil?
+        '\\fI'
+      else
+        "\\fI#{line}\\fP"
+      end
+    end
+
+    def roman(line=nil)
+      if line.nil?
+        '\\fR'
+      else
+        "\\fR#{line}\\fP"
+      end
+    end
+
+    def reset
+      '\\fP'
+    end
+  end
+
+  class Manpage
+    attr_accessor :name, :section, :date, :version, :manual
+    attr_reader :format, :buffer
+
+    def initialize
+      @buffer = []
+      @section = 1
+      @format = ManpageFormatter.new
+      @version = nil
+      @date = nil
+      @manual = nil
+    end
+
+    def frame_outline
+      frame = ".TH"
+      quote(frame, @name)
+      quote(frame, @section)
+      quote(frame, @date)
+      quote(frame, @version)
+      quote(frame, @manual)
+      frame
+    end
+
+    def section_heading(line)
+      prefixed('.SH', heading(line))
+    end
+
+    def subsection_heading(line)
+      prefixed('.SS', heading(line))
+    end
+
+    def paragraph(line=nil)
+      line = if line.nil?
+               '.P'
+             else
+               ".P\n" << line
+             end
+      append(line)
+    end
+
+    def indented_paragraph(item, line)
+      prefixed('.IP', escape(item), escape(line))
+    end
+
+    def hanging_paragraph(line)
+      append(".HP\n" << escape(line))
+    end
+
+    def indented_region
+      append('.RE')
+    end
+
+    def text(line)
+      return if line.nil?
+      append(escape(line))
+    end
+
+    def raw(line)
+      return if line.nil?
+      append(line)
+    end
+
+    def bold(line, type=nil)
+      line = escape(line)
+      case type
+      when nil
+        prefixed('.B', line)
+      when :italics
+        prefixed('.BI', line)
+      when :roman
+        prefixed('.BR', line)
+      else
+        raise Choosy::ConfigurationError.new("Undefined manpage bold type: #{type}")
+      end
+    end
+
+    def italics(line, type=nil)
+      line = escape(line)
+      case type
+      when nil
+        prefixed('.I', line)
+      when :bold
+        prefixed('.IB', line)
+      when :roman
+        prefixed('.IR', line)
+      else
+        raise Choosy::ConfigurationError.new("Undefined manpage italics type: #{type}")
+      end
+    end
+
+    def roman(line, type)
+      line = escape(line)
+      case type
+      when :italics
+        prefixed('.RI', line)
+      when :bold
+        prefixed('.RB', line)
+      else
+        raise Choosy::ConfigurationError.new("Undefined manpage for roman type: #{type}")
+      end
+    end
+
+    def small(line, type=nil)
+      line = escape(line)
+      case type
+      when nil
+        prefixed('.SM', line)
+      when :bold
+        prefixed('.SB', line)
+      else
+        raise Choosy::ConfigurationError.new("Undefined manpage for small type: #{type}")
+      end
+    end
+
+    def comment(line)
+      append('./" ' << line)
+    end
+
+    def line_break
+      append('.br')
+    end
+
+    def nofill(&block)
+      if block_given?
+        append('.nf')
+        yield self
+        append('.fi')
+      else
+        append('.nf')
+      end
+    end
+
+    def fill
+      append('.fi')
+    end
+
+    def term_paragraph(term, para, width=5)
+      append(".TP " << width.to_s << NEWLINE << escape(term) << NEWLINE << escape(para))
+    end
+
+    def to_s(io=nil)
+      io ||= ""
+      io << frame_outline << NEWLINE
+      io << PREFACE
+      @buffer.each do |line|
+        io << line
+        io << NEWLINE
+      end
+      io
+    end
+
+    private
+    # Taken from the Debian best practices
+    PREFACE =<<EOF
+.ie \\n(.g .ds Aq \\(aq
+.el       .ds Aq '
+.\\" disable hyphenation
+.nh
+.\\" disable justification (adjust text to left margin only)
+.ad l
+EOF
+    SQUOTE = ' "'
+    EQUOTE = '"'
+    NEWLINE = "\n"
+
+    def quote(base, val)
+      if val 
+        base << SQUOTE << val.to_s << EQUOTE
+      else
+        base << SQUOTE << ' ' << EQUOTE
+      end
+    end
+
+    def prefixed(tag, quot, line=nil)
+      puts tag if quot.nil?
+      tag << SQUOTE << quot << EQUOTE
+      if line.nil?
+        append(tag)
+      else
+        append(tag << NEWLINE << line)
+      end
+    end
+
+    def append(line)
+      @buffer << line
+      line
+    end
+
+    def escape(line)
+      nline = line.gsub(/-/, "\\-")
+      nline.gsub!(/(\.+)/, '&\1')
+      nline
+    end
+
+    def heading(line)
+      nline = escape(line)
+      nline.upcase!
+      nline.gsub!(/:$/, '')
+      nline
+    end
+  end
+end

data/lib/choosy/printing/manpage_printer.rb

@@ -0,0 +1,95 @@
+require 'choosy/errors'
+require 'choosy/option'
+require 'choosy/dsl/option_builder'
+require 'choosy/printing/base_printer'
+require 'choosy/printing/manpage'
+
+module Choosy::Printing
+  class ManpagePrinter < BasePrinter
+    attr_reader :manpage, :name, :synopsis
+
+    def initialize(options={})
+      super(options)
+
+      @name = options[:name] || "NAME"
+      @synopsis = options[:synopsis] || 'SYNOPSIS'
+
+      @manpage = Manpage.new
+      @manpage.section = options[:section] || 1
+      @manpage.date = options[:date]
+      @manpage.manual = options[:manual]
+      @manpage.version = options[:version] 
+    end
+    
+    def print!(command)
+      if pager?
+        fix_termcap
+        page format!(command), 'groff -Tutf8 -mandoc'
+      else
+        # Fall back to a help printer if there is no pager
+        help = HelpPrinter.new(formatting_options)
+        help.print!(command)
+      end
+    end
+
+    def format_prologue(command)
+      @manpage.name = command_name(command)
+      version_option = command.option_builders[Choosy::DSL::OptionBuilder::VERSION]
+      if version_option && @manpage.version.nil?
+        begin
+          version_option.entity.validation_step.call(nil, nil)
+        rescue Choosy::VersionCalled => e
+          @manpage.version = e.message
+        end
+      end
+
+      format_name(command)
+      format_synopsis(command)
+    end
+
+    def format_name(command)
+      if command.summary
+        @manpage.section_heading(@name)
+        @manpage.text("#{command.name} - #{command.summary}")
+      end
+    end
+
+    def format_synopsis(command)
+      @manpage.section_heading(@synopsis)
+      @manpage.nofill do |man|
+        usage_wrapped(command, '', columns).each do |line|
+          man.text line
+        end
+      end
+    end
+
+    def format_option(option, formatted_option, indent)
+      @manpage.term_paragraph(formatted_option, option.description, indent.length)
+    end
+
+    def format_command(command, formatted_command, indent)
+      @manpage.term_paragraph(formatted_command, command.summary || "", indent.length)
+    end
+
+    def format_element(item)
+      if item.header?
+        @manpage.section_heading(item.value)
+      else
+        @manpage.paragraph(item.value)
+      end
+    end
+
+    def format_epilogue(command)
+      @manpage.to_s
+    end
+
+    protected
+    def option_begin
+      @manpage.format.italics
+    end
+
+    def option_end
+      @manpage.format.reset
+    end
+  end
+end

data/lib/choosy/printing/terminal.rb

@@ -6,26 +6,57 @@ module Choosy::Printing
     DEFAULT_LINE_COUNT = 25
     DEFAULT_COLUMN_COUNT = 80
 
+    attr_writer :lines, :columns
+
     def lines
       @lines ||= find_terminal_size('LINES', 'lines', 0) || DEFAULT_LINE_COUNT
     end
 
-    def lines=(value)
-      @lines = value
-    end
-
     def columns
       @columns ||= find_terminal_size('COLUMNS', 'cols', 1) || DEFAULT_COLUMN_COUNT
     end
 
-    def columns=(value)
-      @columns = value
-    end
-
     def color
       @color ||= Color.new
     end
 
+    def pager?
+      !pager.empty?
+    end
+
+    def pager
+      @pager ||= ENV['PAGER'] || ENV['MANPAGER']
+      return @pager if @pager
+
+      @pager = if command_exists?('less')
+                 'less -R'
+               elsif command_exists?('more')
+                 'more'
+               else
+                 ''
+               end
+    end
+
+    def page(contents, pipe_command=nil)
+      if pager?
+        if pipe_command
+          pipe(contents, "#{pipe_command} | #{pager}")
+        else
+          pipe(contents, pager)
+        end
+      else
+        pipe(contents, pipe_command)
+      end
+    end
+
+    def pipe(contents, command)
+      puts contents if command.nil?
+
+      IO.popen(command, 'w') do |f|
+        f.puts contents
+      end
+    end
+
     # directly from hirb
     def command_exists?(command)
       ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }

data/lib/choosy/printing.rb

@@ -0,0 +1 @@
+

data/lib/choosy/super_command.rb

@@ -6,14 +6,14 @@ require 'choosy/dsl/super_command_builder'
 
 module Choosy
   class SuperCommand < BaseCommand
-    attr_accessor :metaname
+    attr_accessor :metaname, :default_command
 
     def command_builders
       @command_builders ||= {}
     end
 
     def commands
-      @command_builders.values.map {|b| b.command }
+      @command_builders.values.map {|b| b.entity }
     end
 
     def parsimonious=(value)
@@ -44,6 +44,15 @@ module Choosy
       end
     end
 
+    def has_default?
+      !@default_command.nil?
+    end
+
+    def finalize!
+      super
+      @metaname ||= 'COMMAND'
+    end
+
     protected
     def create_builder
       Choosy::DSL::SuperCommandBuilder.new(self)
@@ -58,11 +67,11 @@ module Choosy
       command_name = hc.message
 
       if command_name == Choosy::DSL::SuperCommandBuilder::SUPER
-        puts printer.print!(self)
+        printer.print!(self)
       else
         builder = command_builders[command_name]
         if builder
-          puts printer.print!(builder.command)
+          printer.print!(builder.entity)
         else
           $stdout << "#{@name}: #{format_help(command_name)}\n"
           exit 1

data/lib/choosy/super_parser.rb

@@ -52,6 +52,8 @@ module Choosy
     end
 
     def parse_globals(args)
+      count = args.count
+
       result = SuperParseResult.new(@super_command)
       parser = Parser.new(@super_command, true, @terminals)
       parser.parse!(args, result)
@@ -61,6 +63,8 @@ module Choosy
       if result.unparsed.length == 0
         if @super_command.command_builders[Choosy::DSL::SuperCommandBuilder::HELP]
           raise Choosy::HelpCalled.new(Choosy::DSL::SuperCommandBuilder::SUPER)
+        elsif count == 0 && @super_command.has_default?
+          result.unparsed << @super_command.default_command.to_s
         else
           raise Choosy::SuperParseError.new("requires a command")
         end
@@ -80,7 +84,7 @@ module Choosy
         end
       end
 
-      command = command_builder.command
+      command = command_builder.entity
       parser = Parser.new(command, false, terminals)
       command_result = Choosy::ParseResult.new(command, true)
       parser.parse!(args, command_result)

data/lib/choosy/verifier.rb

@@ -34,12 +34,20 @@ module Choosy
         if result.command.arguments
           arguments = result.command.arguments
 
+          result.args.map! do |value|
+            Converter.convert(arguments.cast_to, value)
+          end
+
           if result.args.length < arguments.arity.min
             raise Choosy::ValidationError.new("#{prefix}too few arguments (minimum is #{arguments.arity.min})")
           elsif result.args.length > arguments.arity.max
             raise Choosy::ValidationError.new("#{prefix}too many arguments (max is #{arguments.arity.max}): '#{result.args[arguments.arity.max]}'")
           end 
 
+          result.args.each do |val|
+            check(arguments.allowable_values, val)
+          end if arguments.restricted?
+
           if arguments.validation_step
             arguments.validation_step.call(result.args, result.options)
           end

data/lib/choosy/version.rb

@@ -1,12 +1,71 @@
-require 'scanf'
+require 'yaml'
+require 'time'
+require 'choosy/errors'
 
 module Choosy
   class Version
-    CURRENT = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
-    MAJOR, MINOR, TINY = CURRENT.scanf('%d.%d.%d')
+    attr_accessor :date_format, :version_file
 
-    def self.to_s
-      CURRENT
+    def initialize(version_file, date_format='%d/%m/%Y')
+      if !File.file?(version_file)
+        raise Choosy::ConfigurationError.new("No version file given: #{version_file}")
+      end
+
+      @version_file = version_file
+      @date_format = date_format
+      reload!
+    end
+
+    def tiny
+      @contents[VERSION][TINY]
+    end
+
+    def minor
+      @contents[VERSION][MINOR]
+    end
+
+    def major
+      @contents[VERSION][MAJOR]
+    end
+    
+    def date
+      @contents[DATE]
     end
+
+    def reload!
+      @contents = YAML.load_file(@version_file)
+    end
+
+    def version!(kind)
+      kind = kind.to_s
+      unless VERSIONS.include?(kind)
+        raise Choosy::VersionError.new("Wrong versioning schema: #{kind}") 
+      end
+
+      VERSIONS.each do |vers|
+        if vers == kind
+          @contents[VERSION][kind] += 1
+          break
+        else
+          @contents[VERSION][vers] = 0
+        end
+      end
+      @contents[DATE] = Time.now.strftime(@date_format)
+      File.open(@version_file, 'w') do |out|
+        YAML.dump(@contents, out)
+      end
+    end
+
+    def to_s
+      "#{major}.#{minor}.#{tiny}"
+    end
+
+    private
+    VERSION = 'version'
+    TINY = 'tiny'
+    MINOR = 'minor'
+    MAJOR = 'major'
+    VERSIONS = [TINY, MINOR, MAJOR]
+    DATE = 'date'
   end
 end

data/spec/choosy/argument_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helpers'
+require 'choosy/argument'
+
+module Choosy
+  describe Argument do
+    before :each do
+      @argument = Argument.new
+    end
+
+    describe :restricted? do
+      it "should be false when there are no allowable_values" do
+        @argument.restricted?.should be(false)
+      end
+
+      it "should be true when there are allowable_values" do
+        @argument.allowable_values = [:a]
+        @argument.restricted?.should be(true)
+      end
+    end
+
+    describe :finalize! do
+      it "should set the arity if not already set" do
+        @argument.finalize!
+        @argument.arity.should eql(0..0)
+      end
+    end#finalize!
+  end
+end

data/spec/choosy/base_command_spec.rb

@@ -6,9 +6,13 @@ module Choosy
     before :each do
       @cmd = Command.new :cmd
     end
-    it "should finalize the builder" do
-      @cmd.printer.should be_a(Choosy::Printing::HelpPrinter)
-    end 
+
+    describe :finalize! do
+      it "should set the printer if not already set" do
+        @cmd.finalize!
+        @cmd.printer.should be_a(Choosy::Printing::HelpPrinter)
+      end
+    end#finalize!
 
     it "should order the options in dependency order" do
       @cmd.alter do

data/spec/choosy/command_spec.rb

@@ -37,7 +37,7 @@ module Choosy
           }.should raise_error(SystemExit)
         end
 
-        o.should match(/-h, --help/)
+        o.should match(/--help/)
       end
 
       it "should make sure that help gets check before other required options" do
@@ -52,7 +52,7 @@ module Choosy
           }.should raise_error(SystemExit)
         end
 
-        o.should match(/-h, --help/)
+        o.should match(/--help/)
       end
     end
 

data/spec/choosy/converter_spec.rb

@@ -106,8 +106,9 @@ module Choosy
         end
 
         it "should be able to parse a good yaml file" do
-          y = Converter.convert(:yaml, File.join(File.dirname(__FILE__), '..', '..', 'lib', 'VERSION'))
-          y.should eql(Choosy::Version.to_s.chomp)
+          version_file = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'VERSION.yml')
+          y = Converter.convert(:yaml, version_file)
+          y['version']['major'].should eql(Choosy::Version.new(version_file).major)
         end
       end
 

data/spec/choosy/dsl/argument_builder_spec.rb

@@ -5,7 +5,7 @@ module Choosy::DSL
   describe ArgumentBuilder do
     before :each do
       @builder = ArgumentBuilder.new
-      @argument = @builder.argument
+      @argument = @builder.entity
     end
 
     describe :required do
@@ -25,6 +25,24 @@ module Choosy::DSL
       end
     end#required
 
+    describe :only do
+      it "should require at least one argument" do
+        attempting {
+          @builder.only
+        }.should raise_error(Choosy::ConfigurationError, /'only'/)
+      end
+
+      it "should set the allowable_values for an option" do
+        @builder.only :this, :that, :other
+        @argument.allowable_values.should eql([:this, :that, :other])
+      end
+
+      it "should cast to a symbol if not already set" do
+        @builder.only :this, :that, :other
+        @argument.cast_to.should eql(:symbol)
+      end
+    end#only
+
     describe :metaname do
       it "should be able to set the name of the metaname" do
         @builder.metaname 'PARAM'
@@ -168,13 +186,6 @@ module Choosy::DSL
         value.should eql('here')
       end
     end#validate
-
-    describe :finalize! do
-      it "should set the arity if not already set" do
-        @builder.finalize!
-        @argument.arity.should eql(0..0)
-      end
-    end#finalize!
   end
 end