radiantcms-couchrest_model 0.1.4 → 0.1.5

data/vendor/plugins/haml/lib/haml/helpers/action_view_extensions.rb

@@ -1,57 +1,45 @@
-module Haml
-  module Helpers
-    @@action_view_defined = true
+require 'haml/helpers/action_view_mods'
 
-    # This module contains various useful helper methods
-    # that either tie into ActionView or the rest of the ActionPack stack,
-    # or are only useful in that context.
-    # Thus, the methods defined here are only available
-    # if ActionView is installed.
-    module ActionViewExtensions
-      # Returns a value for the "class" attribute
-      # unique to this controller/action pair.
-      # This can be used to target styles specifically at this action or controller.
-      # For example, if the current action were `EntryController#show`,
-      #
-      #     %div{:class => page_class} My Div
-      #
-      # would become
-      #
-      #     <div class="entry show">My Div</div>
-      #
-      # Then, in a stylesheet (shown here as {Sass}),
-      # you could refer to this specific action:
-      #
-      #     .entry.show
-      #       font-weight: bold
-      #
-      # or to all actions in the entry controller:
-      #
-      #     .entry
-      #       color: #00f
-      #
-      # @return [String] The class name for the current page
-      def page_class
-        controller.controller_name + " " + controller.action_name
-      end
-      alias_method :generate_content_class_names, :page_class
+if defined?(ActionView)
+  module Haml
+    module Helpers
+      # This module contains various useful helper methods
+      # that either tie into ActionView or the rest of the ActionPack stack,
+      # or are only useful in that context.
+      # Thus, the methods defined here are only available
+      # if ActionView is installed.
+      module ActionViewExtensions
+        # Returns a value for the "class" attribute
+        # unique to this controller/action pair.
+        # This can be used to target styles specifically at this action or controller.
+        # For example, if the current action were EntryController#show,
+        #
+        #   %div{:class => page_class} My Div
+        #
+        # would become
+        #
+        #   <div class="entry show">My Div</div>
+        #
+        # Then, in a stylesheet
+        # (shown here as Sass),
+        # you could refer to this specific action:
+        #
+        #   .entry.show
+        #     :font-weight bold
+        #
+        # or to all actions in the entry controller:
+        #
+        #   .entry
+        #     :color #00f
+        #
+        def page_class
+          controller.controller_name + " " + controller.action_name
+        end
 
-      # Treats all input to \{Haml::Helpers#haml\_concat} within the block
-      # as being HTML safe for Rails' XSS protection.
-      # This is useful for wrapping blocks of code that concatenate HTML en masse.
-      #
-      # This has no effect if Rails' XSS protection isn't enabled.
-      #
-      # @yield A block in which all input to `#haml_concat` is treated as raw.
-      # @see Haml::Util#rails_xss_safe?
-      def with_raw_haml_concat
-        @_haml_concat_raw, old = true, @_haml_concat_raw
-        yield
-      ensure
-        @_haml_concat_raw = old
+        # :stopdoc:
+        alias_method :generate_content_class_names, :page_class
+        # :startdoc:
       end
     end
-
-    include ActionViewExtensions
   end
 end

data/vendor/plugins/haml/lib/haml/helpers/action_view_mods.rb

@@ -1,175 +1,136 @@
-module ActionView
-  class Base
-    def render_with_haml(*args, &block)
-      options = args.first
-
-      # If render :layout is used with a block,
-      # it concats rather than returning a string
-      # so we need it to keep thinking it's Haml
-      # until it hits the sub-render
-      if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
-        return non_haml { render_without_haml(*args, &block) }
-      end
-      render_without_haml(*args, &block)
-    end
-    alias_method :render_without_haml, :render
-    alias_method :render, :render_with_haml
-
-    # Rails >2.1
-    if Haml::Util.has?(:instance_method, self, :output_buffer)
-      def output_buffer_with_haml
-        return haml_buffer.buffer if is_haml?
-        output_buffer_without_haml
-      end
-      alias_method :output_buffer_without_haml, :output_buffer
-      alias_method :output_buffer, :output_buffer_with_haml
-
-      def set_output_buffer_with_haml(new)
-        if is_haml?
-          new = String.new(new) if Haml::Util.rails_xss_safe? &&
-            new.is_a?(Haml::Util.rails_safe_buffer_class)
-          haml_buffer.buffer = new
-        else
-          set_output_buffer_without_haml new
+if defined?(ActionView) and not defined?(Merb::Plugins)
+  module ActionView
+    class Base # :nodoc:
+      def render_with_haml(*args, &block)
+        options = args.first
+
+        # If render :layout is used with a block,
+        # it concats rather than returning a string
+        # so we need it to keep thinking it's Haml
+        # until it hits the sub-render
+        if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
+          return non_haml { render_without_haml(*args, &block) }
         end
