rjspotter-ramaze 2009.06.29

data/lib/ramaze/helper/paginate.rb

@@ -0,0 +1,242 @@
+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
+      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',
+      }
+
+      # 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
+        helper :link, :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.join
+        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)
+          else
+            obj.paginate(@page, @limit)
+          end
+        end
+
+        def link(n, text = n, hash = {})
+          text = h(text.to_s)
+
+          action = Current.action
+          params = request.params.merge(@var.to_s => n)
+          hash[:href] = action.node.r(action.path, 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,100 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Helper
+
+    # = Helper::Partial
+    #
+    # Please note that this helper is deprecated in favor of # Helper::Render,
+    # it has been removed from Innate and remains in Ramaze until 2009.05.
+    #
+    # === 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 Partial
+      module_function
+
+      # Renders a url 'inline'.
+      #
+      # +url+      normal URL, like you'd use for redirecting.
+      # +options+  optional, will be used as request parameters.
+      #
+      # Issues a mock request to the given +url+ with +options+ turned into
+      # query arguments.
+      def render_partial(url, options = {})
+        Ramaze.deprecated('Helper::Partial#render_partial', 'Helper::Render#render_full')
+
+        uri = URI(url)
+        query = options # Innate::Current.request.params.merge(options)
+        uri.query = Rack::Utils.build_query(query)
+
+        body = nil
+
+        Innate::Mock.session do |session|
+          cookie = Innate::Current.session.cookie
+          session.cookie = cookie
+          body = session.get(uri.to_s, options).body
+        end
+
+        body
+      end
+
+      # Render the template file in view_root of the
+      # current controller.
+      #
+      # TODO:
+      # * Doesn't work for absolute paths, but there are no specs for that yet.
+      # * the local variable hack isn't working because innate allocates a new
+      #   binding.
+      #   For now one can simply use instance variables, which I prefer anyway.
+      #
+      # the local binding hack:
+      #
+      #   variables.each do |key, value|
+      #     value = "ObjectSpace._id2ref(#{value.object_id})"
+      #     eval "#{key} = #{value}", action.binding
+      #   end
+
+      def render_template(path, variables = {})
+        Ramaze.deprecated('Helper::Partial#render_template')
+        path = path.to_s
+
+        ext = File.extname(path)
+        basename = File.basename(path, ext)
+
+        action = Innate::Current.action.dup
+        action.layout    = nil
+        action.view      = action.node.find_view(basename, 'html')
+        action.method    = action.node.find_method(basename, action.params)
+
+        action.variables = action.variables.merge(variables)
+        action.sync_variables(action)
+
+        return action.call if action.valid?
+        raise(ArgumentError, "cannot render %p" % path)
+      end
+
+      def render_action(method, *params)
+        Ramaze.deprecated('Helper::Partial#render_action', 'Helper::Render#render_full')
+        render_partial(r(method), *params)
+      end
+    end
+  end
+end

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
+  end
+end

data/lib/ramaze/helper/request_accessor.rb

@@ -0,0 +1,16 @@
+module Ramaze
+  module Helper
+    module RequestAccessor
+      classes = [Rack::Request, Innate::Request, Ramaze::Request]
+      methods = classes.map{|klass| klass.instance_methods(false) }.flatten.uniq
+
+      methods.each do |method|
+        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
+  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/sequel_form.rb

@@ -0,0 +1,284 @@
+module Ramaze
+  module Helper
+    module SequelForm
+      # Pass it an object for your ORM and options for the <form> tag
+      # Usage:
+      #   sequel_form(User, :action => '/create')
+      #   sequel_form(Tag, :action => '/find', :method => 'post')
+      def sequel_form(object, options = {})
+        Ramaze::Form.pick(object, options)
+      end
+    end
+  end
+
+  class Form
+    attr_accessor :object, :options
+
+    YEARS, MONTHS, DAYS, HOURS, MINUTES, SECONDS =
+      (1900..2100), (1..12), (1..31), (0..23), (0..59), (0..59)
+
+    DATE_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ] ]
+
+    TIME_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ],
+      [ :hour,  HOURS ],
+      [ :min,   MINUTES ],
+      [ :sec,   SECONDS ] ]
+
+    # TODO:
+    #   How _elegant_ ...
+    #   Tries to find the right module for extending the Form instance.
+    #   It's problematic since the boundaries of what an model instance or model
+    #   class looks like is very fuzzy, also a problem is that the ORM may not be
+    #   available/required.
+    #
+    #   Maybe we can abstract that a bit by going through an array of procs for
+    #   testing?
+    def self.pick(object, options = {})
+      if defined?(Sequel::Model)
+        if object.is_a?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          InstanceForm.new(object, options)
+        elsif object.ancestors.include?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          ClassForm.new(object, options)
+        end
+      else
+        raise "Unknown ORM for: %p" % object
+      end
+    end
+
+    # Create new instance of Form plus the layer for the ORM
+    def initialize(object, options = {})
+      @object, @options = object, options
+      if layer = options.delete(:layer)
+        extend layer
+      end
+    end
+
+    # Generate and return the final form
+    def to_s
+      out = "<form #{form_attributes}>"
+      out << "<fieldset>"
+      out << generate
+      out << "</fieldset>"
+      out << '<input type="submit" />'
+      out << '<input type="reset" />'
+      out << "</form>"
+    end
+
+    # Decide on the strucuture of the tag based on the hash
+    def field_for(hash)
+      return if hash[:primary_key]
+      args = args_for(hash)
+
+      inner =
+        case type = hash[:type]
+        when :integer
+          field_integer(*args)
+        when :boolean
+          field_boolean(*args)
+        when :text
+          field_textarea(*args)
+        when :varchar
+          field_input(*args)
+        when :date
+          field_date(*args)
+        when :time
+          field_time(*args)
+        else
+          Log.warn "Unknown field: %p" % hash
+          field_input(*args)
+        end
+
+      "<label>#{args.first}: </label>\n#{inner}"
+    end
+
+    private
+
+    # inject to attributes for the <form>
+    def form_attributes
+      options.inject([]){|s,(k,v)| s << "#{k}='#{v}'" }.join(' ')
+    end
+
+    # Start tag with name and attributes
+    def start_tag(name, hash)
+      hash.inject("<#{name}"){|s,(k,v)| s << " #{k}='#{v}'" }
+    end
+
+    # Make a closed tag with name and attributes
+    def closed_tag(name, hash)
+      start_tag(name, hash) << ' />'
+    end
+
+    # Textarea with attributes from hash and the value from @object
+    def textarea(value, hash = {})
+      start_tag(:textarea, hash) << ">#{value}</textarea>"
+    end
+
+    # <input> with optional attributes from hash
+    def input(hash = {})
+      closed_tag(:input, hash)
+    end
+
+    # <input type="checkbox" with optional attributes from hash.
+    def checkbox(hash = {})
+      hash[:type] = :checkbox
+      input(hash)
+    end
+
+    # <option value="value"> with optional attributes from hash
+    def option(value, hash = {})
+      start_tag(:option, hash) << ">#{value}</option>"
+    end
+
+    # Yield method names and values for the Date instance
+    def field_date_generic
+      DATE_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Yield method names and values for the Time/DateTime instance
+    def field_time_generic
+      TIME_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Here go all the layers that are extended for specific ORMs
+    module Layer
+      # Layer for Sequel, only generate needs to be implemented, may change in
+      # future if we abstract more for different ORMs
+      module Sequel
+        # A bit nasty, get the @columns of the object and generate its
+        # field_for
+        def generate
+          columns = object_class.schema.instance_variable_get('@columns')
+          columns.map{|hash| field_for(hash) }.flatten.join("<br />\n")
+        end
+      end
+    end
+  end
+
+  # Form for the model class itself, very similar to an empty instance.
+  class ClassForm < Form
+    # <input name="name" />
+    def field_input(name)
+      input :name => name
+    end
+
+    # <textarea name="name"></textarea>
+    def field_textarea(name)
+      textarea '', :name => name
+    end
+
+    # <input name="name" />
+    def field_integer(name)
+      input :name => name
+    end
+
+    # <input type="checkbox" name="name" />
+    def field_boolean(name)
+      checkbox :name => name
+    end
+
+    # <select> with lots of <option>s
+    def field_date(name)
+      field_date_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # <select> with lots of <option>s
+    def field_time(name)
+      field_time_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # picks the :name
+    def args_for(hash)
+      [ hash[:name] ]
+    end
+
+    # Should be that way, at least for Sequel
+    def object_class
+      @object
+    end
+  end
+
+  # Form for instances of the model class
+  class InstanceForm < Form
+    # returns <input type='text' name='name' value='value' />
+    def field_input(name, value)
+      "<input type='text' name='#{name}' value='#{value}'/>"
+    end
+
+    # returns <textarea name='name'>#{value}</textarea>
+
+    def field_textarea(name, value)
+      "<textarea name='#{name}'>#{value}</textarea>"
+    end
+
+    # returns <input type="text" name="name" value="value" />
+
+    def field_integer(name, value)
+      field_input(name, value)
+    end
+
+    # <input type="checkbox" ...
+    def field_boolean(name, value)
+      if value
+        checkbox :name => name, :value => value, :checked => :checked
+      else
+        checkbox :name => name, :value => value
+      end
+    end
+
+    def field_date(name, value)
+      field_date_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def field_time(name, value)
+      field_time_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def option_range_selected(range, value)
+      range.map do |r|
+        if r == value
+          option(r, :value => r, :selected => :selected)
+        else
+          option(r, :value => r)
+        end
+      end
+    end
+
+    def args_for(hash)
+      name = hash[:name]
+      [ name, @object.send(name) ]
+    end
+
+    # Class for @object, atm Sequel specific?
+    def object_class
+      @object.class
+    end
+  end
+end