manveru-ramaze 2008.08 → 2008.09

data/lib/ramaze/contrib/sequel/relation.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.     
+
+# Pretty DSL to express Sequel relations
+#
+# Usage:
+#   SequelRelation.relations do
+#     the User do
+#       has_many Article
+#       has_one Avatar
+#     end
+#
+#     the Article do
+#       belongs_to User
+#     end
+#
+#     the Avatar do
+#       belongs_to User
+#     end
+#   end
+
+module SequelRelation
+  def self.relations(&block)
+    rema = RelationshipManager.new(&block)
+    rema.finalize
+  end
+
+  class RelationshipManager
+    TODO = {}
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    def finalize
+      TODO.keys.each do |model|
+        model.create_table unless model.table_exists?
+      end
+
+      TODO.each do |model, instructions|
+        instructions.each do |args|
+          model.send(*args)
+        end
+      end
+
+      return # remove this line for debugging
+
+      pp TODO
+
+      TODO.keys.each do |model|
+        puts "the #{model}"
+        assoc = model.send(:association_reflections)
+        assoc.each do |key, reflection|
+          puts "  #{reflection[:type]} => #{key}"
+        end
+      end
+    end
+
+    def the(left_model, &block)
+      @left = left_model
+      TODO[@left] = []
+      instance_eval(&block)
+    end
+
+    def belongs_to(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def has_many(model)
+      todo :create_join, model
+      todo :many_to_many, model.to_s.downcase.pluralize.to_sym
+    end
+
+    def has_one(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def todo(method, *args)
+      TODO[@left] << [method, *args]
+    end
+  end
+end

data/lib/ramaze/controller/resolve.rb

@@ -250,7 +250,7 @@ module Ramaze
       # Raises Ramaze::Error::NoFilter
       # TODO:
       #   * is this called at all for anybody?
-      #     I think everybody does have filters.
+      #     I think everybody has filters.
 
       def raise_no_filter(path)
         raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"

data/lib/ramaze/current.rb

@@ -3,6 +3,54 @@ require 'ramaze/current/response'
 require 'ramaze/current/session'
 
 module Ramaze
+  class Current
+    include Trinity
+    extend Trinity
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      setup(env)
+      before_call
+      record
+
+      @app.call(env)
+      finish
+    ensure
+      after_call
+    end
+
+    def record
+      return unless filter = Global.record
+      request = Current.request
+      Record << request if filter.call(request)
+    end
+
+    def setup(env)
+      self.request = Request.new(env)
+      self.response = Response.new
+      self.session = Session.new
+    end
+
+    def finish
+      session.finish if session
+      response.finish
+    end
+
+    def self.call(env)
+    end
+
+    def before_call
+    end
+
+    def after_call
+    end
+  end
+end
+__END__
+
   module Current
     class << self
       include Trinity
@@ -35,35 +83,27 @@ module Ramaze
       end
 
       def before(&block)
-        @before = block if block
-        @before
+        @before = block_given? ? block : @before
       end
 
       def before_call
-        if before
-          begin
-            before.call
-          rescue Object => e
-            Ramaze::Log.error e
-            raise
-          end
-        end
+        return unless before
+        before.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
       end
 
       def after(&block)
-        @after = block if block
-        @after
+        @after = block_given? ? block : @after
       end
 
       def after_call
-        if after
-          begin
-            after.call
-          rescue Object => e
-            Ramaze::Log.error e
-            raise
-          end
-        end
+        return unless after
+        after.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
       end
     end
   end

data/lib/ramaze/current/response.rb

@@ -15,13 +15,25 @@ module Ramaze
     end
 
     # Build/replace this responses data
-    def build(body = body, status = status, header = header)
+    def build(new_body = body, status = status, header = header)
       header.each do |key, value|
         self[key] = value
       end
 
-      self.body, self.status = body, status
-      self
+      self.body, self.status = new_body, status
+    end
+
+    def body=(obj)
+      if obj.respond_to?(:stat)
+        @length = obj.stat.size
+        @body = obj
+      elsif obj.respond_to?(:size)
+        @body = []
+        @length = 0
+        write(obj)
+      else
+        raise(ArgumentError, "Invalid body: %p" % obj)
+      end
     end
   end
 end

data/lib/ramaze/dispatcher.rb

@@ -14,10 +14,13 @@ module Ramaze
   # The Dispatcher receives requests from adapters and sets up the proper environment
   # to process them and respond.
 
-  module Dispatcher
+  class Dispatcher
+    def initialize(*args)
+      Dispatcher.call(*args)
+    end
 
     # requests are passed to every
-    FILTER = [ Dispatcher::File, Dispatcher::Action ] unless defined?(FILTER)
+    FILTER = OrderedSet[ Dispatcher::File, Dispatcher::Action, ]
 
     # Response codes to cache the output of for repeated requests.
     trait :shielded => [ STATUS_CODE["Not Found"] ]
@@ -28,7 +31,9 @@ module Ramaze
       # Entry point for Adapter#respond, takes a Rack::Request and
       # Rack::Response, sets up the environment and the goes on to dispatch
       # for the given path from rack_request.
-      def handle
+      #
+      # +env+ will be ignored, it's just for compatibility with rack middleware
+      def call(env = nil)
         path = request.path_info.squeeze('/')
         path.sub!(/^#{Regexp.escape(Global.prefix)}/, '/')
         path.squeeze!('/')
@@ -49,6 +54,7 @@ module Ramaze
       rescue Object => exception
         error(exception)
       end
+      alias handle call
 
       # protects against recursive dispatch and reassigns the path_info in the
       # request, the rest of the request is kept intact.

data/lib/ramaze/dispatcher/action.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Dispatcher
+  class Dispatcher
 
     # This dispatcher is responsible for relaying requests to Controller::handle
     # and filtering the results using FILTER.
@@ -26,8 +26,7 @@ module Ramaze
           log(path)
 
           catch(:respond) {
-            body = Controller.handle(path)
-            Response.current.build(body)
+            response.write Controller.handle(path)
           }
 
           FILTER.each{|f| f.call(response)}

data/lib/ramaze/dispatcher/directory.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Dispatcher
+  class Dispatcher
 
     # Generates a directory listing, see Ramaze::Controller::Directory for more
     # information and how to create your own directory listing page

data/lib/ramaze/dispatcher/error.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Dispatcher
+  class Dispatcher
 
     # Last resort dispatcher, tries to recover as much information as possible
     # from the past request and takes the appropiate actions.

data/lib/ramaze/dispatcher/file.rb

@@ -5,7 +5,7 @@ require "time"
 require 'digest/md5'
 
 module Ramaze
-  module Dispatcher
+  class Dispatcher
 
     # First of the dispatchers, looks up the public path and serves the
     # file if found.

data/lib/ramaze/helper/formatting.rb

@@ -104,6 +104,7 @@ module Ramaze
           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
@@ -121,5 +122,37 @@ module Ramaze
       text = string.each_byte.map{|c| "&#%03d" % c}.join
       %(<a href="mailto:#{string}">#{text}</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.count(tag)
+        result[tag] = ((count / total) * diff) + min
+      end
+
+      result
+    end
   end
 end

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