rjspotter-ramaze 2009.06.29

data/lib/ramaze/helper/disqus.rb

@@ -0,0 +1,26 @@
+require 'disqus'
+require 'disqus/view_helpers'
+
+module Ramaze
+  module Helper
+
+    # Provides shortcuts via Disqus::ViewHelpers.
+    #
+    # Make sure that you set your disqus credentials when using this helper:
+    #   Disqus::defaults[:account] = "my_disqus_account"
+    # And optionally, only if you're using the API
+    #   Disqus::defaults[:api_key] = "my_disqus_api_key"
+    #
+    # Available methods are:
+    #
+    #   disqus_combo
+    #   disqus_comment_counts
+    #   disqus_popular_threads
+    #   disqus_recent_comments
+    #   disqus_thread
+    #   disqus_top_commenters
+    module Disqus
+      include ::Disqus::ViewHelpers
+    end
+  end
+end

data/lib/ramaze/helper/flash.rb

@@ -0,0 +1,62 @@
+#          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
+    module Flash
+      include Innate::Traited
+
+      trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
+
+      # answers with Current.session.flash
+      def flash
+        Current.session.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 is designed to be customized permanently or per usage:
+      #
+      #   flashbox("<div class='flash_%key'>%value</div>")
+      #
+      # 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
+end

data/lib/ramaze/helper/form.rb

@@ -0,0 +1,127 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    module Form
+      def form_text(label, name, value = nil)
+        form_input(label, :type => :text, :name => name, :value => value)
+      end
+
+      def form_checkbox(label, name, checked = false)
+        hash = {:type => :checkbox, :name => name}
+        hash[:checked] = 'checked' if checked
+        form_input(label, hash)
+      end
+
+      def form_password(label, name)
+        form_input(label, :type => :password, :name => name)
+      end
+
+      def form_textarea(label, name, value = nil)
+        form_build(:textarea, label, :name => name){ value }
+      end
+
+      def form_file(label, name)
+        form_input(label, :type => :file, :name => name)
+      end
+
+      def form_hidden(name, value = nil)
+        Ramaze::Gestalt.build{ input(:type => :hidden, :name => name, :value => value) }
+      end
+
+      def form_submit(value = nil)
+        hash = {:type => :submit}.merge(form_tabindex)
+        hash[:value] = value if value
+        Ramaze::Gestalt.build{ tr{ td(:colspan => 2){ input(hash) }}}
+      end
+
+      # @example usage, normal select drop-down
+      #
+      #   form_select('Favourite colors', :colors, @colors, :selected => @color)
+      #
+      # @example usage for pre-selected value
+      #
+      #   form_select('Favourite colors', :colors, @colors, :selected => @color)
+      #
+      # @example usage, allow selecting multiple
+      #
+      #   form_select('Cups', :cups, @cups, :selected => @cup, :multiple => 5)
+      def form_select(label, name, values, hash = {})
+        name = name.to_sym
+        id = "form-#{name}"
+        multiple, size = hash.values_at(:multiple, :size)
+
+        s_args = {:name => name, :id => id}.merge(form_tabindex)
+        s_args[:multiple] = :multiple if multiple
+        s_args[:size] = (size || multiple || 1).to_i
+
+        has_selected, selected = hash.key?(:selected), hash[:selected]
+        error = form_errors[name.to_s]
+
+        g = Ramaze::Gestalt.new
+        g.tr do
+          g.td do
+            g.label(:for => id){ "#{label}:" }
+            g.span(:class => 'error'){ error } if error
+          end
+          g.td do
+            g.select(s_args) do
+              values.each do |key, value|
+                value ||= key
+                o_args = {:value => value}
+                o_args[:selected] = :selected if has_selected and value == selected
+                g.option(o_args){ key }
+              end
+            end
+          end
+        end
+
+        g.to_s
+      end
+
+      def form_input(label, hash)
+        form_build(:input, label, hash)
+      end
+
+      def form_build(tag_name, label, hash, &block)
+        name = hash[:name].to_sym
+        form_id = "form-#{name}"
+        opts = hash.merge(form_tabindex.merge(:id => form_id))
+        error = form_errors[name.to_s]
+
+        Ramaze::Gestalt.build do
+          tr do
+            td do
+              label(:for => form_id){ "#{label}:" }
+              span(:class => "error"){ error } if error
+            end
+            td do
+              tag(tag_name, opts, &block)
+            end
+          end
+        end
+      end
+
+      def form_tabindex
+        @tabindex ||= 0
+        @tabindex += 1
+
+        {:tabindex => @tabindex}
+      end
+
+      def form_error(name, message)
+        form_errors[name.to_s] = message.to_s
+      end
+
+      def form_errors
+        @form_errors ||= {}
+      end
+
+      def form_errors_from_model(obj)
+        obj.errors.each do |key, value|
+          form_error(key, value.first % key)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/formatting.rb

