kiss 0.9

data/lib/kiss/sequel_session.rb

@@ -0,0 +1,166 @@
+require 'base64'
+
+class Kiss
+  # Session store using Sequel.
+  class SequelSession
+    
+    # set_schema do
+    #   primary_key :id
+    #   varchar :session_id
+    #   text :data
+    #   timestamp :created_at
+    #   timestamp :updated_at
+    # end
+    
+    attr_accessor :needs_new_cookie
+    
+    class << self
+      def setup_storage(controller)
+        unless controller.db.table_exists?(:sessions)
+          controller.db.create_table :sessions do
+            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
+          end
+      
+          # db << <<-EOT
+          #   CREATE TABLE `sessions` (
+          #     `id` int(11) NOT NULL auto_increment,
+          #     `session_id` varchar(255) default NULL,
+          #     `data` text,
+          #     `created_at` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP,
+          #     `updated_at` timestamp NOT NULL default '0000-00-00 00:00:00',
+          #     PRIMARY KEY (`id`)
+          #   );
+          #   EOT
+        end
+      end
+      
+      def rand_uuid
+        values = [
+          rand(0x0010000),
+          rand(0x0010000),
+          rand(0x0010000),
+          rand(0x0010000),
+          rand(0x0010000),
+          rand(0x1000000),
+          rand(0x1000000),
+        ]
+        "%04x%04x%04x%04x%04x%06x%06x" % values
+      end
+      
+      # Generates a new session ID and creates a row for the new session in the database.
+      def generate
+        new(Sequel::Model(:sessions).create(
+          :session_id => rand_uuid,
+          :data => marshal({}),
+          :created_at => Time.now,
+          :updated_at => Time.now
+        ))
+      end
+
+      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
+      # If none is found, generates a new session.
+      def persist(session_id)
+        if session_id
+          if object = Sequel::Model(:sessions).where(:session_id => session_id).first
+            session = new( object )
+          end
+        end
+        unless session
+          session = generate
+        end
+        session
+      end
+
+      # Don't try to reload ARStore::Session in dev mode.
+      def reloadable? #:nodoc:
+        false
+      end
+
+      # good
+      def marshal(data)
+        Base64.encode64(Marshal.dump(data)) if data
+      end
+
+      # good
+      def unmarshal(data)
+        Marshal.load(Base64.decode64(data)) if data
+      end
+    end
+    
+    def initialize(object)
+      @object = object
+      @data = self.class.unmarshal(@object[:data]) || {}
+    end
+    
+    def 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
+    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
+    end
+
+    # good
+    # Lazy-delete of session data 
+    def delete(key = nil)
+      key ? self.data.delete(key) : self.data.clear
+    end
+    
+    # good
+    def [](key)
+      data[key]
+    end
+
+    # good
+    def []=(key, val)
+      data[key] = val
+    end
+
+    # good
+    def empty?
+      data.empty?
+    end
+
+    # good
+    def each(&b)
+      data.each(&b)
+    end
+
+    # good
+    # Lazy-unmarshal session state.
+    def data
+      @data
+    end
+
+    # good
+    # Has the session been loaded yet?
+    def loaded?
+      !! @data
+    end
+    
+    # good
+    def save
+      @object[:data] = self.class.marshal(self.data)
+      @object[:updated_at] = Time.now
+      @object.save
+    end
+
+    private
+
+    attr_writer :data
+    
+  end
+end

data/lib/kiss/template_methods.rb

