merb 0.5.3 → 0.9.2

data/lib/merb/generators/merb_plugin.rb

@@ -1,22 +0,0 @@
-require 'fileutils'
-require 'find'
-
-module Merb
-  
-  class PluginGenerator    
-    def self.run(path)
-      require 'rubygems'
-      require 'rubigen'
-
-      require 'rubigen/scripts/generate'
-      source = RubiGen::PathSource.new(:application, 
-        File.join(File.dirname(__FILE__), "../../../app_generators"))
-      RubiGen::Base.reset_sources
-      RubiGen::Base.append_sources source
-      RubiGen::Scripts::Generate.new.run([path], :generator => 'merb_plugin', :backtrace => true)
-    end  
-
-  end
-        
-end  
-

data/lib/merb/logger.rb

@@ -1,78 +0,0 @@
-module Merb
-
-  class Logger
-    module Severity
-      DEBUG = 0
-      INFO = 1
-      WARN = 2
-      ERROR = 3
-      FATAL = 4
-      UNKNOWN = 5
-    end
-    include Severity
-
-    attr_accessor :level
-    attr_reader :buffer
-    
-    def initialize(log, level = DEBUG)
-      @level = level
-      @buffer = []
-      @aio = false
-      if log.respond_to?(:write)
-        @log = log
-      elsif File.exist?(log)
-        @log = open(log, (File::WRONLY | File::APPEND))
-        @log.sync = true
-      else
-        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
-        @log.sync = true
-        @log.write("# Logfile created on %s\n" % [Time.now.to_s])
-      end
-      if !Merb.environment.match(/development|test/) && 
-         !RUBY_PLATFORM.match(/java|mswin/) &&
-         !(@log == STDOUT) &&
-          @log.respond_to?(:write_nonblock)
-        @aio = true
-      end
-    end
-    
-    def flush
-      unless @buffer.size == 0
-        if @aio
-          @log.write_nonblock(@buffer.slice!(0..-1).to_s)
-        else
-          @log.write(@buffer.slice!(0..-1).to_s)
-        end
-      end
-    end
-    
-    def close
-      flush
-      @log.close if @log.respond_to?(:close)
-      @log = nil
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      return if @level > severity
-      message = (message || (block && block.call) || progname).to_s
-      # If a newline is necessary then create a new message ending with a newline.
-      # Ensures that the original message is not mutated.
-      message = "#{message}\n" unless message[-1] == ?\n
-      @buffer << message
-      message
-    end
-    
-    Severity.constants.each do |severity|
-      class_eval <<-EOT
-        def #{severity.downcase}(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)
-        end
-       
-        def #{severity.downcase}?
-          #{severity} >= @level
-        end
-      EOT
-    end
-    
-  end
-end

data/lib/merb/mail_controller.rb

