kiss 0.9.4 → 1.0

data/lib/kiss/format.rb

@@ -1,80 +1,218 @@
 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.
+  # This class is used to validate and parse strings into Sequel-ready values.
   class Format
-    def self.regexp
-      @@regexp
-    end
-    def self.error
-      @@error
+    # used to raise exceptions when values don't validate to format regexp
+    class ValidateError < Exception; end
+    
+    @regexp = //
+    @error = 'invalid format'
+    @legend = nil
+    @input_width = nil
+    @default = ''
+    
+    class << self
+      attr_accessor :regexp, :error, :legend, :input_width, :default
+      
+      # copy Format class instance variables to their subclasses
+      def inherited(subclass)
+        self.instance_variables.each do |var|
+          subclass.instance_variable_set(var, instance_variable_get(var))
+        end
+      end
+      
+      def parse(value)
+        value
+      end
+      
+      def value_to_s(value)
+        value.to_s
+      end
+      
+      def validate(value)
+        raise Kiss::Format::ValidateError, @error unless value.to_s =~ @regexp
+        parse(value)
+      end
     end
     
-    class Integer < Kiss::Format
+    class Integer < self
       @regexp = /\A\-?\d+\Z/
       @error = 'must be an integer'
+      @default = 0
+      
+      class << self
+        def parse(value)
+          value.to_i
+        end
+      
+        def validate(value)
+          # remove commas for thousands
+          value =~ /\d/ ? super(value.gsub(/,/,'')) : nil
+        end
+      
+        def value_to_s(value)
+          # add commas for thousands
+          value.format_thousands
+        end
+      end
     end
     
-    class PositiveInteger < Kiss::Format
+    class PositiveInteger < Integer
       @regexp = /\A\d*[1-9]\d*\Z/
       @error = 'must be a positive integer'
     end
     
-    class UnsignedInteger < Kiss::Format
+    class UnsignedInteger < Integer
       @regexp = /\A\d+\Z/
       @error = 'must be a positive integer or zero'
     end
     
-    class NegativeInteger < Kiss::Format
+    class NegativeInteger < Integer
       @regexp = /\A\-\d*[1-9]\d*\Z/
       @error = 'must be a negative integer'
     end
     
-    class AlphaNum
+    class Decimal < Integer
+      @regexp = /\A\-?(\d+(\.\d*)?|\.\d+)\Z/
+      @error = 'must be a decimal number'
+      @default = 0
+      
+      class << self
+        def parse(value)
+          value.to_f
+        end
+      
+        def value_to_s(value)
+          # add commas for thousands, to integer part only
+          value.format_thousands
+        end
+      end
+    end
+    
+    class AlphaNum < self
       @regexp = /\A[a-z0-9]\Z/i
-      @error = 'allows only letters and numbers'
+      @error = 'only letters and numbers allowed'
     end
     
-    class Word
+    class Word < self
       @regexp = /\A\w+\Z/
-      @error = 'allows only letters, numbers, and _'
+      @error = 'only letters, numbers, and underscores allowed'
     end
     
-    class EmailAddress
+    class EmailAddress < self
       @regexp = /\A[A-Z0-9._%+-]+\@([A-Z0-9-]+\.)+[A-Z]{2,4}\Z/i
       @error = 'must be a valid email address'
+      
+      def validate(value)
+        debug 'hi'
+        super(value)
+      end
     end
     
-    class Date
+    class DateTime < self
+      @regexp = /\A\d+\D\d+(\D\d+)?\s+\d{1,2}\:\d{2}\s*[ap]m\Z/i
+      @error = 'must be a valid date and time'
+      @legend = 'm/d/yyyy h:mm a/pm'
+      @input_width = 140
+      @default = SequelZeroTime.new('0000-00-00 00:00:00')
+      
+      class << self
+        def parse(value)
+          ::Time.parse(value.gsub(/[-\.]/,'/'))
+        end
+      
+        def value_to_s(value)
+          value.strftime("%m/%d/%Y %I:%M %p").gsub(/0(\d[\:\/])/,'\1')
+        end
+        
+        def validate(value)
+          value =~ /\S/ ? super(value) : nil
+        end
+      end
+    end
+    
+    class Date < DateTime
       @regexp = /\A\d+\D\d+(\D\d+)?\Z/
       @error = 'must be a valid date'
