kiss 1.1 → 1.7

data/lib/kiss/login.rb

@@ -1,25 +1,25 @@
 class Kiss
   class Login < Hash
     def initialize(session)
-      @session = session
-      @session['login'] ||= {}
+      @_session = session
+      @_session['login'] ||= {}
       
       # check if login expired
       if expired?
         # login expired
-        @session['login'] = {}
+        @_session['login'] = {}
       end
       
-      @persist_data = @session['login']
-      self.merge!(@persist_data)
+      @_persist_data = @_session['login']
+      self.merge!(@_persist_data)
     end
     
     def expired?
-      @session['login']['expires_at'] && session['login']['expires_at'] < Time.now
+      @_session['login']['expires_at'] && session['login']['expires_at'] < Time.now
     end
     
     def persist(data = {})
-      @persist_data.merge!(data)
+      @_persist_data.merge!(data)
       self.merge!(data)
     end
     
@@ -38,7 +38,7 @@ class Kiss
     end
     
     def clear
-      @session['login'] = {}
+      @_session['login'] = {}
       super()
     end
   end

data/lib/kiss/mailer.rb

@@ -1,7 +1,7 @@
 class Kiss
   # This class creates, renders, and sends email messages.
   
-  # @options
+  # @_options
   # :server, :port, :domain, :account, :password, :auth - for SMTP login
   # :from/to - used by SMTP to send message (ignored by sendmail)
   # :message - message headers/body text
@@ -10,91 +10,93 @@ class Kiss
   # :sendmail_path - filesystem path to sendmail executable
   
   class Mailer
-    include Kiss::TemplateMethods
+    @@sendmail_path = "/usr/sbin/sendmail -t"
+    
+    class << self
+      def send(options)
+        if options[:sendmail] || (options[:engine] == :sendmail) || !options[:server]
+          send_via_sendmail(options)
+        else
+          send_via_smtp(options)
+        end
+      end
     
-    attr_accessor :controller
+      # Attempts to send message using /usr/sbin/sendmail.
+      # NOTE: sendmail ignores :from and :to options, using
+      # From and To headers from the message
+      def send_via_sendmail(options)
+        puts options[:message]
+        IO.popen(options[:sendmail] || @@sendmail_path, "w") do |pipe|
+          pipe.puts(options[:message])
+        end
+      end
     
-    def merge_options(options = {})
-      @options.merge!(options)
-      @controller = options[:controller] || @controller
-      @data = options[:data] || @data
+      # Attempts to send message using Net::SMTP.
+      def send_via_smtp(options)
+        require 'net/smtp' unless defined?(Net::SMTP)
+        
+        Net::SMTP.start(
+          options[:server] || 'localhost',
+          options[:port] || 25,
+          options[:domain] || nil,
+          options[:account] || options[:username] || nil,
+          options[:password] || nil,
+          options[:auth] || :plain
+        ) do |smtp|
+      		smtp.sendmail(options[:message], options[:from], options[:to])
+      	end
+      end
     end
     
+    include Kiss::ControllerAccessors
+    include Kiss::RequestAccessors
+    include Kiss::DatabaseAccessors
+    include Kiss::TemplateMethods
+    
+    _attr_accessor :controller, :request, :options
+    
     # Creates new email message object.
-    def initialize(options = {})
-      @options = {}
-      @data = {}
+    def initialize(new_options = {})
+      @_options = {}
+      merge_options(new_options)
+    end
+    
+    def merge_options(new_options = {})
+      if new_options[:controller]
+        @_controller = new_options[:controller]
+        @_options = @_controller.mailer_config.merge(@_options)
+      end
       
-      merge_options(options) if options
+      @_options.merge!(new_options)
+      @_request = new_options[:request] || @_request
     end
     
     # Renders email template to string, unless message option is
     # already set to a string value.
-    def prepare_email_message(options = nil)
-      merge_options(options) if options
+    def prepare_email_message(new_options = {})
+      merge_options(new_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)
+      unless @_options[:message].is_a?(String)
+        if template = @_options[:template]
+          @@template_class ||= Kiss::Template.get_root_class(controller, controller.email_template_dir)
+          @data = @_options[:data] || @_options[:vars]
+          @_options[:message] = @@template_class.get_subclass_from_path('/'+template).new(request, self).call
         else
-          raise 'email message not defined'
+          raise 'no email message or template found to prepare'
         end
       end
     
-      return @options[:message]
+      return @_options[:message]
     end
     
     # Attempts to send message using SMTP, unless :engine option is set to
     # :sendmail.
