kiss 0.9

data/lib/kiss/mailer.rb

@@ -0,0 +1,92 @@
+class Kiss
+  # This class creates, renders, and sends email messages.
+  class Mailer
+    include Kiss::TemplateMethods
+  
+    # Class Methods
+  
+    def self.set_controller(controller)
+      @@controller = controller
+    end
+  
+    # Instance Methods
+    
+    # Creates new email message object.
+    def initialize(options = {})
+      @options = {
+        :engine => :sendmail
+      }.merge(options)
+      
+      @data = {}
+    end
+    
+    # Invokes controller's file_cache.
+    def file_cache(*args,&block)
+      controller.file_cache(*args,&block)
+    end
+    
+    def controller
+      @@controller
+    end
+    
+    # Renders email template to string, unless message option is
+    # already set to a string value.
+    def prepare_email_message(options = {})
+      @options.merge!(options)
+    
+      unless @options[:message].is_a?(String)
+        if template_name = @options[:template]
+          @template_dir = @@controller.email_template_dir
+          raise 'email_template_dir path not set' unless @template_dir
+      
+          data = vars = @options[:data] || @options[:vars]
+      
+          path = "#{@template_dir}/#{template_name}"
+          @options[:message] = erubis(path,binding)
+        else
+          raise 'email message not defined'
+        end
+      end
+    
+      return @options[:message]
+    end
+    
+    # Sets data to be passed to email template.
+    def set(key,value)
+      @data[key] = value
+    end
+    
+    # Attempts to send message using SMTP, unless :engine option is set to
+    # :sendmail.
+    def send(options)
+      @options.merge!(options)
+      if options[:engine] == :sendmail
+        return sendmail
+      else
+        return send_smtp
+      end
+    end
+    
+    # Attempts to send message using /usr/sbin/sendmail.
+    def sendmail(options = {})
+      prepare_email_message(options)
+    
+      IO.popen(@options[:sendmail_path] || "/usr/sbin/sendmail -t","w") do |pipe|
+        pipe.puts(@options[:message])
+      end
+    end
+    
+    # Attempts to send message using Net::SMTP.
+    def send_smtp(options = {})
+      prepare_email_message(options)
+    
+      require 'net/smtp' unless defined?(Net::SMTP)
+      # begin
+        Net::SMTP.start('localhost') do |smtp|
+      		smtp.sendmail(@options[:message], options[:from], options[:to])
+      	end
+      # rescue
+      # end
+    end
+  end
+end

data/lib/kiss/model.rb

@@ -0,0 +1,114 @@
+class Kiss
+  # This class adds functionality to Sequel::Model and automatically loads
+  # model class definitions from model_dir.  It also uses Kiss#file_cache
+  # to cache database model classes, unless no model_dir is specified.
+  class Model < Sequel::Model
+    class << self
+      def name
+        @table.to_s
+      end
+  
+      # Name symbol for default foreign key
+      def default_remote_key
+        :"#{name.singularize.demodulize.underscore}_id"
+      end
+      
+      def set_controller(controller)
+        @@controller = controller
+      end
+      
+      def set_dataset(source)
+        super(source)
+      end
+      
+      def table=(table)
+        @table = table
+      end
+      
+      def controller
+        @@controller
+      end
+      
+      def dbm
+        @@controller.dbm
+      end
+      
+      # TODO: Fix has_many and many_to_many associations
+      def associate(type, name, opts = {}, &block)
+        opts = opts.clone
+    
+        unless opts[:class] || opts[:class_name]
+          opts[:class_name] = name.to_s.pluralize
+        end
+        
+        super(type, name, opts, &block)
+        
+        association_reflections[name]
+      end
+    end
+    
+    def method_missing(meth)
+      raise NoMethodError, "undefined method `#{meth}' for database model `#{self.class.name}'"
+    end
+    
+    def controller
+      @@controller
+    end
+    
+    include Kiss::ControllerAccessors
+  end
+
+  class ModelCache
+    def initialize(controller,model_dir = nil)
+      @controller = controller
+      @model_dir = model_dir && File.directory?(model_dir) ? model_dir : nil
+      @cache = {}
+    end
+  
+    def [](source)
+      (@model_dir && source.is_a?(Symbol)) ? begin
+        # use controller's file_cache
+        model_path = "#{@model_dir}/#{source}.rb"
+        @controller.file_cache(model_path) do |src|
+          klass = Class.new(Kiss::Model)
+          klass.set_dataset(Model.db[source])
+          klass.table = source
+          klass.class_eval(src,model_path) if src
+          klass
+        end
+      end : begin
+        # no model_dir, or source is not a symbol
+        # no mapping from source to filesystem path
+        # use ModelCache's own cache
+        @cache[source] ||= begin
+          klass = Class.new(Kiss::Model)
+          klass.set_dataset(Model.db[source])
+          klass.table = source if source.is_a?(Symbol)
+          klass
+        end
+      end
+    end
+  
+    def db
+      Sequel::Model.db
+    end
+  
+    def literal(*args)
+      Sequel::Model.dataset.literal(*args)
+    end
+    alias_method :quote, :literal
+  
+    def mdy_to_ymd(*args)
+      Kiss.mdy_to_ymd(*args)
+    end
+  end
+end
+
+Sequel::Model::Associations::AssociationReflection.class_eval do
+  def associated_class
+    self[:class] ||= Kiss::Model.controller.dbm[self[:class_name].to_s.pluralize.to_sym]
+  end
+  def default_left_key
+    :"#{self[:model].name.singularize.underscore}_id"
+  end
+end

