Pistos-ramaze 2008.09

data/lib/ramaze/helper/paginate.rb

@@ -0,0 +1,234 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+
+    # Helper for pagination and pagination-navigation.
+    #
+    # See detailed API docs for Paginator below.
+    # Also have a look at the examples/helpers/paginate.rb
+
+    module Paginate
+
+      # Define default options in your Controller, they are being retrieved by
+      # ancestral_trait, so you can also put it into a common superclass
+
+      trait :paginate => {
+        :limit => 10,
+        :var   => 'pager',
+      }
+
+      # Returns a new Paginator instance.
+      #
+      # Note that the pagination relies on being inside a Ramaze request to
+      # gain necessary metadata about the page it resides on, you cannot use it
+      # outside of Ramaze yet.
+      #
+      # The examples below are meant to be used within your controller or view.
+      #
+      # Usage with Array:
+      #   data = (1..100).to_a
+      #   @pager = paginate(data, :limit => 30, :page => 2)
+      #   @pager.navigation
+      #   @pager.each{|e| puts(e) }
+      #
+      # Usage with Sequel:
+      #   data = Article.filter(:public => true)
+      #   @pager = paginate(data, :limit => 5)
+      #   @pager.navigation
+      #   @pager.each{|e| puts(e)
+      #
+      # +dataset+ may be a Sequel dataset or Array
+      # +options+ Takes precedence to trait[:paginate] and may contain
+      #           following pairs:
+      #   :limit  The number of elements used when you call #each on the
+      #           paginator
+      #   :var    The variable name being used in the request, this is helpful
+      #           if you want to use two or more independent paginations on the
+      #           same page.
+      #   :page   The page you are currently on, if not given it will be
+      #           retrieved from current request variables. Defaults to 1 if
+      #           neither exists.
+
+      def paginate(dataset, options = {})
+        options = ancestral_trait[:paginate].merge(options)
+        limit = options[:limit]
+        var   = options[:var]
+        page  = options[:page] || (request[var] || 1).to_i
+
+        Paginator.new(dataset, page, limit, var)
+      end
+
+      # Provides easy pagination and navigation
+
+      class Paginator
+        include Ramaze::Helper::Link
+        include Ramaze::Helper::CGI
+
+        def initialize(data = [], page = 1, limit = 10, var = 'pager')
+          @data, @page, @limit, @var = data, page, limit, var
+          @pager = pager_for(data)
+          @page = @page > page_count ? page_count : @page
+          @pager = pager_for(data)
+        end
+
+        # Returns String with navigation div.
+        #
+        # This cannot be customized very nicely, but you can style it easily
+        # with CSS.
+        #
+        # Output with 5 elements, page 1, limit 3:
+        #   <div class="pager">
+        #     <span class="first grey">&lt;&lt;</span>
+        #     <span class="previous grey">&lt;</span>
+        #     <a class="current" href="/index?pager=1">1</a>
+        #     <a href="/index?pager=2">2</a>
+        #     <a class="next" href="/index?pager=2">&gt;</a>
+        #     <a class="last" href="/index?pager=2">&gt;&gt;</a>
+        #   </div>
+        #
+        # Output with 5 elements, page 2, limit 3:
+        #   <div class="pager" />
+        #     <a class="first" href="/index?user_page=1">&lt;&lt;</a>
+        #     <a class="previous" href="/index?user_page=1">&lt;</a>
+        #     <a href="/index?user_page=1">1</a>
+        #     <a class="current" href="/index?user_page=2">2</a>
+        #     <span class="next grey">&gt;</span>
+        #     <span class="last grey">&gt;&gt;</span>
+        #   </div>
+
+
+        def navigation(limit = 8)
+          out = [ g.div(:class => :pager) ]
+
+          if first_page?
+            out << g.span(:class => 'first grey'){ h('<<') }
+            out << g.span(:class => 'previous grey'){ h('<') }
+          else
+            out << link(1, '<<', :class => :first)
+            out << link(prev_page, '<', :class => :previous)
+          end
+
+          lower = limit ? (current_page - limit) : 1
+          lower = lower < 1 ? 1 : lower
+
+          (lower...current_page).each do |n|
+            out << link(n)
+          end
+
+          out << link(current_page, current_page, :class => :current)
+
+          if last_page?
+            out << g.span(:class => 'next grey'){ h('>') }
+            out << g.span(:class => 'last grey'){ h('>>') }
+          elsif next_page
+            higher = limit ? (next_page + limit) : page_count
+            higher = [higher, page_count].min
+            (next_page..higher).each do |n|
+              out << link(n)
+            end
+
+            out << link(next_page, '>', :class => :next)
+            out << link(page_count, '>>', :class => :last)
+          end
+
+          out << '</div>'
+          out.map{|e| e.to_s}.join("\n")
+        end
+
+        # Useful to omit pager if it's of no use.
+
+        def needed?
+          @pager.page_count > 1
+        end
+
+        # Forward everything to the inner @pager
+
+        def method_missing(meth, *args, &block)
+          @pager.send(meth, *args, &block)
+        end
+
+        private
+
+        def pager_for(obj)
+          @page = @page < 1 ? 1 : @page
+
+          case obj
+          when Array
+            ArrayPager.new(obj, @page, @limit)
+          else
+            obj.paginate(@page, @limit)
+          end
+        end
+
+        def link(n, text = n, hash = {})
+          text = h(text.to_s)
+
+          params = Ramaze::Request.current.params.merge(@var.to_s => n)
+          name = Ramaze::Action.stack.first.name
+          name = '/' if name == 'index' # make nicer...
+          hash[:href] = Rs(name, params)
+
+          g.a(hash){ text }
+        end
+
+        def g
+          Ramaze::Gestalt.new
+        end
+
+        # Wrapper for Array to behave like the Sequel pagination
+
+        class ArrayPager
+          def initialize(array, page, limit)
+            @array, @page, @limit = array, page, limit
+            @page = page_count if @page > page_count
+          end
+
+          def size
+            @array.size
+          end
+
+          def empty?
+            @array.empty?
+          end
+
+          def page_count
+            pages, rest = @array.size.divmod(@limit)
+            rest == 0 ? pages : pages + 1
+          end
+
+          def current_page
+            @page
+          end
+
+          def next_page
+            page_count == @page ? nil : @page + 1
+          end
+
+          def prev_page
+            @page <= 1 ? nil : @page - 1
+          end
+
+          def first_page?
+            @page <= 1
+          end
+
+          def last_page?
+            page_count == @page
+          end
+
+          def each(&block)
+            from = ((@page - 1) * @limit)
+            to = from + @limit
+
+            a = @array[from...to] || []
+            a.each(&block)
+          end
+
+          include Enumerable
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/helper/partial.rb

