padrino-helpers 0.1.0

data/lib/padrino-helpers/format_helpers.rb

@@ -0,0 +1,74 @@
+module Padrino
+  module Helpers
+    module FormatHelpers
+
+      # Returns escaped text to protect against malicious content
+      def escape_html(text)
+        Rack::Utils.escape_html(text)
+      end
+      alias h escape_html
+      alias sanitize_html escape_html
+
+      # Returns escaped text to protect against malicious content
+      # Returns blank if the text is empty
+      def h!(text, blank_text = ' ')
+        return blank_text if text.nil? || text.empty?
+        h text
+      end
+
+
+      # Smart time helper which returns relative text representing times for recent dates
+      # and absolutes for dates that are far removed from the current date
+      # time_in_words(10.days.ago) => '10 days ago'
+      def time_in_words(date)
+        date = date.to_date
+        date = Date.parse(date, true) unless /Date.*/ =~ date.class.to_s
+        days = (date - Date.today).to_i
+
+        return 'today'     if days >= 0 and days < 1
+        return 'tomorrow'  if days >= 1 and days < 2
+        return 'yesterday' if days >= -1 and days < 0
+
+        return "in #{days} days"      if days.abs < 60 and days > 0
+        return "#{days.abs} days ago" if days.abs < 60 and days < 0
+
+        return date.strftime('%A, %B %e') if days.abs < 182
+        return date.strftime('%A, %B %e, %Y')
+      end
+      alias time_ago time_in_words
+
+      # Returns relative time in words referencing the given date
+      # relative_time_ago(Time.now) => 'about a minute ago'
+      def relative_time_ago(from_time)
+        distance_in_minutes = (((Time.now - from_time.to_time).abs)/60).round
+        case distance_in_minutes
+          when 0..1 then 'about a minute'
+          when 2..44 then "#{distance_in_minutes} minutes"
+          when 45..89 then 'about 1 hour'
+          when 90..1439 then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+          when 1440..2879 then '1 day'
+          when 2880..43199 then "#{(distance_in_minutes / 1440).round} days"
+          when 43200..86399 then 'about 1 month'
+          when 86400..525599 then "#{(distance_in_minutes / 43200).round} months"
+          when 525600..1051199 then 'about 1 year'
+          else "over #{(distance_in_minutes / 525600).round} years"
+        end
+      end
+
+      # Used in xxxx.js.erb files to escape html so that it can be passed to javascript from sinatra
+      # escape_javascript("<h1>Hey</h1>")
+      def escape_javascript(html_content)
+        return '' unless html_content
+        javascript_mapping = { '\\' => '\\\\', '</' => '<\/', "\r\n" => '\n', "\n" => '\n' }
+        javascript_mapping.merge("\r" => '\n', '"' => '\\"', "'" => "\\'")
+        escaped_string = html_content.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { javascript_mapping[$1] }
+        "\"#{escaped_string}\""
+      end
+
+      alias js_escape escape_javascript
+      alias js_escape_html escape_javascript
+      alias escape_for_javascript escape_javascript
+
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers.rb

