ptomato-ramaze 2009.02

data/lib/ramaze/helper/cgi.rb

@@ -0,0 +1,39 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Shortcuts to some CGI methods
+
+  module Helper::CGI
+
+    # shortcut for Rack::Utils.escape
+    def url_encode(*args)
+      Rack::Utils.escape(*args.map{|a| a.to_s })
+    end
+
+    # shortcut for Rack::Utils.unescape
+    def url_decode(*args)
+      Rack::Utils.unescape(*args.map{|a| a.to_s })
+    end
+
+    # shortcut for Rack::Utils.escape_html
+    def html_escape(string)
+      Rack::Utils.escape_html(string)
+    end
+
+    # shortcut for CGI.unescapeHTML
+    def html_unescape(string)
+      ::CGI.unescapeHTML(string.to_s)
+    end
+
+    # safely escape all HTML and code
+    def h(string)
+      Rack::Utils.escape_html(string).gsub(/#([{@$]@?)/, '#\1')
+    end
+
+    # one-letter versions help in case like #{h foo.inspect}
+    # ERb/ERuby/Rails compatible
+    alias u url_encode
+  end
+end

data/lib/ramaze/helper/flash.rb

@@ -0,0 +1,74 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # The purpose of this class is to provide an easy way of setting/retrieving
+  # from the current flash.
+  #
+  # Flash is a way to keep a temporary pairs of keys and values for the duration
+  # of two requests, the current and following.
+  #
+  # Very vague Example:
+  #
+  # On the first request, for example on registering:
+  #
+  #   flash[:error] = "You should reconsider your username, it's taken already"
+  #   redirect R(self, :register)
+  #
+  # This is the request from the redirect:
+  #
+  #   do_stuff if flash[:error]
+  #
+  # On the request after this, flash[:error] is gone.
+
+  module Helper::Flash
+    trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
+    # answers with Session.current.flash
+
+    def flash
+      Session.current.flash
+    end
+
+    # Use in your template to display all flash messages that may be stored.
+    # For example, given you stored:
+    #
+    #   flash # => { :error => 'Pleae enter your name'
+    #                :info => 'Do you see the fnords?' }
+    #
+    # Then a flashbox would display:
+    #
+    #   <div class='flash' id='flash_error'>Please enter your name</div>
+    #   <div class='flash' id='flash_info'>Do you see the fnords?</div>
+    #
+    #
+    # This can be customized permanently in your controller:
+    #
+    #   class MainController < Ramaze::Controller
+    #     trait :flashbox => "<div class='flash_%key'>%value</div>"
+    #
+    #     def show_flashbox
+    #       flashbox
+    #     end
+    #   end
+    #
+    # or on a per-usage basis in your action:
+    #
+    #   class MainController < Ramaze::Controller
+    #     def show_flashbox
+    #       flashbox("<div class='flash_%key'>%value</div>")
+    #     end
+    #   end
+    #
+    # Where any occurrence of %key and %value will be replaced by the actual
+    # contents of each element of flash
+
+    def flashbox(tag = ancestral_trait[:flashbox])
+      flash.map{|key, *values|
+        values.flatten.map do |value|
+          tag.gsub(/%key/, key.to_s).gsub(/%value/, value.to_s)
+        end
+      }.flatten.join("\n")
+    end
+  end
+end

data/lib/ramaze/helper/form.rb

@@ -0,0 +1,284 @@
+module Ramaze
+  module Helper
+    module Form
+      # Pass it an object for your ORM and options for the <form> tag
+      # Usage:
+      #   form_for(User, :action => '/create')
+      #   form_for(Tag, :action => '/find', :method => 'GET')
+      def form_for(object, options = {})
+        Ramaze::Form.pick(object, options)
+      end
+    end
+  end
+
+  class Form
+    attr_accessor :object, :options
+
+    YEARS, MONTHS, DAYS, HOURS, MINUTES, SECONDS =
+      (1900..2100), (1..12), (1..31), (0..23), (0..59), (0..59)
+
+    DATE_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ] ]
+
+    TIME_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ],
+      [ :hour,  HOURS ],
+      [ :min,   MINUTES ],
+      [ :sec,   SECONDS ] ]
+
+    # TODO:
+    #   How _elegant_ ...
+    #   Tries to find the right module for extending the Form instance.
+    #   It's problematic since the boundaries of what an model instance or model
+    #   class looks like is very fuzzy, also a problem is that the ORM may not be
+    #   available/required.
+    #
+    #   Maybe we can abstract that a bit by going through an array of procs for
+    #   testing?
+    def self.pick(object, options = {})
+      if defined?(Sequel::Model)
+        if object.is_a?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          InstanceForm.new(object, options)
+        elsif object.ancestors.include?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          ClassForm.new(object, options)
+        end
+      else
+        raise "Unknown ORM for: %p" % object
+      end
+    end
+
+    # Create new instance of Form plus the layer for the ORM
+    def initialize(object, options = {})
+      @object, @options = object, options
+      if layer = options.delete(:layer)
+        extend layer
+      end
+    end
+
+    # Generate and return the final form
+    def to_s
+      out = "<form #{form_attributes}>"
+      out << "<fieldset>"
+      out << generate
+      out << "</fieldset>"
+      out << '<input type="submit" />'
+      out << '<input type="reset" />'
+      out << "</form>"
+    end
+
+    # Decide on the strucuture of the tag based on the hash
+    def field_for(hash)
+      return if hash[:primary_key]
+      args = args_for(hash)
+
+      inner =
+        case type = hash[:type]
+        when :integer
+          field_integer(*args)
+        when :boolean
+          field_boolean(*args)
+        when :text
+          field_textarea(*args)
+        when :varchar
+          field_input(*args)
+        when :date
+          field_date(*args)
+        when :time
+          field_time(*args)
+        else
+          Log.warn "Unknown field: %p" % hash
+          field_input(*args)
+        end
+
+      "<label>#{args.first}: </label>\n#{inner}"
+    end
+
+    private
+
+    # inject to attributes for the <form>
+    def form_attributes
+      options.inject([]){|s,(k,v)| s << "#{k}='#{v}'" }.join(' ')
+    end
+
+    # Start tag with name and attributes
+    def start_tag(name, hash)
+      hash.inject("<#{name}"){|s,(k,v)| s << " #{k}='#{v}'" }
+    end
+
+    # Make a closed tag with name and attributes
+    def closed_tag(name, hash)
+      start_tag(name, hash) << ' />'
+    end
+
+    # Textarea with attributes from hash and the value from @object
+    def textarea(value, hash = {})
+      start_tag(:textarea, hash) << ">#{value}</textarea>"
+    end
+
+    # <input> with optional attributes from hash
+    def input(hash = {})
+      closed_tag(:input, hash)
+    end
+
+    # <input type="checkbox" with optional attributes from hash.
+    def checkbox(hash = {})
+      hash[:type] = :checkbox
+      input(hash)
+    end
+
+    # <option value="value"> with optional attributes from hash
+    def option(value, hash = {})
+      start_tag(:option, hash) << ">#{value}</option>"
+    end
+
+    # Yield method names and values for the Date instance
+    def field_date_generic
+      DATE_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Yield method names and values for the Time/DateTime instance
+    def field_time_generic
+      TIME_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Here go all the layers that are extended for specific ORMs
+    module Layer
+      # Layer for Sequel, only generate needs to be implemented, may change in
+      # future if we abstract more for different ORMs
+      module Sequel
+        # A bit nasty, get the @columns of the object and generate its
+        # field_for
+        def generate
+          columns = object_class.schema.instance_variable_get('@columns')
+          columns.map{|hash| field_for(hash) }.flatten.join("<br />\n")
+        end
+      end
+    end
+  end
+
+  # Form for the model class itself, very similar to an empty instance.
+  class ClassForm < Form
+    # <input name="name" />
+    def field_input(name)
+      input :name => name
+    end
+
+    # <textarea name="name"></textarea>
+    def field_textarea(name)
+      textarea '', :name => name
+    end
+
+    # <input name="name" />
+    def field_integer(name)
+      input :name => name
+    end
+
+    # <input type="checkbox" name="name" />
+    def field_boolean(name)
+      checkbox :name => name
+    end
+
+    # <select> with lots of <option>s
+    def field_date(name)
+      field_date_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # <select> with lots of <option>s
+    def field_time(name)
+      field_time_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # picks the :name
+    def args_for(hash)
+      [ hash[:name] ]
+    end
+
+    # Should be that way, at least for Sequel
+    def object_class
+      @object
+    end
+  end
+
+  # Form for instances of the model class
+  class InstanceForm < Form
+    # returns <input type='text' name='name' value='value' />
+    def field_input(name, value)
+      "<input type='text' name='#{name}' value='#{value}'/>"
+    end
+
+    # returns <textarea name='name'>#{value}</textarea>
+
+    def field_textarea(name, value)
+      "<textarea name='#{name}'>#{value}</textarea>"
+    end
+
+    # returns <input type="text" name="name" value="value" />
+
+    def field_integer(name, value)
+      field_input(name, value)
+    end
+
+    # <input type="checkbox" ...
+    def field_boolean(name, value)
+      if value
+        checkbox :name => name, :value => value, :checked => :checked
+      else
+        checkbox :name => name, :value => value
+      end
+    end
+
+    def field_date(name, value)
+      field_date_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def field_time(name, value)
+      field_time_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def option_range_selected(range, value)
+      range.map do |r|
+        if r == value
+          option(r, :value => r, :selected => :selected)
+        else
+          option(r, :value => r)
+        end
+      end
+    end
+
+    def args_for(hash)
+      name = hash[:name]
+      [ name, @object.send(name) ]
+    end
+
+    # Class for @object, atm Sequel specific?
+    def object_class
+      @object.class
+    end
+  end
+end

