view_mapper 0.1.0

data/test/rails_generator/generators/components/scaffold/scaffold_generator.rb

@@ -0,0 +1,102 @@
+class ScaffoldGenerator < Rails::Generator::NamedBase
+  default_options :skip_timestamps => false, :skip_migration => false, :force_plural => false
+
+  attr_reader   :controller_name,
+                :controller_class_path,
+                :controller_file_path,
+                :controller_class_nesting,
+                :controller_class_nesting_depth,
+                :controller_class_name,
+                :controller_underscore_name,
+                :controller_singular_name,
+                :controller_plural_name
+  alias_method  :controller_file_name,  :controller_underscore_name
+  alias_method  :controller_table_name, :controller_plural_name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+
+    if @name == @name.pluralize && !options[:force_plural]
+      logger.warning "Plural version of the model detected, using singularized version.  Override with --force-plural."
+      @name = @name.singularize
+    end
+
+    @controller_name = @name.pluralize
+
+    base_name, @controller_class_path, @controller_file_path, @controller_class_nesting, @controller_class_nesting_depth = extract_modules(@controller_name)
+    @controller_class_name_without_nesting, @controller_underscore_name, @controller_plural_name = inflect_names(base_name)
+    @controller_singular_name=base_name.singularize
+    if @controller_class_nesting.empty?
+      @controller_class_name = @controller_class_name_without_nesting
+    else
+      @controller_class_name = "#{@controller_class_nesting}::#{@controller_class_name_without_nesting}"
+    end
+  end
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions("#{controller_class_name}Controller", "#{controller_class_name}Helper")
+      m.class_collisions(class_name)
+
+      # Controller, helper, views, test and stylesheets directories.
+      m.directory(File.join('app/models', class_path))
+      m.directory(File.join('app/controllers', controller_class_path))
+      m.directory(File.join('app/helpers', controller_class_path))
+      m.directory(File.join('app/views', controller_class_path, controller_file_name))
+      m.directory(File.join('app/views/layouts', controller_class_path))
+      m.directory(File.join('test/functional', controller_class_path))
+      m.directory(File.join('test/unit', class_path))
+      m.directory(File.join('test/unit/helpers', class_path))
+      m.directory(File.join('public/stylesheets', class_path))
+
+      for action in scaffold_views
+        m.template(
+          "view_#{action}.html.erb",
+          File.join('app/views', controller_class_path, controller_file_name, "#{action}.html.erb")
+        )
+      end
+
+      # Layout and stylesheet.
+      m.template('layout.html.erb', File.join('app/views/layouts', controller_class_path, "#{controller_file_name}.html.erb"))
+      m.template('style.css', 'public/stylesheets/scaffold.css')
+
+      m.template(
+        'controller.rb', File.join('app/controllers', controller_class_path, "#{controller_file_name}_controller.rb")
+      )
+
+      m.template('functional_test.rb', File.join('test/functional', controller_class_path, "#{controller_file_name}_controller_test.rb"))
+      m.template('helper.rb',          File.join('app/helpers',     controller_class_path, "#{controller_file_name}_helper.rb"))
+      m.template('helper_test.rb',     File.join('test/unit/helpers',    controller_class_path, "#{controller_file_name}_helper_test.rb"))
+
+      m.route_resources controller_file_name
+
+      m.dependency 'model', [name] + @args, :collision => :skip
+    end
+  end
+
+  protected
+    # Override with your own usage banner.
+    def banner
+      "Usage: #{$0} scaffold ModelName [field:type, field:type]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--skip-timestamps",
+             "Don't add timestamps to the migration file for this model") { |v| options[:skip_timestamps] = v }
+      opt.on("--skip-migration",
+             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+      opt.on("--force-plural",
+             "Forces the generation of a plural ModelName") { |v| options[:force_plural] = v }
+    end
+
+    def scaffold_views
+      %w[ index show new edit ]
+    end
+
+    def model_name
+      class_name.demodulize
+    end
+end

data/test/rails_generator/lookup.rb

@@ -0,0 +1,249 @@
+require 'pathname'
+
+require File.dirname(__FILE__) + '/spec'
+
+class Object
+  class << self
+    # Lookup missing generators using const_missing.  This allows any
+    # generator to reference another without having to know its location:
+    # RubyGems, ~/.rails/generators, and RAILS_ROOT/generators.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        Rails::Generator::Base.lookup(name).klass
+      else
+        const_missing_before_generators(class_id)
+      end
+    end
+
+    unless respond_to?(:const_missing_before_generators)
+      alias_method :const_missing_before_generators, :const_missing
+      alias_method :const_missing, :lookup_missing_generator
+    end
+  end
+end
+
+# User home directory lookup adapted from RubyGems.
+def Dir.user_home
+  if ENV['HOME']
+    ENV['HOME']
+  elsif ENV['USERPROFILE']
+    ENV['USERPROFILE']
+  elsif ENV['HOMEDRIVE'] and ENV['HOMEPATH']
+    "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+  else
+    File.expand_path '~'
+  end
+end
+
+
+module Rails
+  module Generator
+
+    # Generator lookup is managed by a list of sources which return specs
+    # describing where to find and how to create generators.  This module
+    # provides class methods for manipulating the source list and looking up
+    # generator specs, and an #instance wrapper for quickly instantiating
+    # generators by name.
+    #
+    # A spec is not a generator:  it's a description of where to find
+    # the generator and how to create it.  A source is anything that
+    # yields generators from #each.  PathSource and GemGeneratorSource are provided.
+    module Lookup
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.use_component_sources!
+      end
+
+      # Convenience method to instantiate another generator.
+      def instance(generator_name, args, runtime_options = {})
+        self.class.instance(generator_name, args, runtime_options)
+      end
+
+      module ClassMethods
+        # The list of sources where we look, in order, for generators.
+        def sources
+          read_inheritable_attribute(:sources) or use_component_sources!
+        end
+
+        # Add a source to the end of the list.
+        def append_sources(*args)
+          sources.concat(args.flatten)
+          invalidate_cache!
+        end
+
+        # Add a source to the beginning of the list.
+        def prepend_sources(*args)
+          write_inheritable_array(:sources, args.flatten + sources)
+          invalidate_cache!
+        end
+
+        # Reset the source list.
+        def reset_sources
+          write_inheritable_attribute(:sources, [])
+          invalidate_cache!
+        end
+
+        # Use application generators (app, ?).
+        def use_application_sources!
+          reset_sources
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
+        end
+
+        # Use component generators (model, controller, etc).
+        # 1.  Rails application.  If RAILS_ROOT is defined we know we're
+        #     generating in the context of a Rails application, so search
+        #     RAILS_ROOT/generators.
+        # 2.  Look in plugins, either for generators/ or rails_generators/ 
+        #     directories within each plugin
+        # 3.  User home directory.  Search ~/.rails/generators.
+        # 4.  RubyGems.  Search for gems named *_generator, and look for 
+        #     generators within any RubyGem's 
+        #     /rails_generators/<generator_name>_generator.rb file.
+        # 5.  Builtins.  Model, controller, mailer, scaffold, and so on.
+        def use_component_sources!
+          reset_sources
+          if defined? ::RAILS_ROOT
+            sources << PathSource.new(:lib, "#{::RAILS_ROOT}/lib/generators")
+            sources << PathSource.new(:vendor, "#{::RAILS_ROOT}/vendor/generators")
+            Rails.configuration.plugin_paths.each do |path|
+              relative_path = Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(::RAILS_ROOT))
+              sources << PathSource.new(:"plugins (#{relative_path})", "#{path}/*/**/{,rails_}generators")
+            end
+          end
+          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
+          if Object.const_defined?(:Gem)
+            sources << GemGeneratorSource.new
+            sources << GemPathSource.new
+          end
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
+        end
+
+        # Lookup knows how to find generators' Specs from a list of Sources.
+        # Searches the sources, in order, for the first matching name.
+        def lookup(generator_name)
+          @found ||= {}
+          generator_name = generator_name.to_s.downcase
+          @found[generator_name] ||= cache.find { |spec| spec.name == generator_name }
+          unless @found[generator_name] 
+            chars = generator_name.scan(/./).map{|c|"#{c}.*?"}
+            rx = /^#{chars}$/
+            gns = cache.select{|spec| spec.name =~ rx }
+            @found[generator_name] ||= gns.first if gns.length == 1
+            raise GeneratorError, "Pattern '#{generator_name}' matches more than one generator: #{gns.map{|sp|sp.name}.join(', ')}" if gns.length > 1
+          end
+          @found[generator_name] or raise GeneratorError, "Couldn't find '#{generator_name}' generator"
+        end
+
+        # Convenience method to lookup and instantiate a generator.
+        def instance(generator_name, args = [], runtime_options = {})
+          lookup(generator_name).klass.new(args, full_options(runtime_options))
+        end
+
+        private
+          # Lookup and cache every generator from the source list.
+          def cache
+            @cache ||= sources.inject([]) { |cache, source| cache + source.to_a }
+          end
+
+          # Clear the cache whenever the source list changes.
+          def invalidate_cache!
+            @cache = nil
+          end
+      end
+    end
+
+    # Sources enumerate (yield from #each) generator specs which describe
+    # where to find and how to create generators.  Enumerable is mixed in so,
+    # for example, source.collect will retrieve every generator.
+    # Sources may be assigned a label to distinguish them.
+    class Source
+      include Enumerable
+
+      attr_reader :label
+      def initialize(label)
+        @label = label
+      end
+
+      # The each method must be implemented in subclasses.
+      # The base implementation raises an error.
+      def each
+        raise NotImplementedError
+      end
+
+      # Return a convenient sorted list of all generator names.
+      def names
+        map { |spec| spec.name }.sort
+      end
+    end
+
+
+    # PathSource looks for generators in a filesystem directory.
+    class PathSource < Source
+      attr_reader :path
+
+      def initialize(label, path)
+        super label
+        @path = path
+      end
+
+      # Yield each eligible subdirectory.
+      def each
+        Dir["#{path}/[a-z]*"].each do |dir|
+          if File.directory?(dir)
+            yield Spec.new(File.basename(dir), dir, label)
+          end
+        end
+      end
+    end
+
+    class AbstractGemSource < Source
+      def initialize
+        super :RubyGems
+      end
+    end
+
+    # GemGeneratorSource hits the mines to quarry for generators.  The latest versions
+    # of gems named *_generator are selected.
+    class GemGeneratorSource < AbstractGemSource
+      # Yield latest versions of generator gems.
+      def each
+        dependency = Gem::Dependency.new(/_generator$/, Gem::Requirement.default)
+        Gem::cache.search(dependency).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name.sub(/_generator$/, ''), gem.full_gem_path, label)
+        }
+      end
+    end
+
+    # GemPathSource looks for generators within any RubyGem's /rails_generators/<generator_name>_generator.rb file.
+    class GemPathSource < AbstractGemSource
+      # Yield each generator within rails_generator subdirectories.
+      def each
+        generator_full_paths.each do |generator|
+          yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
+        end
+      end
+
+      private
+        def generator_full_paths
+          @generator_full_paths ||=
+            Gem::cache.inject({}) do |latest, name_gem|
+              name, gem = name_gem
+              hem = latest[gem.name]
+              latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+              latest
+            end.values.inject([]) do |mem, gem|
+              Dir[gem.full_gem_path + '/{rails_,}generators/**/*_generator.rb'].each do |generator|
+                mem << generator
+              end
+              mem
+            end
+        end
+    end
+
+  end
+end