@@ -1,268 +0,0 @@
-
-module Merb
-  
-  # Sending mail from a controller involves three steps:
-  #
-  # * Set mail settings in merb_init.rb (Not shown here...see the Mailer docs).
-  # * Create a MailController subclass with actions and templates.
-  # * Call the MailController from another Controller via the send_mail method.
-  #
-  # First, create a file in app/mailers that subclasses Merb::MailController. 
-  # The actions in this controller will do nothing but render mail.
-  #
-  #   # app/mailers/article_mailer.rb
-  #   class ArticleMailer < Merb::MailController
-  # 
-  #     def notify
-  #       @user = params[:user]
-  #       render_mail
-  #     end
-  # 
-  #   end
-  #
-  # You also can access the params hash for values passed with the 
-  # Controller.send_mail method. See also the documentation for 
-  # render_mail to see all the ways it can be called.
-  #
-  # Create a template in a subdirectory of app/mailers/views that corresponds
-  # to the controller and action name. Put plain text and ERB tags here:
-  #
-  #   # app/mailers/views/article_mailer/notify.text.erb
-  #   Hey, <%= @user.name %>,
-  #   
-  #   We're running a sale on dog bones!
-  #
-  # Finally, call the Controller.send_mail method from a standard 
-  # Merb controller.
-  #
-  #   class Articles < Application
-  #
-  #     def index
-  #       @user = User.find_by_name('louie')
-  #
-  #       send_mail(ArticleMailer, :notify, {
-  #         :from => "me@example.com",
-  #         :to => "louie@example.com",
-  #         :subject => "Sale on Dog Bones!"
-  #       }, { :user => @user })
-  #       render
-  #     end
-  #
-  #   end  
-  #
-  # Note: If you don't pass a fourth argument to Controller.send_mail,
-  # the controller's params will be sent to the MailController subclass
-  # as params. However, you can explicitly send a hash of objects that 
-  # will populate the params hash instead. In either case, you must 
-  # set instance variables in the MailController's actions if you 
-  # want to use them in the MailController's views.
-  #
-  # The MailController class is very powerful. You can:
-  #
-  # * Send multipart email with a single call to render_mail.
-  # * Attach files.
-  # * Render layouts and other templates.
-  # * Use any template engine supported by Merb.
-  
-  class MailController < AbstractController
-   
-    self._template_root = File.expand_path(self._template_root / "../mailers/views")
-    class_inheritable_accessor :_mailer_klass
-    self._mailer_klass  = Merb::Mailer
-    
-    attr_accessor :params, :mailer, :mail
-    attr_reader   :session, :base_controller
-    
-    # You can initialize a MailController with a series of parameters that can
-    # be used by methods in the class. You can also pass in a controller
-    # object, which will be available to the MailController methods as
-    # base_controller.
-    def initialize(params = {}, controller = nil)
-      @params = params
-      @base_controller = controller
-      @session = (controller && controller.session) || {}
-      super
-    end
-    
-    def filters_halted
-    end
-    
-    # Allows you to render various types of things into the text and HTML parts
-    # of an email If you include just text, the email will be sent as
-    # plain-text. If you include HTML, the email will be sent as a multi-part
-    # email.
-    #
-    # There are a lot of ways to use render_mail, but it works similarly to the
-    # default Merb render method.
-    #
-    # First of all, you'll need to store email files in your
-    # app/mailers/views directory. They should be under a directory that
-    # matches the name of your mailer (e.g. TestMailer's views would be stored
-    # under test_mailer).
-    #
-    # The files themselves should be named action_name.mime_type.extension. For
-    # example, an erb template that should be the HTML part of the email, and
-    # rendered from the "foo" action would be named foo.html.erb.
-    #
-    # The only mime-types currently supported are "html" and "text", which
-    # correspond to text/html and text/plain respectively. All template systems
-    # supported by your app are available to MailController, and the extensions
-    # are the same as they are throughout the rest of Merb.
-    #
-    # render_mail can take any of the following option patterns:
-    #
-    #   render_mail
-    #
-    # will attempt to render the current action. If the current action is
-    # "foo", this is identical to render_mail :foo.
-    #
-    #   render_mail :foo
-    # 
-    # checks for foo.html.ext and foo.text.ext and applies them as appropriate.
-    #
-    #   render_mail :action => {:html => :foo, :text => :bar}
-    #
-    # checks for foo.html.ext and bar.text.ext in the view directory of the
-    # current controller and adds them to the mail object if found
-    #
-    #   render_mail :template => {:html => "foo/bar", :text => "foo/baz"}
-    #
-    # checks for bar.html.ext and baz.text.ext in the foo directory and adds
-    # them to the mail object if found.
-    #
-    #   render_mail :html => :foo, :text => :bar
-    #
-    # the same as render_mail :action => {html => :foo, :text => :bar }
-    #
-    #   render_mail :html => "FOO", :text => "BAR"
-    #
-    # adds the text "FOO" as the html part of the email and the text "BAR" as
-    # the text part of the email. The difference between the last two examples
-    # is that symbols represent actions to render, while string represent the
-    # literal text to render. Note that you can use regular render methods
-    # instead of literal strings here, like:
-    #
-    #   render_mail :html => render(:action => :foo)
-    #
-    # but you're probably better off just using render_mail :action at that
-    # point.
-    #
-    # You can also mix and match:
-    #
-    #   render_mail :action => {:html => :foo}, :text => "BAR"
-    #
-    # which would be identical to:
-    #
-    #   render_mail :html => :foo, :text => "BAR"
-    def render_mail(options = @method)
-      @_missing_templates = false # used to make sure that at least one template was found
-      # # If the options are not a hash, normalize to an action hash
-      options = {:action => {:html => options, :text => options}} if !options.is_a?(Hash)
-      
-      # Take care of the options
-      use_options = {}
-      opts = options.dup
-      actions = opts.delete(:action) if opts[:action].is_a?(Hash)
-      templates = opts.delete(:template) if opts[:template].is_a?(Hash)
-      
-      # Prepare the options hash for each format
-      # We need to delete anything relating to the other format here
-      # before we try to render the template.
-      [:html, :text].each do |fmt|
-        opts_hash = use_options[fmt] = {}
-        opts_hash[fmt] = opts.delete(fmt)
-        opts_hash[fmt] ||= actions[fmt] if actions && actions[fmt]
-        opts_hash[:tempalte] = templates[fmt] if templates && templates[fmt]
-      end
-      
-      # Send the result to the mailer
-      { :html => "rawhtml=", :text => "text="}.each do |fmt,meth|
-        begin
-          value = render use_options[fmt].merge!(opts).merge!(:clean_context => true, :format => fmt)
-          @mail.send(meth,value) unless value.nil? || value.empty?
-        rescue => e
-          # An error should be logged if no template is found instead of an error raised
-          if @_missing_templates
-            Merb.logger.error(e)
-          else
-            @_missing_templates = true
-          end
-        end
-      end
-      @mail
-    end
-    
-    # Attaches a file or multiple files to an email. You call this from a
-    # method in your MailController (including a before filter).
-    # 
-    #   attach File.open("foo")
-    #   attach [File.open("foo"), File.open("bar")]
-    # 
-    # You can also include the filename, mime-type, or headers in the
-    # subsequent parameters.
-    # 
-    # If you are passing an array of files, you should use an array of the
-    # allowed parameters:
-    # 
-    #   attach [[File.open("foo"), "bar", "text/html"], [File.open("baz"),
-    # "bat", "text/css"]
-    # 
-    #  which would attach two files ("foo" and "baz" in the filesystem) as
-    # "bar" and "bat" respectively. It would also set the mime-type as
-    # "text/html" and "text/css" respectively.
-    def attach( file_or_files, filename = file_or_files.is_a?(File) ? File.basename(file_or_files.path) : nil, 
-      type = nil, headers = nil)
-      @mail.attach(file_or_files, filename, type, headers)
-    end
-    
-    # take a method name to dispatch to and mail parameters for the MailFactory object.
-    #
-    # Available mail parameters include:
-    #   to
-    #   from
-    #   replyto
-    #   subject
-    #   body
-    #   cc
-    #
-    # Other parameters passed in will be interpreted as email headers, with _'s converted
-    # to -'s.
-    def dispatch_and_deliver(method, mail_params)
-      @mailer         = self.class._mailer_klass.new(mail_params)
-      @mail           = @mailer.mail
-      @method         = method
-      
-      # dipatch and render use params[:action], so set it
-      params[:action] = method
-      body            = dispatch method
-      if !@mail.html.blank? || !@mail.text.blank? 
-        @mailer.deliver!
-        Merb.logger.info "#{method} sent to #{@mail.to} about #{@mail.subject}"
-      else
-        Merb.logger.info "#{method} was not sent because nothing was rendered for it"
-      end
-    end
-
-    # A convenience method that creates a blank copy of the MailController and runs
-    # dispatch_and_deliver on it.
-    def self.dispatch_and_deliver(method, mail_params, send_params = {})
-      new(send_params).dispatch_and_deliver method, mail_params
-    end
-    
-    protected
-    def route
-      @base_controller.route if @base_controller
-    end
-
-    private
-    # This method is here to overwrite the one in the general_controller mixin
-    # The method ensures that when a url is generated with a hash, it contains a controller
-    def get_controller_for_url_generation(opts)
-      controller = opts[:controller] || ( @base_controller.params[:controller] if @base_controller)
-       raise "No Controller Specified for url()" unless controller
-       controller
-    end
-    
-    
-  end
-end

