rango 0.0.3

data/lib/rango/contrib/pagination/adapters/datamapper.rb

@@ -0,0 +1,22 @@
+module DataMapper
+  module Resource
+    module ClassMethods
+      # @since 0.0.2
+      def paginate(pagenum = 1, options = Hash.new)
+        pagenum = 1 if pagenum.nil?
+        page = self.page(pagenum.to_i, options)
+        Page.current = page
+        offset = page.number(:db) * page.per_page
+        self.all(offset: offset, limit: page.per_page, order: [:updated_at.desc]).all(options)
+      end
+
+      # @since 0.0.2
+      def page(current, options = Hash.new)
+        per_page = defined?(PER_PAGE) ? PER_PAGE : 10
+        # the count options are very important
+        # Product.count vs. Product.count(online: true)
+        Page.new(current: current, count: self.count(options), per_page: per_page)
+      end
+    end
+  end
+end

data/lib/rango/contrib/pagination/helpers.rb

@@ -0,0 +1,12 @@
+class Rango
+  module Pagination
+    module PaginationMixin
+      # @since 0.0.2
+      def paginate(page = Page.current)
+        root = File.dirname(__FILE__)
+        template = File.join(root, "pagination")
+        partial template, page: page
+      end
+    end
+  end
+end

data/lib/rango/contrib/pagination/page.rb

@@ -0,0 +1,107 @@
+class Page
+  class << self
+    # @since 0.0.2
+    attr_writer :current
+
+    # @since 0.0.2
+    attr_accessor :route_hook
+
+    # @since 0.0.2
+    def current
+      Rango.logger.debug("Page initialized: #{@current.inspect}")
+      return @current
+    end
+
+    # Page.current = page # implicitly in datamapper.rb
+    # paginate Page.current
+
+    # register_route_hook do ... end
+    # OR
+    # register_route_hook method(:foo)
+    # @since 0.0.2
+    def register_route_hook(callable = nil, &block)
+      callable = (callable.nil? ? block : callable)
+      self.route_hook = callable
+    end
+
+    def route(request, page, int)
+      self.route_hook.call(request, page, int)
+    end
+  end
+
+  # @since 0.0.2
+  attr_accessor :number
+
+  # @since 0.0.2
+  attr_reader   :count, :per_page
+
+  # Page.new(params[:page], count, per_page)
+  #def initialize(current_page, count, per_page)
+  # @since 0.0.2
+  def initialize(params)
+    raise ArgumentError unless params.is_a?(Hash)
+    @count = params[:count].to_i || raise(ArgumentError, "params[:count] must be given")
+    @per_page = (params[:per_page] or 10).to_i
+    # can be nil
+    @number  = (params[:current].nil? ? 1 : params[:current].to_i)
+    @number  = 1   if @number < 1
+    @number  = max if @number > max
+  end
+
+  # NOTE: offset start as normal array from 0, but page from 1!
+  # @since 0.0.2
+  def number(type = :human)
+    case type
+    when :human then @number
+    # it can't be smaller than 0
+    when :db    then @number == 0 ? 0 : @number - 1
+    else raise ArgumentError
+    end
+  end
+
+  # Count of pages
+  # @since 0.0.2
+  def max
+    if @count % @per_page == 0
+      @max ||= (@count / @per_page)
+    else
+      @max ||= (@count / @per_page) + 1
+    end
+  end
+
+  # Current plus 1 or nil if it' the last page
+  # @since 0.0.2
+  def next
+    if @number < max
+      return Page.new(current: @number + 1, count: @count, per_page: @per_page)
+    end
+  end
+
+  # Current minus 1 or nil if it' the first page
+  # @since 0.0.2
+  def previous
+    if @number > 1
+      return Page.new(current: @number - 1, count: @count, per_page: @per_page)
+    end
+  end
+
+  # @since 0.0.2
+  def last
+    Page.new(current: max, count: @count, per_page: @per_page)
+  end
+
+  # @since 0.0.2
+  def first
+    Page.new(current: 1, count: @count, per_page: @per_page)
+  end
+
+  # @since 0.0.2
+  def first?
+    self.number == 1
+  end
+
+  # @since 0.0.2
+  def last?
+    self.number == max
+  end
+end

data/lib/rango/contrib/pagination/strategies.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+Rango.import("contrib/pagination/page")
+
+class Rango
+  module Pagination
+    class Strategy
+      # @since 0.0.2
+      def self.activate
+        Page.register_route_hook(self.new.method(:hook))
+        #Page.register_route_hook do |request, page|
+        #  self.new.hook(request, page)
+        #end
+      end
+    end
+
+    module Strategies
+      class Default < Rango::Pagination::Strategy
+        # @since 0.0.2
+        def hook(request, from, page)
+          return "?page=#{page}"
+        end
+      end
+
+      class PageNumberOnTheEndOfRoute < Rango::Pagination::Strategy
+        # @since 0.0.2
+        def hook(request, from, page)
+          # /products/1
+          return File.join(File.split(request.url)[0..-2].push(page.to_s))
+        end
+      end
+
+      class PageNumberOnTheEndOfRouteExcludeFirstPage < Rango::Pagination::Strategy
+        # Here is terrible important the from parameter
+        # @since 0.0.2
+        def hook(request, from, page)
+          if from.number.eql?(1)
+            # /products
+            File.join(request.url, page.to_s)
+          elsif page.eql?(1) && ! from.number.eql?(1)
+            File.join((request.url)[0..-2]).chomp("/")
+          else
+            # /products/2
+            return PageNumberOnTheEndOfRoute.new.hook(request, from, page)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rango/contrib/syndication.rb