@@ -0,0 +1,98 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      # Captures the html from a block of template code for erb or haml
+      # capture_html(&block) => "...html..."
+      def capture_html(*args, &block)
+        if self.respond_to?(:is_haml?) && is_haml?
+          block_is_haml?(block) ? capture_haml(*args, &block) : block.call
+        elsif has_erb_buffer?
+          result_text = capture_erb(*args, &block)
+          result_text.present? ? result_text : (block_given? && block.call(*args))
+        else # theres no template to capture, invoke the block directly
+          block.call(*args)
+        end
+      end
+
+      # Outputs the given text to the templates buffer directly
+      # concat_content("This will be output to the template buffer in erb or haml")
+      def concat_content(text="")
+        if self.respond_to?(:is_haml?) && is_haml?
+          haml_concat(text)
+        elsif has_erb_buffer?
+          erb_concat(text)
+        else # theres no template to concat, return the text directly
+          text
+        end
+      end
+
+      # Returns true if the block is from an ERB or HAML template; false otherwise.
+      # Used to determine if html should be returned or concatted to view
+      # block_is_template?(block)
+      def block_is_template?(block)
+        block && (block_is_erb?(block) || (self.respond_to?(:block_is_haml?) && block_is_haml?(block)))
+      end
+
+      # Capture a block of content to be rendered at a later time.
+      # Your blocks can also receive values, which are passed to them by <tt>yield_content</tt>
+      # content_for(:name) { ...content... }
+      # content_for(:name) { |name| ...content... }
+      def content_for(key, &block)
+        content_blocks[key.to_sym] << block
+      end
+
+      # Render the captured content blocks for a given key.
+      # You can also pass values to the content blocks by passing them
+      # as arguments after the key.
+      # yield_content :include
+      # yield_content :head, "param1", "param2"
+      def yield_content(key, *args)
+        content_blocks[key.to_sym].map { |content|
+          capture_html(*args, &content)
+        }.join
+      end
+
+      protected
+
+      # Retrieves content_blocks stored by content_for or within yield_content
+      # content_blocks[:name] => ['...', '...']
+      def content_blocks
+        @content_blocks ||= Hash.new {|h,k| h[k] = [] }
+      end
+
+      # Used to capture the html from a block of erb code
+      # capture_erb(&block) => '...html...'
+      def capture_erb(*args, &block)
+        erb_with_output_buffer { block_given? && block.call(*args) }
+      end
+
+      # Concats directly to an erb template
+      # erb_concat("Direct to buffer")
+      def erb_concat(text)
+        @_out_buf << text if has_erb_buffer?
+      end
+
+      # Returns true if an erb buffer is detected
+      # has_erb_buffer? => true
+      def has_erb_buffer?
+        !@_out_buf.nil?
+      end
+
+      # Used to determine if a block is called from ERB.
+      # NOTE: This doesn't actually work yet because the variable __in_erb_template
+      # hasn't been defined in ERB. We need to find a way to fix this.
+      def block_is_erb?(block)
+        has_erb_buffer? || block && eval('defined? __in_erb_template', block)
+      end
+
+      # Used to direct the buffer for the erb capture
+      def erb_with_output_buffer(buf = '') #:nodoc:
+        @_out_buf, old_buffer = buf, @_out_buf
+        yield
+        @_out_buf
+      ensure
+        @_out_buf = old_buffer
+      end
+    end
+  end
+end

data/lib/padrino-helpers/render_helpers.rb

@@ -0,0 +1,63 @@
+module Padrino
+  module Helpers
+    module RenderHelpers
+      # Renders a erb template based on the relative path
+      # erb_template 'users/new'
+      def erb_template(template_path, options={})
+        render_template template_path, options.merge(:template_engine => :erb)
+      end
+
+      # Renders a haml template based on the relative path
+      # haml_template 'users/new'
+      def haml_template(template_path, options={})
+        render_template template_path, options.merge(:template_engine => :haml)
+      end
+
+      # Renders a template from a file path automatically determining rendering engine
+      # render_template 'users/new'
+      # options = { :template_engine => 'haml' }
+      def render_template(template_path, options={})
+        template_engine = options.delete(:template_engine) || resolve_template_engine(template_path)
+        render template_engine.to_sym, template_path.to_sym, options
+      end
+
+      # Partials implementation which includes collections support
+      # partial 'photo/_item', :object => @photo
+      # partial 'photo/_item', :collection => @photos
+      def partial(template, options={})
+        options.reverse_merge!(:locals => {}, :layout => false)
+        path = template.to_s.split(File::SEPARATOR)
+        object_name = path[-1].to_sym
+        path[-1] = "_#{path[-1]}"
+        template_path = File.join(path)
+        raise 'Partial collection specified but is nil' if options.has_key?(:collection) && options[:collection].nil?
+        if collection = options.delete(:collection)
+          options.delete(:object)
+          counter = 0
+          collection.collect do |member|
+            counter += 1
+            options[:locals].merge!(object_name => member, "#{object_name}_counter".to_sym => counter)
+            render_template(template_path, options.merge(:layout => false))
+          end.join("\n")
+        else
+          if member = options.delete(:object)
+            options[:locals].merge!(object_name => member)
+          end
+          render_template(template_path, options.merge(:layout => false))
+        end
+      end
+      alias render_partial partial
+
+      private
+
+        # Returns the template engine (i.e haml) to use for a given template_path
+        # resolve_template_engine('users/new') => :haml
+        def resolve_template_engine(template_path)
+          resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
+          template_file = Dir[resolved_template_path].first
+          raise "Template path '#{template_path}' could not be located in views!" unless template_file
+          template_engine = File.extname(template_file)[1..-1].to_sym
+        end
+    end
+  end
+end