-    def send(options = nil)
-      merge_options(options) if options
-      
-      if @options[:engine] == :sendmail
-        return sendmail
-      else
-        return send_smtp
-      end
-    end
-    
-    # Attempts to send message using /usr/sbin/sendmail.
-    # NOTE: sendmail ignores :from and :to options, using
-    # From and To headers from the message
-    def sendmail(options = nil)
-      merge_options(options) if 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 = nil)
-      merge_options(options) if options
+    def send(new_options = {})
+      merge_options(new_options)
+      merge_options(@_controller.mailer_override)
       
-      prepare_email_message(options)
-    
-      require 'net/smtp' unless defined?(Net::SMTP)
-      # begin
-        Net::SMTP.start(
-          @options[:server] || 'localhost',
-          @options[:port] || 25,
-          @options[:domain] || nil,
-          @options[:account] || @options[:username] || nil,
-          @options[:password] || nil,
-          @options[:auth] || :plain
-        ) do |smtp|
-      		smtp.sendmail(@options[:message], @options[:from], @options[:to])
-      	end
-      # rescue
-      # end
+      prepare_email_message
+      self.class.send(options)
     end
   end
 end

data/lib/kiss/model.rb

@@ -4,26 +4,50 @@ class Kiss
   # to cache database model classes, unless no model_dir is specified.
   class Model < Sequel::Model
     class << self
+      dsl_accessor :value_column, :display_column
+      
       def set_dataset(source)
         super(source)
       end
       
+      def has_many(*args)
+        one_to_many(*args)
+      end
+      
+      def belongs_to(*args)
+        many_to_one(*args)
+      end
+      
+      def has_and_belongs_to_many(*args)
+        many_to_many(*args)
+      end
+      
+      def alias_association(new_name, old_name)
+        alias_method new_name, old_name
+        alias_method :"#{new_name}_dataset", :"#{old_name}_dataset"
+      end
+      alias_method :alias_assoc, :alias_association
+      
       # This method is called by Sequel::Model's association def methods.
       # Must return singularized table name for correct association key names.
       def name
-        @table.to_s.singularize
+        @_table.to_s.singularize
       end
       
       def controller
         db.kiss_controller
       end
       
+      def request
+        db.kiss_request || controller
+      end
+      
       def table
-        @table.to_sym
+        @_table.to_sym
       end
       
       def table=(table)
-        @table = table
+        @_table = table
       end
       
       # Name symbol for default foreign key
@@ -40,7 +64,7 @@ class Kiss
         opts = opts.clone
         
         unless opts[:class] || opts[:class_name]
-          opts[:class_name] = name.to_s.singularize
+          opts[:class_name] = name.to_s.pluralize
         end
         
         super(type, name, opts, &block)
@@ -49,53 +73,222 @@ class Kiss
       end
       
       include Kiss::ControllerAccessors
+      include Kiss::RequestAccessors
+      alias_method :database, :db
+    end
+    
+    def deferred_associations
+      @deferred_associations ||= {}
     end
     