+        render_without_haml(*args, &block)
       end
-      alias_method :set_output_buffer_without_haml, :output_buffer=
-      alias_method :output_buffer=, :set_output_buffer_with_haml
-    end
-  end
-
-  module Helpers
-    # In Rails <=2.1, we've got to override considerable capturing infrastructure.
-    # In Rails >2.1, we can make do with only overriding #capture
-    # (which no longer behaves differently in helper contexts).
-    unless Haml::Util.has?(:instance_method, ActionView::Base, :output_buffer)
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          # Rails' #capture helper will just return the value of the block
-          # if it's not actually in the template context,
-          # as detected by the existance of an _erbout variable.
-          # We've got to do the same thing for compatibility.
-
-          if is_haml? && block_is_haml?(block)
-            capture_haml(*args, &block)
-          else
-            capture_without_haml(*args, &block)
-          end
+      alias_method :render_without_haml, :render
+      alias_method :render, :render_with_haml
+
+      # Rails >2.1
+      if Haml::Util.has?(:instance_method, self, :output_buffer)
+        def output_buffer_with_haml
+          return haml_buffer.buffer if is_haml?
+          output_buffer_without_haml
         end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
+        alias_method :output_buffer_without_haml, :output_buffer
+        alias_method :output_buffer, :output_buffer_with_haml
 
-        def capture_erb_with_buffer_with_haml(buffer, *args, &block)
+        def set_output_buffer_with_haml(new)
           if is_haml?
-            capture_haml(*args, &block)
+            haml_buffer.buffer = new
           else
-            capture_erb_with_buffer_without_haml(buffer, *args, &block)
+            set_output_buffer_without_haml new
           end
         end
-        alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
-        alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
+        alias_method :set_output_buffer_without_haml, :output_buffer=
+        alias_method :output_buffer=, :set_output_buffer_with_haml
       end
+    end
 
-      module TextHelper
-        def concat_with_haml(string, binding = nil)
-          if is_haml?
-            haml_buffer.buffer.concat(string)
-          else
-            concat_without_haml(string, binding)
+    # This overrides various helpers in ActionView
+    # to make them work more effectively with Haml.
+    module Helpers
+      # :stopdoc:
+      # In Rails <=2.1, we've got to override considerable capturing infrastructure.
+      # In Rails >2.1, we can make do with only overriding #capture
+      # (which no longer behaves differently in helper contexts).
+      unless Haml::Util.has?(:instance_method, ActionView::Base, :output_buffer)
+        module CaptureHelper
+          def capture_with_haml(*args, &block)
+            # Rails' #capture helper will just return the value of the block
+            # if it's not actually in the template context,
+            # as detected by the existance of an _erbout variable.
+            # We've got to do the same thing for compatibility.
+
+            if is_haml? && block_is_haml?(block)
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
+            end
           end
-        end
-        alias_method :concat_without_haml, :concat
-        alias_method :concat, :concat_with_haml
-      end
-    else
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          if Haml::Helpers.block_is_haml?(block)
-            capture_haml(*args, &block)
-          else
-            capture_without_haml(*args, &block)
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
+
+          def capture_erb_with_buffer_with_haml(buffer, *args, &block)
+            if is_haml?
+              capture_haml(*args, &block)
+            else
+              capture_erb_with_buffer_without_haml(buffer, *args, &block)
+            end
           end
+          alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
+          alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
         end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
-      end
-    end
-
-    module TagHelper
-      def content_tag_with_haml(name, *args, &block)
-        return content_tag_without_haml(name, *args, &block) unless is_haml?
 
-        preserve = haml_buffer.options[:preserve].include?(name.to_s)
-
-        if block_given? && block_is_haml?(block) && preserve
-          return content_tag_without_haml(name, *args) {preserve(&block)}
+        module TextHelper
+          def concat_with_haml(string, binding = nil)
+            if is_haml?
+              haml_buffer.buffer.concat(string)
+            else
+              concat_without_haml(string, binding)
+            end
+          end
+          alias_method :concat_without_haml, :concat
+          alias_method :concat, :concat_with_haml
         end
