nitro 0.20.0 → 0.21.0

data/lib/nitro/caching/fragments.rb

@@ -9,60 +9,60 @@ module Nitro
 
 module Caching
 
-	# Action caching.
+  # Action caching.
 
-	module Fragments
+  module Fragments
 
-		@@store = FileStore.new # MemoryStore.new
+    @@store = FileStore.new # MemoryStore.new
 
-		def self.store 
-			@@store 
-		end
-		
-		def self.store=(store) 
-			@@store = store
-		end
-		
-		def self.get(name, options = {})
-			return @@store.read(name, options)
-		end
-		
-		def self.put(name, content = nil, options = {})
-			@@store.write(name, content, options)
-			return content
-		end
-		
-		def self.append_features(base) # :nodoc: 
-			super
-		end
+    def self.store 
+      @@store 
+    end
+    
+    def self.store=(store) 
+      @@store = store
+    end
+    
+    def self.get(name, options = {})
+      return @@store.read(name, options)
+    end
+    
+    def self.put(name, content = nil, options = {})
+      @@store.write(name, content, options)
+      return content
+    end
+    
+    def self.append_features(base) # :nodoc: 
+      super
+    end
 
-		private
+    private
 
-		def cache(name = nil, options = {}, &block)
-			name = @action_name unless name	
-			cache_fragment(block, "#{name}#{options}", options)
-		end
+    def cache(name = nil, options = {}, &block)
+      name = @action_name unless name  
+      cache_fragment(block, "#{name}#{options}", options)
+    end
 
-		def cache_fragment(block, name, options = {})
-			unless caching_enabled?
-				block.call
-				return
-			end
+    def cache_fragment(block, name, options = {})
+      unless caching_enabled?
+        block.call
+        return
+      end
 
-			if fragment = Fragments.get(name, options)
-				@out << fragment
-			else
-				pos = @out.length				
-				block.call
-				Fragments.put(name, @out[pos..-1], options)
-			end
-		end
+      if fragment = Fragments.get(name, options)
+        @out << fragment
+      else
+        pos = @out.length        
+        block.call
+        Fragments.put(name, @out[pos..-1], options)
+      end
+    end
 
-		def expire_fragment(name, options = {})
-			Fragments.store.delete(name, options)
-		end
-	end
-	
+    def expire_fragment(name, options = {})
+      Fragments.store.delete(name, options)
+    end
+  end
+  
 end
 
 end

data/lib/nitro/caching/invalidation.rb

@@ -1,24 +1,24 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: invalidation.rb 1 2005-04-11 11:04:30Z gmosx $
+# $Id: invalidation.rb 182 2005-07-22 10:07:50Z gmosx $
 
 module Nitro
 
 module Caching
 
-	# Support for invalidating output/fragment caches.
-	
-	module Invalidation
+  # Support for invalidating output/fragment caches.
+  
+  module Invalidation
 
-  	def self.append_features(base) #:nodoc:
-			super
-			base.extend(ClassMethods)
-		end
+    def self.append_features(base) #:nodoc:
+      super
+      base.extend(ClassMethods)
+    end
 
-		module ClassMethods
-		end
+    module ClassMethods
+    end
 
-	end
+  end
 
 end
 

data/lib/nitro/caching/output.rb

@@ -6,71 +6,71 @@ module Nitro
 
 module Caching
 
