rubigen 1.0.0

data/lib/rubigen/options.rb

@@ -0,0 +1,136 @@
+require 'optparse'
+
+module RubiGen
+  module Options
+    def self.included(base)
+      base.extend(ClassMethods)
+      class << base
+        if respond_to?(:inherited)
+          alias_method :inherited_without_options, :inherited
+        end
+        alias_method :inherited, :inherited_with_options
+      end
+    end
+
+    module ClassMethods
+      def inherited_with_options(sub)
+        inherited_without_options(sub) if respond_to?(:inherited_without_options)
+        sub.extend(RubiGen::Options::ClassMethods)
+      end
+
+      def mandatory_options(options = nil)
+        if options
+          write_inheritable_attribute(:mandatory_options, options)
+        else
+          read_inheritable_attribute(:mandatory_options) or write_inheritable_attribute(:mandatory_options, {})
+        end
+      end
+
+      def default_options(options = nil)
+        if options
+          write_inheritable_attribute(:default_options, options)
+        else
+          read_inheritable_attribute(:default_options) or write_inheritable_attribute(:default_options, {})
+        end
+      end
+
+      # Merge together our class options.  In increasing precedence:
+      #   default_options   (class default options)
+      #   runtime_options   (provided as argument)
+      #   mandatory_options (class mandatory options)
+      def full_options(runtime_options = {})
+        default_options.merge(runtime_options).merge(mandatory_options)
+      end
+
+    end
+
+    # Each instance has an options hash that's populated by #parse.
+    def options
+      @options ||= {}
+    end
+    attr_writer :options
+
+    protected
+      # Convenient access to class mandatory options.
+      def mandatory_options
+        self.class.mandatory_options
+      end
+
+      # Convenient access to class default options.
+      def default_options
+        self.class.default_options
+      end
+
+      # Merge together our instance options.  In increasing precedence:
+      #   default_options   (class default options)
+      #   options           (instance options)
+      #   runtime_options   (provided as argument)
+      #   mandatory_options (class mandatory options)
+      def full_options(runtime_options = {})
+        self.class.full_options(options.merge(runtime_options))
+      end
+
+      # Parse arguments into the options hash.  Classes may customize
+      # parsing behavior by overriding these methods:
+      #   #banner                 Usage: ./script/generate [options]
+      #   #add_options!           Options:
+      #                             some options..
+      #   #add_general_options!   General Options:
+      #                             general options..
+      def parse!(args, runtime_options = {})
+        self.options = {}
+
+        @option_parser = OptionParser.new do |opt|
+          opt.banner = banner
+          add_options!(opt)
+          add_general_options!(opt)
+          opt.parse!(args)
+        end
+
+        return args
+      ensure
+        self.options = full_options(runtime_options)
+      end
+
+      # Raise a usage error.  Override usage_message to provide a blurb
+      # after the option parser summary.
+      def usage(message = usage_message)
+        raise UsageError, "#{@option_parser}\n#{message}"
+      end
+
+      def usage_message
+        ''
+      end
+
+      # Override with your own usage banner.
+      def banner
+        "Usage: #{$0} [options]"
+      end
+
+      # Override to add your options to the parser:
+      #   def add_options!(opt)
+      #     opt.on('-v', '--verbose') { |value| options[:verbose] = value }
+      #   end
+      def add_options!(opt)
+      end
+
+      # Adds general options like -h and --quiet.  Usually don't override.
+      def add_general_options!(opt)
+        opt.separator 'General Options:'
+
+        opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
+        opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
+        opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
+        opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
+        opt.on('-q', '--quiet', 'Suppress normal output.') { |v| options[:quiet] = v }
+        opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
+        opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
+          options[:svn] = `svn status`.inject({}) do |opt, e|
+            opt[e.chomp[7..-1]] = true
+            opt
+          end
+        end
+      end
+
+  end
+end

data/lib/rubigen/scripts/destroy.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module RubiGen::Scripts
+  class Destroy < Base
+    mandatory_options :command => :destroy
+    
+    protected
+    def usage_message
+      usage = "\nInstalled Generators\n"
+      RubiGen::Base.sources.each do |source|
+        label = source.label.to_s.capitalize
+        names = source.names
+        usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+      end
+
+      usage << <<-end_blurb
+
+This script will destroy all files created by the corresponding 
+script/generate command. For instance, script/destroy test_unit create_post
+will delete the appropriate test_create_post.rb file in /test.
+      
+For instructions on finding new generators, run script/generate
+end_blurb
+      return usage
+    end
+  end
+end

data/lib/rubigen/scripts/generate.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module RubiGen::Scripts
+  class Generate < Base
+    mandatory_options :command => :create
+  end
+end

data/lib/rubigen/scripts/update.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module RubiGen::Scripts
+  class Update < Base
+    mandatory_options :command => :update
+
+    protected
+      def banner
+        "Usage: #{$0} [options] scaffold"
+      end
+  end
+end

