torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/lib/haml/helpers/action_view_extensions.rb

@@ -1,57 +0,0 @@
-module Haml
-  module Helpers
-    @@action_view_defined = true
-
-    # 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](http://sass-lang.com)),
-      # 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
-
-      # 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
-      end
-    end
-
-    include ActionViewExtensions
-  end
-end

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/lib/haml/helpers/action_view_mods.rb

@@ -1,260 +0,0 @@
-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
-        end
-      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)
-            value = nil
-            buffer = capture_haml(*args) { value = yield(*args) }
-            return buffer unless buffer.empty?
-            return value if value.is_a?(String)
-          else
-            capture_without_haml(*args, &block)
-          end
-        end
-        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
-
-      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
-    else
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          if Haml::Helpers.block_is_haml?(block)
-            _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
-            value = nil
-            buffer = capture_haml(*args) { value = yield(*args) }
-            str =
-              if !buffer.empty?
-                buffer
-              elsif value.is_a?(String)
-                value
-              else
-                ''
-              end
-            return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
-            return str
-          else
-            capture_without_haml(*args, &block)
-          end
-        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)}
-        end
-
-        content = content_tag_without_haml(name, *args, &block)
-        content = Haml::Helpers.preserve(content) if preserve && content
-        content
-      end
-
-      alias_method :content_tag_without_haml, :content_tag
-      alias_method :content_tag, :content_tag_with_haml
-    end
-
-    class InstanceTag
-      # Already includes TagHelper
-      include Haml::Helpers
-
-      def haml_buffer
-        @template_object.send :haml_buffer
-      end
-
-      def is_haml?
-        @template_object.send :is_haml?
-      end
-
-      def content_tag(*args, &block)
-        html_tag = content_tag_with_haml(*args, &block)
-        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))
-      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?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
-              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 wrap_block
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-          end
-        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)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-          if wrap_block
-            oldproc = proc
-            proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
-          end
-          res = form_for_without_haml(object_name, *args, &proc)
-          res << "\n" if wrap_block
-          res
-        end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
-      end
-
-      module CacheHelper
-        # This is a workaround for a Rails 3 bug
-        # that's present at least through beta 3.
-        # Their fragment_for assumes that the block
-        # will return its contents as a string,
-        # which is not always the case.
-        # Luckily, it only makes this assumption if caching is disabled,
-        # so we only override that case.
-        def fragment_for_with_haml(*args, &block)
-          return fragment_for_without_haml(*args, &block) if controller.perform_caching
-          capture(&block)
-        end
-        alias_method :fragment_for_without_haml, :fragment_for
-        alias_method :fragment_for, :fragment_for_with_haml
-      end
-    else
-      module FormTagHelper
-        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if is_haml?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
-              oldproc = proc
-              proc = haml_bind_proc do |*args|
-                concat "\n"
-                tab_up
-                oldproc.call(*args)
-                tab_down
-                concat haml_indent
-              end
-              concat haml_indent
-            end
-            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            if block_given?
-              concat "\n"
-              return Haml::Helpers::ErrorReturn.new("form_tag")
-            end
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-          end
-        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)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-          if wrap_block
-            oldproc = proc
-            proc = haml_bind_proc do |*args|
-              tab_up
-              oldproc.call(*args)
-              tab_down
-              concat haml_indent
-            end
-            concat haml_indent
-          end
-          form_for_without_haml(object_name, *args, &proc)
-          concat "\n" if wrap_block
-          Haml::Helpers::ErrorReturn.new("form_for") if is_haml?
-        end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
-      end
-    end
-  end
-end
-
-require "haml/helpers/rails_323_textarea_fix" if Haml::Util.ap_geq?("3.2.3")

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/lib/haml/helpers/rails_323_textarea_fix.rb

@@ -1,41 +0,0 @@
-require "abstract_controller/rendering"
-
-# Rails 3.2.3's form helpers add a newline after opening textareas, which can
-# cause problems with newlines being considered content rather than markup.
-# These changes fix the issue by making the helpers emit "<haml:newline/>"
-# rather than the leading newline. The tag is then replaced by a newline after
-# rendering.
-#
-# This should be considered nothing more than an emergency hotfix to ensure
-# compatibility with the latest version of Rails, made at a moment when the Haml
-# project is transitioning to a new maintainer.
-
-# module AbstractController
-#   module Rendering
-#     def render_to_body_with_haml(options = {})
-#       if rendered = render_to_body_without_haml(options)
-#         rendered.gsub('<haml:newline/>', "\n").html_safe
-#       end
-#     end
-#     alias_method_chain :render_to_body, :haml
-#   end
-# end
-
-module ActionView
-  module Helpers
-
-    module FormTagHelper
-      def text_area_tag_with_haml(*args)
-        text_area_tag_without_haml(*args).sub('>&#x000A;', ">\n").html_safe
-      end
-      alias_method_chain :text_area_tag, :haml
-    end
-
-    module FormHelper
-      def text_area_with_haml(*args)
-        text_area_without_haml(*args).sub('>&#x000A;', ">\n").html_safe
-      end
-      alias_method_chain :text_area, :haml
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/lib/haml/helpers/xss_mods.rb