-    def method_missing(meth)
-      raise NoMethodError, "undefined method `#{meth}' for database model `#{self.class.name}'"
+    def deferred_association_method_calls
+      @deferred_association_method_calls ||= []
+    end
+    
+    def set_associated_object(opts, o)
+      if o && !o.pk
+        if (da = deferred_associations[opts[:name]]) != o
+          if da
+            da.deferred_association_method_calls.delete_if {|c| c[1] == [self, opts.setter_method, da] }
+            remove_deferred_reciprocal_object(opts, o)
+          end
+          
+          deferred_associations[opts[:name]] = o
+          o.deferred_association_method_calls << [false, [self, opts.setter_method, o]]
+          add_deferred_reciprocal_object(opts, o)
+        end
+        o
+      else
+        deferred_associations.delete(opts[:name])
+        super
+      end
+    end
+    
+    def add_associated_object(opts, o)
+      need_missing_opk = opts.need_associated_primary_key? && !o.pk
+      if !pk || need_missing_opk
+        double_defer = !pk && need_missing_opk
+        # TODO: add :uniq check here (and patch this in Sequel as well)
+        (deferred_associations[opts[:name]] ||= []).push(o)
+        
+        method_call = [double_defer, [self, opts.add_method, o]]
+        deferred_association_method_calls << method_call unless pk
+        o.deferred_association_method_calls << method_call if need_missing_opk
+        
+        add_deferred_reciprocal_object(opts, o)
+        o
+      else
+        deferred_associations[opts[:name]].delete(o) if deferred_associations[opts[:name]]
+        super
+      end
+    end
+
+    # Add/Set the current object to/as the given object's reciprocal association.
+    def add_deferred_reciprocal_object(opts, o)
+      return unless reciprocal = opts.reciprocal
+      if opts.reciprocal_array?
+        if array = o.deferred_associations[reciprocal] and !array.include?(self)
+          array.push(self)
+        end
+      else
+        o.deferred_associations[reciprocal] = self
+      end
+    end
+    
+    def load_associated_objects(opts, reload=false)
+      if d = deferred_associations[opts[:name]]
+        opts.returns_array? ? super + d : d
+      else
+        super || set_associated_object(opts, opts.associated_class.new)
+      end
+    end
+
+    # Remove all associated objects from the given association
+    def remove_all_associated_objects(opts)
+      ret = super
+      if deferred_associations.include?(opts[:name])
+        def_ret = deferred_associations[opts[:name]].each do |o|
+          method_call = [self, opts.add_method, o]
+          deferred_association_method_calls.delete_if {|c| c[1] == method_call }
+          o.deferred_association_method_calls.delete_if {|c| c[1] == method_call }
+          remove_deferred_reciprocal_object(opts, o)
+        end
+        deferred_associations[opts[:name]] = []
+        (ret || []) + def_ret
+      else
+        ret
+      end
+    end
+
+    # Remove the given associated object from the given association
+    def remove_associated_object(opts, o)
+      if (array = deferred_associations[opts[:name]]) and array.delete(o)
+        method_call = [self, opts.add_method, o]
+        deferred_association_method_calls.delete_if {|c| c[1] == method_call }
+        o.deferred_association_method_calls.delete_if {|c| c[1] == method_call }
+        remove_deferred_reciprocal_object(opts, o)
+      else
+        super
+      end
+      o
+    end
+
+    # Remove/unset the current object from/as the given object's reciprocal association.
+    def remove_deferred_reciprocal_object(opts, o)
+      return unless reciprocal = opts.reciprocal
+      if opts.reciprocal_array?
+        if array = o.deferred_associations[reciprocal]
+          array.delete_if{|x| self === x}
+        end
+      else
+        o.deferred_associations[reciprocal] = nil
+      end
+    end
+    
+    def after_create
+      deferred_association_method_calls.each do |call|
+        if call[0]
+          # call[0] (double_defer) is true
+          # now set it to false, do nothing else
+          # (defer again until other side is created)
+          call[0] = false
+        else
+          m = call[1]
+          m.shift.send(*m) if m
+        end
+      end
+      @deferred_association_method_calls = []
+    end
+    
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /(\w+)\?\Z/
+        column = $1.to_sym
+        if respond_to?(column)
+          val = self.send(column, *args, &block)
+          return !(val.nil? || val.zero?)
+        end
+      end
+      raise NoMethodError, "undefined method `#{meth}' for database model `#{self.class.name.pluralize}'"
     end
     
     def controller
       self.class.controller
     end
     
+    def request
+      self.class.request
+    end
+    
+    def name
+      self[:name] || self.class.table.to_s.singularize.titleize
+    end
+    
+    # Creates and invokes new Kiss::Mailer instance to send email message via SMTP.
+    def new_email(options = {})
+      request.new_email({
+        :data => self
+      }.merge(options))
+    end
+    
+    def send_email(options = {})
+      new_email(options).send
+    end
+    
+    def to_hash
+      result = {}
+      keys.each do |key|
+        result[key] = values[key]
+      end
+      result
+    end
+    
     include Kiss::ControllerAccessors
+    include Kiss::RequestAccessors
+    alias_method :database, :db
   end
 
   class ModelCache
-    def self.model_dir=(model_dir = nil)
-      @@model_dir = model_dir && ::File.directory?(model_dir) ? model_dir : nil
-    end
-    
-    def initialize(database = nil)
-      @db = database
-      @cache = {}
+    def initialize(database, model_dir)
+      @_db = database
+      @_model_dir = model_dir
+      @_cache = {}
+      
+      # TODO: Fix this to use file cache and subclass hierarchy, so models can be
+      # reloaded if _model.rb changes.
+      @_root_class = Class.new(Kiss::Model)
+      if File.exist?(filename = "#{@_model_dir}/_model.rb")
+        @_root_class.class_eval(File.read(filename), filename)
+      end
     end
     
-    def new_model_class(database,source)
-      klass = Class.new(Kiss::Model)
+    def new_model_class(database, source)
+      klass = Class.new(@_root_class)
       klass.set_dataset(database[source])
       klass.table = source
+      klass.class_eval do
+        @_value_column = :id
+        @_display_column = :name
+      end
       klass
     end
   
     def [](source)
       raise 'argument to model cache must be symbol of database table name' unless source.is_a?(Symbol)
       