@@ -0,0 +1,189 @@
+#          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
+    module_function
+
+    FORMATTING_NUMBER_COUNTER = { 0 => 'no', 2 => 'two', 3 => 'three',
+      4 => 'four', 5 => 'five', 6 => 'six', 7 => 'seven', 8 => 'eight',
+      9 => 'nine', 10 => 'ten' }
+
+    # Answers with a representation of given +count+ with correct grammar.
+    # If no +items+ argument is given, and the +count+ argument is not 1, then
+    # we first check whether the +item+ argument responds to #pluralize (for
+    # example if you are using Sequel). If this doesn't work we append 's' to
+    # the +item+ argument.
+    #
+    # @example usage
+    #   numeric_counter(0, 'comment') # => 'no comments'
+    #   numeric_counter(1, 'comment') # => 'one comment'
+    #   numeric_counter(2, 'comment') # => '2 comments'
+
+    def number_counter(count, item, items = nil)
+      count, item = count.to_i, item.to_s
+
+      if count == 1
+        "one #{item}"
+      else
+        items ||= item.respond_to?(:pluralize) ? item.pluralize : "#{item}s"
+        prefix = FORMATTING_NUMBER_COUNTER[count] || count
+        "#{prefix} #{items}"
+      end
+    end
+
+    # 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(email, text = nil)
+      obfuscated = email.to_s.each_byte.map{|c| "&#%03d" % c}.join
+      %(<a href="mailto:#{obfuscated}">#{text || obfuscated}</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

data/lib/ramaze/helper/gestalt.rb

@@ -0,0 +1,47 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    module Gestalt
+      CACHE_G = {}
+
+      def gestalt(&block)
+        Ramaze::Gestalt.new(&block)
+      end
+
+      def build(&block)
+        Ramaze::Gestalt.build(&block)
+      end
+
+      def g(meth = nil, view = nil)
+        meth ||= caller[0].slice(/`(.*)'?/).gsub(/[\`\']/, '')
+        view_name = (self.class.to_s.sub('Controller', '') + 'View').split('::')
+        view ||= view_name.inject(Object){ |ns, name| ns.const_get(name) }
+
+        gestalt_class = CACHE_G[view] ||= g_class
+        gestalt = gestalt_class.new
+        gestalt.extend(view)
+        instance_variables.each do |iv|
+          gestalt.instance_variable_set(iv, instance_variable_get(iv))
+        end
+        gestalt.__send__(meth)
+        gestalt.to_s
+      end
+
+      def g_class
+        ancs = self.class.ancestors
+        helpers = Ramaze::Helper.constants.map{ |c| Ramaze::Helper.const_get(c)}
+        our_helpers = ancs & helpers
+        our_helpers.delete(Ramaze::Helper::Gestalt)
+        gestalt_class = Class.new(Ramaze::Gestalt){ include(*our_helpers) }
+      end
+
+      def method_missing(sym, *args, &block)
+        @gestalt ||= gestalt
+        @gestalt.send(sym, *args, &block)
+      end
+    end
+  end
+end
+
+module Ramaze::Helper::Link; undef :a end