padrino-helpers-cj 0.12.2

data/lib/padrino-helpers/output_helpers/abstract_handler.rb

@@ -0,0 +1,61 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      class AbstractHandler
+        attr_reader :template, :output_buffer
+
+        def initialize(template)
+          @template = template
+          @output_buffer = template.instance_variable_get(:@_out_buf)
+        end
+
+        ##
+        # Returns true if the block given is of the handler's template type; false otherwise.
+        #
+        # @example
+        #   @handler.engine_matches?(block) => true
+        #
+        def engine_matches?(block)
+        end
+
+        ##
+        # Captures the html from a block of template code for this handler.
+        #
+        # This method is called to capture content of a block-loving helpers in templates.
+        # Haml has a special method to do this, for Erb and Slim we save original buffer,
+        # call the block and then restore the buffer.
+        #
+        # @example
+        #   @handler.capture_from_template(&block) => "...html..."
+        #
+        def capture_from_template(*args, &block)
+          self.output_buffer, _buf_was = ActiveSupport::SafeBuffer.new, self.output_buffer
+          raw = block.call(*args)
+          captured = template.instance_variable_get(:@_out_buf)
+          self.output_buffer = _buf_was
+          engine_matches?(block) && !captured.empty? ? captured : raw.to_s
+        end
+
+        ##
+        # Outputs the given text to the template.
+        #
+        # This method is called when template uses block-aware helpers. For Slim and Haml such
+        # helpers just return output to use with `=`. For Erb this method is implemented in
+        # ErbHandler by concatenating given text to output buffer.
+        #
+        # @example
+        #   @handler.concat_to_template("This will be output to the template buffer")
+        #
+        def concat_to_template(text="")
+          text
+        end
+
+        protected
+
+        def output_buffer=(val)
+          template.instance_variable_set(:@_out_buf, val)
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers/erb_handler.rb

@@ -0,0 +1,27 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      ##
+      # Handler for Erb template.
+      #
+      class ErbHandler < AbstractHandler
+        ##
+        # Outputs the given text to the templates buffer directly.
+        #
+        def concat_to_template(text="")
+          output_buffer << text
+          nil
+        end
+
+        ##
+        # Returns true if the block is Erb.
+        #
+        def engine_matches?(block)
+          block.binding.eval('defined? __in_erb_template')
+        end
+      end
+      OutputHelpers.register(:erb, ErbHandler)
+      OutputHelpers.register(:erubis, ErbHandler)
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers/haml_handler.rb

@@ -0,0 +1,25 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      ##
+      # Handler for Haml templates.
+      #
+      class HamlHandler < AbstractHandler
+        ##
+        # Returns true if the block is for Haml
+        #
+        def engine_matches?(block)
+          template.block_is_haml?(block)
+        end
+
+        ##
+        # Captures the html from a block of template code for this handler.
+        #
+        def capture_from_template(*args, &block)
+          engine_matches?(block) ? template.capture_haml(*args, &block) : block.call(*args)
+        end
+      end
+      OutputHelpers.register(:haml, HamlHandler)
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers/slim_handler.rb

@@ -0,0 +1,18 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      ##
+      # Handler for Slim templates.
+      #
+      class SlimHandler < AbstractHandler
+        ##
+        # Returns true if the block is for Slim.
+        #
+        def engine_matches?(block)
+          block.binding.eval('defined? __in_slim_template')
+        end
+      end
+      OutputHelpers.register(:slim, SlimHandler)
+    end
+  end
+end

data/lib/padrino-helpers/render_helpers.rb