@@ -1,165 +0,0 @@
-module Haml
-  module Helpers
-    # This module overrides Haml helpers to work properly
-    # in the context of ActionView.
-    # Currently it's only used for modifying the helpers
-    # to work with Rails' XSS protection methods.
-    module XssMods
-      def self.included(base)
-        %w[html_escape find_and_preserve preserve list_of surround
-           precede succeed capture_haml haml_concat haml_indent
-           haml_tag escape_once].each do |name|
-          base.send(:alias_method, "#{name}_without_haml_xss", name)
-          base.send(:alias_method, name, "#{name}_with_haml_xss")
-        end
-      end
-
-      # Don't escape text that's already safe,
-      # output is always HTML safe
-      def html_escape_with_haml_xss(text)
-        str = text.to_s
-        return text if str.html_safe?
-        Haml::Util.html_safe(html_escape_without_haml_xss(str))
-      end
-
-      # Output is always HTML safe
-      def find_and_preserve_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(find_and_preserve_without_haml_xss(*args, &block))
-      end
-
-      # Output is always HTML safe
-      def preserve_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(preserve_without_haml_xss(*args, &block))
-      end
-
-      # Output is always HTML safe
-      def list_of_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(list_of_without_haml_xss(*args, &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def surround_with_haml_xss(front, back = front, &block)
-        Haml::Util.html_safe(
-          surround_without_haml_xss(
-            haml_xss_html_escape(front),
-            haml_xss_html_escape(back),
-            &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def precede_with_haml_xss(str, &block)
-        Haml::Util.html_safe(precede_without_haml_xss(haml_xss_html_escape(str), &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def succeed_with_haml_xss(str, &block)
-        Haml::Util.html_safe(succeed_without_haml_xss(haml_xss_html_escape(str), &block))
-      end
-
-      # Output is always HTML safe
-      def capture_haml_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(capture_haml_without_haml_xss(*args, &block))
-      end
-
-      # Input is escaped
-      def haml_concat_with_haml_xss(text = "")
-        haml_concat_without_haml_xss(@_haml_concat_raw ? text : haml_xss_html_escape(text))
-      end
-
-      # Output is always HTML safe
-      def haml_indent_with_haml_xss
-        Haml::Util.html_safe(haml_indent_without_haml_xss)
-      end
-
-      # Input is escaped, haml_concat'ed output is always HTML safe
-      def haml_tag_with_haml_xss(name, *rest, &block)
-        name = haml_xss_html_escape(name.to_s)
-        rest.unshift(haml_xss_html_escape(rest.shift.to_s)) unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
-        with_raw_haml_concat {haml_tag_without_haml_xss(name, *rest, &block)}
-      end
-
-      # Output is always HTML safe
-      def escape_once_with_haml_xss(*args)
-        Haml::Util.html_safe(escape_once_without_haml_xss(*args))
-      end
-
-      private
-
-      # Escapes the HTML in the text if and only if
-      # Rails XSS protection is enabled *and* the `:escape_html` option is set.
-      def haml_xss_html_escape(text)
-        return text unless Haml::Util.rails_xss_safe? && haml_buffer.options[:escape_html]
-        html_escape(text)
-      end
-    end
-
-    class ErrorReturn
-      # Any attempt to treat ErrorReturn as a string should cause it to blow up.
-      alias_method :html_safe, :to_s
-      alias_method :html_safe?, :to_s
-      alias_method :html_safe!, :to_s
-    end
-  end
-end
-
-module ActionView
-  module Helpers
-    module CaptureHelper
-      def with_output_buffer_with_haml_xss(*args, &block)
-        res = with_output_buffer_without_haml_xss(*args, &block)
-        case res
-        when Array; res.map {|s| Haml::Util.html_safe(s)}
-        when String; Haml::Util.html_safe(res)
-        else; res
-        end
-      end
-      alias_method :with_output_buffer_without_haml_xss, :with_output_buffer
-      alias_method :with_output_buffer, :with_output_buffer_with_haml_xss
-    end
-
-    module FormTagHelper
-      def form_tag_with_haml_xss(*args, &block)
-        res = form_tag_without_haml_xss(*args, &block)
-        res = Haml::Util.html_safe(res) unless block_given?
-        res
-      end
-      alias_method :form_tag_without_haml_xss, :form_tag
-      alias_method :form_tag, :form_tag_with_haml_xss
-    end
-
-    module FormHelper
-      def form_for_with_haml_xss(*args, &block)
-        res = form_for_without_haml_xss(*args, &block)
-        return Haml::Util.html_safe(res) if res.is_a?(String)
-        return res
-      end
-      alias_method :form_for_without_haml_xss, :form_for
-      alias_method :form_for, :form_for_with_haml_xss
-    end
-
-    module TextHelper
-      def concat_with_haml_xss(string)
-        if is_haml?
-          haml_buffer.buffer.concat(haml_xss_html_escape(string))
-        else
-          concat_without_haml_xss(string)
-        end
-      end
-      alias_method :concat_without_haml_xss, :concat
-      alias_method :concat, :concat_with_haml_xss
-
-      # safe_concat was introduced in Rails 3.0
-      if Haml::Util.has?(:instance_method, self, :safe_concat)
-        def safe_concat_with_haml_xss(string)
-          if is_haml?
-            haml_buffer.buffer.concat(string)
-          else
-            safe_concat_without_haml_xss(string)
-          end
-        end
-        alias_method :safe_concat_without_haml_xss, :safe_concat
-        alias_method :safe_concat, :safe_concat_with_haml_xss
-      end
-    end
-  end
-end