mack 0.5.0 → 0.5.5

data/lib/rendering/engine/haml.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "view_template")
+module Mack
+  module Rendering
+    module Engine
+      class Haml < Mack::Rendering::Engine::Base
+        
+        def render(io, binding)
+          ::Haml::Engine.new(io).render(binding)
+        end
+        
+        def extension
+          :haml
+        end
+        
+      end
+    end
+  end
+end

data/lib/rendering/engine/markaby.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), "..", "view_template")
+module Mack
+  module Rendering
+    module Engine
+      class Markaby < Mack::Rendering::Engine::Base
+        
+        def render(io, binding)
+          @_markaby = ::Markaby::Builder.new({}, self.view_template)
+          self.view_template.instance_variable_set("@_markaby", @_markaby)
+          eval(io, binding)
+        end
+        
+        def extension
+          :mab
+        end
+        
+        module ViewHelpers
+          def mab
+            @_markaby
+          end
+        end
+        
+      end
+    end
+  end
+end
+Mack::Rendering::ViewTemplate.send(:include, Mack::Rendering::Engine::Markaby::ViewHelpers)

data/lib/rendering/engine/registry.rb

@@ -0,0 +1,48 @@
+module Mack
+  module Rendering
+    module Engine
+      # A registry used to store which Mack::Rendering::Type objects can use which Mack::Rendering::Engine objects.
+      # 
+      # Example:
+      #   Mack::Rendering::Engine::Registry.register(:bar, :sass)
+      #   render(:bar, "my_file") will now get run through Mack::Rendering::Type::Bar and Mack::Rendering::Engine::Sass
+      class Registry
+        include Singleton
+        
+        # Returns all the engines registered with the system.
+        attr_reader :engines
+      
+        def initialize
+          @engines = {
+            :action => [:erubis, :builder, :markaby, :haml],
+            :template => [:erubis, :builder, :markaby, :haml],
+            :partial => [:erubis, :builder, :markaby, :haml],
+            :layout => [:erubis, :markaby, :haml],
+            :xml => [:builder, :erubis, :markaby, :haml]
+          }
+        end
+        
+        # Registers an engine to a type.
+        # 
+        # Example:
+        # Mack::Rendering::Engine::Registry.register(:action, :haml)
+        def register(type, engine)
+          type = type.to_sym
+          if self.engines.has_key?(type)
+            self.engines[type].insert(0, engine)
+          else
+            self.engines[type] = [engine]
+          end
+        end
+      
+        class << self
+        
+          def method_missing(sym, *args)
+            Mack::Rendering::Engine::Registry.instance.send(sym, *args)
+          end
+        
+        end
+      end # Registry
+    end # Engines
+  end # Rendering
+end # Mack

data/lib/rendering/type/action.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'file_base')
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Used to render a template that's relative to a controller.
+      # 
+      # Example:
+      #   class UsersController < Mack::Controller::Base
+      #     # /users/:id
+      #     def show
+      #       @user = User.first(params(:id))
+      #     end
+      #     # /users
+      #     def index
+      #       @users = User.all
+      #       render(:action, :list)
+      #     end
+      #   end
+      # When some calls /users/1 the file: app/views/users/show.html.erb will be rendered.
+      # When some calls /users the file: app/views/users/list.html.erb will be rendered.
+      class Action < Mack::Rendering::Type::FileBase
+        
+        # See Mack::Rendering::Type::FileBase render_file for more information.
+        # 
+        # The path to the file is built like such:
+        #   app/views/#{controller name}/#{render_value || action name (show, index, etc...)}.#{format (html, xml, js, etc...)}.#{extension defined in the engine}
+        # Example:
+        #   app/views/users/show.html.erb 
+        def render
+          a_file = File.join(self.controller_view_path, "#{self.render_value}.#{self.options[:format]}")
+          render_file(a_file)
+        end
+        
+      end # Action
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/base.rb