@@ -0,0 +1,125 @@
+class Kiss
+  module TemplateMethods
+    include Kiss::ControllerAccessors
+    
+    # Contains data set by action/mailer logic to be displayed in templates.
+    def data
+      @data
+    end
+    alias_method :vars, :data
+    
+    # Merges specified data (key-value pairs) into template data hash.
+    def set(vars)
+      vars.each_pair do |key,value|
+        # convert symbols to strings
+        @data[key.to_s] = value
+      end
+    end
+    
+    # Shorthand to access vars.title, here for backward compatibility.
+    # Note: @title is deprecated for use in templates and will not be
+    # supported in Kiss 1.0.  Use title and title= instead.
+    def title
+      vars.title
+    end
+    
+    # Shorthand to set vars.title, here for backward compatibility.
+    # Note: @title is deprecated for use in templates and will not be
+    # supported in Kiss 1.0.  Use title and title= instead.
+    def title=(new_title)
+      vars.title = new_title
+      @title = new_title
+    end
+    
+    # Returns value of next layout file, which will be used to wrap the
+    # results of current rendering template.
+    # Note: @layout is deprecated for use in templates and will not be
+    # supported in Kiss 1.0.  Use layout and layout= instead.
+    def layout
+      # @layout deprecated; future will be action.layout
+      @layout
+    end
+    
+    # Sets path to next layout file, which will be used to wrap the
+    # results of current rendering template.
+    # Note: @layout is deprecated for use in templates and will not be
+    # supported in Kiss 1.0.  Use layout and layout= instead.
+    def layout=(new_layout)
+      # @layout deprecated; future will be action.layout
+      @layout = new_layout
+    end
+    
+    # Reads file specified by options and return contents (without template
+    # processing).
+    def insert(options = {})
+      path = get_template_path(options)
+      content = File.read(path)
+    end
+    
+    # Processes template specified by options and return results.
+    def process(options = {})
+      path = get_template_path(options)
+      content = erubis(path,binding)
+    end
+    
+    # Gets path to insert/template file from specified options.
+    def get_template_path(options)
+      @current_template_dir ||= @template_dir
+      
+      path = options.is_a?(String) ? options : "#{options[:template]}.#{options[:extension] || 'rhtml'}"
+      path = path =~ /\A\// ? "#{@template_dir}#{path}" : "#{@current_template_dir}/#{path}"
+    
+      path
+    end
+    
+    # Processes specified template file using specified binding.
+    # content is used to pass previously rendered results into 
+    # wrapper templates such as layouts.
+    def erubis(path,template_binding = binding,content = nil)
+      # params note: content (if provided) is passed to erubis template via binding
+      
+      # set template dir to dir that contains this template
+      @current_template_dir ||= @template_dir
+      old_template_dir = @current_template_dir
+      @current_template_dir = path.sub(/\/?[^\/]*\Z/,'')
+      
+      eruby_src = file_cache(path,'template') do |template|
+        # macros
+        template.gsub!(/\<\%\s*macro\s+(\w+.*?)\s*\%\>/,'<% def \1; _buf = \'\' %>')
+        template.gsub!(/\<\%\s*end\s+macro\s*\%\>/,'<% _buf; end %>')
+    
+        # for loop iterator
+        template.gsub!(/\<\%\s*for\s+(\w+)\s+in\s+(.*?)\s*\%\>/,'<% loop = Kiss::Iterator.new(\2); for \1 in loop.collection; loop.increment %>')
+        # while loop iterator
+        template.gsub!(/\<\%\s*while\s+(.*?)\s*\%\>/,'<% loop = Kiss::Iterator.new; while \1; loop.increment %>')
+      
+        Erubis::Eruby.new(template).src
+      end
+      result = eval eruby_src, template_binding, path
+      
+      # restore previous template dir
+      @template_dir = old_template_dir
+      
+      result
+    end
+    
+    # Escapes string for use in URLs.
+    def url_encode(string)
+    	# don't encode to hex: letters, numbers, periods, spaces
+    	# encode space to +
+      string.gsub(/([^A-Za-z0-9\.])/) { sprintf("%%%02X", $&.unpack("C")[0]) }
+    end
+    alias_method :escape, :url_encode
+    alias_method :h, :url_encode
+    
+    # Encodes string for output to HTML.
+    def escape_html(str)
+      Rack::Utils.escape_html(str)
+    end
+    
+    # Formats number to two decimal places.
+    def currency(num)
+      sprintf("%0.2f",num.to_f)
+    end
+  end
+end