@@ -0,0 +1,63 @@
+module Padrino
+  module Helpers
+    ##
+    # Helpers related to rendering within templates (i.e partials).
+    #
+    module RenderHelpers
+      ##
+      # Render a partials with collections support.
+      #
+      # @param [String] template
+      #   Relative path to partial template.
+      # @param [Hash] options
+      #   Options hash for rendering options.
+      # @option options [Object] :object
+      #   Object rendered in partial.
+      # @option options [Array<Object>] :collection
+      #   Partial is rendered for each object in this collection.
+      # @option options [Hash] :locals ({})
+      #   Local variables accessible in the partial.
+      # @option options [Symbol] :engine
+      #   Explicit rendering engine to use for this partial.
+      #
+      # @return [String] The html generated from this partial.
+      #
+      # @example
+      #   partial 'photo/item', :object => @photo
+      #   partial 'photo/item', :collection => @photos
+      #   partial 'photo/item', :locals => { :foo => :bar }
+      #   partial 'photo/item', :engine => :erb
+      #
+      # @note If using this from Sinatra, pass explicit +:engine+ option
+      #
+      def partial(template, options={}, &block)
+        options = { :locals => {}, :layout => false }.update(options)
+        explicit_engine = options.delete(:engine)
+
+        path,_,name = template.to_s.rpartition(File::SEPARATOR)
+        template_path = File.join(path,"_#{name}").to_sym
+        object_name = name.partition('.').first.to_sym
+
+        objects, counter = if options[:collection].respond_to?(:inject)
+          [options.delete(:collection), 0]
+        else
+          [[options.delete(:object)], nil]
+        end
+
+        locals = options[:locals]
+        objects.each_with_object(ActiveSupport::SafeBuffer.new) do |object,html|
+          locals[object_name] = object if object
+          locals["#{object_name}_counter".to_sym] = counter += 1 if counter
+          content =
+            if block_given?
+              concat_content render(explicit_engine, template_path, options){ capture_html(&block) }
+            else
+              render(explicit_engine, template_path, options)
+            end
+          html.safe_concat content if content
+        end
+      end
+      alias :render_partial :partial
+    end
+  end
+end

data/lib/padrino-helpers/tag_helpers.rb