@@ -0,0 +1,59 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Mack::Rendering::Type objects need to extend this class.
+      # 
+      # The method 'render' needs to be implemented as in all subclasses.
+      class Base
+        
+        # Returns the Mack::Rendering::ViewTemplate object associated with this render.
+        attr_reader :view_template
+        
+        def initialize(view_template)
+          @view_template = view_template
+        end
+        
+        needs_method :render
+        
+        # If a file is found on disk it will be yielded up.
+        # 
+        # Example:
+        #   find_file("path", "to", "my", "file") do |f|
+        #     puts File.open(f).read
+        #   end
+        def find_file(*path)
+          f = File.join(path)
+          if File.exists?(f)
+            yield f
+          end
+        end
+        
+        # Can be overridden by subclasses to prevent layouts being used with the render.
+        def allow_layout?
+          true
+        end
+        
+        def find_engine(e)
+          eval("Mack::Rendering::Engine::#{e.to_s.camelcase}")
+        end
+        
+        def method_missing(sym, *args)
+          self.view_template.send(sym, *args)
+        end
+        
+        # See Mack::Rendering::ViewTemplate content_for for more details.
+        def capture(*args, &block)
+          @engine.capture(*args, &block)
+        end
+        
+        # Returns the directory path for the current controller.
+        def controller_view_path
+          ivar_cache do
+            File.join(Mack::Configuration.views_directory, self.controller.controller_name)
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/rendering/type/file_base.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'base')
+module Mack
+  module Rendering
+    module Type
+      class FileBase < Mack::Rendering::Type::Base
+        
+        # Returns a string representing the file stored on disk, once it's be run through
+        # the first found Mack::Rendering::Engine object associated with this Mack::Rendering::Type.
+        # 
+        # Since engines are stored in an array, the are looped through until a template is found on disk.
+        # If no template is found then a Mack::Errors::ResourceNotFound exception is thrown.
+        def render_file(file, type = :action)
+          Mack::Rendering::Engine::Registry.engines[type].each do |e|
+            @engine = find_engine(e).new(self.view_template)
+            find_file(file + ".#{@engine.extension}") do |f|
+              return @engine.render(File.open(f).read, self.binder)
+            end
+          end
+          raise Mack::Errors::ResourceNotFound.new(file + ".*")
+        end
+        
+        # Passes concatenation messages through to the Mack::Rendering::Engine object.
+        # This should append the text, using the passed in binding, to the final output
+        # of the render.
+        def concat(txt, b)
+          @engine.concat(txt, b)
+        end
+        
+      end # FileBase
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/inline.rb

@@ -0,0 +1,26 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # This class allows for a template to be rendered inline in a controller, and not served from disk.
+      # 
+      # Examples:
+      #   <%= render(:inline, "<%= 2 + 2 %> should equal 4") %> # => "4 should equal 4"
+      #   <%= render(:inline, "xml.hello("Mark")", :engine => :builder) %> # => "<hello>Mark</hello>"
+      class Inline < Mack::Rendering::Type::Base
+        
+        def render
+          @engine = find_engine((self.options[:engine] || :erubis)).new(self.view_template)
+          return @engine.render(self.render_value, self.binder)
+        end
+        
+        # Passes concatenation messages through to the Mack::Rendering::Engine object.
+        # This should append the text, using the passed in binding, to the final output
+        # of the render.
+        def concat(txt, b)
+          @engine.concat(txt, b)
+        end
+        
+      end # Inline
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/layout.rb

@@ -0,0 +1,26 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Used to render layouts around views.
+      class Layout < Mack::Rendering::Type::FileBase
+        
+        # See Mack::Rendering::Type::FileBase render_file for more information.
+        # 
+        # The path to the file is built like such:
+        #   app/views/layouts/#{options[:layout] || "application"}.#{format (html, xml, js, etc...)}.#{extension defined in the engine}
+        # Example:
+        #   app/views/layouts/application.html.erb 
+        def render
+          l_file = File.join(Mack::Configuration.views_directory, 'layouts', "#{self.options[:layout]}.#{self.options[:format]}")
+          begin
+            render_file(l_file, :layout)
+          rescue Mack::Errors::ResourceNotFound => e
+            MACK_DEFAULT_LOGGER.warn(e)
+            self.view_template.yield_to :view
+          end
+        end
+        
+      end # Layout
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/partial.rb