data/lib/kiss/rack/bench.rb

@@ -0,0 +1,131 @@
+def bench(label = nil)
+  Rack::Bench.close_bench_item(Kernel.caller[0])
+  Rack::Bench.on
+  
+  if label
+    Rack::Bench.push_bench_item(
+      :label => label,
+      :start_time => Time.now,
+      :start_context => Kernel.caller[0]
+    )
+  end
+end
+
+module Rack
+  # Rack::Bench adds benchmarking capabilities to Kiss applications.
+  #
+  # bench(label) starts a new timer, which ends upon the next call to
+  # bench, or when execution returns to Rack::Bench.
+  #
+  # bench can be called without a label to end the previous timer 
+  # without starting a new one.
+  #
+  # Total request duration is also displayed for any request in which
+  # the bench function is called.
+  class Bench
+    def self.on
+      @@bench = true
+    end
+    
+    def self.close_bench_item(end_context = nil)
+      if @@bench_items[-1] && !@@bench_items[-1][:end_time]
+        @@bench_items[-1][:end_time] = Time.now
+        @@bench_items[-1][:end_context] = end_context
+      end
+    end
+    
+    def self.push_bench_item(item)
+      @@bench_items.push(item)
+    end
+    
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @@bench = false
+      @@bench_items = []
+      
+      start_time = Time.now
+      code, headers, body = @app.call(env)
+      end_time = Time.now
+      
+      if @@bench
+        Rack::Bench.close_bench_item
+        contents = <<-EOT
+<style>
+.kiss_bench {
+  text-align: left;
+  padding: 3px 7px;
+  border: 1px solid #ec4;
+  border-top: 1px solid #fff4bb;
+  border-bottom: 1px solid #d91;
+  background-color: #ffe590;
+  font-size: 12px;
+  color: #101;
+}
+.kiss_bench a {
+  color: #930;
+  text-decoration: none;
+}
+.kiss_bench a:hover {
+  color: #930;
+  text-decoration: underline;
+}
+</style>
+EOT
+        
+        contents += @@bench_items.map do |item|
+          start_link = context_link(item[:start_context])
+          end_link = context_link(item[:end_context])
+          
+          <<-EOT
+<div class="kiss_bench">
+<tt><b>#{item[:label].gsub(/\</,'&lt;')} duration: #{sprintf("%0.3f",item[:end_time].to_f - item[:start_time].to_f)} s</b></tt>
+<small style="line-height: 105%; display: block; padding-bottom: 3px">kiss bench<br/>started at #{start_link}<br/>ended at #{end_link || 'return to kiss bench'}</small>
+</div>
+EOT
+        end.join
+        
+        contents += <<-EOT
+<div class="kiss_bench">
+<tt><b>TOTAL request duration: #{sprintf("%0.3f",end_time.to_f - start_time.to_f)} s</b></tt>
+<br><small>kiss bench request total</small>
+</div>
+EOT
+      else
+        contents = ''
+      end
+      
+      body.each {|p| contents += p }
+      headers['Content-Length'] = contents.length.to_s
+    
+      [ code, headers, contents ]
+    end
+    
+    def absolute_path(filename)
+      filename = ( filename =~ /\A\// ? '' : (Dir.pwd + '/') ) + filename
+    end
+    
+    def context_link(context)
+      return nil unless context
+      
+      filename, line, method = context.split(/:/)
+      textmate_url = "txmt://open?url=file://" + h(absolute_path(filename)) + '&amp;line=' + line
+      %Q(<a href="#{textmate_url}">#{filename}:#{line}</a> #{method})
+    end
+    
+    def textmate_href(frame)
+      "txmt://open?url=file://" + h(absolute_path(context)).sub(/:/,'&amp;line=')
+    end
+
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj).gsub(/^(\s+)/) {'&nbsp;' * $1.length}
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+  end
+end

data/lib/kiss/rack/email_errors.rb

@@ -0,0 +1,64 @@
+module Rack
+  # Rack::EmailErrors sends error responses (code 5xx) to email addresses as
+  # specified in the Rack::Builder config.
+  class EmailErrors
+    def initialize(app,agent,app_name,from,*to)
+      @app = app
+      @agent = agent == :sendmail ? '/usr/sbin/sendmail -t' : agent
+      @app_name = app_name
+      @from = from
+      @to = to.flatten
+    end
+
+    def call(env)
+      code, headers, body = @app.call(env)
+      
+      if code >= 500 && code < 600
+        begin # rescue any errors in message composition and sending
+          error_type = headers['X-Kiss-Error-Type'] || "#{code} Error"
+          error_message = headers['X-Kiss-Error-Message']
+          
+          message = <<-EOT
+Content-type: text/html
+From: #{@from}
+To: #{@to.join(', ')}
+Subject: #{@app_name} - #{error_type}#{ error_message ? ": #{error_message}" : ''}
+
+EOT
+          
+          body.each do |part|
+            message += part
+          end
+          
+          if @agent.is_a?(String)
+            IO.popen(@agent,"w") do |pipe|
+              pipe.puts(message)
+            end
+          else
+            require 'net/smtp' unless defined?(Net::SMTP)
+            smtp = @agent.is_a?(Net::SMTP) ? @agent : Net::SMTP.new('localhost')
+            smtp.start do |smtp|
+          		smtp.send_message(message, @from, *@to)
+          	end
+        	end
+        rescue
+        end
+        
+        body = <<-EOT
+<html>
+<head>
+<title>Error</title>
+</head>
+<body>
+<h1>Application Server Error</h1>
+<p>Sorry, an error occurred.  Our technical staff has been notified and will investigate this issue.</p>
+</body>
+</html>
+EOT
+        headers['Content-Length'] = body.length.to_s
+      end
+      
+      [ code, headers, body ]
+    end
+  end
+end

data/lib/kiss/rack/facebook.rb

@@ -0,0 +1,28 @@
+module Rack
+  # Rack::Facebook formats HTTP responses to remove certain status codes
+  # and HTML entities that are invalid as FBML responses.
+  class Facebook
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      code, headers, body = @app.call(env)
+      
+      if code >= 500 && code < 600
+        code = 200
+      end
+      
+      contents = ''
+      body.each {|p| contents += p }
+      
+      contents.gsub!(/txmt:\/\//, 'http://textmate.local/')
+      contents.gsub!('<body>','<div class="body">')
+      contents.gsub!('</body>','</div>')
+      
+      headers['Content-Length'] = contents.length.to_s
+      
+      [ code, headers, contents ]
+    end
+  end
+end

data/lib/kiss/rack/file_not_found.rb

@@ -0,0 +1,42 @@
+module Rack
+  # Rack::FileNotFound rescues Kiss::TemplateFileNotFound exceptions
+  # (raised when action template files are not found) and returns an
+  # HTTP 404 error response.
+  class FileNotFound
+    def initialize(app,path = nil)
+      @app = app
+      @body = path ? (
+        ::File.file?(path) ?
+          ::File.read(path) :
+          template('could not find specified FileNotFound error document')
+        ) : template
+    end
+
+    def call(env)
+      code, headers, body = @app.call(env)
+    rescue Kiss::TemplateFileNotFound => e
+      [ 404, {
+        "Content-Type" => "text/html",
+        "Content-Length" => @body.length.to_s
+      }, @body ]
+    end
+    
+    def template(error = nil)
+      <<EOT
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <title>File Not Found</title>
+</head>
+<body>
+<h1>404 File Not Found</h1>
+
+#{error ? "<p>Additionally, #{error}.</p>" : ''}
+</body>
+</html>
+EOT
+    end
+  end
+end

data/lib/kiss/rack/log_exceptions.rb

@@ -0,0 +1,23 @@
+module Rack
+  # Rack::ShowExceptions catches exceptions raised from the app,
+  # showing a useful backtrace with clickable stack frames and 
+  # TextMate links to source files, as well as the last database
+  # query, GET/POST params, cookies, and Rack environment variables.
+  #
+  # Be careful using this on public-facing sites as it could reveal 
+  # potentially sensitive information to malicious users.
+
+  class LogExceptions
+    def initialize(app,path)
+      @app = app
+      @@file = ::File.open(path,'w')
+    end
+    
+    def call(env)
+      @app.call(env)
+    rescue StandardError, LoadError, SyntaxError => e
+      @@file.print Kiss::ExceptionReport.generate(env, e) + "\n--- End of exception report --- \n\n"
+      raise
+    end
+  end
+end

data/lib/kiss/rack/show_debug.rb

@@ -0,0 +1,82 @@
+$debug_messages = []
+def debug(object)
+  $debug_messages.push( [object.inspect, Kernel.caller[0]] )
+  object
+end
+
+module Rack
+  # Rack::ShowDebug displays messages logged by the debug function.
+  #
+  # Be careful using this on public-facing sites as it could reveal 
+  # potentially sensitive information to malicious users.
+  
+  class ShowDebug
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      $debug_messages = []
+      code, headers, body = @app.call(env)
+      
+      if $debug_messages.size > 0
+        contents = <<-EOT
+<style>
+.kiss_debug {
+  text-align: left;
+  padding: 3px 7px;
+  border: 1px solid #ebe;
+  border-top: 1px solid #fdf;
+  border-bottom: 1px solid #d6d;
+  background-color: #fbf;
+  font-size: 12px;
+  color: #101;
+}
+.kiss_debug a {
+  color: #707;
+  text-decoration: none;
+}
+.kiss_debug a:hover {
+  color: #707;
+  text-decoration: underline;
+}
+</style>
+EOT
+        contents += $debug_messages.map do |object,context|
+          filename, line, method = context.split(/:/)
+          textmate_url = "txmt://open?url=file://" + h(absolute_path(filename)) + '&amp;line=' + line
+          <<-EOT
+<div class="kiss_debug">
+<tt><b>#{object.gsub(/\</,'&lt;')}</b></tt>
+<br><small>kiss debug output at <a href="#{textmate_url}">#{filename}:#{line}</a> #{method}</small>
+</div>
+EOT
+        end.join
+      else
+        contents = ''
+      end
+      
+      body.each {|p| contents += p }
+      headers['Content-Length'] = contents.length.to_s
+      
+      [ code, headers, contents ]
+    end
+    
+    def absolute_path(filename)
+      filename = ( filename =~ /\A\// ? '' : (Dir.pwd + '/') ) + filename
+    end
+    
+    def textmate_href(frame)
+      "txmt://open?url=file://" + h(absolute_path(context)).sub(/:/,'&amp;line=')
+    end
+
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj).gsub(/^(\s+)/) {'&nbsp;' * $1.length}
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+  end
+end

data/lib/kiss/rack/show_exceptions.rb

@@ -0,0 +1,27 @@
+module Rack
+  # Rack::ShowExceptions catches exceptions raised from the app,
+  # showing a useful backtrace with clickable stack frames and 
+  # TextMate links to source files, as well as the last database
+  # query, GET/POST params, cookies, and Rack environment variables.
+  #
+  # Be careful using this on public-facing sites as it could reveal 
+  # potentially sensitive information to malicious users.
+
+  class ShowExceptions
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      @app.call(env)
+    rescue StandardError, LoadError, SyntaxError => e
+      body = Kiss::ExceptionReport.generate(env, e)
+      [500, {
+        "Content-Type" => "text/html",
+        "Content-Length" => body.length.to_s,
+        "X-Kiss-Error-Type" => e.class.name,
+        "X-Kiss-Error-Message" => e.message.sub(/\n.*/m,'')
+      }, body]
+    end
+  end
+end

data/lib/kiss/sequel_mysql.rb

@@ -0,0 +1,23 @@
+module Sequel
+  module MySQL
+    class Dataset < Sequel::Dataset
+      # Returns results from dataset query as array of arrays,
+      # instead of array of hashes. 
+      def all_arrays(opts = nil, &block)
+        a = []
+        fetch_arrays(select_sql(opts)) {|r| a << r}
+        a.each(&block) if block
+        a
+      end
+      
+      # Fixes bug in Sequel 1.5; shouldn't be needed for Sequel 2.x
+      # (need to double-check, however).
+      def fetch_arrays(sql)
+        @db.execute_select(sql) do |r|
+          r.each_array {|row| yield row}
+        end
+        self
+      end
+    end
+  end
+end