kiss 0.9

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2005-2008 MultiWidget LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+    s.platform  =   Gem::Platform::RUBY
+    s.name      =   'kiss'
+    s.version   =   File.read('VERSION').chomp
+    s.author    =   'Shawn Van Ittersum'
+    s.email     =   'shawn @nospam@ multiwidget.com'
+    s.homepage  =   'http://www.rubykiss.org'
+    s.rubyforge_project = 'kiss'
+    s.summary   =   'An MVC web application framework using Rack, Sequel, and Erubis.'
+    s.files     =   %w( Rakefile VERSION LICENSE ) + Dir['{lib,tests}/**/*']
+    s.require_path  =   'lib'
+    s.test_files    =   Dir.glob('tests/*.rb')
+    s.has_rdoc      =   true
+    
+    s.rdoc_options << '--main' << 'Kiss' <<
+                      '--title' << 'Kiss: Ruby MVC Web Framework -- RDoc Reference Documentation'
+    
+    s.add_dependency('rack')
+    s.add_dependency('sequel','>=2.2.0')
+    s.add_dependency('erubis')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+
+task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
+    puts "generated pkg/#{spec.name}-#{spec.version}.gem"
+end

data/VERSION

@@ -0,0 +1 @@
+0.9

data/lib/kiss/action.rb

@@ -0,0 +1,204 @@
+class Kiss
+  class Action
+    include Kiss::TemplateMethods
+  
+    # Class Methods
+  
+    class << self
+      # Sets reference back to controller (Kiss instance).
+      def set_controller(controller)
+        @@controller = controller
+      end
+    end
+  
+    # Instance Methods
+  
+    # Raises custom error message for missing methods, specifying current action
+    # more clearly than standard error message.
+    def method_missing(meth)
+      raise NoMethodError, "undefined method `#{meth}' for action `#{@action}'"
+    end
+  
+    # Creates a new action instance from controller data.
+    def initialize
+      @action = @@controller.action
+    
+      @data = {}
+      @forms = {}
+      @template_dir = @@controller.template_dir
+    end
+  
+    # Invokes controller's file_cache, setting exception class to Kiss::TemplateFileNotFound,
+    # which will be raised if file is not found.  (This exception class may be caught and
+    # handled by Rack builder option FileNotFound to produce an HTTP 404 error response.)
+    def file_cache(path,fnf_file_type,fnf_exception_class = Kiss::TemplateFileNotFound,&block)
+      controller.file_cache(path,fnf_file_type,fnf_exception_class,&block)
+    end
+  
+    def controller
+      @@controller
+    end
+  
+    def forms
+      @forms
+    end
+  
+    # Returns true is `form' param matches current action path.
+    def form_action_match
+      form = params['form']
+      return false unless form =~ /^\w+(\/\w+)*$/s
+      return form == @action || @action =~ /\/#{form}/
+    end
+  
+    # Returns object from specified table, with id matching first argument (or argument of specified index).
+    def arg_object(table,index = 0)
+      result = dbm[table][arg(index)]
+      raise "#{table.to_s.singularize} not found" unless result
+    
+      result
+    end
+  
+    # Returns arg_object, or new object of specified table if arg_object is not found.
+    def arg_object_or_new(table,*args)
+      return (arg_object(table,*args) ) rescue dbm[table].new
+    end
+  
+    # Validates param of specified key against specified format.
+    def validate_param(key, format, required = false)
+      value = @params[key]
+      print_key = key.gsub('_',' ')
+    
+      case (Kiss.validate_value(value, format, required))
+      when :missing:
+        raise "required param '#{key}' is missing"
+      when :invalid:
+        raise "param '#{key}' is invalid"
+      end
+    
+      value
+    end
+  
+    # Validates argument of specified index against specified format.
+    def validate_arg(index, options)
+      value = @args[index]
+    
+      case (Kiss.validate_value(value, format, required))
+      when :missing:
+        raise "required arg #{index} is missing"
+      when :invalid:
+        raise "arg #{index} is invalid"
+      end
+      
+      value
+    end
+  
+    # Creates and invokes new Kiss::Mailer instance to send email message via sendmail.
+    def sendmail(options)
+      Kiss::Mailer.new.sendmail({
+        :data => data
+      }.merge(options))
+    end
+  
+    # Creates and invokes new Kiss::Mailer instance to send email message via SMTP,
+    # unless options specify :engine => :sendmail.
+    def send_email(options)
+      controller.new_email.send({
+        :data => data
+      }.merge(options))
+    end
+  
+    # Sends HTTP 302 response to redirect client agent to specified URL.
+    def redirect_url(*args)
+      controller.redirect_url(*args)
+    end
+  
+    # Redirects to specified action path, which may also include arguments.
+    def redirect_action(action)
+      redirect_url "#{app}#{ app_absolute_path(action) }"
+    end
+  
+    # Convert specified action path by prefixing current action_subdir,
+    # unless specified path starts with slash (/).
+    def app_absolute_path(path)
+      debug path
+      path = controller.action_subdir + '/' + path if path !~ /\A\//
+      path
+    end
+  
+    # Return string result from rendering specified string or template options.
+    def render_to_string(options)
+      if options.is_a?(String)
+        return options
+      elsif options[:text]
+        return options[:text].to_s
+      end
+    
+      @base_url ||= app(action_subdir + '/')
+      @layout = options.is_a?(Hash) && options.has_key?(:layout) ? options[:layout] : "/_layout"
+    
+      content = options[:content].is_a?(String) ? options[:content] : process({
+        :template => action,
+        :extension => extension
+      }.merge(options))
+    
+      while @layout
+        layout_path = get_template_path(
+          :template => @layout,
+          :extension => options[:extension] || extension
+        ) rescue break
+      
+        # clear layout
+        # (however, layout template is allowed to set @layout to something else)
+        @layout = nil
+      
+        # process layout file
+        content = erubis(layout_path,binding,content)
+      end
+    
+      # Kiss 0.9: action parser now redirects into directories (with trailing slash)
+      # don't need to add base tag anymore
+      #content.sub(/(\<html)/i,%Q(<base href="#{@base_url}" />\\1))
+      content
+    end
+  
+    # Render and return response to Rack.
+    def render(options = {})
+      output = render_to_string(options)
+      controller.send_response(output,options)
+    end
+  
+    # Placeholder for generic actions that do nothing but render template.
+    # render is called from Kiss#call after this method returns.
+    def call; end
+  
+    # Creates and adds form to current action, using specified attributes.
+    def add_form(attrs = {})
+      # make sure form not already defined for this request
+      @forms ||= {}
+      attrs[:name] ||= @action
+      form_name = attrs[:name]
+      raise "page contains multiple forms named '#{form_name}'" if @forms.has_key?(form_name)
+    
+      # create form
+      uri = app + request.path_info
+      @forms[form_name] = @form = Kiss::Form.new({
+        :action => uri,
+        :request => self
+      }.merge(attrs))
+  
+      # add data from controller to form
+      if params['form'] == @form.name
+        @form.submitted = true
+        @form.params = params
+      end
+  
+      return @form
+    end
+  
+    # Returns most recently added form.
+    # Shorthand for forms[0] when there is only one form.
+    def form
+      @form
+    end
+  end
+end