+      @legend = 'm/d/yyyy'
+      @input_width = 80
+      @default = SequelZeroTime.new('0000-00-00')
+      
+      def self.value_to_s(value)
+        value.strftime("%m/%d/%Y")
+      end
+    end
+    
+    class Time < DateTime
+      @regexp = /\A\d+\:\d+\s*[ap]m\Z/i,
+      @error = 'must be a valid time'
+      @legend = 'h:mm a/pm'
+      @input_width = 80
+    end
+    
+    class MonthYear < Date
+      @regexp = /\A\d+\D\d+\Z/
+      @error = 'must be a valid month and year (m/yyyy)'
+      @legend = 'm/yyyy'
+      @input_width = 80
+      
+      class << self
+        def parse(value)
+          month, year = value.sub(/\A\s*/,'').sub(/\s*\Z/,'').split(/\D+/)
+          # convert two-digit years to four-digit years
+          year = year.to_i
+          if year < 100
+            year += 1900
+            year += 100 if year < ::Time.now.year - 95
+          end
+          begin
+            ::Time.parse("#{month}/#{year}")
+          rescue ArgumentError => e
+            raise Kiss::Format::ValidateError, e.message
+          end
+        end
+      
+        def value_to_s(value)
+          value.strftime("%m/%Y")
+        end
+      end
     end
     
     
