ramaze 2008.06 → 2008.11

data/lib/ramaze/helper/paginate.rb

@@ -0,0 +1,233 @@
+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::Request.current.request_path
+          hash[:href] = R(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/redirect.rb

@@ -59,7 +59,7 @@ module Ramaze
     def raw_redirect(target, opts = {})
       target = target.to_s
       header = {'Location' => target}
-      status = opts[:status] || STATUS_CODE["See Other"]
+      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}'")

data/lib/ramaze/helper/rest.rb

@@ -25,7 +25,7 @@ module Ramaze
           trait[:REST][:active] = hm
         end
 
-        (%w[GET PUT POST DELETE] << :any).each do |http_method|
+        (%w[GET PUT POST DELETE] << 'any').each do |http_method|
           define_method("on_#{http_method.downcase}") do |*args|
             if args.empty?
               on(http_method)

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

@@ -25,7 +25,7 @@ module Ramaze
       def user
         model = ancestral_trait[:user_model] ||= ::User
         callback = ancestral_trait[:user_callback] ||= nil
-        Thread.current[:user] ||= Wrapper.new(model, callback)
+        STATE[:user] ||= Wrapper.new(model, callback)
       end
 
       # shortcut for user.user_login but default argument are request.params
@@ -51,12 +51,7 @@ module Ramaze
       # 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
-        # make it a BlankSlate
-        instance_methods.each do |meth|
-          undef_method(meth) unless meth.to_s =~ /^__.+__$/
-        end
-
+      class Wrapper < BlankSlate
         attr_accessor :_model, :_callback, :_user
 
         def initialize(model, callback)
@@ -82,14 +77,14 @@ module Ramaze
           elsif _model.respond_to?(:authenticate)
             _model.authenticate(creds)
           else
-            Log.warn("Helper::User has no callback and model doesn't respond to #authenticate")
+            Log.warn("Helper::User has no callback and %p doesn't respond to #authenticate" % _model)
             nil
           end
         end
 
         def _logout
           _persistence.clear
-          Thread.current[:user] = nil
+          STATE[:user] = nil
         end
 
         def _logged_in?

data/lib/ramaze/log.rb

@@ -10,7 +10,7 @@ begin
 rescue LoadError => ex
   puts ex
   puts "For nice colors on windows, please `gem install win32console`"
-  Ramaze::Informer.trait[:colorize] = false
+  Ramaze::Logger::Informer.trait[:colorize] = false
 end
 
 module Ramaze
@@ -22,6 +22,6 @@ module Ramaze
   autoload :Logger,    "ramaze/log/logger.rb"
 
   unless defined?(Log)
-    Log = Logging::LogHub.new(Logging::Logger::Informer)
+    Log = Logger::LogHub.new(Logger::Informer)
   end
 end

data/lib/ramaze/log/analogger.rb

@@ -4,39 +4,37 @@
 require 'swiftcore/Analogger/Client'
 
 module Ramaze
-  module Logging
-    module Logger
+  module Logger
 
-      # Informer for the Swiftcore Analogger logging system.
-      #
-      # You can find it at http://analogger.swiftcore.org and install with
-      # gem install analogger
+    # Informer for the Swiftcore Analogger logging system.
+    #
+    # You can find it at http://analogger.swiftcore.org and install with
+    # gem install analogger
 
-      class Analogger < ::Swiftcore::Analogger::Client
-        include Logging
+    class Analogger < ::Swiftcore::Analogger::Client
+      include Logging
 
-        # identifier for your application
-        trait :name => 'walrus'
+      # identifier for your application
+      trait :name => 'walrus'
 
-        # Host analogger runs on
-        trait :host => '127.0.0.1'
+      # Host analogger runs on
+      trait :host => '127.0.0.1'
 
-        # Port analogger runs on
-        trait :port => 6766
+      # Port analogger runs on
+      trait :port => 6766
 
-        # Create a new instance, parameters default to the traits.
+      # Create a new instance, parameters default to the traits.
 
-        def initialize(name = class_trait[:name], host = class_trait[:host], port = class_trait[:port])
-          super
-        end
+      def initialize(name = class_trait[:name], host = class_trait[:host], port = class_trait[:port])
+        super
+      end
 
-        # integration to Logging
+      # integration to Logging
 
-        def log(tag, *args)
-          log(tag, args.join("\n"))
-        end
+      def log(tag, *args)
+        log(tag, args.join("\n"))
       end
-
     end
+
   end
 end

data/lib/ramaze/log/growl.rb

@@ -4,37 +4,35 @@
 require 'ruby-growl'
 
 module Ramaze
-  module Logging
-    module Logger
+  module Logger
 
-      # Informer for the growl notification system on OSX.
+    # Informer for the growl notification system on OSX.
 
-      class Growl < ::Growl
+    class Growl < ::Growl
 
-        trait :defaults => {
-          :name => 'walrus',
-          :host => 'localhost',
-          :password => 'walrus',
-          :all_notifies => %w[error warn debug info dev],
-          :default_notifies => %w[error warn info]
-        }
+      trait :defaults => {
+        :name => 'walrus',
+        :host => 'localhost',
+        :password => 'walrus',
+        :all_notifies => %w[error warn debug info dev],
+        :default_notifies => %w[error warn info]
+      }
 
-        # Takes the options from the default trait for merging.
+      # Takes the options from the default trait for merging.
 
-        def initialize(options = {})
-          options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
-          super(*options)
-        end
+      def initialize(options = {})
+        options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
+        super(*options)
+      end
 
-        # integration to Logging
+      # integration to Logging
 
-        def log(tag, *args)
-          notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
-        rescue Errno::EMSGSIZE
-          # Send size was to big (not really), ignore
-        end
+      def log(tag, *args)
+        notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
+      rescue Errno::EMSGSIZE
+        # Send size was to big (not really), ignore
       end
-
     end
+
   end
 end