-
-        returning content_tag_without_haml(name, *args, &block) do |content|
-          return Haml::Helpers.preserve(content) if preserve && content
+      else
+        module CaptureHelper
+          def capture_with_haml(*args, &block)
+            if Haml::Helpers.block_is_haml?(block)
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
+            end
+          end
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
         end
       end
 
-      alias_method :content_tag_without_haml, :content_tag
-      alias_method :content_tag, :content_tag_with_haml
-    end
+      module TagHelper
+        def content_tag_with_haml(name, *args, &block)
+          return content_tag_without_haml(name, *args, &block) unless is_haml?
 
-    class InstanceTag
-      # Includes TagHelper
+          preserve = haml_buffer.options[:preserve].include?(name.to_s)
 
-      def haml_buffer
-        @template_object.send :haml_buffer
-      end
+          if block_given? && block_is_haml?(block) && preserve
+            return content_tag_without_haml(name, *args) {preserve(&block)}
+          end
 
-      def is_haml?
-        @template_object.send :is_haml?
-      end
+          returning content_tag_without_haml(name, *args, &block) do |content|
+            return Haml::Helpers.preserve(content) if preserve && content
+          end
+        end
 
-      def content_tag(*args)
-        html_tag = content_tag_with_haml(*args)
-        return html_tag unless respond_to?(:error_wrapping)
-        return error_wrapping(html_tag) if method(:error_wrapping).arity == 1
-        return html_tag unless object.respond_to?(:errors) && object.errors.respond_to?(:on)
-        return error_wrapping(html_tag, object.errors.on(@method_name))
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
       end
-    end
 
-    if Haml::Util.ap_geq_3?
-      module FormTagHelper
-        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if is_haml?
-            if block_given?
-              oldproc = proc
-              proc = haml_bind_proc do |*args|
-                concat "\n"
-                with_tabs(1) {oldproc.call(*args)}
-              end
-            end
-            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            res << "\n" if block_given?
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-          end
+      class InstanceTag
+        # Includes TagHelper
+
+        def haml_buffer
+          @template_object.send :haml_buffer
         end
-        alias_method :form_tag_without_haml, :form_tag
-        alias_method :form_tag, :form_tag_with_haml
-      end
 
-      module FormHelper
-        def form_for_with_haml(object_name, *args, &proc)
-          if block_given? && is_haml?
-            oldproc = proc
-            proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
-          end
-          res = form_for_without_haml(object_name, *args, &proc)
-          res << "\n" if block_given? && is_haml?
-          res
+        def is_haml?
+          @template_object.send :is_haml?
         end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
+
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
       end
-    else
+
       module FormTagHelper
         def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
           if is_haml?
@@ -213,6 +174,8 @@ module ActionView
         alias_method :form_for_without_haml, :form_for
         alias_method :form_for, :form_for_with_haml
       end
+      # :startdoc:
     end
   end
 end
+

data/vendor/plugins/haml/lib/haml/html.rb

@@ -2,18 +2,48 @@ require File.dirname(__FILE__) + '/../haml'
 
 require 'haml/engine'
 require 'rubygems'
+require 'hpricot'
 require 'cgi'
 
 module Haml
+  # This class contains the functionality used in the +html2haml+ utility,
+  # namely converting HTML documents to Haml templates.
+  # It depends on Hpricot for HTML parsing (http://code.whytheluckystiff.net/hpricot/).
   class HTML
-    # A module containing utility methods that every Hpricot node
-    # should have.
-    module Node
-      # Returns the Haml representation of the given node.
-      #
-      # @param tabs [Fixnum] The indentation level of the resulting Haml.
-      # @option options (see Haml::HTML#initialize)
-      def to_haml(tabs, options)
+    # Creates a new instance of Haml::HTML that will compile the given template,
+    # which can either be a string containing HTML or an Hpricot node,
+    # to a Haml string when +render+ is called.
+    def initialize(template, options = {})
+      @@options = options
+
+      if template.is_a? Hpricot::Node
+        @template = template
+      else
+        if template.is_a? IO
+          template = template.read
+        end
+
+        if @@options[:rhtml]
+          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
+          match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
+        end
+
+        method = @@options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
+        @template = method.call(template.gsub('&', '&amp;'))
+      end
+    end
+
+    # Processes the document and returns the result as a string
+    # containing the Haml template.
+    def render
+      @template.to_haml(0)
+    end
+    alias_method :to_haml, :render
+
+    module ::Hpricot::Node
+      # Returns the Haml representation of the given node,
+      # at the given tabulation.
+      def to_haml(tabs = 0)
         parse_text(self.to_s, tabs)
       end
 
