ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/helper/paginate.rb

@@ -0,0 +1,315 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    # Helper for pagination and pagination-navigation.
+    #
+    # See {Ramaze::Helper::Paginate#paginate} for more information.
+    #
+    module Paginate
+      include Traited
+
+      # 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',
+        :css   => {
+            :first    => 'first',
+            :prev     => 'prev',
+            :next     => 'next',
+            :last     => 'last',
+            :current  => 'current',
+            :number   => '',
+            :disabled => 'grey'
+        }
+      }
+
+      ##
+      # 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)
+      #
+      # Note that you must first extend Sequel with the pagination extension"
+      #
+      #     Sequel.extension :pagination
+      #
+      # Customizing the classes to use for the various HTML elements of the
+      # page list can be done by passing a key ``:css`` to the list of options.
+      # In this hash you can set the following keys:
+      #
+      # * first, defaults to "first"
+      # * prev, defaults to "prev"
+      # * next, defaults to "next"
+      # * last, defaults to "last"
+      # * current, defaults to "current"
+      # * number, empty by default
+      # * disabled, defaults to "grey"
+      #
+      # These options can also be specified globally in the trait ``:paginate``
+      # as following:
+      #
+      #     class Posts < Ramaze::Controller
+      #       map '/'
+      #
+      #       trait :paginate => {
+      #         :limit => 10,
+      #         :var   => 'page',
+      #         :css   => {
+      #           :first => 'first_item',
+      #           :prev  => 'prev_item',
+      #           # and so on.
+      #         }
+      #       }
+      #     end
+      #
+      # @param [Sequel::Dataset|Array] dataset May be a Sequel dataset or an
+      #  Array
+      # @param [Hash] options A hash containing custom options that takes
+      #  precedence to ``trait[:paginate].
+      # @option options [Fixnum] :limit The number of elements used when you
+      #  call #each on the paginator
+      # @option options [String] :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.
+      # @option options [Fixnum] :page The page you are currently on, if not
+      #  given it will be retrieved from current request variables. Defaults to
+      #  1 if neither exists.
+      # @option options [Hash] :css A hash containing various options that can
+      #  be used to customize the HTML classes to use for the various page
+      #  links.
+      #
+      def paginate(dataset, options = {})
+        options = ancestral_trait[:paginate].merge(options)
+        limit = options[:limit]
+        var   = options[:var]
+        page  = options[:page] || (request[var] || 1).to_i
+        opts = {}
+        opts.merge!({:css => options[:css]}) if options[:css]
+        Paginator.new(dataset, page, limit, var, opts)
+      end
+
+      # Provides easy pagination and navigation
+      class Paginator
+        include Ramaze::Helper
+        helper :link, :cgi
+        attr_reader :css
+
+        def initialize(data = [], page = 1, limit = 10, var = 'pager', opts = {})
+          @data, @page, @limit, @var = data, page, limit, var
+          @css = Paginate.trait[:paginate][:css].dup
+          @css.merge!(opts[:css]) if opts[:css]
+          @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)
+          g = Ramaze::Gestalt.new
+          g.div :class => :pager do
+            if first_page?
+              g.span(:class => "#{@css[:first]} #{@css[:disabled]}"){ h('<<') }
+              g.span(:class => "#{@css[:prev]} #{@css[:disabled]}"){ h('<') }
+            else
+              link(g, 1, '<<', :class => @css[:first])
+              link(g, prev_page, '<', :class => @css[:prev])
+            end
+
+            lower = limit ? (current_page - limit) : 1
+            lower = lower < 1 ? 1 : lower
+
+            (lower...current_page).each do |n|
+              link(g, n, n, :class => @css[:number])
+            end
+
+            link(g, current_page, current_page,
+              :class => "#{@css[:current]} #{@css[:number]}" )
+
+            if last_page?
+              g.span(:class => "#{@css[:next]} #{@css[:disabled]}"){ h('>') }
+              g.span(:class => "#{@css[:last]} #{@css[:disabled]}"){ h('>>') }
+            elsif next_page
+              higher = limit ? (next_page + limit) : page_count
+              higher = [higher, page_count].min
+              (next_page..higher).each do |n|
+                link(g, n, n, :class => @css[:number])
+              end
+
+              link(g, next_page, '>', :class => @css[:next])
+              link(g, page_count, '>>', :class => @css[:last])
+            end
+          end
+          g.to_s
+        end
+
+        # Useful to omit pager if it's of no use.
+        def needed?
+          @pager.page_count > 1
+        end
+
+        # these methods are actually on the pager, but we def them here for
+        # convenience (method_missing in helper is evil and even slower)
+        def page_count  ; @pager.page_count  ; end
+        def each(&block); @pager.each(&block); end
+        def first_page? ; @pager.first_page? ; end
+        def prev_page   ; @pager.prev_page   ; end
+        def current_page; @pager.current_page; end
+        def last_page   ; @pager.last_page   ; end
+        def last_page?  ; @pager.last_page?  ; end
+        def next_page   ; @pager.next_page   ; end
+        def empty?      ; @pager.empty?      ; end
+        def count       ; @pager.count       ; end
+
+        private
+
+        def pager_for(obj)
+          @page = @page < 1 ? 1 : @page
+
+          case obj
+          when Array
+            ArrayPager.new(obj, @page, @limit)
+          when (defined?(DataMapper::Collection) and DataMapper::Collection)
+            DataMapperPager.new(obj, @page, @limit)
+          else
+            obj.paginate(@page, @limit)
+          end
+        end
+
+        def link(g, n, text = n, hash = {})
+          text = h(text.to_s)
+
+          action = Current.action
+          params = request.params.merge(@var.to_s => n)
+          params.keys.each do |p|
+            if params[p].is_a?(Array) and not p.end_with?('[]')
+              params["#{p}[]"] = params.delete(p)
+            end
+          end
+          hash[:href] = action.node.r(action.path, params)
+
+          g.a(hash){ text }
+        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 = 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
+
+        # Wrapper for DataMapper::Collection to behave like the Sequel
+        # pagination.
+        # needs 'datamapper' (or 'dm-core' and 'dm-aggregates')
+        class DataMapperPager < ArrayPager
+
+          def initialize(*args)
+            unless defined?(DataMapper::Aggregates)
+              Ramaze::Log.warn "paginate.rb: it is strongly " +
+                               "recommended to require 'dm-aggregates'"
+            end
+
+            super
+          end
+
+          def size
+            @cached_size ||= @array.count
+          end
+
+          def empty?
+            size == 0
+          end
+        end # DataMapperPager
+      end # Paginator
+    end # Paginate
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/remarkably.rb

