kiss 1.1 → 1.7

data/lib/kiss/sequel_session.rb

@@ -12,7 +12,7 @@ class Kiss
     #   timestamp :updated_at
     # end
     
-    attr_accessor :needs_new_cookie
+    _attr_accessor :needs_new_cookie, :object
     
     class << self
       def setup_storage(controller)
@@ -21,9 +21,10 @@ class Kiss
             primary_key :id, :null => false
             column :session_id, :varchar, :null => false
             column :data, :text
-            column :created_at, :timestamp, :null => false
             column :updated_at, :timestamp, :null => false
-            index :session_id
+            column :created_at, :timestamp, :null => false
+            index :session_id, :unique => true
+            index :updated_at
           end
       
           # db << <<-EOT
@@ -93,24 +94,24 @@ class Kiss
     end
     
     def initialize(object)
-      @object = object
-      @data = self.class.unmarshal(@object[:data]) || {}
+      @_object = object
+      @_data = self.class.unmarshal(@_object[:data]) || {}
     end
     
     def values(*args)
-      @object.values(*args)
+      @_object.values(*args)
     end
 
     # Regenerate the Session ID
     def regenerate
-      @object.update_attributes(:session_id => Kiss::SessionMixin::rand_uuid)
-      @needs_new_cookie = true
+      @_object.update_attributes(:session_id => Kiss::SessionMixin::rand_uuid)
+      @_needs_new_cookie = true
     end 
 
     # Recreates the cookie with the default expiration time 
     # Useful during log in for pushing back the expiration date 
     def refresh_expiration
-      @needs_new_cookie = true
+      @_needs_new_cookie = true
     end
 
     # good
@@ -142,20 +143,20 @@ class Kiss
     # good
     # Lazy-unmarshal session state.
     def data
-      @data
+      @_data
     end
 
     # good
     # Has the session been loaded yet?
     def loaded?
-      !! @data
+      !! @_data
     end
     
     # good
     def save
-      @object[:data] = self.class.marshal(self.data)
-      @object[:updated_at] = Time.now
-      @object.save
+      @_object[:data] = self.class.marshal(self.data)
+      @_object[:updated_at] = Time.now
+      @_object.save
     end
 
     private

data/lib/kiss/static_file.rb

@@ -1,27 +1,34 @@
 class Kiss
   class StaticFile
-    def initialize(path,mime_type = nil)
-      @path = path
-      @mime_type = mime_type
+    def initialize(path, options = {})
+      @_path = path
+      @_options = options
     end
     
     def finish
-      ext = File.extname(@path)[1..-1]
+      ext = File.extname(@_path)[1..-1]
       
-      if File.file?(@path) && File.readable?(@path)
-        [200, {
-           "Last-Modified"  => File.mtime(@path).rfc822,
-           "Content-Type"   => @mime_type || Kiss.mime_type(ext) || "text/plain",
-           "Content-Length" => File.size(@path).to_s
-         }, self]
+      headers = {
+        "Last-Modified"  => File.mtime(@_path).rfc822,
+        "Content-Type"   => @_options[:type] || Kiss.mime_type(ext) || "text/plain",
+        "Content-Length" => File.size(@_path).to_s
+      }
+      
+      if @_options[:filename]
+        headers['Content-Disposition'] = "#{@_options[:disposition] || 'inline'}; filename=#{@_options[:filename]}"
+      elsif @_options[:disposition]
+        headers['Content-Disposition'] = @_options[:disposition]
+      end
+      
+      if File.file?(@_path) && File.readable?(@_path)
+        [200, headers, self]
       else
-        return [404, {"Content-Type" => "text/plain"},
-                ["File not found: #{@path}\n"]]
+        raise "file not found: #{@_path}"
       end
     end
 
     def each