@@ -0,0 +1,105 @@
+#          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
+
+  # = Helper::Partial
+  #
+  # === Example Usage
+  #
+  #   class MyController
+  #     def index
+  #     end
+  #     def list
+  #       plain = request['plain']
+  #       "Hello World from List!  Plain List == #{plain}"
+  #     end
+  #   end
+  #
+  #
+  #   <html>
+  #     <head><title>Partial Render Index</title></head>
+  #     <body>
+  #       #{render_partial(Rs(:list), 'plain' => true)}
+  #     </body>
+  #   </html>
+
+  module Helper::Partial
+    module_function
+
+    # Renders a url 'inline'.
+    #
+    # url:      normal URL, like you'd use for redirecting.
+    # options:  optional, will be used as request parameters.
+
+    def render_partial(url, options = {})
+      # Save any request params that clash with the ones we're about to add in.
+      saved = {}
+      options.keys.each {|x| saved[x] = Request.current.params[x] }
+
+      # Add/overwrite with the specified params. Ensure keys are strings since
+      # request[:foo] converts key to string when performing lookup.
+      options.each do |key, value|
+        Request.current.params[key.to_s] = value
+      end
+
+      Controller.handle(url)
+    ensure
+      # Always reinstate the original
+      options.keys.each {|x| Request.current.params[x] = saved[x] }
+    end
+
+    # Render the template file in view_root of the
+    # current controller.
+
+    def render_template(file, vars = {})
+      current = Action.current
+      options = { :controller => current.controller,
+                  :instance => current.instance.dup }
+
+      file = file.to_s
+
+      if Pathname(file).absolute?
+        file = file.squeeze '/'
+        unless File.exist?(file)
+          Log.warn "render_template: #{file} does not exist."
+          return ''
+        end
+        options[:template] = file
+      else
+        roots = [options[:controller].template_paths].flatten
+
+        if (files = Dir["{#{roots.join(',')}}"/"{#{file},#{file}.*}"]).any?
+          options[:template] = files.first.squeeze '/'
+        else
+          Log.warn "render_template: #{file} does not exist in the following directories: #{roots.join(',')}."
+          return ''
+        end
+      end
+
+      binding = options[:instance].scope
+      
+      # For Ruby 1.9/1.8.7
+      binding = binding.binding if binding.respond_to?(:binding)
+
+      vars.each do |name, value|
+        options[:instance].instance_variable_set("@#{name}", value)
+
+        value = "ObjectSpace._id2ref(#{ value.object_id })"
+        eval "#{ name } = #{ value }", binding
+      end
+
+      options[:binding] = binding
+
+      Ramaze::Action(options).render
+    end
+
+    # shortcut to render_partial, accepts a method and contructs a link to the
+    # current controller, then calls render_partial on that
+
+    def render_action method, *params
+      render_partial(Rs(method), *params)
+    end
+
+  end
+end