@@ -0,0 +1,40 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Used to render partials. Partials are small reusable templates. They have to start with an _.
+      # 
+      # Example:
+      #   <%= render(:partial, "users/form") %> # => /users/_form.html.erb
+      class Partial < Mack::Rendering::Type::FileBase
+        
+        # See Mack::Rendering::Type::FileBase render_file for more information.
+        # 
+        # The path to the file is built like such:
+        #   app/views/#{controller name}/#{partial name with prefixed _}.#{format (html, xml, js, etc...)}.#{extension defined in the engine}
+        # Example:
+        #   app/views/users/_form.html.erb 
+        def render
+          partial = self.render_value.to_s
+          parts = partial.split("/")
+          if parts.size == 1
+            # it's local to this controller
+            partial = "_" << partial
+            partial = File.join(self.controller_view_path, partial)
+          else
+            # it's elsewhere
+            parts[parts.size - 1] = "_" << parts.last
+            partial = File.join(Mack::Configuration.views_directory, parts)
+          end
+          partial = "#{partial}.#{self.options[:format]}"
+          render_file(partial, :partial)
+        end
+        
+        # No layouts should be used with this Mack::Rendering::Type
+        def allow_layout?
+          false
+        end
+        
+      end # Partial
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/public.rb

@@ -0,0 +1,29 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Used to render files stored in the public directory. These files are NOT run through any engines
+      # and are returned 'as is'.
+      class Public < Mack::Rendering::Type::Base
+        
+        # Attempts to find the file on disk and return it. If no file extension is provided then the 'format' 
+        # of the request is appended to the file name.
+        def render
+          p_file = self.render_value
+          if File.extname(p_file).blank?
+            p_file = "#{p_file}.#{self.options[:format]}"
+          end
+          find_file(Mack::Configuration.public_directory, p_file) do |f|
+            return File.open(f).read
+          end
+          raise Mack::Errors::ResourceNotFound.new(p_file)
+        end
+        
+        # No layouts should be used with this Mack::Rendering::Type
+        def allow_layout?
+          false
+        end
+        
+      end # Public
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/template.rb

@@ -0,0 +1,22 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Pretty much the same thing as Mack::Rendering::Type::Action, except the template is relative to the app/views directory,
+      # and not the app/views/#{controller name} directory like action.
+      class Template < Mack::Rendering::Type::FileBase
+        
+        # See Mack::Rendering::Type::FileBase render_file for more information.
+        # 
+        # The path to the file is built like such:
+        #   app/views/#{template (show, index, etc...)}.#{format (html, xml, js, etc...)}.#{extension defined in the engine}
+        # Example:
+        #   <%= render(:template, "users/show") %> # => app/views/users/show.html.erb
+        def render
+          t_file = File.join(Mack::Configuration.views_directory, "#{self.render_value}.#{self.options[:format]}")
+          render_file(t_file, :template)
+        end
+        
+      end # Template
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/text.rb

@@ -0,0 +1,17 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # This is pretty damn brain dead, it just returns the text you supplied to it.
+      # 
+      # Example:
+      #   <%= render(:text, "Hello World") %> # => "Hello World"
+      class Text < Mack::Rendering::Type::Base
+        
+        def render
+          self.render_value
+        end
+        
+      end # Text
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/type/url.rb