-      File.open(@path, "rb") { |file|
+      File.open(@_path, "rb") { |file|
         while part = file.read(8192)
           yield part
         end

data/lib/kiss/template.rb

@@ -0,0 +1,327 @@
+class Kiss
+  class Template
+    class << self
+      _attr_reader :subdir, :filename, :path, :parent_class, :root_class, :template_dir
+      attr_reader :layout
+      
+      # Called when this class or one of its subclasses is inherited.
+      # subclass (Class) - the new, inheriting subclass
+      def inherited(subclass)
+        subclass.init_child_classes
+      end
+      
+      # Initialize the subclasses instance variable of this class (or subclass)
+      def init_child_classes
+        @_child_classes = {}
+      end
+      
+      # Gets path to template file according to specified options
+      # Options:
+      # template - template path, relative to current Template subclass subdirectory or,
+      #   if starting with '/', relative to root template directory
+      # extension - template file extension, to be appended to template path unless
+      #   template path already contains a dot
+      def get_template_path(options = {})
+        path = options[:template]
+        unless path =~ /\./
+          path += '.' + (options[:extension] || 'rhtml')
+        end
+        
+        # If template doesn't start with '/', prepend current Template subclass
+        # subdirectory path.
+        (path =~ /\A\//) ? path : "#{options[:subdir] || self.subdir}/#{path}"
+      end
+      
+      def get_root_class(controller, root_dir)
+        parent_class = self
+        
+        klass = Class.new(self)
+        Kiss.register_class_path(klass, root_dir)
+        klass.class_eval do
+          @@controller = controller
+          @_parent_class = parent_class
+          @_root_class = klass
+          @_template_dir = root_dir
+          @layout = nil
+        end
+        klass
+      end
+      
+      # Select or create the matching template subclass for a given template path.
+      def get_subclass_from_path(path, default_extension = nil)
+        # TODO: If Kiss configured not to modify template cache,
+        # then we should check whether this path has a registered
+        # class and, if so, return it.
+        
+        extension = (path =~ /\.(\w+)\Z/) ? $1 : default_extension
+        dot_extension = extension ? ('.' + extension) : ''
+        
+        # If path starts with slash, get subclass from root template class for 
+        # the same dot_extension. Else get subclass from this template class.
+        klass = if path[0,1] == '/'
+          path = path[1, path.length]
+          root_class.get_child_class(dot_extension)
+        else
+          self
+        end
+        klass.get_subclass_from_path_parts(path.split(/\/+/), dot_extension)
+      end
+      
+      def get_subclass_from_path_parts(parts, dot_extension = '')
+        part = parts.shift
+        return self if !part
+        raise 'bad template path' if part !~ /\A[\w\-\.]*\Z/i
+        
+        test_path = subdir + '/' + part
+        klass = if @@controller.directory_exists?(@_template_dir + test_path)
+          get_child_class(dot_extension, test_path).
+            get_subclass_from_path_parts(parts, dot_extension)
+        else
+          raise 'bad template path' unless parts.empty?
+          get_child_class(dot_extension, subdir, part)
+        end
+        
+        klass
+      end
+      
+      def get_child_class(dot_extension, subdir = '', filename = nil)
+        # each subdir must get a subclass of the parent dir class;
+        # each subclass has its own @_child_classes hash of its subdirs
+        
+        is_directory_subclass = !filename
+        
+        if filename
+          filename += dot_extension unless filename =~ /#{dot_extension}\Z/
+        else
+          filename = '_macros' + dot_extension
+        end
+        template_path = subdir + '/' + filename
+        absolute_fs_path = @_template_dir + template_path
+        template_body, template_cache_changed = @@controller.file_cache(absolute_fs_path, true)
+        
+        layout_path = subdir + '/_layout' + dot_extension
+        layout_file, layout_cache_changed = @@controller.file_cache(@_template_dir + layout_path, true)
+        
+        # Inherit this class's layout path if no layout file in subdir.
+        layout_path = @layout unless layout_file
+        
+        if template_cache_changed || !@_child_classes.has_key?(filename)
+          child_class = create_child_class(
+            :subdir => subdir,
+            :filename => filename,
+            :layout => layout_path,
+            :path => template_path
+          )
+          Kiss.register_class_path(child_class, absolute_fs_path)
+          if template_body
+            source = get_ruby_source_from_erb(template_body)
+            source = ('def erubis(content); ' + source + '; end') unless is_directory_subclass
+            child_class.class_eval(source, absolute_fs_path)
+          end
+          @_child_classes[filename] = child_class
+        elsif layout_cache_changed
+          # Layout file either added or modified; in case it was newly added,
+          # set the subclass's @layout (if it's not already set).
+          @_child_classes[filename].class_eval do
+            @layout ||= layout_path
+          end
+        end
+               
+        @_child_classes[filename]
+      end
+      
+      def create_child_class(attrs)
+        instance_var_attrs = {
+          :parent_class => self,
+          :root_class => @_root_class,
+          :template_dir => @_template_dir
+        }.merge(attrs)
+        
+        klass = Class.new(self)
+        klass._instance_variables_set_from_attrs(instance_var_attrs)
+        klass
+      end
+      
+      def get_ruby_source_from_erb(erb)
+        source = Erubis::Eruby.new(preprocess_erb(erb)).src
+        source.gsub!(/\b_buf\b/, '@_buf')
+        source
+      end
+      
+      # Pre-process Kiss additions in ERB code.
+      def preprocess_erb(erb)
+        # macros
+        result = erb.gsub(
+          /\<\%\s*macro\s+(\w+)/,
+          "<% def \\1(*args, &block); ob = swap_buf(''); _macro_\\1(*args, &block); swap_buf(ob); end; def _macro_\\1"
+        ).gsub(
+          /\<\%\s*end\s+macro\s*\%\>/,
+          '<% end %>'
+        )
+        
+        # may be DEPRECATED soon
+        # generic loop iterator, using 'iterate'
+        result.gsub!(/\<\%\s*iterate\s+(\w+)\s+(.*?)\s*\%\>/,
+          "<% \\1 = Kiss::Iterator.new; \\2; \\1.increment %>")
+        
+        # DEPRECATED
+        # for loop iterator
+        result.gsub!(/\<\%\s*for\s+(\w+)\s+in\s+(.*?)\s*\%\>/,
+          "<% \\1_loop = Kiss::Iterator.new(\\2); for \\1 in \\1_loop.collection; \\1_loop.increment %>")
+        
+        result
+      end
+    
+      def include_macros(template_path)
+        if template_path[0,1] != '/'
+          template_path = subdir + '/' + template_path
+        end
+        template_body = @@controller.file_cache(@_template_dir + template_path)
+        raise 'bad template path' if !template_body
+        class_eval(get_ruby_source_from_erb(template_body))
+      end
+      
+    end
+    self.init_child_classes
+    
+    include Kiss::ControllerAccessors
+    include Kiss::RequestAccessors
+    include Kiss::DatabaseAccessors
+    include Kiss::TemplateMethods
+    
+    attr_accessor :layout, :title
+    
+    _attr_reader :locals, :request
+    alias_method :local, :locals
+    
+    def initialize(request, delegate = nil, predecessor = nil, locals = {})
+      @_delegate = delegate
+      @_request = request
+      @_controller = delegate.controller if delegate
+      @_predecessor = predecessor || delegate
+      @_locals = locals
+    end
+    
+    def make_layout_absolute(relative_object)
+      if @layout && @layout !~ /\A\//
+        @layout = relative_object.class.subdir + '/' + @layout
+      end
+    end
+    
+    def call(content = nil)
+      import_instance_variables(@_predecessor)
+      make_layout_absolute(@_predecessor)
+      
+      content = erubis(content)
+      
+      # self.class.no_more_macros
+      
+      make_layout_absolute(self)
+      export_instance_variables(@_predecessor)
+      
+      content
+    end
+    
+    def erubis(content, locals = {})
+      raise Kiss::FileNotFoundError::Template, "template not found: '#{self.class.path}'"
+    end
+    
+    private
+    
+    def include_macros(template_path)
+      self.class.include_macros(template_path)
+    end
+    
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /\A_class_(\d+)_(.*)/
+        __send__ $2.to_sym, $1.to_i, *args, &block
+      else
+        @_delegate.__send__ method, *args, &block
+      end
+    end
+    
+    def context_class
+      Kiss.context_class
+    end
+    
+    # Reads file specified by options and return contents (without template
+    # processing).
+    def read_file(filename)
+      File.read(filename)
+    end
+    
+    def insert(*args)
+      File.read(self.class.template_dir + context_class.get_template_path(get_options_hash(*args)))
+    end
+    alias_method :insert_file, :insert
+    
+    # Processes template specified by options and return results.
+    def process_template(*args)
+      options = get_options_hash(*args)
+      path = context_class.get_template_path(options)
+      
+      if (options[:data] || options[:vars])
+        new_data = (options[:data] || {}).merge(options[:vars] || {})
+        old_data = self.data
+        self.data = self.data.merge(new_data)
+      else
+        old_data = nil
+      end
+      
+      # can Template.get_child_class do the path parsing? maybe...
+      # and then Action.get_child_class can do the same? what about parsing mixed-in args?
+      content = self.class.root_class.get_subclass_from_path(path).new(request, @_delegate, self, options[:locals] || options[:local] || {}).call
+      self.data = old_data if old_data
+      
+      content
+    end
+    alias_method :render, :process_template
+    alias_method :process, :process_template
+    alias_method :process_partial, :process_template
+    alias_method :render_partial, :process_template
+    
+    # Convert arguments into options hash for use get_template_path.
+    # - get_options_hash(template_path)
+    # - get_options_hash(template_path, options_hash)
+    # - get_options_hash(options_hash)
+    # where template_path is relative to the app's template_dir
+    # and options_hash specifies:
+    # - template: template path
+    # - layout: layout template path
+    def get_options_hash(*args)
+      case args.length
+      when 0
+        {}
+      when 1
+        args[0].is_a?(Hash) ? args[0] : { :template => args[0] }
+      when 2
+        args[1].merge( :template => args[0] )
+      else
+        raise 'too many arguments'
+      end
+    end
+    
+    
+    # Escapes string for use in URLs.
+    def url_escape(string)
+      string.url_escape
+    end
+    alias_method :u, :url_escape
+    alias_method :escape, :url_escape
+    alias_method :url_encode, :url_escape
+    alias_method :escape_url, :url_escape
+    
+    # Encodes string for output to HTML.
+    def html_escape(str)
+      str.html_escape
+    end
+    alias_method :h, :html_escape
+    alias_method :escape_html, :html_escape
+    
+    def swap_buf(n)
+      o = @_buf
+      @_buf = n
+      o
+    end
+  end
+end