data/lib/merb/mailer.rb

@@ -1,87 +0,0 @@
-begin
-  require 'mailfactory'
-  require 'net/smtp'
-rescue LoadError
-  puts "You need to install the mailfactory gem to use Merb::Mailer"
-  Merb.logger.warn "You need to install the mailfactory gem to use Merb::Mailer"
-end  
-
-class MailFactory
-  attr_reader :html, :text
-end
-
-module Merb
-
-  # You'll need a simple config like this in merb_init.rb if you want
-  # to actually send mail:
-  #
-  #   Merb::Mailer.config = {
-  #     :host=>'smtp.yourserver.com',
-  #     :port=>'25',              
-  #     :user=>'user',
-  #     :pass=>'pass',
-  #     :auth=>:plain # :plain, :login, :cram_md5, the default is no auth
-  #   }
-  # 
- 	#   or 
- 	# 
- 	#   Merb::Mailer.config = {:sendmail_path => '/somewhere/odd'}
-  #   Merb::Mailer.delivery_method = :sendmail
-  #
-  # You could send mail manually like this (but it's better to use
-  # a MailController instead).
-  # 
-  #   m = Merb::Mailer.new :to => 'foo@bar.com',
-  #                        :from => 'bar@foo.com',
-  #                        :subject => 'Welcome to whatever!',
-  #                        :body => partial(:sometemplate)
-  #   m.deliver!                     
-
-  class Mailer
-    
-    class_inheritable_accessor :config, :delivery_method, :deliveries
-    attr_accessor :mail
-    self.deliveries = []
-    
-    def sendmail
-      sendmail = IO.popen("#{config[:sendmail_path]} #{@mail.to}", 'w+') 
-      sendmail.puts @mail.to_s
-      sendmail.close
-    end
-  
-    # :plain, :login, or :cram_md5
-    def net_smtp
-      Net::SMTP.start(config[:host], config[:port].to_i, config[:domain], 
-                      config[:user], config[:pass], config[:auth]) { |smtp|
-        smtp.send_message(@mail.to_s, @mail.from.first, @mail.to.to_s.split(/[,;]/))
-      }
-    end
-    
-    def test_send
-      deliveries << @mail
-    end
-    
-    def deliver!
-      send(delivery_method || :net_smtp)
-    end
-      
-    def attach(file_or_files, filename = file_or_files.is_a?(File) ? File.basename(file_or_files.path) : nil, 
-      type = nil, headers = nil)
-      if file_or_files.is_a?(Array)
-        file_or_files.each {|k,v| @mail.add_attachment_as k, *v}
-      else
-        raise ArgumentError, "You did not pass in a file. Instead, you sent a #{file_or_files.class}" if !file_or_files.is_a?(File)
-        @mail.add_attachment_as(file_or_files, filename, type, headers)
-      end
-    end
-      
-    def initialize(o={})
-      self.config = {:sendmail_path => '/usr/sbin/sendmail'} if config.nil? 
-      o[:rawhtml] = o.delete(:html)
-      m = MailFactory.new()
-      o.each { |k,v| m.send "#{k}=", v }
-      @mail = m
-    end
-    
-  end
-end