merb 0.3.7 → 0.4.0

data/lib/merb/erubis_ext.rb

@@ -0,0 +1,10 @@
+require 'erubis'
+module Erubis
+  class MEruby < Erubis::Eruby
+    include PercentLineEnhancer
+    include StringBufferEnhancer
+  end
+  def self.load_yaml_file(file, binding = binding)
+    YAML::load(Erubis::MEruby.new(IO.read(File.expand_path(file))).result(binding))
+  end
+end

data/lib/merb/exceptions.rb

@@ -0,0 +1,173 @@
+begin
+  require 'coderay'
+rescue LoadError => ex
+end
+
+module Merb
+  # ControllerExceptions are a way of simplifying controller code by placing
+  # exceptional logic back into the MVC pattern.
+  #
+  # When a ControllerException is raised within your application merb will
+  # attempt to re-route the request to your Exceptions controller to render
+  # the error in a friendly mannor.
+  #
+  # For example you might have an action in your app that raises NotFound
+  # if a some resource was not available
+  #
+  #   def show
+  #     product = Product.find(params[:id])
+  #     raise NotFound if product.nil?
+  #     [...]
+  #   end
+  #
+  # This would halt execution of your action and re-route it over to your
+  # Exceptions controller which might look something like
+  #
+  # class Exceptions < Application
+  #   def not_found
+  #     render :layout => :none
+  #   end
+  # end
+  #
+  # As usual the not_found action will look for a template in
+  #   app/views/exceptions/not_found.html.erb
+  #
+  # Note: All standard ControllerExceptions have an HTTP status code associated 
+  # with them which is sent to the browser when the action it is rendered.
+  #
+  # Note: If you do not specifiy how to handle raised ControllerExceptions 
+  # or an unhandlable exception occurs within your customised exception action
+  # then they will be rendered using the built-in error template
+  # in development mode this "built in" template will show stack-traces for
+  # any of the ServerError family of exceptions (you can force the stack-trace
+  # to display in production mode using the :exception_details config option in 
+  # merb.yml)
+  #
+  #
+  # Internal Exceptions 
+  #
+  # Any other rogue errors (not ControllerExceptions) that occur during the 
+  # execution of you app will be converted into the ControllerException 
+  # InternalServerError, and like all ControllerExceptions can be caught
+  # on your Exceptions controller.
+  #
+  # InternalServerErrors return status 500, a common use for cusomizing this
+  # action might be to send emails to the development team, warning that their
+  # application have exploded. Mock example:
+  #
+  #   def internal_server_error
+  #     MySpecialMailer.deliver(
+  #       "team@cowboys.com", 
+  #       "Exception occured at #{Time.now}", 
+  #       params[:exception])
+  #     render :inline => 'Something is wrong, but the team are on it!'
+  #   end
+  #
+  # Note: The special param[:exception] is available in all Exception actions 
+  # and contains the ControllerException that was raised (this is handy if
+  # you want to display the associated message or display more detailed info)
+  #
+  #
+  # Extending ControllerExceptions
+  #
+  # To extend the use of the ControllerExceptions one may extend any of the 
+  # HTTPError classes.
+  #
+  # As an example we can create an exception called AdminAccessRequired.
+  #
+  #   class AdminAccessRequired < Merb::ControllerExceptions::Unauthorized; end
+  #
+  # Add the required action to our Exceptions controller
+  #
+  #   class Exceptions < Application
+  #     def admin_access_required
+  #       render
+  #     end
+  #   end
+  #
+  # In app/views/exceptions/admin_access_required.rhtml
+  # 
+  #   <h1>You're not an administrator!</h1>
+  #   <p>You tried to access <%= @tried_to_access %> but that URL is 
+  #   restricted to administrators.</p>
+  #
+  module ControllerExceptions
+    class Base < StandardError
+      def name
+        self.class.to_s.snake_case.split('::').last
+      end
+    end
+    
+    class Informational                 < Merb::ControllerExceptions::Base; end
+      class Continue                    < Merb::ControllerExceptions::Informational; STATUS = 100; end
+      class SwitchingProtocols          < Merb::ControllerExceptions::Informational; STATUS = 101; end
+    class Successful                    < Merb::ControllerExceptions::Base; end
+      class OK                          < Merb::ControllerExceptions::Successful; STATUS = 200; end
+      class Created                     < Merb::ControllerExceptions::Successful; STATUS = 201; end
+      class Accepted                    < Merb::ControllerExceptions::Successful; STATUS = 202; end
+      class NonAuthoritativeInformation < Merb::ControllerExceptions::Successful; STATUS = 203; end
+      class NoContent                   < Merb::ControllerExceptions::Successful; STATUS = 204; end
+      class ResetContent                < Merb::ControllerExceptions::Successful; STATUS = 205; end
+      class PartialContent              < Merb::ControllerExceptions::Successful; STATUS = 206; end
+    class Redirection                   < Merb::ControllerExceptions::Base; end
+      class MultipleChoices             < Merb::ControllerExceptions::Redirection; STATUS = 300; end
+      class MovedPermanently            < Merb::ControllerExceptions::Redirection; STATUS = 301; end
+      class MovedTemporarily            < Merb::ControllerExceptions::Redirection; STATUS = 302; end
+      class SeeOther                    < Merb::ControllerExceptions::Redirection; STATUS = 303; end
+      class NotModified                 < Merb::ControllerExceptions::Redirection; STATUS = 304; end
+      class UseProxy                    < Merb::ControllerExceptions::Redirection; STATUS = 305; end
+      class TemporaryRedirect           < Merb::ControllerExceptions::Redirection; STATUS = 307; end
+    class ClientError                   < Merb::ControllerExceptions::Base; end
+      class BadRequest                  < Merb::ControllerExceptions::ClientError; STATUS = 400; end
+      class Unauthorized                < Merb::ControllerExceptions::ClientError; STATUS = 401; end
+      class PaymentRequired             < Merb::ControllerExceptions::ClientError; STATUS = 402; end
+      class Forbidden                   < Merb::ControllerExceptions::ClientError; STATUS = 403; end
+      class NotFound                    < Merb::ControllerExceptions::ClientError; STATUS = 404; end
+        class ActionNotFound            < Merb::ControllerExceptions::NotFound; end
+        class TemplateNotFound          < Merb::ControllerExceptions::NotFound; end
+        class LayoutNotFound            < Merb::ControllerExceptions::NotFound; end
+      class MethodNotAllowed            < Merb::ControllerExceptions::ClientError; STATUS = 405; end
+      class NotAcceptable               < Merb::ControllerExceptions::ClientError; STATUS = 406; end
+      class ProxyAuthenticationRequired < Merb::ControllerExceptions::ClientError; STATUS = 407; end
+      class RequestTimeout              < Merb::ControllerExceptions::ClientError; STATUS = 408; end
+      class Conflict                    < Merb::ControllerExceptions::ClientError; STATUS = 409; end
+      class Gone                        < Merb::ControllerExceptions::ClientError; STATUS = 410; end
+      class LengthRequired              < Merb::ControllerExceptions::ClientError; STATUS = 411; end
+      class PreconditionFailed          < Merb::ControllerExceptions::ClientError; STATUS = 412; end
+      class RequestEntityTooLarge       < Merb::ControllerExceptions::ClientError; STATUS = 413; end
+      class RequestURITooLarge          < Merb::ControllerExceptions::ClientError; STATUS = 414; end
+      class UnsupportedMediaType        < Merb::ControllerExceptions::ClientError; STATUS = 415; end
+      class RequestRangeNotSatisfiable  < Merb::ControllerExceptions::ClientError; STATUS = 416; end
+      class ExpectationFailed           < Merb::ControllerExceptions::ClientError; STATUS = 417; end
+    class ServerError                   < Merb::ControllerExceptions::Base; end
+      class NotImplemented              < Merb::ControllerExceptions::ServerError; STATUS = 501; end
+      class BadGateway                  < Merb::ControllerExceptions::ServerError; STATUS = 502; end
+      class ServiceUnavailable          < Merb::ControllerExceptions::ServerError; STATUS = 503; end
+      class GatewayTimeout              < Merb::ControllerExceptions::ServerError; STATUS = 504; end
+      class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; STATUS = 505; end
+      class InternalServerError         < Merb::ControllerExceptions::ServerError; STATUS = 500
+        DEFAULT_TEMPLATE = ::Merb::Dispatcher::DEFAULT_ERROR_TEMPLATE
+      
+        def initialize(exception = nil)
+          @exception = exception
+          @coderay = CodeRay rescue nil
+        end
+      
+        def backtrace
+          @exception ? @exception.backtrace : backtrace
+        end
+      
+        def message
+          @exception ? @exception.message : message
+        end
+      end
+  end
+  
+  # PLEASE STOP REMOVING THIS ONE GUYS! It's used to show exceptions in the log file
+  # this is the second time I've had to add it back.
+  def self.exception(e) 
+    "#{ e.message } - (#{ e.class })\n" <<  
+    "#{(e.backtrace or []).join("\n")}" 
+  end
+
+end  

