kiss 0.9

data/lib/kiss/form.rb

@@ -0,0 +1,414 @@
+class Kiss
+  class Form
+    module AttributesSetter
+      def set_attributes(attrs_original,required = [])
+        unless attrs_original.is_a?(Hash) then
+          raise "first parameter must be a hash of attributes: #{attrs_original}"
+        end
+    
+        attrs = attrs_original.clone
+    
+        required.each do |key|
+          raise "missing required parameter '#{key}'" unless attrs[key]
+          send("#{key}=", attrs[key])
+          attrs.delete(key)
+        end
+    
+        attrs.each_pair do |key,value|
+          send("#{key}=", value)
+        end
+      end
+    end
+    include Kiss::Form::AttributesSetter
+  
+    require 'kiss/form/field';
+  
+    attr_accessor(
+      :name,:params,:submitted,:action,:controller,:id,:url,:request,
+      :object,:fields,:fields_hash,:method,:enctype,:errors,:submit,:cancel,:style,:class,
+      :has_field_errors,:error_class,:field_error_class,:mark_required,:object
+    )
+  
+  
+    @@field_types = {
+      :text => TextField,
+      :hidden => HiddenField,
+      :textarea => TextAreaField,
+      :password => PasswordField,
+      #:multitext => MultiTextField,
+      :boolean => BooleanField,
+      :file => FileField,
+      :select => SelectField,
+      :radio => RadioField,
+      :checkbox => CheckboxField,
+      :multiselect => MultiSelectField,
+      :submit => SubmitField,
+    }
+    
+    
+    # Creates a new form object with specified attributes.
+    def initialize(attrs)
+      set_attributes(attrs,[:name,:action])
+    
+      raise "Missing required option 'name'" unless @name && (@name != '')
+    
+      @method ||= 'post'
+    
+      # move field definitions to different var
+      # want to use @fields for array of Field objects
+      @fields_specs = @fields || []
+    
+      @fields = []
+      @fields_hash = {}
+      @default_values ||= {}
+      @params = {}
+    
+      @fields_specs.each do |field|
+        # create field here
+        add_field(field)
+      end
+      
+    	@errors = []
+    	@field_errors = {}
+    end
+    
+    # Adds a section break, which causes form's table to close and new table to open when form is rendered.
+    def add_section_break
+      @fields << :section_break
+    end
+    
+    # Creates and adds a field to the form, according to specified attributes.
+    def add_field(attrs)
+      raise "added second field named '#{attrs[:name]}'; field names must be unique" if @fields_hash[attrs[:name]]
+      
+      attrs[:type] ||= :text
+      type = attrs[:type].to_sym
+      unless @@field_types.has_key?(type)
+        type = attrs[:type] = :text
+      end
+      
+      @has_required_fields ||= attrs[:required]
+      
+      field_class = @@field_types[type]
+      field = field_class.new(attrs)
+      
+      field_name = field.name.to_s
+      field.form = self
+      
+      unless type == :submit
+        @fields << field
+        @fields_hash[field_name] = field
+      end
+      
+      @enctype = 'multipart/form-data' if field.type == :file
+      
+      # if param submitted, set value of field to match
+      if (param = @params[field_name])
+        field.value = param
+      elsif @object && !attrs.has_key?(:value)
+        value = @object[field_name.to_sym] || @object[field_name]
+      
+        case field.format
+        when :date:
+          field.value = value ? value.strftime("%m/%d/%Y") : ''
+        when :datetime:
+          field.value = value ? value.strftime("%m/%d/%Y %I:%M%p") : ''
+        else
+          field.value = value.to_s
+        end
+      end
+      
+      field
+    end
+    
+    # Creates and adds set of submit buttons to the form, per specified attributes.
+    def add_submit(attrs)
+      @submit = add_field({
+        :type => :submit,
+        :name => 'submit',
+        :save => false
+      }.merge(attrs) )
+    end
+    
+    # Gets hash of form values ready to be saved to Sequel::Model object.
+    def sequel_values
+      @sequel_values ||= begin
+        hash = {}
+        @fields.each {|field| hash[field.name] = field.sequel_value unless field == :section_break }
+        hash
+      end
+    end
+    
+    # Gets hash of form values.
+    def values
+      @values ||= begin
+        hash = {}
+        @fields.each {|field| hash[field.name] = field.value unless field == :section_break}
+        hash
+      end
+    end
+    
+    # Add error message to be rendered with form.
+    # If multiple args given, first arg is field name, and second arg (error message)
+    # will render next to specified field.
+    def add_error(*args)
+      if args.size > 2
+        raise 'too many args'
+      elsif args.size == 0
+        raise 'at least one arg required'
+      end
+      
+      # args.size == 1 or 2
+      if args.size == 1
+        if args[0].is_a?(String)
+          @errors << args[0]
+          return
+        else
+          field_name = args[0].field_name.to_s
+          message = args[0].message
+        end
+      else # args.size == 2
+        # args == [field_name, message]
+        field_name = args[0].to_s
+        message = args[1]
+      end
+      return @fields_hash[field_name].add_error(message)
+    end
+    
+    # Validates form values against fields' format and required attributes,
+    # and returns values unless form has errors.
+    def validate
+      return nil unless submitted
+      
+    	@fields.each {|field| field.validate unless field == :section_break }
+  	  
+  	  has_errors ? nil : values
+    end
+    
+    # Saves form values to Sequel::Model object.
+    def save(object = @object)
+      @fields.each do |field|
+        next if field == :section_break
+    		# ignore fields whose name starts with underscore
+        next if field.name =~ /\A\_/
+    		# don't save 'ignore' fields to the database
+        next if field.ignore || !field.save
+        
+        object[field.name.to_sym] = field.sequel_value
+      end
+    
+      object.save
+    end
+    
+    # Returns true if form has errors.
+    def has_errors
+      (@errors.size > 0 || @has_field_errors)
+    end
+    
+    # Checks whether form was submitted and accepted by user and, if so,
+    # whether form validates.
+    # If form validates, saves form values to form's Sequel::Model object 
+    # and returns true.  Otherwise, returns false.
+    def process(object = @object)
+      return false unless submitted
+    
+      if accepted
+        validate
+        return false if has_errors
+      
+        save(object)
+      end
+  	  
+    	return true
+    end
+    
+    # Returns true if user submitted form with non-cancel submit button
+    # (non-nil submit param, not equal to cancel submit button value).
+    def accepted
+      raise 'form missing submit field' unless @submit
+      return params[@submit.name] != @submit.cancel
+    end
+    
+    # Renders error HTML block for top of form, and returns as string.
+    def errors_html
+      return nil unless has_errors
+      
+      @errors << "Please remedy the errors shown below." if @has_field_errors
+      
+      if @errors.size == 1
+        content = @errors[0]
+      else
+        content = "<ul>" + @errors.map {|e| "<li>#{e}</li>"}.join + "</ul>"
+      end
+      
+      @errors.pop if @has_field_errors
+      
+      plural = @errors.size > 1 || @has_field_errors ? 's' : nil
+      %Q(<table border=0 cellspacing=0><tr class="kiss_error"><th>Error#{plural}</th></td><td class="kiss_required"></td><td>#{content}</td></tr></table>)
+    end
+    
+    # Renders current action using form's HTML as action render content.
+    def render(options = {})
+      @request.render options.merge(:content => html)
+    end
+    
+    # Renders beginning of form (form open tag and form/field/error styles).
+    def html_open
+      @error_class ||= 'kiss_form_error_message'
+      @field_error_class ||= @error_class
+      
+      # form tag
+      form_attrs = ['method','enctype','class','style'].map do |attr|
+        "#{attr}=\"#{send attr}\""
+      end.join(' ')
+      form_tag = %Q(<form action="#{@action}" #{form_attrs}><input type=hidden name="form" value="#{@name}">)
+      
+      # style tag
+      styles = []
+      styles.push( <<-EOT
+.kiss_form table {
+  margin-bottom: 6px;
+}
+.kiss_form td {
+  padding: 2px 4px;
+}
+.kiss_form tr.kiss_error {
+  background-color: #ff8;
+}
+.kiss_form tr.kiss_error th {
+  vertical-align: top;
+  padding: 2px 4px 3px 4px;
+  text-align: right;
+  background-color: #fc7;
+  color: #900;
+  border: 1px solid #f96;
+  border-right: none;
+}
+.kiss_form tr.kiss_error td {
+  vertical-align: top;
+  padding: 2px 6px 3px 6px;
+  border: 1px solid #f96;
+  border-left: none;
+  color: #000;
+}
+.kiss_form tr.kiss_error ul {
+  padding-left: 16px;
+  margin: 0;
+}
+.kiss_form tr.kiss_error td.kiss_required {
+  padding: 0;
+  border-right: none;
+}
+.kiss_form .kiss_help {
+  padding: 0px 3px 8px 6px;
+  font-size: 90%;
+  color: #555;
+}
+.kiss_form td.kiss_required {
+  padding: 2px 0px;
+  color: #c00;
+}
+.kiss_form td.kiss_label {
+  text-align: right;
+  white-space: nowrap;
+}
+.kiss_form tr.kiss_prompt td {
+  padding: 8px 3px 2px 4px;
+}
+.kiss_form tr.kiss_submit td.kiss_submit {
+  padding: 6px 3px;
+}
+.kiss_form input[type="text"],.kiss_form textarea {
+  width: 250px;
+}
+EOT
+      )
+      styles.push( <<-EOT
+.kiss_form_error_message {
+  padding: 1px 4px 2px 4px;
+  border: 1px solid #f96;
+  background-color: #ff8;
+  color: #900;
+  font-size: 85%;
+  display: block;
+  float: left;
+  margin-top: 1px;
+  
+}
+.kiss_form_error_message div {
+  color: #c00;
+  font-weight: bold;
+}
+.kiss_form_error_message ul {
+  padding-left: 16px;
+  margin: 0;
+}
+EOT
+      ) if @error_class == 'kiss_form_error_message'
+      style_tag = styles.size == 0 ? '' : "<style>" + styles.join('') + "</style>"
+      
+      # combine
+      return %Q(#{form_tag}#{style_tag}<div class="kiss_form">#{errors_html})
+    end
+    
+    # Renders end of form (form close tag).
+    def html_close
+      '</div></form>'
+    end
+    
+    # Renders form fields HTML.
+    def fields_html
+      @fields.map do |field|
+        field == :section_break ? begin
+          table_html_close + table_html_open
+        end : field_html(field)
+      end.join
+    end
+    
+    # Renders open of form table.
+    def table_html_open
+      %Q(<table border=0 cellspacing=0>) +
+        (@has_required_fields && @mark_required ? %Q( <tr><td></td><td class="kiss_required">*</td><td colspan=2 class="kiss_help">Required field.</td></tr> ) : '')
+    end
+    
+    # Renders close of form table.
+    def table_html_close
+      '</table>'
+    end
+    
+    # Renders form submit buttons.
+    def submit_html
+      field_html(@submit)
+    end
+    
+    # Renders complete form HTML.
+    def html
+      return [
+        html_open,
+        table_html_open,
+        fields_html,
+        submit_html,
+        table_html_close,
+        html_close
+      ].flatten.join
+    end
+    
+    # Renders HTML for specified form field.
+    def field_html(field)
+      type = field.type
+      prompt = field.prompt.to_s
+      label = field.label.to_s
+      
+      [
+    	  (prompt != '' ? %Q(<tr class="kiss_prompt"><td colspan=2></td><td colspan=2>#{prompt}</td></tr>) : ''),
+    		"",
+        %Q(<tr class="kiss_#{type}"><td class="kiss_label">),
+        label != '' && prompt == '' ? label + ':' : '',
+        '</td><td class="kiss_required">',
+        field.required ? @mark_required : '',
+    	  %Q(</td><td class="kiss_#{type}">),
+    		field.html, "</td></tr>"
+    	].join
+    end
+  end
+end

data/lib/kiss/format.rb

@@ -0,0 +1,80 @@
+class Kiss
+  # This class leftover from a previous version of Kiss and is not currently used.
+  # In fact, this file is not required from any other part of Kiss.
+  # 
+  # But we're keeping it around in case it's useful for the anticipated rewrite of 
+  # Kiss.validate_format.
+  class Format
+    def self.regexp
+      @@regexp
+    end
+    def self.error
+      @@error
+    end
+    
+    class Integer < Kiss::Format
+      @regexp = /\A\-?\d+\Z/
+      @error = 'must be an integer'
+    end
+    
+    class PositiveInteger < Kiss::Format
+      @regexp = /\A\d*[1-9]\d*\Z/
+      @error = 'must be a positive integer'
+    end
+    
+    class UnsignedInteger < Kiss::Format
+      @regexp = /\A\d+\Z/
+      @error = 'must be a positive integer or zero'
+    end
+    
+    class NegativeInteger < Kiss::Format
+      @regexp = /\A\-\d*[1-9]\d*\Z/
+      @error = 'must be a negative integer'
+    end
+    
+    class AlphaNum
+      @regexp = /\A[a-z0-9]\Z/i
+      @error = 'allows only letters and numbers'
+    end
+    
+    class Word
+      @regexp = /\A\w+\Z/
+      @error = 'allows only letters, numbers, and _'
+    end
+    
+    class EmailAddress
+      @regexp = /\A[A-Z0-9._%+-]+\@([A-Z0-9-]+\.)+[A-Z]{2,4}\Z/i
+      @error = 'must be a valid email address'
+    end
+    
+    class Date
+      @regexp = /\A\d+\D\d+(\D\d+)?\Z/
+      @error = 'must be a valid date'
+    end
+    
+    
+    @@classes = {
+      :integer => Kiss::Format::Integer,
+      
+      :integer_positive => Kiss::Format::PositiveInteger,
+      :positive_integer => Kiss::Format::PositiveInteger,
+      :id => Kiss::Format::PositiveInteger,
+      
+      :integer_unsigned => Kiss::Format::UnsignedInteger,
+      :unsigned_integer => Kiss::Format::UnsignedInteger,
+      :id_or_zero => Kiss::Format::UnsignedInteger,
+      :id_zero => Kiss::Format::UnsignedInteger,
+      
+      :integer_negative => Kiss::Format::NegativeInteger,
+      :negative_integer => Kiss::Format::NegativeInteger,
+      
+      :word => Kiss::Format::Word,
+      :alphanum => Kiss::Format::AlphaNum,
+      :email_address => Kiss::Format::EmailAddress,
+      :date => Kiss::Format::Date
+    }
+    def self.from_symbol(symbol)
+      return @@classes[symbol] || (raise "no format for #{symbol}")
+    end
+  end
+end

data/lib/kiss/hacks.rb

@@ -0,0 +1,140 @@
+# This is a collection of hacks to enable various Ruby lnaguage enhancements
+# and other features of Kiss.
+
+# Placeholder; overloaded by Kiss Rack builder option ShowDebug.
+def debug(*args); end
+# Placeholder; overloaded by Kiss Rack builder option Bench.
+def bench(*args); end
+# Placeholder; to be overloaded by Kiss Rack builder option MultiBench
+# (not yet implemented).
+def multibench(*args); end
+
+class Kiss
+  # Used when Kiss#file_cache called from Kiss::Action#file_cache.
+  # Caught by Kiss's Rack builder option FileNotFound.
+  class TemplateFileNotFound < LoadError; end
+  class FileNotFound < LoadError; end
+end
+
+
+# Methods to enable hash.attr == hash[attr] syntax,
+# including hash.id and hash.type
+class Hash
+  def method_missing(meth,*args)
+    if /=$/=~(meth=meth.id2name) then
+      self[meth[0...-1]] = (args.length<2 ? args[0] : args)
+    else
+      self[meth] || self[meth.to_sym]
+    end
+  end
+  def id
+    self['id'] || self [:id]
+  end
+  def type
+    self['type'] || self [:type] || Hash
+  end
+end
+
+# Enables FixNum conversion to time duration values (in seconds).
+class Fixnum
+  # 2.weeks = 14.days
+  def weeks
+    self * 7.days
+  end
+  # 1.days = 24.hours
+  def days
+    self * 24.hours
+  end
+  # 1.hours = 60.minutes = 3600 (seconds)
+  def hours
+    self * 60.minutes
+  end
+  # 1.minutes = 60 (seconds)
+  # 5.minutes = 300 (seconds)
+  def minutes
+    self * 60
+  end
+  # 5.minutes.ago = Time.now - 300
+  def ago
+    Time.now - self
+  end
+end
+
+class Date
+  # Returns string representing date in m/d/yyyy format
+  def mdy
+    sprintf('%d/%d/%04d',month,mday,year)
+  end
+end
+
+class NilClass
+  def mdy
+    ''
+  end
+  def size
+    0
+  end
+  def length
+    0
+  end
+end
+
+# Corrections to sequel_core/core_sql.rb
+class String
+  def to_sequel_time
+    self == '0000-00-00 00:00:00' ? nil : begin
+      Time.parse(self)
+    rescue Exception => e
+      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Date object.
+  def to_date
+    begin
+      Date.parse(self)
+    rescue Exception => e
+      if (self == '0000-00-00')
+        nil
+      else
+        raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
+      end
+    end
+  end
+  
+  def to_const
+    begin
+      parts = self.split(/::/)
+      klass = Kernel
+      while (next_part = parts.shift)
+        klass = klass.const_get(next_part)
+      end
+      
+      klass
+    rescue
+      raise "Constant '#{self}' not defined"
+    end
+  end
+end
+
+class Symbol
+  def to_const
+    self.to_s.to_const
+  end
+end
+
+module Rack
+  class Request
+    def server
+      url = scheme + "://"
+      url << host
+
+      if scheme == "https" && port != 443 ||
+          scheme == "http" && port != 80
+        url << ":#{port}"
+      end
+      
+      url
+    end
+  end
+end

data/lib/kiss/iterator.rb

@@ -0,0 +1,56 @@
+class Kiss
+  # Enables `loop' features for certain template loops (while, for...in).
+  # Similar to features of Perl's Template::Iterator by Andy Wardley.
+  class Iterator
+    attr_reader :index, :collection
+    
+    # Creates a new loop iterator.
+    def initialize(collection = nil)
+      @collection = collection
+      @index = -1
+    end
+    
+    # Used by template erubis pre-processing voodoo to advance
+    # the iterator index.  Not intended for any other use.
+    def increment
+      @index = @index + 1
+    end
+    
+    # Return current iteration number, indexed from one instead of zero.
+    def count
+      @index + 1
+    end
+    
+    # Returns true if this is loop's first iteration.
+    def first
+      @index == 0
+    end
+    
+    # Returns true if this is the last iteration of a
+    # loop over a collection.
+    def last
+      count == size
+    end
+    
+    # Return previous item in loop-iterated collection.
+    def prev
+      @collection ? @collection[index-1] : nil
+    end
+    
+    # Return next item in loop-iterated collection.
+    def next
+      @collection ? @collection[index+1] : nil
+    end
+    
+    # Returns index of loop's last iteration.
+    def max
+      @collection ? @collection.size-1 : nil
+    end
+    
+    # Returns number of iterations in loop over a collection
+    # (size of the iterated collection).
+    def size
+      @collection ? @collection.size : nil
+    end
+  end
+end