data/lib/padrino-helpers/tag_helpers.rb

@@ -0,0 +1,42 @@
+module Padrino
+  module Helpers
+    module TagHelpers
+      # Creates an html input field with given type and options
+      # input_tag :text, :class => "test"
+      def input_tag(type, options = {})
+        options.reverse_merge!(:type => type)
+        tag(:input, options)
+      end
+
+      # Creates an html tag with given name, content and options
+      # content_tag(:p, "hello", :class => 'light')
+      # content_tag(:p, :class => 'dark') do ... end
+      # parameters: content_tag(name, content=nil, options={}, &block)
+      def content_tag(*args, &block)
+        name = args.first
+        options = args.extract_options!
+        tag_html = block_given? ? capture_html(&block) : args[1]
+        tag_result = tag(name, options.merge(:content => tag_html))
+        block_is_template?(block) ? concat_content(tag_result) : tag_result
+      end
+
+      # Creates an html tag with the given name and options
+      # tag(:br, :style => 'clear:both')
+      # tag(:p, :content => "hello", :class => 'large')
+      def tag(name, options={})
+        content = options.delete(:content)
+        identity_tag_attributes.each { |attr| options[attr] = attr.to_s if options[attr]  }
+        html_attrs = options.collect { |a, v| v.blank? ? nil : "#{a}=\"#{v}\"" }.compact.join(" ")
+        base_tag = (html_attrs.present? ? "<#{name} #{html_attrs}" : "<#{name}")
+        base_tag << (content ? ">#{content}</#{name}>" : " />")
+      end
+
+      protected
+
+      # Returns a list of attributes which can only contain an identity value (i.e selected)
+      def identity_tag_attributes
+        [:checked, :disabled, :selected, :multiple]
+      end
+    end
+  end
+end

data/test/active_support_helpers.rb

@@ -0,0 +1,7 @@
+unless Fixnum.method_defined?(:days)
+  require 'active_support/core_ext/object/misc'
+  require 'active_support/core_ext/date'
+  require 'active_support/core_ext/time'
+  require 'active_support/core_ext/numeric'
+  require 'active_support/duration'
+end

data/test/fixtures/markup_app/app.rb

@@ -0,0 +1,61 @@
+require 'sinatra/base'
+require 'haml'
+
+class MarkupDemo < Sinatra::Base
+  register Padrino::Helpers
+
+  configure do
+    set :root, File.dirname(__FILE__)
+  end
+
+  get '/:engine/:file' do
+    show(params[:engine], params[:file].to_sym)
+  end
+
+  helpers do
+    # show :erb, :index
+    # show :haml, :index
+    def show(kind, template)
+      eval("#{kind.to_s} #{template.to_sym.inspect}")
+    end
+
+    def captured_content(&block)
+      content_html = capture_html(&block)
+      "<p>#{content_html}</p>"
+    end
+
+    def concat_in_p(content_html)
+      concat_content "<p>#{content_html}</p>"
+    end
+
+    def ruby_not_template_block
+      determine_block_is_template('ruby') do
+        content_tag(:span, "This not a template block")
+      end
+    end
+
+    def determine_block_is_template(name, &block)
+      concat_content "<p class='is_template'>The #{name} block passed in is a template</p>" if block_is_template?(block)
+    end
+  end
+end
+
+class MarkupUser
+  def errors; Errors.new; end
+  def session_id; 45; end
+  def gender; 'male'; end
+  def remember_me; '1'; end
+  def permission; Permission.new; end
+end
+
+class Permission
+  def can_edit; true; end
+  def can_delete; false; end
+end
+
+class Errors < Array
+  def initialize; self << [:fake, :second, :third]; end
+  def full_messages
+    ["This is a fake error", "This is a second fake error", "This is a third fake error"]
+  end
+end