data/lib/merb/generators/merb_app/merb_app.rb

@@ -4,33 +4,13 @@ require 'find'
 module Merb
   
   class AppGenerator    
-    SKELETON_DIR = File.expand_path File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'examples/skeleton')
-    
     def self.run(path)
-      @path = path
-      @path = File.expand_path(@path)
-      if File.exists? @path
-        STDERR.puts "ERROR: Path #{@path} already exists! Aborting!"
-        exit 1
-      end
+      require 'rubygems'
+      require 'rubigen'
 
-      puts "Copying skeleton app to '#@path'"
-      # Unpacks 'test.tar' to 'x', creating 'x' if necessary.
-      FileUtils.cp_r(SKELETON_DIR, @path)
-      Find.find(@path) do |f|
-        FileUtils.rm_rf(f) if /\.svn$/ =~ f
-      end
-      public_path = File.expand_path(File.join(@path, "dist", "public"))
-      mailer_path = File.expand_path(File.join(@path, "dist", "app", "mailers"))
-      app_path    = File.expand_path(File.join(@path, "dist", "app"))
-      FileUtils.mkdir_p(["#{mailer_path}/helpers", 
-                         "#{mailer_path}/views", 
-                         "#{@path}/log", 
-                         "#{app_path}/models",
-                         "#{public_path}/javascripts",
-                         "#{public_path}/stylesheets",
-                         "#{public_path}/images"])
-      puts 'Done' 
+      require 'rubigen/scripts/generate'
+      RubiGen::Base.use_application_sources!
+      RubiGen::Scripts::Generate.new.run([path], :generator => 'merb', :backtrace => true)
     end  
 
   end