data/lib/rubigen/scripts.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/options'
+
+module RubiGen
+  module Scripts
+
+    # Generator scripts handle command-line invocation.  Each script
+    # responds to an invoke! class method which handles option parsing
+    # and generator invocation.
+    class Base
+      include Options
+      default_options :collision => :ask, :quiet => false
+
+      # Run the generator script.  Takes an array of unparsed arguments
+      # and a hash of parsed arguments, takes the generator as an option
+      # or first remaining argument, and invokes the requested command.
+      def run(args = [], runtime_options = {})
+        begin
+          parse!(args.dup, runtime_options)
+        rescue OptionParser::InvalidOption => e
+          # Don't cry, script. Generators want what you think is invalid.
+        end
+
+        # Generator name is the only required option.
+        unless options[:generator]
+          usage if args.empty?
+          options[:generator] ||= args.shift
+        end
+
+        # Look up generator instance and invoke command on it.
+        RubiGen::Base.instance(options[:generator], args, options).command(options[:command]).invoke!
+      rescue => e
+        puts e
+        puts "  #{e.backtrace.join("\n  ")}\n" if options[:backtrace]
+        raise SystemExit
+      end
+
+      protected
+        # Override with your own script usage banner.
+        def banner
+          "Usage: #{$0} generator [options] [args]"
+        end
+
+        def usage_message
+          usage = "\nInstalled Generators\n"
+          RubiGen::Base.sources.inject({}) do |mem, source|
+            label = source.label.to_s.capitalize
+            mem[label] ||= []
+            mem[label] |= source.names
+            mem
+          end.each_pair do |label, names|
+            usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+          end
+
+          usage << <<-end_blurb
+
+More are available at http://rubigen.rubyforge.org/
+end_blurb
+
+          usage << <<-end_blurb
+Run generate with no arguments for usage information
+     #{$0} test_unit
+
+end_blurb
+          return usage
+        end
+    end # Base
+
+  end
+end

data/lib/rubigen/simple_logger.rb

@@ -0,0 +1,44 @@
+module RubiGen
+  class SimpleLogger # :nodoc:
+    attr_reader :out
+    attr_accessor :quiet
+
+    def initialize(out = $stdout)
+      @out = out
+      @quiet = false
+      @level = 0
+    end
+
+    def log(status, message, &block)
+      @out.print("%12s  %s%s\n" % [status, '  ' * @level, message]) unless quiet
+      indent(&block) if block_given?
+    end
+
+    def indent(&block)
+      @level += 1
+      if block_given?
+        begin
+          block.call
+        ensure
+          outdent
+        end
+      end
+    end
+
+    def outdent
+      @level -= 1
+      if block_given?
+        begin
+          block.call
+        ensure
+          indent
+        end
+      end
+    end
+
+    private
+      def method_missing(method, *args, &block)
+        log(method.to_s, args.first, &block)
+      end
+  end
+end

data/lib/rubigen/spec.rb

@@ -0,0 +1,42 @@
+module RubiGen
+  # A spec knows where a generator was found and how to instantiate it.
+  # Metadata include the generator's name, its base path, and the source
+  # which yielded it (PathSource, GemPathSource, etc.)
+  class Spec
+    attr_reader :name, :path, :source
+
+    def initialize(name, path, source)
+      @name, @path, @source = name, path, source
+    end
+
+    # Look up the generator class.  Require its class file, find the class
+    # in ObjectSpace, tag it with this spec, and return.
+    def klass
+      unless @klass
+        require class_file
+        @klass = lookup_class
+        @klass.spec = self
+      end
+      @klass
+    end
+
+    def class_file
+      "#{path}/#{name}_generator.rb"
+    end
+
+    def class_name
+      "#{name.camelize}Generator"
+    end
+
+    private
+      # Search for the first Class descending from RubiGen::Base
+      # whose name matches the requested class name.
+      def lookup_class
+        ObjectSpace.each_object(Class) do |obj|
+          return obj if obj.ancestors.include?(RubiGen::Base) and
+                        obj.name.split('::').last == class_name
+        end
+        raise NameError, "Missing #{class_name} class in #{class_file}"
+      end
+  end
+end

data/lib/rubigen/version.rb

@@ -0,0 +1,9 @@
+module Rubigen #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/rubigen.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright (c) 2004 Jeremy Kemper
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+
+begin
+  require 'active_support' 
+rescue LoadError
+  require 'rubygems'
+  gem 'activesupport'
+  require 'active_support' 
+end
+
+require 'rubigen/base'
+require 'rubigen/lookup'
+require 'rubigen/commands'
+
+RubiGen::Base.send(:include, RubiGen::Lookup)
+RubiGen::Base.send(:include, RubiGen::Commands)
+
+# Set up a default logger for convenience.
+require 'rubigen/simple_logger'
+RubiGen::Base.logger = RubiGen::SimpleLogger.new(STDOUT)
+

data/script/destroy

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+require File.join(File.dirname(__FILE__), %w[.. lib rubigen])
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! :rubygems, :newgem
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+require File.join(File.dirname(__FILE__), %w[.. lib rubigen])
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! :rubygems, :newgem
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/rubigen/version.rb'
+version  = Rubigen::VERSION::STRING
+download = 'http://rubyforge.org/projects/rubigen'
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+template = ERB.new(File.open(template).read)
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+$stdout << template.result(binding)