data/lib/kiss/controller_accessors.rb

@@ -0,0 +1,101 @@
+class Kiss
+  module ControllerAccessors
+    def environment
+      controller.environment
+    end
+  
+    def params
+      controller.params
+    end
+  
+    def args
+      controller.args
+    end
+    
+    def session
+      controller.session
+    end
+  
+    def login
+      controller.login
+    end
+  
+    def request
+      controller.request
+    end
+  
+    def pub(*args)
+      controller.pub(*args)
+    end
+  
+    def set_login_expires(*args)
+      controller.set_login_expires(*args)
+    end
+  
+    def set_login_data(*args)
+      controller.set_login_data(*args)
+    end
+  
+    def set_login_session(*args)
+      controller.set_login_session(*args)
+    end
+  
+    def reset_login_data
+      controller.reset_login_data
+    end
+  
+    def reset_login_session
+      controller.reset_login_session
+    end
+  
+    def login_session_valid?
+      controller.login_session_valid?
+    end
+  
+    def db
+      controller.db
+    end
+    alias_method :database, :db
+  
+    def dbm
+      controller.dbm
+    end
+    alias_method :models, :dbm
+  
+    def app(*args)
+      controller.app(*args)
+    end
+  
+    def host
+      controller.host
+    end
+  
+    def action
+      controller.action
+    end
+    
+    def extension
+      controller.extension
+    end
+  
+    def action_subdir
+      controller.action_subdir
+    end
+  
+    def upload_dir
+      controller.upload_dir
+    end
+  
+    def arg(index)
+      controller.args[index]
+    end
+  
+    def authenticate
+      controller.authenticate
+    end
+  
+    def new_email
+      controller.new_email
+    end
+  end
+end