@@ -0,0 +1 @@
+# coding: utf-8

data/lib/rango/exceptions.rb

@@ -0,0 +1,269 @@
+# coding: utf-8
+
+require "erb"
+require "extlib"
+
+# TODO: documentation
+# TODO: specs
+class SettingsNotFound < StandardError
+end
+
+class TemplateNotFound < StandardError
+  # @since 0.0.2
+  attr_accessor :message
+
+  # @since 0.0.2
+  def initialize(template, locations)
+    self.message = "Template '#{template}' wasn't found in any of these locations: #{locations.join(", ")}."
+  end
+end
+
+# @since 0.0.1
+class AnyStrategyMatched < StandardError
+end
+
+# @since 0.0.2
+class SkipFilter < StandardError
+end
+
+# @since 0.0.2
+class SkipRoute < StandardError
+end
+
+# superclass of all the controller exceptions
+class Rango
+  module HttpExceptions
+    class HttpError < StandardError
+      # @since 0.0.1
+      attr_accessor :status, :params
+
+      # @since 0.0.1
+      def initialize(status, params = nil)
+        self.status = status
+        self.params = params
+      end
+
+      # @since 0.0.1
+      def headers
+        {'Content-Type' => 'text/html'}
+      end
+
+      # @since 0.0.1
+      def render
+        content = Rango.path.join("../../templates/errors/#{self.status}.html.erb").read
+        ERB.new(content).result(binding)
+      end
+
+      # @since 0.0.1
+      def call(env)
+        return [self.status, self.headers, self.body]
+      end
+    end
+
+    class Error404 < HttpError
+      # @since 0.0.1
+      attr_accessor :params
+
+      # @since 0.0.1
+      def initialize(params = nil)
+        super("404")
+      end
+
+      # @since 0.0.1
+      def body
+        @routes = Project.router.routes
+        @router = Project.settings.router
+        @path   = "TODO" # or maybe rack env ... THIS SHOULD BE IMPLEMENTED AS RACK MIDDLEWARE
+        self.render
+      end
+    end
+
+    class Error406 < HttpError
+      # @since 0.0.1
+      attr_accessor :params
+
+      # @since 0.0.1
+      def initialize(params)
+        super("406")
+      end
+
+      # @since 0.0.1
+      def body
+        self.render
+      end
+    end
+
+    class Error500 < HttpError
+      # @since 0.0.1
+      attr_accessor :exception, :params
+
+      # @since 0.0.1
+      def initialize(exception, params)
+        super("500")
+        self.exception = exception
+        self.params = params
+      end
+
+      # @since 0.0.1
+      def body
+        self.render
+        # ["<h1>#{exception.message}</h2>", '@exception.bactrace.join("<br />")']
+      end
+    end
+  end
+end
+
+
+# stolen from merb
+
+class Rango
+  module HttpExceptions
+    STATUS_CODES = {}
+    class Base < StandardError #:doc:
+
+      # === Returns
+      # Integer:: The status-code of the error.
+      #
+      # @overridable
+      # :api: plugin
+      def status; self.class.status; end
+      alias :to_i :status
+
+      class << self
+
+        # Get the actual status-code for an Exception class.
+        #
+        # As usual, this can come from a constant upwards in
+        # the inheritance chain.
+        #
+        # ==== Returns
+        # Fixnum:: The status code of this exception.
+        #
+        # :api: public
+        def status
+          const_get(:STATUS) rescue 0
+        end
+        alias :to_i :status
+
+        # Set the actual status-code for an Exception class.
+        #
+        # If possible, set the STATUS constant, and update
+        # any previously registered (inherited) status-code.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        #
+        # ==== Returns
+        # (Integer, nil):: The status set on this exception, or nil if a status was already set.
+        #
+        # :api: private
+        def status=(num)
+          unless self.status?
+            register_status_code(self, num)
+            self.const_set(:STATUS, num.to_i)
+          end
+        end
+
+        # See if a status-code has been defined (on self explicitly).
+        #
+        # ==== Returns
+        # Boolean:: Whether a status code has been set
+        #
+        # :api: private
+        def status?
+          self.const_defined?(:STATUS)
+        end
+
+        # Registers any subclasses with status codes for easy lookup by
+        # set_status in Merb::Controller.
+        #
+        # Inheritance ensures this method gets inherited by any subclasses, so
+        # it goes all the way down the chain of inheritance.
+        #
+        # ==== Parameters
+        #
+        # subclass<Merb::ControllerExceptions::Base>::
+        #   The Exception class that is inheriting from Merb::ControllerExceptions::Base
+        #
+        # :api: public
+        def inherited(subclass)
+          # don't set the constant yet - any class methods will be called after self.inherited
+          # unless self.status = ... is set explicitly, the status code will be inherited
+          register_status_code(subclass, self.status) if self.status?
+        end
+
+        private
+
+        # Register the status-code for an Exception class.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        #
+        # :api: privaate
+        def register_status_code(klass, code)
+          name = self.to_s.split('::').last.snake_case
+          STATUS_CODES[name.to_sym] = code.to_i
+        end
+      end
+    end
+
+    # informational
+    class Informational               < Rango::HttpExceptions::Base; end
+    class Continue                    < Rango::HttpExceptions::Informational; self.status = 100; end
+    class SwitchingProtocols          < Rango::HttpExceptions::Informational; self.status = 101; end
+
+    # successful
+    class Successful                  < Rango::HttpExceptions::Base; end
+    class OK                          < Rango::HttpExceptions::Successful; self.status = 200; end
+    class Created                     < Rango::HttpExceptions::Successful; self.status = 201; end
+    class Accepted                    < Rango::HttpExceptions::Successful; self.status = 202; end
+    class NonAuthoritativeInformation < Rango::HttpExceptions::Successful; self.status = 203; end
+    class NoContent                   < Rango::HttpExceptions::Successful; self.status = 204; end
+    class ResetContent                < Rango::HttpExceptions::Successful; self.status = 205; end
+    class PartialContent              < Rango::HttpExceptions::Successful; self.status = 206; end
+
+    # redirection
+    class Redirection                 < Rango::HttpExceptions::Base; end
+    class MultipleChoices             < Rango::HttpExceptions::Redirection; self.status = 300; end
+    class MovedPermanently            < Rango::HttpExceptions::Redirection; self.status = 301; end
+    class MovedTemporarily            < Rango::HttpExceptions::Redirection; self.status = 302; end
+    class SeeOther                    < Rango::HttpExceptions::Redirection; self.status = 303; end
+    class NotModified                 < Rango::HttpExceptions::Redirection; self.status = 304; end
+    class UseProxy                    < Rango::HttpExceptions::Redirection; self.status = 305; end
+    class TemporaryRedirect           < Rango::HttpExceptions::Redirection; self.status = 307; end
+
+    # client error
+    class ClientError                 < Rango::HttpExceptions::Base; end
+    class BadRequest                  < Rango::HttpExceptions::ClientError; self.status = 400; end
+    class MultiPartParseError         < Rango::HttpExceptions::BadRequest; end
+    class Unauthorized                < Rango::HttpExceptions::ClientError; self.status = 401; end
+    class PaymentRequired             < Rango::HttpExceptions::ClientError; self.status = 402; end
+    class Forbidden                   < Rango::HttpExceptions::ClientError; self.status = 403; end
+    class NotFound                    < Rango::HttpExceptions::ClientError; self.status = 404; end
+    class ActionNotFound              < Rango::HttpExceptions::NotFound; end
+    class TemplateNotFound            < Rango::HttpExceptions::NotFound; end
+    class LayoutNotFound              < Rango::HttpExceptions::NotFound; end
+    class MethodNotAllowed            < Rango::HttpExceptions::ClientError; self.status = 405; end
+    class NotAcceptable               < Rango::HttpExceptions::ClientError; self.status = 406; end
+    class ProxyAuthenticationRequired < Rango::HttpExceptions::ClientError; self.status = 407; end
+    class RequestTimeout              < Rango::HttpExceptions::ClientError; self.status = 408; end
+    class Conflict                    < Rango::HttpExceptions::ClientError; self.status = 409; end
+    class Gone                        < Rango::HttpExceptions::ClientError; self.status = 410; end
+    class LengthRequired              < Rango::HttpExceptions::ClientError; self.status = 411; end
+    class PreconditionFailed          < Rango::HttpExceptions::ClientError; self.status = 412; end
+    class RequestEntityTooLarge       < Rango::HttpExceptions::ClientError; self.status = 413; end
+    class RequestURITooLarge          < Rango::HttpExceptions::ClientError; self.status = 414; end
+    class UnsupportedMediaType        < Rango::HttpExceptions::ClientError; self.status = 415; end
+    class RequestRangeNotSatisfiable  < Rango::HttpExceptions::ClientError; self.status = 416; end
+    class ExpectationFailed           < Rango::HttpExceptions::ClientError; self.status = 417; end
+
+    # server error
+    class ServerError                 < Rango::HttpExceptions::Base; end
+    class InternalServerError         < Rango::HttpExceptions::ServerError; self.status = 500; end
+    class NotImplemented              < Rango::HttpExceptions::ServerError; self.status = 501; end
+    class BadGateway                  < Rango::HttpExceptions::ServerError; self.status = 502; end
+    class ServiceUnavailable          < Rango::HttpExceptions::ServerError; self.status = 503; end
+    class GatewayTimeout              < Rango::HttpExceptions::ServerError; self.status = 504; end
+    class HTTPVersionNotSupported     < Rango::HttpExceptions::ServerError; self.status = 505; end
+  end
+end