data/test/fixtures/markup_app/views/capture_concat.erb

@@ -0,0 +1,14 @@
+<% @content = captured_content do %>
+  <span>Captured Line 1</span>
+  <span>Captured Line 2</span>
+<% end %>
+<%= @content %>
+
+<% concat_in_p('Concat Line 3') %>
+
+<% determine_block_is_template('erb') do %>
+  <span>This is erb</span>
+  <span>This is erb</span>
+<% end %>
+  
+<% ruby_not_template_block %>

data/test/fixtures/markup_app/views/capture_concat.haml

@@ -0,0 +1,13 @@
+- @content = captured_content do
+  %span Captured Line 1
+  %span Captured Line 2
+= @content
+
+- concat_in_p('Concat Line 3')
+
+- determine_block_is_template('haml') do
+  %span This is haml
+  %span This is haml
+  
+- ruby_not_template_block
+  

data/test/fixtures/markup_app/views/content_for.erb

@@ -0,0 +1,11 @@
+<% content_for :demo do %>
+  <h1>This is content yielded from a content_for</h1>
+<% end %>
+  
+<div class='demo'><%= yield_content :demo %></p>
+  
+<% content_for :demo2 do |fname, lname| %>
+  <h1>This is content yielded with name <%= fname + " " + lname %></h1>
+<% end %>
+  
+<div class='demo2'><%= yield_content :demo2, "Johnny", "Smith" %></div>

data/test/fixtures/markup_app/views/content_for.haml

@@ -0,0 +1,9 @@
+- content_for :demo do
+  %h1 This is content yielded from a content_for
+  
+.demo= yield_content :demo
+
+- content_for :demo2 do |fname, lname|
+  %h1 This is content yielded with name #{fname + " " + lname}
+  
+.demo2= yield_content :demo2, "Johnny", "Smith"

data/test/fixtures/markup_app/views/content_tag.erb

@@ -0,0 +1,11 @@
+<%= content_tag :p, "Test 1", :class => 'test', :id => "test1" %>
+
+<%= content_tag :p, "Test 2" %>
+
+<% content_tag(:p, :class => 'test', :id => 'test3') do %>
+  <span>Test 3</span>
+<% end %>
+  
+<% content_tag(:p) do %>
+  <span>Test 4</span>
+<% end %>

data/test/fixtures/markup_app/views/content_tag.haml

@@ -0,0 +1,9 @@
+= content_tag :p, "Test 1", :class => 'test', :id => "test1"
+
+= content_tag :p, "Test 2"
+
+- content_tag(:p, :class => 'test', :id => 'test3') do
+  %span Test 3
+  
+- content_tag(:p) do
+  %span Test 4

data/test/fixtures/markup_app/views/fields_for.erb

@@ -0,0 +1,8 @@
+<% @user = MarkupUser.new %>
+<% form_for @user , '/demo1', :id => 'demo-fields-for' do |f| %>
+  <%= f.text_field :gender %>
+  <% fields_for @user.permission do |permission| %>
+    <%= permission.check_box :can_edit %>
+    <%= permission.check_box :can_delete %>
+  <% end %>
+<% end %>

data/test/fixtures/markup_app/views/fields_for.haml

@@ -0,0 +1,6 @@
+- @user = MarkupUser.new
+- form_for @user , '/demo1', :id => 'demo-fields-for' do |f|
+  = f.text_field :gender
+  - fields_for @user.permission do |permission|
+    = permission.check_box :can_edit
+    = permission.check_box :can_delete