@@ -23,13 +53,8 @@ module Haml
         '  ' * tabs
       end
 
-      def attr_hash
-        attributes.to_hash
-      end
-
       def parse_text(text, tabs)
         text.strip!
-        text.gsub!('#{', '\#{') #'
         if text.empty?
           String.new
         else
@@ -42,112 +67,40 @@ module Haml
         end
       end
     end
-  end
-end
-
-# Haml monkeypatches various Hpricot classes
-# to add methods for conversion to Haml.
-# @private
-module Hpricot
-  # @see Hpricot
-  module Node
-    include Haml::HTML::Node
-  end
 
-  # @see Hpricot
-  class BaseEle
-    include Haml::HTML::Node
-  end
-end
+    # :stopdoc:
 
-require 'hpricot'
-
-module Haml
-  # Converts HTML documents into Haml templates.
-  # Depends on [Hpricot](http://github.com/whymirror/hpricot) for HTML parsing.
-  #
-  # Example usage:
-  #
-  #     Haml::HTML.new("<a href='http://google.com'>Blat</a>").render
-  #       #=> "%a{:href => 'http://google.com'} Blat"
-  class HTML
-    # @param template [String, Hpricot::Node] The HTML template to convert
-    # @option options :rhtml [Boolean] (false) Whether or not to parse
-    #   ERB's `<%= %>` and `<% %>` into Haml's `=` and `-`
-    # @option options :xhtml [Boolean] (false) Whether or not to parse
-    #   the HTML strictly as XHTML
-    def initialize(template, options = {})
-      @options = options
-
-      if template.is_a? Hpricot::Node
-        @template = template
-      else
-        if template.is_a? IO
-          template = template.read
-        end
-
-        if @options[:rhtml]
-          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
-          match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
-        end
-
-        method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
-        @template = method.call(template.gsub('&', '&amp;'))
-      end
+    def self.options
+      @@options
     end
 
-    # Processes the document and returns the result as a string
-    # containing the Haml template.
-    def render
-      @template.to_haml(0, @options)
-    end
-    alias_method :to_haml, :render
-
-    # @private
     TEXT_REGEXP = /^(\s*).*$/
 
-    # @see Hpricot
-    # @private
     class ::Hpricot::Doc
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
-        (children || []).inject('') {|s, c| s << c.to_haml(0, options)}
+      def to_haml(tabs = 0)
+        output = ''
+        children.each { |child| output += child.to_haml(0) } if children
+        output
       end
     end
 
-    # @see Hpricot
-    # @private
     class ::Hpricot::XMLDecl
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
+      def to_haml(tabs = 0)
         "#{tabulate(tabs)}!!! XML\n"
       end
     end
 
-    # @see Hpricot
-    # @private
-    class ::Hpricot::CData
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
-        "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
-      end
-    end
-
-    # @see Hpricot
-    # @private
     class ::Hpricot::DocType
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
-        attrs = public_id.nil? ? ["", "", ""] :
-          public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
+      def to_haml(tabs = 0)
+        attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
         if attrs == nil
           raise Exception.new("Invalid doctype")
         end
 
         type, version, strictness = attrs.map { |a| a.downcase }
         if type == "html"
-          version = ""
-          strictness = "strict" if strictness == ""
+          version = "1.0"
+          strictness = "transitional"
         end
 
         if version == "1.0" || version.empty?
@@ -158,49 +111,45 @@ module Haml
           strictness = nil
         end
 
-        version = " #{version.capitalize}" if version
-        strictness = " #{strictness.capitalize}" if strictness
+        version = " #{version}" if version
+        if strictness
+          strictness[0] = strictness[0] - 32
+          strictness = " #{strictness}"
+        end
 
         "#{tabulate(tabs)}!!!#{version}#{strictness}\n"
       end
     end
 
-    # @see Hpricot
-    # @private
     class ::Hpricot::Comment
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
+      def to_haml(tabs = 0)
         "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