data/test/rails_generator/manifest.rb

@@ -0,0 +1,53 @@
+module Rails
+  module Generator
+
+    # Manifest captures the actions a generator performs.  Instantiate
+    # a manifest with an optional target object, hammer it with actions,
+    # then replay or rewind on the object of your choice.
+    #
+    # Example:
+    #   manifest = Manifest.new { |m|
+    #     m.make_directory '/foo'
+    #     m.create_file '/foo/bar.txt'
+    #   }
+    #   manifest.replay(creator)
+    #   manifest.rewind(destroyer)
+    class Manifest
+      attr_reader :target
+
+      # Take a default action target.  Yield self if block given.
+      def initialize(target = nil)
+        @target, @actions = target, []
+        yield self if block_given?
+      end
+
+      # Record an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+
+      # Replay recorded actions.
+      def replay(target = nil)
+        send_actions(target || @target, @actions)
+      end
+
+      # Rewind recorded actions.
+      def rewind(target = nil)
+        send_actions(target || @target, @actions.reverse)
+      end
+
+      # Erase recorded actions.
+      def erase
+        @actions = []
+      end
+
+      private
+        def send_actions(target, actions)
+          actions.each do |method, args, block|
+            target.send(method, *args, &block)
+          end
+        end
+    end
+
+  end
+end

