ptomato-ramaze 2009.02

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

data/lib/ramaze/helper/ultraviolet.rb

@@ -0,0 +1,44 @@
+module Ramaze
+  module Helper
+    module Ultraviolet
+      trait :ultraviolet => {
+        :output       => 'xhtml',
+        :syntax       => nil, # syntax_name, nil|false indicates automatic detection
+        :line_numbers => false,
+        :style        => 'classic', # render_style
+        :headers      => false, # ouput document with all headers
+      }
+
+      # Parse and output the file at the given path.
+      # Please head over to the Ultraviolet documentation for more information
+      # on possible options.
+      def ultraviolet(path, options = {})
+        o = ancestral_trait[:ultraviolet].merge(options)
+        output, syntax, lines, style, headers =
+          o.values_at(:output, :syntax, :line_numbers, :style, :headers)
+
+        syntax ||= Uv.syntax_for_file(path).first.first
+        code = File.read(path)
+
+        p [code, output, syntax, lines, style, headers]
+        Uv.parse(code, output, syntax, lines, style, headers)
+      end
+
+      # Return absolute path to the css of given name.
+      #
+      # Usually this will point to somewhere in the gem tree.
+      #
+      # It seems like Uv will add support for user-defined PATH in the future,
+      # so we will, to be future-proof, traverse the Uv.path even though it
+      # currently will only have one directory.
+
+      def ultraviolet_css(theme)
+        Uv.path.each do |path|
+          Dir[path/"render/xhtml/files/css/*.css"].each do |css|
+            return css if File.basename(css, '.css') == theme
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/user.rb

@@ -0,0 +1,110 @@
+module Ramaze
+  module Helper
+
+    # This helper provides a convenience wrapper for handling authentication
+    # and persistence of users.
+    #
+    # Example:
+    #
+    # class MainController < Ramaze::Controller
+    #   def index
+    #     if logged_in?
+    #       "Hello #{user.name}"
+    #     else
+    #       A('login', :href => Rs(:login))
+    #     end
+    #   end
+    #
+    #   def login
+    #     user_login if request.post?
+    #   end
+    # end
+
+    module User
+      # return existing or instantiate User::Wrapper
+      def user
+        model = ancestral_trait[:user_model] ||= ::User
+        callback = ancestral_trait[:user_callback] ||= nil
+        STATE[:user] ||= Wrapper.new(model, callback)
+      end
+
+      # shortcut for user.user_login but default argument are request.params
+
+      def user_login(creds = request.params)
+        user._login(creds)
+      end
+
+      # shortcut for user.user_logout
+
+      def user_logout
+        user._logout
+      end
+
+      def logged_in?
+        user._logged_in?
+      end
+
+      # Wrapper for the ever-present "user" in your application.
+      # It wraps around an arbitrary instance and worries about authentication
+      # and storing information about the user in the session.
+      #
+      # In order to not interfere with the wrapped instance/model we start our
+      # methods with an underscore.
+      # Suggestions on improvements as usual welcome.
+      class Wrapper < BlankSlate
+        attr_accessor :_model, :_callback, :_user
+
+        def initialize(model, callback)
+          @_model, @_callback = model, callback
+          @_user = nil
+          _login
+        end
+
+        def _login(creds = _persistence)
+          if @_user = _would_login?(creds)
+            self._persistence = creds
+          end
+        end
+
+        # The callback should return an instance of the user, otherwise it
+        # should answer with nil.
+        #
+        # This will not actually login, just check whether the credentials
+        # would result in a user.
+        def _would_login?(creds)
+          if c = @_callback
+            c.call(creds)
+          elsif _model.respond_to?(:authenticate)
+            _model.authenticate(creds)
+          else
+            Log.warn("Helper::User has no callback and there is no %p::authenticate" % _model)
+            nil
+          end
+        end
+
+        def _logout
+          _persistence.clear
+          STATE[:user] = nil
+        end
+
+        def _logged_in?
+          !!_user
+        end
+
+        def _persistence=(creds)
+          Current.session[:USER] = creds
+        end
+
+        def _persistence
+          Current.session[:USER] || {}
+        end
+
+        # Refer everything not known
+        def method_missing(meth, *args, &block)
+          return unless _user
+          _user.send(meth, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/xhtml.rb

@@ -0,0 +1,23 @@
+module Ramaze::Helper
+  module XHTML
+    def css(name, media = 'screen', options = {})
+      if options.empty?
+        "<link rel='stylesheet' href='/css/#{name}.css' type='text/css' media='#{media}' />"
+      elsif options[:only] == 'IE'
+        "<!--[if IE]>#{css(name, media)}<![endif]-->"
+      end
+    end
+
+    def css_for(*names)
+      names.flatten.map{|name| css(name) }.join("\n")
+    end
+
+    def js(name)
+      "<script src='/js/#{name}.js' type='text/javascript'></script>"
+    end
+
+    def js_for(*names)
+      names.flatten.map{|name| js(name) }.join("\n")
+    end
+  end
+end

data/lib/ramaze/helper.rb

@@ -0,0 +1,87 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/trinity'
+
+module Ramaze
+
+  # A module used by the Templates and the Controllers
+  # it provides both Ramaze::Trinity (request/response/session)
+  # and also a helper method, look below for more information about it
+
+  module Helper
+    LOOKUP = Set.new
+    PATH = ['']
+    path = File.expand_path("#{BASEDIR}/../spec/ramaze/helper/")
+    trait :ignore => [
+      /#{Regexp.escape(path)}\//
+    ]
+
+    module Methods
+      def self.included other
+        other.send :extend, Trinity
+        other.send :extend, Methods
+        other.send :include, Trinity
+        super
+      end
+
+      def self.extend_object other
+        other.send :extend, Trinity
+        super
+      end
+
+      # This loads the helper-files from /ramaze/helper/helpername.rb and
+      # includes it into Ramaze::Template (or wherever it is called)
+      #
+      # Usage:
+      #   helper :redirect, :link
+
+      def helper(*syms)
+        syms.each do |sym|
+          name = sym.to_s
+          if mod = find_helper(name)
+            use_helper(mod)
+          else
+            if require_helper(name)
+              redo
+            else
+              raise LoadError, "helper #{name} not found"
+            end
+          end
+        end
+      end
+
+      private
+
+      # returns the Ramaze::Helper::Name Module Constant if exists.
+
+      def find_helper(name)
+        name = name.to_s.camel_case
+        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
+        if mod_name = ramaze_helper_consts.first
+          ::Ramaze::Helper.const_get(mod_name)
+        end
+      end
+
+      # Loads helper from /lib/ramaze/helper/name.(so, bundle, rb)
+      # raises LoadError if helper not found.
+
+      def require_helper(name)
+        paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
+        glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
+        files = Dir[glob]
+        ignore = Helper.trait[:ignore]
+        files.reject!{|f| ignore.any?{|i| f =~ i }}
+        raise LoadError, "file for #{name} not found" unless file = files.first
+        require(file)
+      end
+
+      # injects the helper via include and extend, takes Constant as argument.
+
+      def use_helper(mod)
+        include mod
+        extend mod
+      end
+    end
+  end
+end