-    # @see Hpricot
-    # @private
     class ::Hpricot::Elem
-      # @see Haml::HTML::Node#to_haml
-      def to_haml(tabs, options)
+      def to_haml(tabs = 0)
         output = "#{tabulate(tabs)}"
-        if options[:rhtml] && name[0...5] == 'haml:'
-          return output + send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
+        if HTML.options[:rhtml] && name[0...5] == 'haml:'
+          return output + HTML.send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
         end
 
-        output += "%#{name}" unless name == 'div' &&
-          (static_id?(options) || static_classname?(options))
+        output += "%#{name}" unless name == 'div' && (static_id? || static_classname?)
 
-        if attr_hash
-          if static_id?(options)
-            output += "##{attr_hash['id']}"
+        if attributes
+          if static_id?
+            output += "##{attributes['id']}"
             remove_attribute('id')
           end
-          if static_classname?(options)
-            attr_hash['class'].split(' ').each { |c| output += ".#{c}" }
+          if static_classname?
+            attributes['class'].split(' ').each { |c| output += ".#{c}" }
             remove_attribute('class')
           end
-          output += haml_attributes(options) if attr_hash.length > 0
+          output += haml_attributes if attributes.length > 0
         end
 
         (self.children || []).inject(output + "\n") do |output, child|
-          output + child.to_haml(tabs + 1, options)
+          output + child.to_haml(tabs + 1)
         end
       end
 
@@ -208,48 +157,44 @@ module Haml
       
       def dynamic_attributes
         @dynamic_attributes ||= begin
-          Haml::Util.map_hash(attr_hash) do |name, value|
-            next if value.empty?
-            full_match = nil
-            ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
-              full_match = $`.empty? && $'.empty?
-              CGI.unescapeHTML(full_match ? $1: "\#{#{$1}}")
+          attributes.inject({}) do |dynamic, pair|
+            name, value = pair
+            unless value.empty?
+              full_match = nil
+              ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
+                full_match = $`.empty? && $'.empty?
+                full_match ? $1: "\#{#{$1}}"
+              end
+              unless ruby_value == value
+                dynamic[name] = full_match ? ruby_value : %("#{ruby_value}")
+              end
             end
-            next if ruby_value == value
-            [name, full_match ? ruby_value : %("#{ruby_value}")]
+            dynamic
           end
         end
       end
-
-      def haml_tag_loud(text)
-        "= #{text.gsub(/\n\s*/, ' ').strip}\n"
-      end
-
-      def haml_tag_silent(text)
-        text.split("\n").map { |line| "- #{line.strip}\n" }.join
-      end
-
-      def static_attribute?(name, options)
-        attr_hash[name] and !dynamic_attribute?(name, options)
+      
+      def static_attribute?(name)
+        attributes[name] and !dynamic_attribute?(name)
       end
       
-      def dynamic_attribute?(name, options)
-        options[:rhtml] and dynamic_attributes.key?(name)
+      def dynamic_attribute?(name)
+        HTML.options[:rhtml] and dynamic_attributes.key?(name)
       end
       
-      def static_id?(options)
-        static_attribute?('id', options)
+      def static_id?
+        static_attribute? 'id'
       end
       
-      def static_classname?(options)
-        static_attribute?('class', options)
+      def static_classname?
+        static_attribute? 'class'
       end
 
       # Returns a string representation of an attributes hash
       # that's prettier than that produced by Hash#inspect
-      def haml_attributes(options)
-        attrs = attr_hash.map do |name, value|
-          value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
+      def haml_attributes
+        attrs = attributes.map do |name, value|
+          value = dynamic_attribute?(name) ? dynamic_attributes[name] : value.inspect
           name = name.index(/\W/) ? name.inspect : ":#{name}"
           "#{name} => #{value}"
         end
@@ -257,6 +202,14 @@ module Haml
       end
     end
 
+    def self.haml_tag_loud(text)
+      "= #{text.gsub(/\n\s*/, ' ').strip}\n"
+    end
+
+    def self.haml_tag_silent(text)
+      text.split("\n").map { |line| "- #{line.strip}\n" }.join
+    end
+
     private
 
     def match_to_html(string, regex, tag)
@@ -264,5 +217,6 @@ module Haml
         "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
       end
     end
+    # :startdoc:
   end
 end