@@ -0,0 +1,14 @@
+require 'remarkably'
+
+module Ramaze
+  module Helper
+    module Remarkably
+      include ::Remarkably::Common
+
+      # Avoid calling the Helper::Link#a method
+      def a(*args, &block)
+        method_missing(:a, *args, &block)
+      end
+    end # Remarkably
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/request_accessor.rb

@@ -0,0 +1,20 @@
+require 'rack/request'
+module Ramaze
+  module Helper
+    module RequestAccessor
+      classes = [Rack::Request, Rack::Request::Helpers, Rack::Request::Env, Innate::Request, Ramaze::Request]
+      methods = classes.map { |klass|
+        klass.instance_methods(false)
+      }.flatten.uniq
+
+      methods.each do |method|
+        next if method == :intialize
+        if method =~ /=/
+          eval("def %s(a) request.%s a; end" % [method, method])
+        else
+          eval("def %s(*a) request.%s(*a); end" % [method, method])
+        end
+      end
+    end # RequestAccessor
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/send_file.rb

@@ -0,0 +1,34 @@
+module Ramaze
+  module Helper
+    ##
+    # The SendFile module can be used to stream a file to the user's computer.
+    # While the performance of the module isn't optimal it's convenient and
+    # relatively easy to use.
+    #
+    module SendFile
+      ##
+      # The send_file method streams the specified file to the user's browser.
+      #
+      # @param [String] filename The name or path to the file which will be 
+      #  streamed to the user.
+      # @param [String] content_type The type of file we're dealing with. For
+      #  example, if we want to stream a JPG image we'd set this variable to
+      #  'image/jpg'.
+      # @param [String] content_disposition Value for the Content-Disposition 
+      #  header.
+      #
+      def send_file(filename, content_type = nil, content_disposition = nil)
+        content_type ||= Rack::Mime.mime_type(::File.extname(filename))
+        content_disposition ||= File.basename(filename)
+
+        response.body = ::File.open(filename, 'rb')
+        response['Content-Length'] = ::File.size(filename).to_s
+        response['Content-Type'] = content_type
+        response['Content-Disposition'] = content_disposition
+        response.status = 200
+
+        throw(:respond, response)
+      end
+    end # SendFile
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/simple_captcha.rb