data/lib/merb/generators/merb_generator_helpers.rb

@@ -0,0 +1,317 @@
+# Provides some basic generator support that is generally required in various 
+# Generators
+
+module Merb
+  module GeneratorHelpers
+    
+    class ModelGeneratorBase < RubiGen::Base
+
+      default_options :author => nil
+      attr_reader :name, :model_attributes
+      attr_accessor :model_template_name, :model_test_generator_name, :migration_generator_name
+      
+      def initialize(runtime_args, runtime_options = {})
+        super
+        usage if args.empty?
+        @class_name = args.shift.snake_case.to_const_string
+        extract_options
+      end
+
+      def manifest
+        unless @class_name
+          puts banner
+          exit 1
+        end
+        record do |m|
+
+          # ensure there are no other definitions of this model already defined.
+          m.class_collisions(@class_name)
+          # Ensure appropriate folder(s) exists
+          m.directory 'app/models'
+          # 
+          model_filename = @class_name.snake_case
+          spec_filename = @class_name.snake_case.pluralize
+          table_name = spec_filename
+
+
+          # Create stubs
+          m.template  model_template_name, 
+                      "app/models/#{model_filename}.rb", 
+                      :assigns => {  :class_name => @class_name, 
+                                     :table_attributes => model_attributes}
+
+          # Check to see if a scope has been set for which test framework to use.
+          # If we try to run the dependency without an :rspec or :test_unit scope an
+          # error will be raised.
+          scopes = RubiGen::Base.sources.select{ |s| s.is_a?( RubiGen::PathFilteredSource )}.first.filters
+          if scopes.include?(:rspec) || scopes.include?(:test_unit)
+            unless options[:skip_testing] 
+              m.dependency model_test_generator_name, [@class_name]
+            end
+          else
+            puts "\nSelect a scope for :rspec or :test_unit in script/generate if you want to generate test stubs\n\n"
+          end
+
+          unless options[:skip_migration]
+            m.dependency migration_generator_name,["add_model_#{spec_filename}"], :table_name => table_name, :table_attributes => model_attributes
+          end
+
+        end    
+      end
+
+      protected
+        def banner
+            <<-EOS
+Creates a new model for merb
+
+USAGE: #{$0} #{spec.name} NameOfModel [field:type field:type]
+
+Example:
+  #{$0} #{spec.name} person
+
+  If you already have 3 migrations, this will create the AddModelPeople migration in
+  schema/migration/004_add_model_people.rb
+
+Options: 
+  --skip-migration will not create a migration file
+
+EOS
+          end
+
+        def add_options!(opts)
+          opts.separator ''
+          opts.separator 'Options:'
+          # For each option below, place the default
+          # at the top of the file next to "default_options"
+          # opts.on("-a", "--author=\"Your Name\"", String,
+          #         "Some comment about this option",
+          #         "Default: none") { |options[:author]| }
+          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+          opts.on( "--skip-migration", "Don't generate a migration for this model") { |options[:skip_migration]| }
+          opts.on( "--skip-testing", "Don't generate a test or spec file for this model") { |options[:skip_testing]| }
+        end
+
+        def extract_options
+          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+          # Templates can access these value via the attr_reader-generated methods, but not the
+          # raw instance variable value.
+          # @author = options[:author]
+          # get the attributes into a format that can be used.
+          attribute = Struct.new(:name, :type)
+          @model_attributes = args.map{ |b| b.split(":").size > 1 ? attribute.new(*b.split(":")) : nil }.compact
+        end
+    end
+    
+    class MigrationGeneratorBase < RubiGen::Base
+
+      default_options :author => nil
+
+      attr_reader :name
+      attr_accessor :migration_template_name
+      
+      def initialize(runtime_args, runtime_options = {})
+        super
+        usage if args.empty?
+        @class_name = args.shift
+        options[:table_name] ||= runtime_options[:table_name]
+        extract_options
+      end
+
+      def manifest
+        unless @class_name
+          puts banner
+          exit 1
+        end
+        record do |m|
+          # Ensure appropriate folder(s) exists
+          m.directory 'schema/migrations'
+
+          # Create stubs
+          highest_migration = Dir[Dir.pwd+'/schema/migrations/*'].map{|f| File.basename(f) =~ /^(\d+)/; $1}.max
+          filename = format("%03d_%s", (highest_migration.to_i+1), @class_name.snake_case)
+          m.template "new_migration.erb", "schema/migrations/#{filename}.rb", 
+            :assigns => { :class_name => @class_name, 
+                          :table_name => options[:table_name],
+                          :table_attributes => options[:table_attributes] }
+
+        end
+      end
+
+      protected
+        def banner
+          <<-EOS
+Creates a new migration for merb
+
+USAGE: #{$0} #{spec.name} NameOfMigration [field:type field:type]
+
+Example:
+  #{$0} #{spec.name} AddPeople
+
+  If you already have 3 migrations, this will create the AddPeople migration in
+  schema/migration/004_add_people.rb
+
+  #{$0} #{spec.name} project --table-name projects_table name:string created_at:timestamp
+
+  This will create a migration that creates a table call projects_table with these attributes:
+    string :name
+    timestamp :created_at
+
+EOS
+        end
+
+        def add_options!(opts)
+          opts.separator ''
+          opts.separator 'Options:'
+          # For each option below, place the default
+          # at the top of the file next to "default_options"
+          # opts.on("-a", "--author=\"Your Name\"", String,
+          #         "Some comment about this option",
+          #         "Default: none") { |options[:author]| }
+          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+          opts.on( "--table-name=\"table_name_for_migration\"", 
+                    String,
+                    "Include a create table with the given table name"){ |options[:table_name]| }
+        end
+
+        def extract_options
+          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+          # Templates can access these value via the attr_reader-generated methods, but not the
+          # raw instance variable value.
+          # @author = options[:author]
+          if !options[:table_attributes]
+            attribute = Struct.new(:name, :type)
+            options[:table_attributes] = args.map{ |b| b.split(":").size == 2 ? attribute.new(*b.split(":")) : nil }.compact
+          end
+        end
+    end
+    
+    class MerbModelTestGenerator < RubiGen::Base
+
+      default_options :author => nil
+
+      attr_reader :name, :model_test_template_name, :model_test_path_name, :model_test_file_suffix
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+        usage if args.empty?
+        @class_name = args.shift.snake_case.to_const_string
+        extract_options
+      end
+
+      def manifest
+        unless @class_name
+          puts banner
+          exit 1
+        end
+        record do |m|
+          # ensure there are no other definitions of this model already defined.
+          # Ensure appropriate folder(s) exists
+          m.directory model_test_path_name
+          # 
+          model_filename = @class_name.snake_case
+
+          # Create stubs
+          m.template model_test_template_name, 
+            "#{model_test_path_name}/#{model_filename}_#{model_test_file_suffix}.rb", 
+            :assigns => {:class_name => @class_name}
+        end
+      end
+
+      protected
+
+
+        def add_options!(opts)
+          # opts.separator ''
+          # opts.separator 'Options:'
+          # For each option below, place the default
+          # at the top of the file next to "default_options"
+          # opts.on("-a", "--author=\"Your Name\"", String,
+          #         "Some comment about this option",
+          #         "Default: none") { |options[:author]| }
+          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+        end
+
+        def extract_options
+          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+          # Templates can access these value via the attr_reader-generated methods, but not the
+          # raw instance variable value.
+          # @author = options[:author]
+        end
+    end
+    
+    # Pass the following options are available to this generatrs
+    class ControllerGeneratorBase < RubiGen::Base
+
+      default_options :author => nil
+
+      attr_reader :name, :class_name, :file_name
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+        usage if args.empty?
+        @name             = args.shift
+        @class_name       = @name.camel_case #.pluralize
+        @file_name        = @name.snake_case #.pluralize
+        @engine           = runtime_options[:engine] || "erb" # set by subclasses only
+        @template_actions = runtime_options[:actions] || %w[index] # Used by subclasses only
+        @test_generator   = runtime_options[:test_stub_generator] || "merb_controller_test"
+        extract_options
+      end
+
+      def manifest
+        record do |m|
+          
+          # ensure there are no other definitions of this model already defined.
+          m.class_collisions(@class_name)
+          
+          m.directory "app/controllers"
+          m.template "controller.rb", "app/controllers/#{file_name}.rb", :assigns => {:actions => @template_actions}
+          
+          m.directory "app/views/#{file_name}"
+          
+          # Include templates if they exist
+          @template_actions.each do |the_action|  
+            template_name = "#{the_action}.html.#{@engine}"
+            template_path = "/" + source_path(spec.name).split("/")[0..-2].join("/")
+
+            if File.exists?(File.join(template_path,template_name))
+              m.template template_name, "app/views/#{file_name}/#{template_name}"
+            end
+          end
+
+          m.directory "app/helpers/"
+          m.template "helper.rb", "app/helpers/#{file_name}_helper.rb"
+          m.dependency @test_generator, [name], :destination => destination_root, :template_actions => @template_actions
+        end
+      end
+
+      protected
+        def banner
+          <<-EOS
+    Creates a Merb controller
+
+    USAGE: #{$0} #{spec.name} name"
+    EOS
+        end
+
+        def add_options!(opts)
+          # opts.separator ''
+          # opts.separator 'Options:'
+          # For each option below, place the default
+          # at the top of the file next to "default_options"
+          # opts.on("-a", "--author=\"Your Name\"", String,
+          #         "Some comment about this option",
+          #         "Default: none") { |options[:author]| }
+          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+        end
+
+        def extract_options
+          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+          # Templates can access these value via the attr_reader-generated methods, but not the
+          # raw instance variable value.
+          # @author = options[:author]
+        end
+    end
+    
+  end
+end