-	# Output caching.
-
-	module Output
-
-		def self.append_features(base) # :nodoc: 
-			super
-			base.extend(ClassMethods)
-			base.module_eval do
-				cattr_accessor :output_cache_root, 'public'
-			end
-		end
-
-		module ClassMethods
-
-			def do_cache_output(path, content)
-				filepath = output_cache_path(path)
-				FileUtils.makedirs(File.dirname(filepath))
-				File.open(filepath, 'w+') { |f| f.write(content) }
-				Logger.debug "Cached page: #{filepath}" if $DBG
-			end
-
-			# Enable output caching for the given actions.
-
-			def cache_output(*actions)
-				return unless caching_enabled?
-
-				str = actions.collect { |a| ":#{a}" }.join(', ')
-
-				module_eval %{
-					post "do_cache_output", :only => [ #{str} ]
-				}
-			end
-
-			private
-
-			def output_cache_path(path)
-				filename = ((path.empty? || path == '/') ? '/index' : path.dup)
-#				filename.gsub!(/\/$/, '')
-				filename << 'index.html' unless (name.split('/').last || name).include? '.'
-				return output_cache_root + '/' + filename 										
-			end
-			
-		end
-
-		private
-
-		def do_cache_output
-			if caching_enabled? and caching_allowed?
-				self.class.do_cache_output(@request.uri, @out)
-			end
-		end
-
-		def expire_output(name)
-			begin
-				FileUtils.rm("#{context.dispatcher.public_root}/#{name}/index.html")
-			rescue Object
-				# gmosx: is this the right thing to do?
-			end
-		end
-		
-		def caching_allowed?
-			!@request.post?
-		end
-
-	end
+  # Output caching.
+
+  module Output
+
+    def self.append_features(base) # :nodoc: 
+      super
+      base.extend(ClassMethods)
+      base.module_eval do
+        cattr_accessor :output_cache_root, 'public'
+      end
+    end
+
+    module ClassMethods
+
+      def do_cache_output(path, content)
+        filepath = output_cache_path(path)
+        FileUtils.makedirs(File.dirname(filepath))
+        File.open(filepath, 'w+') { |f| f.write(content) }
+        Logger.debug "Cached page: #{filepath}" if $DBG
+      end
+
+      # Enable output caching for the given actions.
+
+      def cache_output(*actions)
+        return unless caching_enabled?
+
+        str = actions.collect { |a| ":#{a}" }.join(', ')
+
+        module_eval %{
+          post "do_cache_output", :only => [ #{str} ]
+        }
+      end
+
+      private
+
+      def output_cache_path(path)
+        filename = ((path.empty? || path == '/') ? '/index' : path.dup)
+#        filename.gsub!(/\/$/, '')
+        filename << 'index.html' unless (name.split('/').last || name).include? '.'
+        return output_cache_root + '/' + filename                     
+      end
+      
+    end
+
+    private
+
+    def do_cache_output
+      if caching_enabled? and caching_allowed?
+        self.class.do_cache_output(@request.uri, @out)
+      end
+    end
+
+    def expire_output(name)
+      begin
+        FileUtils.rm("#{context.dispatcher.public_root}/#{name}/index.html")
+      rescue Object
+        # gmosx: is this the right thing to do?
+      end
+    end
+    
+    def caching_allowed?
+      !@request.post?
+    end
+
+  end
 
 end
 

data/lib/nitro/caching/stores.rb

@@ -1,6 +1,6 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: stores.rb 9 2005-04-13 00:08:20Z nasis $
+# $Id: stores.rb 182 2005-07-22 10:07:50Z gmosx $
 
 require 'fileutils'
 
@@ -12,72 +12,72 @@ module Nitro
 
 module Caching
 
-	# Cached fragments are stored in memory.
-
-	class MemoryStore < Glue::SafeHash
-
-		def read(name, options = {})
-			self[name]
-		end
-		
-		def write(name, content = '', options = {})
-			self[name] = content
-		end
-
-		def delete(name, options = {}) 
-			self.delete(name)
-		end
-
-	end
-
-	# Cached fragments are stored as html files
-	# on the filesystem.
-
-	class FileStore
-		cattr_accessor :cache_root, 'cache'
-		
-		def initialize(cache_root = FileStore.cache_root)
-			@cache_root = cache_root
-		end
-		
-		def read(name, options = {})
-			begin
-				IO.read(path_for_name(name))
-			rescue
-				nil
-			end
-		end
-
-		def write(name, content = '', options = {})
-			begin
-				path = path_for_name(name)
-				dir = File.dirname(path)
-				FileUtils.makedirs(dir) unless File.exists?(dir)
-				
-				File.open(path, 'w+') { |f| f.write(content) }
-			rescue
-				Logger.error "Could not save cached file '#{path}'"
-			end
-		end
-
-		def delete(name, options = {})
-			path = path_for_name(name)
-			File.delete(path) if File.exist?(path)
-		end
-		
-		private
-
-		def path_for_name(name)
-			"#@cache_root/#{name}"
-		end
-
-	end
-
-	class DrbStrore
-	end
-	
-	class MemcacheStore
-	end
+  # Cached fragments are stored in memory.
+
+  class MemoryStore < Glue::SafeHash
+
+    def read(name, options = {})
+      self[name]
+    end
+    
+    def write(name, content = '', options = {})
+      self[name] = content
+    end
+
+    def delete(name, options = {}) 
+      self.delete(name)
+    end
+
+  end
+
+  # Cached fragments are stored as html files
+  # on the filesystem.
+
+  class FileStore
+    cattr_accessor :cache_root, 'cache'
+    
+    def initialize(cache_root = FileStore.cache_root)
+      @cache_root = cache_root
+    end
+    
+    def read(name, options = {})
+      begin
+        IO.read(path_for_name(name))
+      rescue
+        nil
+      end
+    end
+
+    def write(name, content = '', options = {})
+      begin
+        path = path_for_name(name)
+        dir = File.dirname(path)
+        FileUtils.makedirs(dir) unless File.exists?(dir)
+        
+        File.open(path, 'w+') { |f| f.write(content) }
+      rescue
+        Logger.error "Could not save cached file '#{path}'"
+      end
+    end
+
+    def delete(name, options = {})
+      path = path_for_name(name)
+      File.delete(path) if File.exist?(path)
+    end
+    
+    private
+
+    def path_for_name(name)
+      "#@cache_root/#{name}"
+    end
+
+  end
+
+  class DrbStrore
+  end
+  
+  class MemcacheStore
+  end
 
 end
 

data/lib/nitro/compiler.rb

@@ -0,0 +1,262 @@
+require 'facet/object/singleton_class'
+
+require 'nitro/template'
+require 'nitro/compiler/errors'
+
+module Nitro
+
+# The Compiler transforms published methods (actions) and 
+# assorted template files (views) into specialized code that 
+# responds to a URI.
+
+class Compiler
+  unless const_defined? :PROTO_TEMPLATE_ROOT
+    PROTO_TEMPLATE_ROOT = "#{Nitro.proto_path}/public"
+  end
+  
+  # Set to true to force reloading of code and templates for
+  # each request. Extremely useful during development. Must be
+  # turned off in production servers to avoid the severe
+  # performance penalty.
+  
+  setting :reload, :default => true, :doc => 'If true all code and templates are reloaded in each request'
+  
+  # Action names with double underscores (__) are converted
+  # to subdirectories. Here are some example mappings:
+  #
+  # hello_world -> template_root/hello_world.xhtml
+  # this__is__my__hello_world -> template_root/this/is/my/hello_world
+  
+  def template_for_action(action, template_root = Template.root, ext = Template.extension)
+    # attempt to find a template of the form
+    # template_root/action.xhtml
+
+    path = "#{template_root}/#{action.gsub(/__/, '/')}.#{ext}".squeeze('/')
+
+    unless File.exist?(path)
+      # attempt to find a template of the form
+      # template_root/action/index.xhtml
+
+      path = "#{template_root}/#{action.gsub(/__/, '/')}/#{Template.default}.#{ext}".squeeze('/')
+
+      unless File.exist?(path)  
+        # No template found!
+        return nil
+      end
+    end
+
+    return path
+  end
+
+  # This is methods transforms the template. Typically 
+  # template processors are added as aspects to this method 
+  # to allow for customized template transformation prior 
+  # to compilation.
+  # 
+  # The default transformation extracts the Ruby code from
+  # processing instructions.
+  
+  def transform_template(template)
+    Template.transform(template)
+  end
+
+  # Compile the template into a render method.
+  
+  def compile_template(klass, action, path)
+    Logger.debug "Compiling template '#{klass}: #{path}'" if $DBG
+
+    template = File.read(path)
+  
+    code = %{
+      def #{action}_template
+        #{transform_template(template)}
+      end
+    }
+
+    begin
+      klass.class_eval(code, path)
+    rescue SyntaxError => e
+      raise TemplateCompileError.new(code, template, e)
+    end        
+  end
+
+  # Compiles an action.
+  #
+  # Passes the action name and the parent action name in the
+  # @action_name and @parent_action_name respectively.
+  #--
+  # TODO: cleanup this method.
+  #++
+  
+  def compile_action(klass, action)    
+    #--
+    # gmosx: Move elsewhere.
+    #++
+    
+    Aspects.include_advice_modules(klass)
+    
+    action = action.to_s.gsub(/_action$/, '')
+    
+    return false unless action
+
+    Logger.debug "Compiling action '#{klass}##{action}'" if $DBG
+
+    valid = false
+    
+    code = %{
+      def #{action}_action
+        @parent_action_name = @action_name
+        @action_name = '#{action}'
+    }
+  
+    # Inject the pre advices.
+
+    code << Aspects.gen_advice_code(action, klass.advices, :pre) 
+
+    # Call the action
+    
+    if klass.action_methods.include?(action)
+      valid = true
+
+      # Annotated parameters.
+
+      if meta = klass.action_metadata[action.intern]
+        params = meta.params.keys
+        params = params.collect { |p| "@#{p} = @context['#{p}']" }
+        code << "#{params.join(';')}"
+      end
+                                                                
+      # Try to resolve action parameters.
+
+      param_count = klass.instance_method(action.intern).arity 
+      
+      # gmosx, FIXME: REIMPLEMENT THIS!!!!
+      
+      if param_count > 0
+        code << %{
+          params = []
+          qs = context.query_string.split(/[&;]/)
+          
+          #{param_count}.times do |i|
+            params << qs.shift.split(/=/).last
+          end
+          
+          action_return_value = #{action}(*params)
+        }
+      else
+        code << %{
+          action_return_value = #{action}
+        }
+      end
+      code << %{
+        unless :stop == action_return_value      
+      }
+    end
+    
+    # Try to call the template method if it exists. It is a 
+    # nice practice to put output related code in this method 
+    # instead of the main action so that this method can be 
+    # overloaded separately.
+    #
+    # If no template method exists, try to convert an external
+    # template file into a template method. It is an even 
+    # better practice to place the output related code in an 
+    # external template file.
+
+    # Take :view metadata into account.
+
+    view = nil
+    if md = klass.action_metadata[action.intern] 
+      view = md[:view]
+    end
+    view ||= action
+
+    cklass = klass    
+    template_path = nil
+
+    loop do
+      template_root = nil
+
+      if cklass.respond_to?(:template_root)
+        template_root = cklass.template_root
+      end
+
+      # Don't use a proto template if there is an action 
+      # defined.      
+      
+      template_root ||= PROTO_TEMPLATE_ROOT unless valid
+
+      if template_root and template_path = template_for_action(view.to_s, template_root)
+        valid = true
+        code << %{
+          #{action}_template;
+        }
+        break
+      end 
+      
+      break unless cklass = cklass.superclass
+    end
+
+    return false unless valid
+
+    if klass.action_methods.include?(action)
+      code << %{
+        if @out.empty? and action_return_value.is_a?(String)
+          print(action_return_value)
+        end
+      end
+      }
+    end
+
+    if Render.redirect_on_empty
+      code << %{
+        redirect_referer if @out.empty?
+      }
+    end
+
+    # Inject the post advices.
+
+    code << Aspects.gen_advice_code(action, klass.advices, :post) 
+
+    code << %{
+        @action_name = @parent_action_name
+      end
+    }
+
+    # First compile the action method. 
+    
+#    begin
+      klass.class_eval(code)
+#    rescue SyntaxError => e
+#      raise ActionCompileError.new(code, action, e)
+#    end
+    
+    compile_template(klass, action, template_path) if template_path
+
+    return true
+
+  end
+
+  # Compiles an action method in the given (controller) class.
+  # A sync is used to make compilation thread safe.
+  
+  def compile(klass, action)
+    compile_action(klass, action)
+  end
+
+  # :section: Helper methods.
+
+  class << self
+    # Helper method for manipulating the template transformation
+    # pipeline.
+    
+    def setup_transform_template(&block)
+      send :define_method, :transform_template, block
+    end
+    alias_method :setup_template_transform, :setup_transform_template
+    alias_method :setup_template_transformation, :setup_transform_template
+  end
+      
+end
+
+end