@@ -0,0 +1,61 @@
+module Ramaze
+  module Helper
+    # Produce very simple question/answer pairs.
+    #
+    # The default is a trivial mathematical problem.
+    #
+    # Usage (trait is optional):
+    #
+    #     class RegisterController < Ramaze::Controller
+    #       trait :captcha => lambda{
+    #         ["the answer to everything", "42"]
+    #       }
+    #
+    #       def index
+    #         %(
+    #           <form action="#{r(:answer}">
+    #             What is #{simple_captcha}?
+    #             <input type="text" name="answer" />"
+    #             <input type="submit" />
+    #           </form>
+    #         ).strip
+    #       end
+    #
+    #       def answer
+    #         check_captcha(request[:answer])
+    #       end
+    #     end
+    #
+    module SimpleCaptcha
+      include Ramaze::Traited
+
+      NUMBERS = [5, 10, 15, 20]
+
+      # lambda should return question and answer in [question, answer] form
+      trait :captcha => lambda{
+        ns = Array.new(2){ NUMBERS.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]
+      }
+
+      # Call the trait[:captcha] and store question/answer in session
+      def simple_captcha
+        question, answer  = ancestral_trait[:captcha].call
+        session[:CAPTCHA] = { :question => question, :answer => answer.to_s }
+
+        question
+      end
+
+      # check the given +answer+ against the answer stored in the session.
+      def check_captcha(answer)
+        return false unless captcha = session[:CAPTCHA]
+
+        answer.to_s.strip == captcha[:answer].to_s
+      end
+    end # SimpleCaptcha
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/stack.rb

@@ -1,68 +1,78 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 
 module Ramaze
+  module Helper
+    ##
+    # Provides an call/answer mechanism, this is useful for example in a
+    # login-system.
+    #
+    # It is basically good to redirect temporarily 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 Stack
+      # redirect to another location and pushing the current location
+      # on the session[:STACK]
+      def push(frame)
+        (session[:STACK] ||= []) << frame
+      end
 
-  # 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 if inside_stack?
-  #       redirect '/'
-  #     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 call this
-      (session[:STACK] ||= []) << request.fullpath
-      redirect this
-    end
-
-    # return to the last location on session[:STACK]
-
-    def answer
-      if inside_stack?
-        stack = session[:STACK]
-        target = stack.pop
-        session.delete(:STACK) if stack.empty?
-        redirect target
+      def call(this)
+        push(request.fullpath)
+        redirect(this)
       end
-    end
 
-    # check if the stack has something inside.
+      ##
+      # 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
 
-    def inside_stack?
-      session[:STACK] and session[:STACK].any?
-    end
-  end
-end
+      # check if the stack has something inside.
+      def inside_stack?
+        session[:STACK] and session[:STACK].any?
+      end
+    end # Stack
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/tagz.rb

@@ -1,19 +1,20 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT 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
+    ##
+    # 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' } }
+    #
     Tagz = ::Tagz
-  end
-end
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/thread.rb

@@ -0,0 +1,25 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+module Ramaze
+  module Helper
+    module Thread
+      ##
+      # The thread method executes the specified block in a new thread.
+      #
+      # @param [Block] block The block that contains the code that will be 
+      #  executed in the new 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 # Thread
+  end # Helper
+end # Ramaze