data/lib/ramaze/helper/formatting.rb

@@ -0,0 +1,162 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Helper::Formatting
+
+    # Format a floating number nicely for display.
+    #
+    # Usage:
+    #   number_format(123.123)           # => '123.123'
+    #   number_format(123456.12345)      # => '123,456.12345'
+    #   number_format(123456.12345, '.') # => '123.456,12345'
+
+    def number_format(n, delimiter = ',')
+      delim_l, delim_r = delimiter == ',' ? %w[, .] : %w[. ,]
+      h, r = n.to_s.split('.')
+      [h.reverse.scan(/\d{1,3}/).join(delim_l).reverse, r].compact.join(delim_r)
+    end
+
+    # Answer with the ordinal version of a number.
+    #
+    # Usage:
+    #   ordinal(1)   # => "1st"
+    #   ordinal(2)   # => "2nd"
+    #   ordinal(3)   # => "3rd"
+    #   ordinal(13)  # => "13th"
+    #   ordinal(33)  # => "33rd"
+    #   ordinal(100) # => "100th"
+    #   ordinal(133) # => "133rd"
+
+    def ordinal(number)
+      number = number.to_i
+
+      case number % 100
+      when 11..13; "#{number}th"
+      else
+        case number % 10
+        when 1; "#{number}st"
+        when 2; "#{number}nd"
+        when 3; "#{number}rd"
+        else    "#{number}th"
+        end
+      end
+    end
+
+    # stolen and adapted from rails
+    def time_diff from_time, to_time = Time.now, include_seconds = false
+      distance_in_minutes = (((to_time - from_time).abs)/60).round
+      distance_in_seconds = ((to_time - from_time).abs).round if include_seconds
+
+      case distance_in_minutes
+        when 0..1
+          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+          case distance_in_seconds
+            when 0..4   then 'less than 5 seconds'
+            when 5..9   then 'less than 10 seconds'
+            when 10..19 then 'less than 20 seconds'
+            when 20..39 then 'half a minute'
+            when 40..59 then 'less than a minute'
+            else             '1 minute'
+          end
+
+        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..525959   then "#{(distance_in_minutes / 43200).round} months"
+        when 525960..1051919 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525960).round} years"
+      end
+    end
+
+    # copied from actionpack
+    AUTO_LINK_RE = %r{
+                    (                          # leading text
+                      <\w+.*?>|                # leading HTML tag, or
+                      [^=!:'"/]|               # leading punctuation, or
+                      ^                        # beginning of line
+                    )
+                    (
+                      (?:https?://)|           # protocol spec, or
+                      (?:www\.)                # www.*
+                    )
+                    (
+                      [-\w]+                   # subdomain or domain
+                      (?:\.[-\w]+)*            # remaining subdomains or domain
+                      (?::\d+)?                # port
+                      (?:/(?:(?:[~\w\+@%-]|(?:[,.;:][^\s$]))+)?)* # path
+                      (?:\?[\w\+@%&=.;-]+)?     # query string
+                      (?:\#[\w\-]*)?           # trailing anchor
+                    )
+                    ([[:punct:]]|\s|<|$)       # trailing text
+                   }x unless defined? AUTO_LINK_RE
+
+    # Turns all urls into clickable links.  If a block is given, each url
+    # is yielded and the result is used as the link text.
+    def auto_link(text, opts = {})
+      html_options = ' ' + opts.map{|k,v| "#{k}='#{v}'"}.join(' ') if opts.any?
+      text.gsub(AUTO_LINK_RE) do
+        all, a, b, c, d = $&, $1, $2, $3, $4
+        if a =~ /<a\s/i # don't replace URL's that are already linked
+          all
+        else
+          text = b + c
+          text = yield(text) if block_given?
+          %(#{a}<a href="#{b=="www."?"http://www.":b}#{c}"#{html_options}>#{text}</a>#{d})
+        end
+      end
+    end
+    alias autolink auto_link
+
+    # takes a string and optional argument for outputting compliance HTML
+    # instead of XHTML.
+    # e.g nl2br "a\nb\n\c" #=> 'a<br />b<br />c'
+
+    def nl2br(string, xhtml = true)
+      br = xhtml ? '<br />' : '<br>'
+      string.gsub(/\n/, br)
+    end
+
+    # Maybe port to ruby < 1.8.7 ?
+    def obfuscate_email(string)
+      string = string.to_s
+      text = string.each_byte.map{|c| "&#%03d" % c}.join
+      %(<a href="mailto:#{string}">#{text}</a>)
+    end
+
+    # Returns Hash with tags as keys and their weight as value.
+    #
+    # Example:
+    #     tags = %w[ruby ruby code ramaze]
+    #     tagcloud(tags)
+    #     # => {"code"=>0.75, "ramaze"=>0.75, "ruby"=>1.0}
+    #
+    # The weight can be influenced by adjusting the +min+ and +max+ parameters,
+    # please make sure that +max+ is larger than +min+ to get meaningful output.
+    #
+    # This is not thought as immediate output to your template but rather to
+    # help either implementing your own algorithm or using the result as input
+    # for your tagcloud.
+    #
+    # Example:
+    #     - tagcloud(tags).each do |tag, weight|
+    #       - style = "font-size: %0.2fem" % weight
+    #       %a{:style => style, :href => Rs(tag)}= h(tag)
+
+    def tagcloud(tags, min = 0.5, max = 1.5)
+      result = {}
+      total = tags.size.to_f
+      diff = max - min
+
+      tags.uniq.each do |tag|
+        count = tags.respond_to?(:count) ? tags.count(tag) : tags.select{|t| t==tag }.size
+        result[tag] = ((count / total) * diff) + min
+      end
+
+      result
+    end
+  end
+end