-      database = @db
-      @@model_dir ? begin
-        # use file_cache
-        model_path = "#{@@model_dir}/#{source}.rb"
-        Kiss.file_cache(model_path) do |src|
-          klass = new_model_class(database,source)
-          klass.class_eval(src,model_path) if src
+      database = @_db
+      @_model_dir ? begin
+        # TODO: use request's file_cache
+        model_path = "#{@_model_dir}/#{source}.rb"
+        db.kiss_controller.file_cache(model_path) do |src|
+          klass = new_model_class(database, source)
+          klass.class_eval(src, model_path) if src
           klass
         end
-      end : @cache[source] ||= new_model_class(database,source)
+      end : @_cache[source] ||= new_model_class(database, source)
     end
   
     def database
-      @db
+      @_db
     end
     alias_method :db, :database
   
@@ -103,16 +296,12 @@ class Kiss
       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] ||= self[:model].controller.dbm[self[:class_name].to_s.pluralize.to_sym]
+    self[:class] ||= (self[:model].request || self[:model].controller).dbm[self[:class_name].to_s.pluralize.to_sym]
   end
   def default_left_key
     :"#{self[:model].name.singularize.underscore}_id"
@@ -131,7 +320,7 @@ class Date
   class << self
     alias_method :old_parse, :parse
     def parse(*args, &block)
-      return SequelZeroTime.new(args[0]) if args[0] =~ /0000/
+      return SequelZeroTime.new(args[0]) if args[0] =~ /0000-00-00/
       old_parse(*args, &block)
     end
   end
@@ -184,12 +373,110 @@ 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
+    integer, decimal = value.split(/\./, 2)
+    integer.reverse.gsub(/(\d{3})/, '\1,').sub(/\,(-?)$/, '\1').reverse + '.' + decimal
+  end
+end
+
+class SequelZeroTime < String
+  def initialize(value = '0000-00-00 00:00', *args, &block)
+    super(value, *args, &block)
   end
   
-  # Formats number to two decimal places.
-  def format_currency
-    format_thousands(sprintf("%0.2f",to_f))
+  # arithmetic operators
+  def +(*args)
+    self
+  end
+  def -(*args)
+    self
   end
-end
+  
+  # comparision operators
+  def ==(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : false
+  end
+  def >(value)
+    return false
+  end
+  def >=(value)
+    (value == 0 || value.is_a?(SequelZeroTime)) ? true : false
+  end
+  def <(value)
+    return true
+  end
+  def <=(value)
+    return true
+  end
+  
+  # format conversion
+  def to_f; 0; end
+  def to_i; 0; end
+  def to_s; ''; end
+  
+  # timezone conversion
+  def set_timezone!(zone, utc)
+    self
+  end
+  def from_timezone(zone)
+    self
+  end
+  def to_timezone(zone)
+    self
+  end
+  def to_utc
+    self
+  end
+  def zone
+    ''
+  end
+  
+  # string representations
+  def strftime(*args); ''; end
+  def md; ''; end
+  def md_full; ''; end
+  alias_method :md_long, :md_full
+  def mdy; ''; end
+  def mdy_full; ''; end
+  alias_method :mdy_long, :mdy_full
+  def mdy_hm; ''; end
+  def mdy_hmz; ''; end
+  def mdy_hms; ''; end
+  def mdy_hmsz; ''; end
+  def ymd_hm; ''; end
+  def ymd_hmz; ''; end
+  def ymd_hms; ''; end
+  def ymd_hmsz; ''; end
+  def sql; '0000-00-00 00:00'; end
+  def mdy_hm_full; ''; end
+  alias_method :mdy_hm_long, :mdy_hm_full
+  def mdy_hmz_full; ''; end
+  alias_method :mdy_hmz_long, :mdy_hmz_full
+  def hm; ''; end
+  def hmz; ''; end
+  def hms; ''; end
+  def hmsz; ''; end
+  def hm_mdy; ''; end
+  def hmz_mdy; ''; end
+  def hms_mdy; ''; end
+  def hmsz_mdy; ''; end
+  def hm_mdy_full; ''; end
+  alias_method :hm_mdy_long, :hm_mdy_full
+  def hmz_mdy_full; ''; end
+  alias_method :hmz_mdy_long, :hmz_mdy_full
+  
+  def zero?; true; end
+  
+  def in_between?(*args); false; end
+end
+
+IrregularInflection = proc do
+  def self.irregular(singular, plural)
+    singular(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + singular[1..-1])
+    plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+    
+    singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1])
+  end
+end
+Sequel::Inflections.class_eval &IrregularInflection
+String::Inflections.class_eval &IrregularInflection