data/lib/ramaze/helper/redirect.rb

@@ -0,0 +1,82 @@
+#          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
+
+  # Helper::Redirect actually takes advantage of Helper::Link.link_raw to build the links
+  # it redirects to.
+  # It doesn't do much else than this:
+  #     setting a status-code of 303 and a response['Location'] = link
+  # returning some nice text for visitors who insist on ignoring those hints :P
+  #
+  # Usage:
+  #   redirect Rs()
+  #   redirect R(MainController)
+  #   redirect R(MainController, :foo)
+  #   redirect 'foo/bar'
+  #   redirect 'foo/bar', :status => 301
+  #
+  # TODO:
+  #   - maybe some more options, like a delay
+  #
+
+  module Helper::Redirect
+
+    # render to the browser directly, ignoring any templates
+    #
+    # Usage:
+    #   respond 'Page not found', 404
+    #   respond render_template('forbidden.erb'), 403
+    #   respond File.open('file.jpg'), 200, 'Content-Type' => 'image/jpeg'
+
+    def respond(*args)
+      response.build(*args)
+      throw(:respond)
+    end
+
+    # Usage:
+    #   redirect Rs()
+    #   redirect R(MainController)
+    #   redirect R(MainController, :foo)
+    #   redirect 'foo/bar'
+    #   redirect 'foo/bar', :status => 301
+
+    def redirect(target, opts = {})
+      target = target.to_s
+
+      unless target =~ %r!^https?://!
+        target[0,0] = '/' unless target =~ %r!^/!
+        if host = request.env['HTTP_HOST']
+          target[0,0] = "http://#{host}"
+        end
+      end
+
+      raw_redirect(target, opts)
+    end
+
+    # Do not perform any mutations on the target like #redirect does.
+    # Suitable if you have to redirect to a different subdomain or host.
+    def raw_redirect(target, opts = {})
+      target = target.to_s
+      header = {'Location' => target}
+      status = opts[:status] || STATUS_CODE["Moved Temporarily"]
+      body = %{You are being redirected, please follow <a href="#{target}">this link to: #{target}</a>!}
+
+      Log.info("Redirect to '#{target}'")
+      request[:redirected] = true
+      throw(:redirect, [body, status, header])
+    end
+
+    # Are we being redirected?
+    def redirected?
+      request[:redirected]
+    end
+
+    # redirect to the location the browser says it's coming from.
+
+    def redirect_referer
+      redirect request.referer
+    end
+    alias redirect_referrer redirect_referer
+  end
+end

data/lib/ramaze/helper/rest.rb

@@ -0,0 +1,43 @@
+module Ramaze
+  module Helper
+    module REST
+      def self.included(klass)
+        klass.class_eval do
+          trait :REST => {
+            'GET' => [], 'PUT' => [],
+            'POST' => [], 'DELETE' => [],
+            :any => [],
+          }
+          extend Indicate
+
+          def self.method_added(name)
+            name = name.to_s
+            active = trait[:REST][:active] ||= :any
+            trait[:REST][active] << name
+          end
+        end
+      end
+
+      module Indicate
+        def on(http_method)
+          hm = http_method.to_s.upcase
+          trait[:REST][hm] = []
+          trait[:REST][:active] = hm
+        end
+
+        (%w[GET PUT POST DELETE] << 'any').each do |http_method|
+          define_method("on_#{http_method.downcase}") do |*args|
+            if args.empty?
+              on(http_method)
+            else
+              trait[:REST][http_method] += args.flatten
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# POST /foo/bar
+# methods_on_post[/foo/bar]

data/lib/ramaze/helper/sendfile.rb

@@ -0,0 +1,16 @@
+#          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
+
+  # Helper for quickly push out files with the proper mimetype.
+
+  module Helper::SendFile
+    # Sets Content-Type to the mimetype of the file and opens the file you pass
+    # it, then throws :respond to finish off the request.
+
+    def send_file(file, mime_type = Tool::MIME.type_for(file))
+      respond File.open(file, 'rb'), 200, 'Content-Type' => mime_type
+    end
+  end
+end

data/lib/ramaze/helper/sequel.rb

@@ -0,0 +1,55 @@
+#          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::Sequel
+
+    # Very crude paginator, may contain serious bugs, please fix :)
+    # pass it the result of YourModel.paginate, target is where links point to.
+    def paginator(paginated, target)
+      page_count = paginated.page_count
+      prev_page = paginated.prev_page
+      current_page = paginated.current_page
+      next_page = paginated.next_page
+
+      lower = (current_page - 3).abs
+      lower = lower == 0 ? 1 : lower
+
+      out = ['<div class="paginator">']
+
+      if prev_page
+        out << %(<a class="paginator_prev" href="#{Rs(target, prev_page)}">&lt;&nbsp;Prev</a>)
+      else
+        out << %(<span class="paginator_prev">&lt;&nbsp;Prev</span>)
+      end
+
+      if current_page > 3
+        out << %(<a class="paginator_page" href="#{Rs(target, 1)}">#{1}</a> ... )
+      end
+
+      lower.upto(current_page) do |pc|
+        next if pc == current_page
+        out << %(<a class="paginator_page" href="#{Rs(target, pc)}">#{pc}</a>)
+      end
+
+      out << %(<span class="paginator_current">#{current_page}</span>)
+
+      current_page.upto([page_count, current_page + 3].min) do |pc|
+        next if pc == current_page
+        out << %(<a class="paginator_page" href="#{Rs(target, pc)}">#{pc}</a>)
+      end
+
+      if current_page < (page_count - 3)
+        out << %(.. <a class="paginator_page" href="#{Rs(target, page_count)}">#{page_count}</a>)
+      end
+
+      if next_page
+        out << %(<a class="paginator_next" href="#{Rs(target, next_page)}">Next&nbsp;&gt;</a>)
+      else
+        out << %(<span class="paginator_next">Next&nbsp;&gt;</span>)
+      end
+      out << '</div>'
+      out.join(" ")
+    end
+  end
+end

data/lib/ramaze/helper/simple_captcha.rb

@@ -0,0 +1,31 @@
+module Ramaze
+  module Helper
+    module SimpleCaptcha
+      def simple_captcha
+        question, answer = generate_captcha
+        session[:CAPTCHA] = {
+          :question => question, :answer => answer.to_s
+        }
+        question
+      end
+
+      def check_captcha(answer)
+        if captcha = session[:CAPTCHA]
+          should = captcha[:answer].to_s
+          should == answer.to_s.strip
+        end
+      end
+
+      def generate_captcha
+        n = [5, 10, 15, 20]
+        ns = Array.new(2){ n.sort_by{rand}.first }.sort
+        op = rand > 0.42 ? [ns[0], :+, ns[1]] : [ns[1], :-, ns[0]]
+
+        question = op.join(' ')
+        answer = op[0].send(op[1], op[2])
+
+        [question, answer]
+      end
+    end
+  end
+end

data/lib/ramaze/helper/stack.rb

@@ -0,0 +1,77 @@
+#          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
+
+  # provides an call/answer mechanism, this is useful for example in a
+  # login-system.
+  #
+  # It is basically good to redirect temporarly somewhere else without
+  # forgetting where you come from and offering a nice way to get back
+  # to the last urls.
+  #
+  # Example:
+  #
+  # class AuthController < Controller
+  #   helper :stack
+  #
+  #   def login pass
+  #     if pass == 'password'
+  #       session[:logged_in] = true
+  #       answer '/'
+  #     else
+  #       "failed"
+  #     end
+  #   end
+  #
+  #   def logged_in?
+  #     !!session[:logged_in]
+  #   end
+  # end
+  #
+  # class ImportantController < Controller
+  #   helper :stack
+  #
+  #   def secret_information
+  #     call :login unless logged_in?
+  #     "Agent X is assigned to fight the RubyNinjas"
+  #   end
+  # end
+
+  module Helper::Stack
+    # redirect to another location and pushing the current location
+    # on the session[:STACK]
+
+    def push(frame)
+      (session[:STACK] ||= []) << frame
+    end
+
+    def call(this)
+      push request.fullpath
+      redirect this
+    end
+
+    # return to the last location on session[:STACK]
+    # The optional alternative paramter will be used to redirect in case you
+    # are not inside_stack?
+    # If the session has no stack and no alternative is given this won't do
+    # anything
+
+    def answer(alternative = nil)
+      if inside_stack?
+        stack = session[:STACK]
+        target = stack.pop
+        session.delete(:STACK) if stack.empty?
+        redirect target
+      elsif alternative
+        redirect alternative
+      end
+    end
+
+    # check if the stack has something inside.
+
+    def inside_stack?
+      session[:STACK] and session[:STACK].any?
+    end
+  end
+end

data/lib/ramaze/helper/tagz.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'tagz'
+
+module Ramaze
+
+  # Allows you to use some shortcuts for Tagz in your Controller.
+
+  # use this inside your controller to directly build Tagz
+  # Refer to the Tagz-documentation and testsuite for more examples.
+  # Usage:
+  #   tagz { h1_{ "Apples & Oranges" } }                   #=> "<h1>Apples &amp; Oranges</h1>"
+  #   tagz { h1_(:class => 'fruits&floots'){ 'Apples' } }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
+
+  module Helper
+    Tagz = ::Tagz
+  end
+end

data/lib/ramaze/helper/thread.rb

@@ -0,0 +1,17 @@
+#          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::Thread
+    def thread &block
+      parent_thread = Thread.current
+      Thread.new do
+        begin
+          block.call
+        rescue Exception => e
+          parent_thread.raise(e)
+        end
+      end
+    end
+  end
+end