merb 0.3.7 → 0.4.0

data/lib/merb/merb_yaml_store.rb

@@ -1,31 +0,0 @@
-require 'yaml/store'
-
-module Merb
-  # thanks to Michael Fellinger from Ramaze
-  class SimpleModel
-    attr_accessor :db
-  
-    def initialize(filename = "#{DIST_ROOT}/schema/db.yaml")
-      FileUtils.touch(filename)
-      @db = YAML::Store.new(filename)
-    end
-  
-    def method_missing(meth, *args, &block)
-      @db.transaction do
-        @db.send(meth, *args, &block)
-      end
-    end
-    
-    def [](key)
-      @db.transaction do
-        @db[key]
-      end
-    end
-  
-    def []=(key, value)
-      @db.transaction do
-        @db[key] = value
-      end
-    end
-  end
-end

data/lib/merb/mixins/render_mixin.rb

@@ -1,283 +0,0 @@
-module Merb
-
-  module RenderMixin
-   
-    def self.included(base)
-      base.class_eval {        
-        class_inheritable_accessor :_template_root,
-                                   :_layout
-                                    
-        @@template_extensions = { }                           
-        self._layout = :application
-        self._template_root = File.expand_path(MERB_VIEW_ROOT)
-        # This method is called by templating-engines to register themselves with
-        # a list of extensions that will be looked up on #render of an action.
-        def self.register_engine(engine, *extensions)
-          [extensions].flatten.uniq.each do |ext|
-            @@template_extensions[ext] = engine
-          end  
-        end
-        
-      }
-    end
-
-    # universal render method. Template handlers are registered
-    # by template extension. So you can use the same render method
-    # for any kind of template that implements an adapter module.
-    # out of the box Merb support Erubis, Haml, Markaby and Builder templates
-    #
-    # Erubis template ext:  .herb .jerb .erb
-    # Markaby template ext: .mab
-    # Builder template ext: .rxml .builder .xerb 
-    # Haml template ext: .haml
-    #
-    # Examples:
-    #
-    #   render
-    #
-    # Looks for views/controllername/actionname.* and renders
-    # the template with the proper engine based on its file extension.
-    #
-    #   render :layout => :none
-    #
-    # Renders the current template with no layout. XMl Builder templates
-    # are exempt from layout by default.
-    # 
-    #   render :action => 'foo'
-    #
-    # Renders views/controllername/foo.*
-    #
-    #   render :nothing => 200
-    #
-    # Renders nothing with a status of 200
-    #
-    #   render :template => 'shared/message'
-    #
-    # Renders views/shared/message
-    #
-    #   render :js => "$('some-div').toggle();"
-    #
-    # If the right hand side of :js => is a string then the proper
-    # javascript headers will be set and the string will be returned 
-    # verbatim as js.
-    #
-    #   render :js => :spinner
-    #
-    # When the rhs of :js => is a Symbol, it will be used as the 
-    # action/template name so: views/controllername/spinner.jerb
-    # will be rendered as javascript
-    #
-    #   render :js => true
-    #
-    # This will just look for the current controller/action template
-    # with the .jerb extension and render it as javascript
-    #
-    # XML can be rendered with the same options as Javascript.
-    #
-    #   render :xml => @posts.to_xml
-    #   render :xml => "<foo><bar>Hi!</bar></foo>"
-    #
-    # This will set the appropriate xml headers and render the rhs
-    # of :xml => as a string. SO you can pass any xml string to this
-    # to be rendered. 
-    #
-    #   render :xml => :hello
-    #
-    # Renders the hello.xrb template for the current controller.
-    #
-    #   render :xml => true
-    #   render :xml => true, :action => "buffalo"
-    #
-    # Renders the buffalo.xerb template for the current controller.
-    #
-    def render(opts={}, &blk)
-      
-      action = if kind_of?(Merb::ControllerExceptions::Base)
-        self.class.name.snake_case.split('::').last
-      else
-        opts[:action] || params[:action]
-      end
-      
-      opts[:layout] ||= _layout 
-      
-      case
-      when status = opts[:nothing]
-        return render_nothing(status)
-      when partial = opts[:partial]
-        template = find_partial(partial, opts)
-        opts[:layout] = :none
-        
-        # Add an instance variable that can be used to create the locals in the
-        # partial
-        if opts[:locals]
-          @_merb_partial_locals = opts[:locals]
-        end
-        opts[:clean_context] = true
-      when js = opts[:js]
-        headers['Content-Type'] = "text/javascript"
-        opts[:layout] = :none
-        case js
-        when String
-          return js
-        when Symbol
-          template = find_template(:action => js, :ext => 'jerb')
-        else
-          template = find_template(:action => action, :ext => 'jerb')
-        end
-      when xml = opts[:xml]
-        headers['Content-Type'] = 'application/xml'
-        headers['Encoding']     = 'UTF-8'
-        # TODO This is the same as the js logic above. Can it be refactored?
-        case xml
-        when String
-          return xml
-        when Symbol
-          template = find_template(:action => xml, :ext => 'rxml,xerb,builder')
-        else
-          template = find_template(:action => action, :ext => 'rxml,xerb,builder')
-        end
-      when template = opts[:template]
-        template = find_template(:template => template)
-      else          
-        template = find_template(:action => action)
-      end
-
-      engine = engine_for(template)
-      options = {
-        :file     => template,
-        :view_context  => (opts[:clean_context] ? clean_view_context : cached_view_context),
-        :opts => opts
-      }
-      content = engine.transform(options)
-      if engine.exempt_from_layout? || opts[:layout] == :none
-        content 
-      else
-        wrap_layout(content, opts)
-      end
-    end
-
- 
-    
-    # does a render with no layout. Also sets the
-    # content type header to text/javascript. Use
-    # this when you want to render a template with 
-    # .jerb extension.
-    def render_js(template=nil)
-      render :js => true, :action => (template || params[:action])
-    end
-
-    # renders nothing but sets the status, defaults
-    # to 200. does send one ' ' space char, this is for
-    # safari and flash uploaders to work.
-    def render_nothing(status=200)
-      @_status = status
-      return " "
-    end
-
-    def set_status(status)
-      @_status = status
-    end
-
-    def render_no_layout(opts={})
-      render opts.update({:layout => :none})
-    end 
-    
-    # This is merb's partial render method. You name your 
-    # partials _partialname.* , and then call it like
-    # partial(:partialname). If there is no '/' character
-    # in the argument passed in it will look for the partial 
-    # in the view directory that corresponds to the current
-    # controller name. If you pass a string with a path in it
-    # you can render partials in other view directories. So
-    # if you create a views/shared directory then you can call
-    # partials that live there like partial('shared/foo')
-    def partial(template, locals={})
-      render :partial => template, :locals => locals
-    end 
-
-    # +catch_content+ catches the thrown content from another template
-    # So when you throw_content(:foo) {...} you can catch_content :foo
-    # in another view or the layout.
-    def catch_content(name)
-      cached_view_context.instance_variable_get("@_#{name}_content")
-    end
-    
-    private
-    
-      # this returns a ViewContext object populated with all
-      # the instance variables in your controller. This is used
-      # as the view context object for the Erubis templates.
-      def cached_view_context
-        @_view_context_cache ||= ViewContext.new(self)
-      end
-      
-      def clean_view_context
-        ViewContext.new(self)
-      end
-    
-      def wrap_layout(content, opts={})
-        if opts[:layout] != :application
-          layout_choice = find_template(:layout => opts[:layout])
-        else
-          if name = find_template(:layout => self.class.name.snake_case.split('::').join('/'))
-            layout_choice = name
-          else
-            layout_choice = find_template(:layout => :application)
-          end  
-        end      
-        
-        cached_view_context.instance_variable_set('@_layout_content', content)
-        engine = engine_for(layout_choice)
-        options = {
-          :file     => layout_choice,
-          :view_context  => cached_view_context,
-          :opts => opts
-        }
-        engine.transform(options)
-      end
-      
-      # OPTIMIZE : combine find_template and find_partial ?
-      def find_template(opts={})
-        if template = opts[:template]
-          path = _template_root / template
-        elsif opts[:action] and kind_of?(Merb::ControllerExceptions::Base)
-          path = _template_root / 'exceptions' / opts[:action]
-        elsif action = opts[:action]
-          segment = self.class.name.snake_case.split('::').join('/')
-          path = _template_root / segment / action
-        elsif _layout = opts[:layout]
-          path = _template_root / 'layout' / _layout
-        else
-          raise "called find_template without an :action or :layout"  
-        end
-        extensions = [@@template_extensions.keys].flatten.uniq
-        glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
-        Dir[glob].first
-      end
-      
-      def find_partial(template, opts={})
-        if template =~ /\//
-          t = template.split('/')
-          template = t.pop
-          path = _template_root / t.join('/') / "_#{template}"
-        else  
-          segment = self.class.name.snake_case.split('::').join('/')
-          path = _template_root  / segment / "_#{template}"
-        end
-        extensions = [@@template_extensions.keys].flatten.uniq
-        glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
-        Dir[glob].first
-      end
-    
-      # lookup the template_extensions for the extname of the filename
-      # you pass. Answers with the engine that matches the extension, Template::Erubis
-      # is used if none matches.
-      def engine_for(file)
-        extension = File.extname(file)[1..-1]
-        @@template_extensions[extension]
-      rescue
-        ::Merb::Template::Erubis
-      end
-      
-  end  
-end