data/test/rails_generator/options.rb

@@ -0,0 +1,150 @@
+require 'optparse'
+
+module Rails
+  module Generator
+    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(Rails::Generator::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 ''
+          opt.separator 'Rails Info:'
+          opt.on('-v', '--version', 'Show the Rails version number and quit.')
+          opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
+
+          opt.separator ''
+          opt.separator 'General Options:'
+
+          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
+          opt.on('-g', '--git', 'Modify files with git. (Note: git must be in path)') do
+            options[:git] = `git status`.inject({:new => {}, :modified => {}}) do |opt, e|
+              opt[:new][e.chomp[14..-1]] = true if e =~ /new file:/
+              opt[:modified][e.chomp[14..-1]] = true if e =~ /modified:/
+              opt
+            end
+          end
+        end
+
+    end
+  end
+end

data/test/rails_generator/scripts/destroy.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module Rails::Generator::Scripts
+  class Destroy < Base
+    mandatory_options :command => :destroy
+
+    protected
+    def usage_message
+      usage = "\nInstalled Generators\n"
+      Rails::Generator::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
+
+script/generate command. For instance, 'script/destroy migration CreatePost'
+will delete the appropriate XXX_create_post.rb migration file in db/migrate,
+while 'script/destroy scaffold Post' will delete the posts controller and
+views, post model and migration, all associated tests, and the map.resources
+:posts line in config/routes.rb.
+
+For instructions on finding new generators, run script/generate.
+end_blurb
+      return usage
+    end
+  end
+end

data/test/rails_generator/scripts/generate.rb

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

data/test/rails_generator/scripts/update.rb

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

data/test/rails_generator/scripts.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/options'
+
+module Rails
+  module Generator
+    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.
+          Rails::Generator::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"
+            Rails::Generator::Base.sources.inject([]) do |mem, source|
+              # Using an association list instead of a hash to preserve order,
+              # for aesthetic reasons more than anything else.
+              label = source.label.to_s.capitalize
+              pair = mem.assoc(label)
+              mem << (pair = [label, []]) if pair.nil?
+              pair[1] |= source.names
+              mem
+            end.each do |label, names|
+              usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+            end
+
+            usage << <<end_blurb
+
+More are available at http://wiki.rubyonrails.org/rails/pages/AvailableGenerators
+  1. Download, for example, login_generator.zip
+  2. Unzip to directory #{Dir.user_home}/.rails/generators/login
+     to use the generator with all your Rails apps
+end_blurb
+
+            if Object.const_defined?(:RAILS_ROOT)
+              usage << <<end_blurb
+     or to #{File.expand_path(RAILS_ROOT)}/lib/generators/login
+     to use with this app only.
+end_blurb
+            end
+
+            usage << <<end_blurb
+  3. Run generate with no arguments for usage information
+       #{$0} login
+
+Generator gems are also available:
+  1. gem search -r generator
+  2. gem install login_generator
+  3. #{$0} login
+
+end_blurb
+            return usage
+          end
+      end # Base
+
+    end
+  end
+end