merb 0.3.4 → 0.3.7

data/lib/merb/merb_mail_controller.rb

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__)+'/merb_mailer'
+
+module Merb
+  class MailController < AbstractController
+   
+    self._template_root = File.expand_path(DIST_ROOT / "app/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) || {}
+    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
+    # dist/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, a herb template that should be the HTML part of the email, and
+    # rendered from the "foo" action would be named foo.html.herb.
+    #
+    # 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)
+      # If the options are not a hash, normalize to an action hash
+      options = {:action => {:html => options, :text => options}} if !options.is_a?(Hash)
+      # Normalize :html => :sym and :text => :sym to an action hash
+      options[:action] ||= {}
+        options[:action][:html] = options.delete(:html) if options[:html].is_a?(Symbol)
+        options[:action][:text] = options.delete(:text) if options[:text].is_a?(Symbol)
+      options.delete(:action) if options[:action].empty?
+
+      # set type to action or template, if the hash includes :action or :template
+      type = options.keys.find {|x| x.to_s =~ /(action|template)/}
+      # normalize :action/:template => ... to :action/template => {:html => ..., :text => ...}
+      options[type] = {:html => options[type], :text => options[type]} if type && !options[type].is_a?(Hash)
+      for mime_type in [:html, :text]
+        # if action or template, get the template to render. If not, get the string to render. If none
+        # are available, use the default params[:action]
+        renderer = (type && options[type][mime_type] ? options[type][mime_type] : options[mime_type]).to_s
+        # action or template
+        if type && options[type][mime_type]
+          # build the template to render
+          mime_renderer = renderer + ".#{mime_type}" if !(renderer =~ /.#{mime_type}$/)
+          if find_template(type => mime_renderer)
+            @mail.send((mime_type == :html ? "rawhtml=" : "text="), 
+              render(type => mime_renderer, :layout => mimed_layout(mime_type, options[:layout]))) 
+          elsif find_template(type => renderer) && mime_type == :text
+            @mail.text = render(type => renderer, :layout => options[:layout])
+          end
+        # string to render
+        else
+          @mail.send((mime_type == :html ? "rawhtml=" : "text="), renderer)
+        end
+      end
+    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
+      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)
+      new({}).dispatch_and_deliver method, mail_params
+    end
+    
+    private
+    def mimed_layout(mime_type, layout = nil)
+      if layout && layout != :application
+        layout_choice = find_template(:layout => layout + ".#{mime_type}") ||
+          find_template(:layout => layout)
+      elsif name = find_template(:layout => self.class.name.snake_case + ".#{mime_type}")
+        layout_choice = name
+      elsif name = find_template(:layout => self.class.name.snake_case)
+        layout_choice = name
+      elsif name = find_template(:layout => "application.#{mime_type}")
+        layout_choice = name
+      else
+        layout_choice = find_template(:layout => "application")
+      end
+      layout_choice = layout_choice.split("/").last.split(".")[0...-1].join(".")
+    end
+    
+  end
+end

data/lib/merb/merb_mailer.rb

@@ -1,5 +1,3 @@
-
-
 begin
   require 'mailfactory'
   require 'net/smtp'
@@ -8,10 +6,16 @@ rescue LoadError
   MERB_LOGGER.warn "You need to install the mailfactory gem to use Merb::Mailer"
 end  
 
+class MailFactory
+  attr_reader :html, :text
+end
+
 module Merb
   class Mailer
     
-    class_inheritable_accessor :config
+    class_inheritable_accessor :config, :delivery_method, :deliveries
+    attr_accessor :mail
+    self.deliveries = []
     
     def sendmail
       sendmail = IO.popen("sendmail #{@mail.to}", 'w+')
@@ -22,28 +26,40 @@ module Merb
     # :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].intern||:plain)) { |smtp|
-        smtp.send_message(@mail.to_s, @mail.from, @mail.to)
-      }  
+                      config[:user], config[:pass], (config[:auth].to_sym||:plain)) { |smtp|
+        smtp.send_message(@mail.to_s, @mail.from.first, @mail.to)
+      }
+    end
+    
+    def test_send
+      deliveries << @mail
     end
     
     def deliver!
-      config == :sendmail ? sendmail : net_smtp
+      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 if config.nil?
+      o[:rawhtml] = o.delete(:html)
       @mail = returning MailFactory.new() do |m|
-        m.to = o[:to]
-        m.from = o[:from]
-        m.subject = o[:subject]
-        m.text = o[:body]
-        m.html = o[:html] if o[:html]
+        o.each { |k,v| m.send "#{k}=", v }
       end
-    end 
+    end
     
   end
 end
+
 =begin
 
 
@@ -54,10 +70,14 @@ Merb::Mailer.config = {
   :pass=>'pass',
   :auth=>:plain # :plain, :login, or :cram_md5, default :plain
 }