-    @@classes = {
-      :integer => Kiss::Format::Integer,
+    @@symbols = {
+      :integer => Integer,
+      
+      :integer_positive => PositiveInteger,
+      :positive_integer => PositiveInteger,
+      :id => PositiveInteger,
+      
+      :integer_unsigned => UnsignedInteger,
+      :unsigned_integer => UnsignedInteger,
+      :id_or_zero => UnsignedInteger,
+      :id_zero => UnsignedInteger,
+      
+      :integer_negative => NegativeInteger,
+      :negative_integer => NegativeInteger,
       
-      :integer_positive => Kiss::Format::PositiveInteger,
-      :positive_integer => Kiss::Format::PositiveInteger,
-      :id => Kiss::Format::PositiveInteger,
+      :decimal => Decimal,
       
-      :integer_unsigned => Kiss::Format::UnsignedInteger,
-      :unsigned_integer => Kiss::Format::UnsignedInteger,
-      :id_or_zero => Kiss::Format::UnsignedInteger,
-      :id_zero => Kiss::Format::UnsignedInteger,
+      :word => Word,
+      :alphanum => AlphaNum,
       
-      :integer_negative => Kiss::Format::NegativeInteger,
-      :negative_integer => Kiss::Format::NegativeInteger,
+      :email => EmailAddress,
+      :email_address => EmailAddress,
       
-      :word => Kiss::Format::Word,
-      :alphanum => Kiss::Format::AlphaNum,
-      :email_address => Kiss::Format::EmailAddress,
-      :date => Kiss::Format::Date
+      :datetime => DateTime,
+      :date => Date,
+      :time => Time,
+      :month_year => MonthYear
     }
-    def self.from_symbol(symbol)
-      return @@classes[symbol] || (raise "no format for #{symbol}")
+    def self.lookup(format)
+      format = format.to_sym if format.is_a?(String)
+      format.is_a?(Symbol) ?
+        # if symbol, lookup format by symbol
+        @@symbols[format] || self :
+        # else return format, or Kiss::Format if format not defined
+        format || self
     end
   end
 end

data/lib/kiss/hacks.rb

@@ -1,14 +1,21 @@
 # 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
 
+# This gets called outside of controller contexts; used mainly for debugging
+# during Kiss framework development.
+def debug(object)
+  print "Content-type: text/html\n\n" unless $debug
+  $debug = true
+  
+  puts object.inspect + '<br/>'
+  puts '<small>at ' + Kernel.caller[0] + '</small><br/>'
+  object
+end
+
 class Kiss
   # Used when Kiss#file_cache called from Kiss::Action#file_cache.
   # Caught by Kiss's Rack builder option FileNotFound.
@@ -58,12 +65,30 @@ class Fixnum
   def ago
     Time.now - self
   end
+  
+  # format thousands
+  def format_thousands
+    to_s.reverse.gsub(/(\d{3})/,'\1,').sub(/\,(-?)$/,'\1').reverse
+  end
+end
+
+class BigDecimal
+  # Formats number with comma-separated thousands.
+  def format_thousands(value = to_f.to_s)
+    integer, decimal = value.split(/\./,2)
+    integer.reverse.gsub(/(\d{3})/,'\1,').sub(/\,(-?)$/,'\1').reverse + '.' + decimal
+  end
+  
+  # Formats number to two decimal places.
+  def format_currency
+    format_thousands(sprintf("%0.2f",to_f))
+  end
 end
 
 class Date
   # Returns string representing date in m/d/yyyy format
   def mdy
-    sprintf('%d/%d/%04d',month,mday,year)
+    strftime("%m/%d/%Y")
   end
 end
 
@@ -77,31 +102,117 @@ class NilClass
   def length
     0
   end
+  # Ruby default: nil.id == 4 (now deprecated, but still present in 1.8)
+  # can cause unexpected results when using id from nil Sequel results
+  # so we'll raise an error instead, effectively undefining 'id' method
+  def id
+    raise NoMethodError, "undefined method `id' for nil:NilClass"
+  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})"
+class SequelZeroTime < String
+  def initialize(value = '0000-00-00 00:00',*args,&block)
+    super(value,*args,&block)
+  end
+  
+  # arithmetic operators
+  def +(*args)
+    self
+  end
+  def -(*args)
+    self
+  end
+  
+  # comparision operators
+  def ==(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : false
+  end
+  def >(*args)
+    return false
+  end
+  def >=(*args)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : false
+  end
+  def <(*args)
+    return true
+  end
+  def <=(*args)
+    return true
+  end
+  
+  # format conversion
+  def to_f
+    0
+  end
+  def to_i
+    0
+  end
+  def to_s
+    ''
+  end
+  def strftime(*args)
+    ''
+  end
+  def mdy
+    ''
+  end
+end
+
+class Date
+  class << self
+    alias_method :old_parse, :parse
+    def parse(*args, &block)
+      return SequelZeroTime.new(args[0]) if args[0] =~ /0000/
+      old_parse(*args, &block)
     end
   end
+  
+  # comparision operators
+  def ==(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  end
+  def >(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : super(value)
+  end
+  def >=(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : super(value)
+  end
+  def <(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  end
+  def <=(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  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
+class Time
+  class << self
+    alias_method :old_parse, :parse
+    def parse(*args, &block)
+      return SequelZeroTime.new(args[0]) if args[0] =~ /0000/
+      old_parse(*args, &block)
     end
   end
   
+  # comparision operators
+  def ==(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  end
+  def >(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : super(value)
+  end
+  def >=(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : super(value)
+  end
+  def <(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  end
+  def <=(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? false : super(value)
+  end
+end
+
+class String
   def to_const
     begin
       parts = self.split(/::/)

data/lib/kiss/mailer.rb

@@ -2,17 +2,10 @@ 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 = {})
+    def initialize(controller,options = {})
+      @controller = controller
       @options = {
         :engine => :sendmail
       }.merge(options)
@@ -20,13 +13,8 @@ class Kiss
       @data = {}
     end
     
-    # Invokes controller's file_cache.
-    def file_cache(*args,&block)
-      controller.file_cache(*args,&block)
-    end
-    
     def controller
-      @@controller
+      @controller
     end
     
     # Renders email template to string, unless message option is
@@ -36,7 +24,7 @@ class Kiss
     
       unless @options[:message].is_a?(String)
         if template_name = @options[:template]
-          @template_dir = @@controller.email_template_dir
+          @template_dir = controller.email_template_dir
           raise 'email_template_dir path not set' unless @template_dir
       
           data = vars = @options[:data] || @options[:vars]