data/lib/merb/mixins/responder_mixin.rb

@@ -1,159 +0,0 @@
-require 'enumerator'
-
-module Merb
-  # use this in your controllers to switch output based on
-  # the HTTP_ACCEPT header. like so:
-  # respond_to do |type|
-  #   type.js { render_js }
-  #   type.html { render }
-  #   type.xml { @foo.to_xml }
-  #   type.yaml { @foo.to_yaml }
-  # end  
-  module ResponderMixin
-    
-    def respond_to(&block)
-      responder = Rest::Responder.new(request.env['HTTP_ACCEPT'], params)
-      block.call(responder)
-      responder.respond(headers)
-      @_status = responder.status if responder.status
-      responder.body
-    end
-
-    module Rest
-      
-      TYPES = {
-        :all  => %w[*/*],
-        :yaml => %w[application/x-yaml text/yaml],
-        :text => %w[text/plain],
-        :html => %w[text/html application/xhtml+xml application/html],
-        :xml  => %w[application/xml text/xml application/x-xml],
-        :js   => %w[application/json text/x-json text/javascript application/javascript application/x-javascript]
-      }
-      
-      class Responder
-      
-        attr_reader :body, :type, :status
-      
-        def initialize(accept_header, params={})
-          MERB_LOGGER.info accept_header
-          @accepts = Responder.parse(accept_header)
-          @params = params
-          @stack  = {}
-        end
-      
-        def method_missing(symbol, &block)
-          raise "respond_to expects a block" unless block_given?
-          # the first method we encounter here will be used for the catch all mime-type */*
-          @stack[:all] = block unless @stack[:all]
-          @stack[symbol] = block
-        end
-        
-        def respond(headers)
-          unless @stack.keys.all?{|k| TYPES.has_key?(k) }
-            raise "unrecognized mime type in respond_to block"
-          end
-          mime_type = negotiate_content
-          if mime_type
-            headers['Content-Type'] = mime_type.super_range
-            @body   = @stack[mime_type.to_sym].call
-          else
-            raise ControllerExceptions::NotAcceptable
-          end
-        end
-        
-        protected
-          
-          def self.parse(accept_header)
-            # parse the raw accept header into a unique, sorted array of AcceptType objects
-            returning( accept_header.split(/,/).enum_for(:each_with_index).map do |entry,index|
-              AcceptType.new(entry,index += 1)
-            end.sort.uniq ) do |list|
-              # firefox (and possibly other browsers) send broken default accept headers.
-              # fix them up by sorting alternate xml forms (namely application/xhtml+xml)
-              # ahead of pure xml types (application/xml,text/xml).
-              if app_xml = list.detect{|e| e.super_range == 'application/xml'}
-                list.select{|e| e.to_s =~ /\+xml/}.each { |acc_type|
-                  list[list.index(acc_type)],list[list.index(app_xml)] = 
-                    list[list.index(app_xml)],list[list.index(acc_type)] }
-              end
-            end
-          end
-          
-        private
-        
-          def negotiate_content
-            if @params[:format]
-              negotiate_by_format
-            elsif (@stack.keys & @accepts.map(&:to_sym)).size > 0
-              negotiate_by_accept_header
-            end
-          end
-          
-          def negotiate_by_format
-            format = @params[:format].to_sym
-            if @stack[format]
-              if @accepts.map(&:to_sym).include?(format)
-                @accepts.detect{|a| a.to_sym == format }
-              else
-                AcceptType.new(TYPES[format].first,0)
-              end
-            end
-          end
-          
-          def negotiate_by_accept_header
-            @accepts.each do |accept|
-              return accept if @stack[accept.to_sym] || accept.to_sym == :all
-            end
-          end
-        
-      end
-
-      class AcceptType
-
-        attr_reader :media_range, :quality, :index, :type, :sub_type
-        
-        def initialize(entry,index)
-          @index = index
-          @media_range, quality = entry.split(/;\s*q=/).map(&:strip)
-          @type, @sub_type = @media_range.split(/\//)
-          quality ||= 0.0 if @media_range == '*/*'
-          @quality = ((quality || 1.0).to_f * 100).to_i
-        end
-      
-        def <=>(entry)
-          returning((entry.quality <=> quality).to_s) do |c|
-            c.replace((index <=> entry.index).to_s) if c == '0'
-          end.to_i
-        end
-      
-        def eql?(entry)
-          synonyms.include?(entry.media_range)
-        end
-      
-        def ==(entry); eql?(entry); end
-      
-        def hash; super_range.hash; end
-      
-        def synonyms
-          TYPES.values.select{|e| e.include?(@media_range)}.flatten
-        end
-      
-        def super_range
-          synonyms.first || @media_range
-        end
-      
-        def to_sym
-          TYPES.select{|k,v| v == synonyms }.flatten.first
-        end
-      
-        def to_s
-          @media_range
-        end
-      
-      end
-      
-    end
-
-  end
-  
-end