+
+Merb::Mailer.delivery_method = :sendmail
+
 m = Merb::Mailer.new :to => 'foo@bar.com',
                      :from => 'bar@foo.com',
                      :subject => 'Welcome to whatever!',
                      :body => partial(:sometemplate)
 m.deliver!                     
 
+
 =end

data/lib/merb/merb_part_controller.rb

@@ -0,0 +1,42 @@
+module Merb
+  class PartController < AbstractController
+    self._template_root = File.expand_path(DIST_ROOT / "app/parts/views")
+    
+    def initialize(web_controller)
+      @_benchmarks = {}
+      @web_controller = web_controller
+    end
+
+    def dispatch(action=:to_s)
+      old_action = params[:action]
+      params[:action] = action
+      super(action)
+      params[:action] = old_action
+      @_body
+    end
+    
+    def request
+       @web_controller.request  
+    end
+            
+    def params
+      @web_controller.params
+    end  
+    
+    def cookies
+      @web_controller.cookies
+    end  
+
+    def headers
+      @web_controller.headers
+    end
+    
+    def session
+      @web_controller.session
+    end
+
+    def response
+      @web_controller.response
+    end
+  end
+end    

data/lib/merb/merb_plugins.rb

@@ -0,0 +1,293 @@
+# TODO: Find Merb app root so we aren't wantonly copying Rakefiles
+# TODO: Figure out a good way to handle the lack of install/uninstall script
+# TODO: Minimum versions for local gems in install
+
+require 'yaml'
+require 'rubygems'
+
+module Merb
+  class PluginManager
+    
+    def self.gem_name
+      @@gem_name
+    end
+    
+    def self.gem_spec
+      @@gem_spec
+    end
+    
+    def self.options
+      @@options
+    end
+    
+    def self.gem_name=(val)
+      @@gem_name = val
+    end
+    
+    def self.gem_spec=(val)
+      @@gem_spec = val
+    end
+    
+    def self.options=(val)
+      @@options = val
+    end
+
+
+    # Run a particular plugin action
+    def self.action(action, gem_name = nil, opts = [])
+      @@gem_name = gem_name
+      @@options = opts.flatten
+      
+      case action
+        when 'install':
+          install
+        when 'uninstall':
+          uninstall
+        when 'remove':
+          remove_from_manifest
+        when 'list':
+          list
+        when 'help'
+          help
+        when 'migrate'
+          migrate
+        when 'update'
+          raise "This hasn't been implemented yet!"
+        when 'upgrade'
+          raise "This hasn't been implemented yet!"
+        else
+          raise "Invalid action: #{action}"
+      end
+    end
+    
+    # Install a new plugin named +gem_name+.
+    def self.install
+      raise "Plugin already installed!" if plugin_installed?
+      
+      self.gem_spec = find_locally or install_gem 
+      
+      run_install_script
+      copy_rakefile
+      add_to_manifest
+    rescue Exception => e
+      puts "\n!!! Plugin installation FAILED: #{e.message}\n\n"
+    end
+    
+    # Check the manifest to see if the plugin is already installed in this application.
+    def self.plugin_installed?
+      with_manifest do |manifest|
+        return manifest.has_key?(gem_name)
+      end
+    rescue
+      false
+    end
+    
+    # Search the local Rubygems installation for the gem.
+    def self.find_locally
+      all_installed_gems = Gem::SourceIndex.from_installed_gems
+      latest_gem_version = all_installed_gems.search(gem_name).sort_by {|x| x.version.version }.last
+      require 'pp'
+
+      if latest_gem_version
+        puts "Local gem found."
+        return latest_gem_version
+      else
+        puts "Can't find gem...installing."
+        return false
+      end
+    end
+    
+    # Run the installation code in the gem.
+    def self.run_install_script
+      require "#{gem_name}/install"
+    end
+    
+    # Copy the Rakefile from the gem to a directory in our application.
+    def self.copy_rakefile
+      path = gem_spec.loaded_from.split(/specifications/)[0] + "gems/#{gem_name}-#{gem_spec.version.version}/"
+      
+      merb_rake_file = path + "Rakefile.merb"
+      
+      require 'fileutils'
+      Dir.mkdir 'plugins' if !File.exists?('plugins/')
+      FileUtils.cp merb_rake_file, "plugins/#{gem_name}.rake"
+      
+      File.open('Rakefile', 'a') do |rakefile|
+        rakefile.write("\nrequire 'plugins/#{gem_name}.rake\n")
+      end
+    end
+    
+    def self.remove_rakefile
+      FileUtils.rm "plugins/#{gem_name}.rake"
+      
+      File.open('Rakefile', 'r+') do |rakefile|
+        contents = rakefile.read
+        contents.gsub!("\nrequire 'plugins/#{gem_name}.rake\n", "")
+        
+        rakefile.pos = 0
+        rakefile.write contents
+        rakefile.truncate rakefile.pos
+      end
+    end
+    
+    # Do a gem installation since it wasn't found in the locally installed gems.
+    def self.install_gem
+      require 'rubygems/installer'
+      
+      options = {
+          :domain => :both, 
+          :generate_rdoc => true,
+          :generate_ri   => true,
+          :force => false, 
+          :test => false, 
+          :wrappers => true,
+          :version => "> 0",
+          :install_dir => Gem.dir,
+          :security_policy => nil }
+          
+      
+          
+      puts "Attempting local install..."
+      local_install = Gem::Installer.new(gem_name, options).install(options[:force], options[:install_dir]) rescue false
+      
+      if !local_install
+        # Do remote installation
+        require 'rubygems/remote_installer'     
+        
+        Gem.configuration = ConfigStub.new
+        
+        puts "Attempting remote installation..."
+        installer = Gem::RemoteInstaller.new(options)
+        
+        @@options.each do |opt|
+          installer.sources << opt.gsub(/source=/, '') if opt.scan(/^source=/) != []
+          options[:version] = "> #{opt.gsub(/version=/, '')}" if opt.scan(/^version=/) != []
+        end
+        
+        remote_install = installer.install(gem_name, options[:version], options[:force], options[:install_dir]) rescue false
+      end
+      
+      if !remote_install && !local_install
+        raise "That plugin can't be found in locally or in a remote repository."
+      else
+        find_locally
+      end
+    end
+    
+    # Method to open and load our manifest; yields the manifest data to whatever method calls it.
+    def self.with_manifest
+      File.open('plugins.manifest', 'r+') do |manifest_file|
+        manifest_data = YAML::load(manifest_file.read)
+        manifest_data = {} if !manifest_data.is_a?(Hash)
+
+        yield manifest_data
+        
+        manifest_file.pos = 0
+        manifest_file.write manifest_data.to_yaml
+        manifest_file.truncate manifest_file.pos
+      end
+    end
+    
+    # Write our newly installed plugin to the application's manifest.
+    def self.add_to_manifest
+      with_manifest do |manifest_data|
+        manifest_data[gem_name] = {'version' => gem_spec.version.version}
+      end
+    end
+    
+    def self.uninstall
+      raise "That plugin isn't installed!" if !plugin_installed?
+      
+      require "#{gem_name}/uninstall" rescue nil
+      
+      remove_rakefile
+      remove_from_manifest
+      uninstall_gem
+    end
+    
+    def self.remove_from_manifest
+      with_manifest do |manifest|
+        manifest.delete(gem_name)
+      end
+    end
+    
+    def self.uninstall_gem
+      require 'rubygems/installer'
+      require 'rubygems/doc_manager'
+      
+      options = {
+          :domain => :both, 
+          :generate_rdoc => true,
+          :generate_ri   => true,
+          :force => false, 
+          :test => false, 
+          :wrappers => true,
+          :version => "> 0",
+          :install_dir => Gem.dir,
+          :security_policy => nil }
+          
+      Gem::Uninstaller.new(gem_name, options).uninstall
+    end
+    
+    def self.list
+      with_manifest do |manifest_data|
+        manifest_data.each do |key, value|
+          gem_name = key
+          gem_spec = find_locally
+          puts "#{key} (#{gem_spec.version.version})"
+          puts "\t#{gem_spec.description}\n"
+        end
+      end
+    end
+    
+    def self.migrate
+      raise "This hasn't been implemented yet!"
+    end
+    
+    def self.help
+      puts """
+Merb Plugins
+The -P (--plugin) option fed to Merb allows you to manage plugins.
+
+Commands
+--------
+install     Installs a new plugin.
+uninstall   Uninstalls a plugin, removing its entry from the manifest and uninstalling the gem.
+remove      Uninstalls a plugin, removing its entry from the manifest but leaving the gem installed.
+list        Lists all installed plugins for this Merb application.
+upgrade     Upgrades a plugin to the specified version.
+update      Updates a plugin to the latest available version.
+migrate     Reads the manifest for this application, installing and updating gems as needed.
+help        Shows this help message.
+
+"""
+    end
+  end
+  
+  # Class to stub out the verbose flag in Rubygems user interaction lib
+  class ConfigStub
+    attr_accessor :verbose
+    
+    def initialize
+      @verbose = false
+    end
+  end
+end
+
+module Gem
+  # Fixes a bug in RubyGems where the SilentProgressReporter class is
+  # inaccurately named SilentReporter. Maybe one day we'll monkeypatch this for
+  # our own purposes.
+  class SilentProgressReporter
+    attr_reader :count
+
+    def initialize(out_stream, size, initial_message)
+    end
+
+    def updated(message)
+    end
+
+    def done
+    end
+  end
+end