@@ -0,0 +1,120 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # This class will render the contents of a url.
+      # 
+      # Examples:
+      # This is considered a 'remote' request and will be made using GET.
+      #   <%= render(:url, "http://www.mackframework.com") %>
+      # This is considered a 'remote' request and will be made using POST.
+      #   <%= render(:url, "http://www.mackframework.com", :method => :post) %>
+      # This is considered a 'remote' request and will be made using GET, and will have query string parameters.
+      #   <%= render(:url, "http://www.mackframework.com", :parameters => {:name => "mark"}) %> # http://www.mackframework.com?name=mark
+      # This is considered a 'remote' request and will be made using POST, and will have form parameters.
+      #   <%= render(:url, "http://www.mackframework.com", :method => :post, :parameters => {:name => "mark"}) %>
+      # 
+      # 'Local' requests can also be made:
+      # This is considered a 'local' request and will be made using GET.
+      #   <%= render(:url, "/users") %>
+      # This is considered a 'local' request and will be made using POST.
+      #   <%= render(:url, "/users", :method => :post) %>
+      # This is considered a 'local' request and will be made using GET, and will have query string parameters.
+      #   <%= render(:url, "/users", :parameters => {:name => "mark"}) %> # /users?name=mark
+      # This is considered a 'local' request and will be made using POST, and will have form parameters.
+      #   <%= render(:url, "/users", :method => :post, :parameters => {:name => "mark"}) %>
+      class Url < Mack::Rendering::Type::Base
+        
+        # No layouts should be used with this Mack::Rendering::Type
+        def allow_layout?
+          false
+        end
+        
+        # Retrieves the contents of the url using either GET or POST, passing along any specified parameters.
+        def render
+          options = {:method => :get, :raise_exception => false}.merge(self.options)
+          url = self.render_value
+          remote = url.match(/^[a-zA-Z]+:\/\//)
+          case options[:method]
+          when :get
+            if remote
+              do_render_remote_url(url_with_query(url, options[:parameters]), options) do |uri, options|
+                Net::HTTP.get_response(uri)
+              end
+            else
+              do_render_local_url(url, options) do |url, options|
+                Rack::MockRequest.new(self.app_for_rendering).get(url, options)
+              end
+            end
+          when :post
+            if remote
+              do_render_remote_url(url, options) do |uri, options|
+                Net::HTTP.post_form(uri, options[:parameters] || {})
+              end
+            else
+              do_render_local_url(url, options) do |url, options|
+                Rack::MockRequest.new(self.app_for_rendering).post(url, options)
+              end
+            end
+          else
+            raise Mack::Errors::UnsupportRenderUrlMethodType.new(options[:method])
+          end
+        end
+
+        private
+        def do_render_remote_url(url, options)
+          Timeout::timeout(app_config.mack.render_url_timeout || 5) do
+            uri = URI.parse(url)
+            response = yield uri, options
+            if response.code == "200"
+              return response.body
+            else
+              if options[:raise_exception]
+                raise Mack::Errors::UnsuccessfulRenderUrl.new(uri, response)
+              else
+                return ""
+              end
+            end
+          end
+        end
+
+        def do_render_local_url(url, options)
+          Timeout::timeout(app_config.mack.render_url_timeout || 5) do
+            cooks = {}
+            self.cookies.all.each do |c,v|
+              cooks[c] = v[:value]
+            end
+            request = self.view_template.request
+            # MACK_DEFAULT_LOGGER.debug "ORIGINAL REQUEST: #{request.env.inspect}"
+            env = request.env.dup
+            env - ["rack.input", "rack.errors", "PATH_INFO", "REQUEST_PATH", "REQUEST_URI", "REQUEST_METHOD"]
+            env["rack.request.query_hash"] = options[:parameters] || {}
+            env["HTTP_COOKIE"] = "#{app_config.mack.session_id}=#{request.session.id};" if env["HTTP_COOKIE"].nil?
+            options = env.merge(options)
+            # MACK_DEFAULT_LOGGER.debug "NEW OPTIONS: #{options.inspect}"
+            # MACK_DEFAULT_LOGGER.debug "url: #{url}"
+            response = yield url, options
+            if response.successful?
+              return response.body
+            else
+              if options[:raise_exception]
+                raise Mack::Errors::UnsuccessfulRenderUrl.new(url, response)
+              else
+                return ""
+              end
+            end
+          end
+        end
+
+        def url_with_query(url, parameters = {})
+          unless parameters.empty?
+            url = url.to_s.dup
+            url << "?"
+            url << parameters.to_params(true)
+          end
+          url
+        end
+        
+      end
+    end
+  end
+end