@@ -0,0 +1,294 @@
+module Padrino
+  module Helpers
+    ##
+    # Helpers related to producing html tags within templates.
+    #
+    module TagHelpers
+      ##
+      # Tag values escaped to html entities.
+      #
+      ESCAPE_VALUES = {
+        "&" => "&",
+        "<" => "&lt;",
+        ">" => "&gt;",
+        '"' => "&quot;"
+      }.freeze
+
+      ##
+      # Cached Regexp for escaping values to avoid rebuilding one
+      # on every escape operation.
+      #
+      ESCAPE_REGEXP = Regexp.union(*ESCAPE_VALUES.keys).freeze
+
+      BOOLEAN_ATTRIBUTES = [
+        :autoplay,
+        :autofocus,
+        :formnovalidate,
+        :checked,
+        :disabled,
+        :hidden,
+        :loop,
+        :multiple,
+        :muted,
+        :readonly,
+        :required,
+        :selected,
+        :declare,
+        :defer,
+        :ismap,
+        :itemscope,
+        :noresize,
+        :novalidate
+      ].freeze
+
+      ##
+      # Custom data attributes,
+      # feel free to update with yours:
+      #
+      #   Padrino::Helpers::TagHelpers::DATA_ATTRIBUTES.push(:dialog)
+      #   text_field :foo, :dialog => true
+      #   # Generates: <input type="text" data-dialog="true" name="foo" />
+      #
+      DATA_ATTRIBUTES = [
+        :method,
+        :remote,
+        :confirm
+      ].freeze
+
+      ##
+      # A html_safe newline string to avoid allocating a new on each
+      # concatenation.
+      #
+      NEWLINE = "\n".html_safe.freeze
+
+      ##
+      # Creates an HTML tag with given name, content, and options.
+      #
+      # @overload content_tag(name, content, options = nil)
+      #   @param [Symbol] name
+      #     The name of the HTML tag to create.
+      #   @param [String] content
+      #     The content inside of the tag.
+      #   @param [Hash] options
+      #     The HTML options to include in this tag.
+      #
+      # @overload content_tag(name, options = nil, &block)
+      #   @param [Symbol] name
+      #     The name of the HTML tag to create.
+      #   @param [Hash] options
+      #     The HTML options to include in this tag.
+      #   @param [Proc] block
+      #     The block returning HTML content.
+      #
+      # @macro [new] global_html_attributes
+      #   @option options [String] :id
+      #     Specifies a unique identifier for the element.
+      #   @option options [String] :class
+      #     Specifies the stylesheet class of the element.
+      #   @option options [String] :title
+      #     Specifies the title for the element.
+      #   @option options [String] :accesskey
+      #     Specifies a shortcut key to access the element.
+      #   @option options [Symbol] :dropzone
+      #     Specifies what happens when dragged items are dropped on the element. (:copy, :link, :move)
+      #   @option options [Boolean] :hidden
+      #     Specifies whether or not the element is hidden from view.
+      #   @option options [Boolean] :draggable
+      #     Specifies whether or not the element is draggable. (true, false, :auto)
+      #   @option options [Boolean] :contenteditable
+      #     Specifies whether or not the element is editable.
+      #
+      # @return [String]
+      #   Generated HTML with specified +options+.
+      #
+      # @example
+      #   content_tag(:p, 'Hello World', :class => 'light')
+      #
+      #   # => <p class="light">
+      #   # =>   Hello World
+      #   # => </p>
+      #
+      #   content_tag(:p, :class => 'dark') do
+      #     link_to 'Padrino', 'http://www.padrinorb.com'
+      #   end
+      #
+      #   # => <p class="dark">
+      #   # =>   <a href="http://www.padrinorb.com">Padrino</a>
+      #   # => </p>
+      #
+      def content_tag(name, content = nil, options = nil, &block)
+        if block_given?
+          options = content if content.is_a?(Hash)
+          content = capture_html(&block)
+        end
+
+        options    = parse_data_options(name, options)
+        attributes = tag_attributes(options)
+        output = ActiveSupport::SafeBuffer.new
+        output.safe_concat "<#{name}#{attributes}>"
+        if content.respond_to?(:each) && !content.is_a?(String)
+          content.each{ |item| output.concat item; output.safe_concat NEWLINE }
+        else
+          output.concat content.to_s
+        end
+        output.safe_concat "</#{name}>"
+
+        block_is_template?(block) ? concat_content(output) : output
+      end
+
+      ##
+      # Like #content_tag, but assumes its input to be safe and doesn't
+      # escape. It also returns safe HTML.
+      #
+      # @see #content_tag
+      #
+      def safe_content_tag(name, content = nil, options = nil, &block)
+        mark_safe(content_tag(name, mark_safe(content), options, &block))
+      end
+
+      ##
+      # Creates an HTML input field with the given type and options.
+      #
+      # @param [Symbol] type
+      #   The type of input to create.
+      # @param [Hash] options
+      #   The HTML options to include in this input.
+      #
+      # @option options [String] :id
+      #   Specifies a unique identifier for the input.
+      # @option options [String] :class
+      #   Specifies the stylesheet class of the input.
+      # @option options [String] :name
+      #   Specifies the name of the input.
+      # @option options [String] :accesskey
+      #   Specifies a shortcut key to access the input.
+      # @option options [Integer] :tabindex
+      #   Specifies the tab order of the input.
+      # @option options [Boolean] :hidden
+      #   Specifies whether or not the input is hidden from view.
+      # @option options [Boolean] :spellcheck
+      #   Specifies whether or not the input should have it's spelling and grammar checked for errors.
+      # @option options [Boolean] :draggable
+      #   Specifies whether or not the input is draggable. (true, false, :auto)
+      # @option options [String] :pattern
+      #   Specifies the regular expression pattern that the input's value is checked against.
+      # @option options [Symbol] :autocomplete
+      #   Specifies whether or not the input should have autocomplete enabled. (:on, :off)
+      # @option options [Boolean] :autofocus
+      #   Specifies whether or not the input should automatically get focus when the page loads.
+      # @option options [Boolean] :required
+      #   Specifies whether or not the input is required to be completed before the form is submitted.
+      # @option options [Boolean] :readonly
+      #   Specifies whether or not the input is read only.
+      # @option options [Boolean] :disabled
+      #   Specifies whether or not the input is disabled.
+      #
+      # @return [String]
+      #   Generated HTML with specified +options+.
+      #
+      # @example
+      #   input_tag :text, :name => 'handle'
+      #   # => <input type="test" name="handle" />
+      #
+      #   input_tag :password, :name => 'password', :size => 20
+      #   # => <input type="password" name="password" size="20" />
+      #
+      #   input_tag :text, :name => 'username', :required => true, :autofocus => true
+      #   # => <input type="text" name="username" required autofocus />
+      #
+      #   input_tag :number, :name => 'credit_card', :autocomplete => :off
+      #   # => <input type="number" autocomplete="off" />
+      #
+      def input_tag(type, options = {})
+        tag(:input, { :type => type }.update(options))
+      end
+
+      ##
+      # Creates an HTML tag with the given name and options.
+      #
+      # @param [Symbol] name
+      #  The name of the HTML tag to create.
+      # @param [Hash] options
+      #  The HTML options to include in this tag.
+      #
+      # @macro global_html_attributes
+      #
+      # @return [String]
+      #   Generated HTML with specified +options+.
+      #
+      # @example
+      #   tag :hr, :class => 'dotted'
+      #   # => <hr class="dotted" />
+      #
+      #   tag :input, :name => 'username', :type => :text
+      #   # => <input name="username" type="text" />
+      #
+      #   tag :img, :src => 'images/pony.jpg', :alt => 'My Little Pony'
+      #   # => <img src="images/pony.jpg" alt="My Little Pony" />
+      #
+      #   tag :img, :src => 'sinatra.jpg, :data => { :nsfw => false, :geo => [34.087, -118.407] }
+      #   # => <img src="sinatra.jpg" data-nsfw="false" data-geo="34.087 -118.407" />
+      #
+      def tag(name, options = nil, open = false)
+        options = parse_data_options(name, options)
+        attributes = tag_attributes(options)
+        "<#{name}#{attributes}#{open ? '>' : ' />'}".html_safe
+      end
+
+      private
+
+      ##
+      # Returns a compiled list of HTML attributes.
+      #
+      def tag_attributes(options)
+        return '' unless options
+        options.inject('') do |all,(key,value)|
+          next all unless value
+          all << ' ' if all.empty?
+          all << if value.is_a?(Hash)
+            nested_values(key, value)
+          elsif BOOLEAN_ATTRIBUTES.include?(key)
+            %(#{key}="#{key}" )
+          else
+            %(#{key}="#{escape_value(value)}" )
+          end
+        end.chomp!(' ')
+      end
+
+      ##
+      # Escape tag values to their HTML/XML entities.
+      #
+      def escape_value(string)
+        string.to_s.gsub(ESCAPE_REGEXP) { |char| ESCAPE_VALUES[char] }
+      end
+
+      ##
+      # Iterate through nested values.
+      #
+      def nested_values(attribute, hash)
+        hash.inject('') do |all,(key,value)|
+          attribute_with_name = "#{attribute}-#{key.to_s.dasherize}"
+          all << if value.is_a?(Hash)
+            nested_values(attribute_with_name, value)
+          else
+            %(#{attribute_with_name}="#{escape_value(value)}" )
+          end
+        end
+      end
+
+      ##
+      # Parses custom data attributes.
+      #
+      def parse_data_options(tag, options)
+        return unless options
+        parsed_options = options.dup
+        options.each do |key, value|
+          next if !DATA_ATTRIBUTES.include?(key) || (tag.to_s == 'form' && key == :method)
+          parsed_options["data-#{key}"] = parsed_options.delete(key)
+          parsed_options[:rel] = 'nofollow' if key == :method
+        end
+        parsed_options
+      end
+    end
+  end
+end