rango 0.0.3 → 0.0.4

data/lib/rango/cli/templater.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+# I know, I know, we have Rubigen, Templater and others,
+# but Rango needs something really simple, so user can
+# start work immediately and can't study bloated docs
+
+require_gem_or_exit "erubis"
+
+require "fileutils"
+require "tempfile"
+require "find"
+
+# @since 0.0.3
+# @example
+#   Rango::CLI::Templater.create("my_generator_dir", user: "botanicus", constant: -> { |argv| argv.first.camel_case })
+module Rango
+  module CLI
+    class Templater
+      def self.create(*args)
+        templater = self.new(*args)
+        Rango.logger.debug("Context: #{templater.context.inspect}")
+        templater.create
+      end
+
+      attr_accessor :context
+      def initialize(content_dir, context = Hash.new)
+        @content_dir, @context = content_dir, context.reverse_merge(name: File.basename(Dir.pwd))
+      end
+
+      def create
+        Find.find(@content_dir) do |template|
+          file = self.expand_path(template)
+          next if template == @content_dir
+          if File.file?(template)
+            proceed_file(template, file)
+          else
+            unless Dir.exist?(file)
+              Rango.logger.debug("[MKDIR] #{file}")
+              FileUtils.mkdir_p(file)
+            end
+          end
+        end
+      end
+
+      protected
+      # replace %variable% in file path
+      # %name%_controller.rb => application_controller.rb
+      def expand_path(file)
+        file = self.location(file).sub(/\.rbt$/, "")
+        @context.each do |key, value|
+          file.gsub!(/%#{Regexp::quote(key)}%/, value.to_s)
+        end
+        return file
+      end
+
+      def location(file)
+        file.sub(%r[^#{Regexp::quote(@content_dir)}/?], "")
+      end
+
+      def proceed_file(template, file)
+        FileUtils.mkdir_p(File.dirname(file))
+        if template.end_with?(".rbt")
+          if File.exist?(file)
+            Rango.logger.debug("[RETEMPLATE] #{file} (from #{template})")
+          else
+            Rango.logger.debug("[TEMPLATE] #{file} (from #{template})")
+          end
+          File.open(file, "w") do |file|
+            eruby = Erubis::Eruby.new(File.read(template))
+            begin
+              output = eruby.evaluate(@context)
+            rescue Exception => exception
+              Rango.logger.error("Exception occured in template #{template}: #{exception.message}")
+            end
+            file.print(output)
+          end
+        else # just copy
+          if File.exist?(file)
+            Rango.logger.debug("[RECOPY] #{file} (from #{template})")
+            FileUtils.cp_f(template, file)
+          else
+            Rango.logger.debug("[COPY] #{file} (from #{template})")
+            FileUtils.cp(template, file)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rango/contrib/pagination.rb

@@ -1,12 +1,14 @@
-require "pathname" # TODO: it should be done in dm-aggregates
-Rango.dependency("dm-aggregates")
+# encoding: utf-8
+
+require "pathname" # TODO: it should be done in dm-aggregates # TODO 2: don't use this crappy shit at all!
+#Rango.dependency("dm-aggregates")
 
 Rango.import("contrib/pagination/page")
 Rango.import("contrib/pagination/strategies")
 Rango.import("contrib/pagination/helpers")
 Rango.import("contrib/pagination/adapters/#{Project.settings.orm || "datamapper"}")
 
-Rango.import("mvc/controller") # TODO: it should not works just with controller
+Rango.import("controller") # TODO: it should not works just with controller
 Rango::Controller.send(:include, Rango::Pagination::PaginationMixin)
 # require code that must be loaded before the application
 

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module DataMapper
   module Resource
     module ClassMethods

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

@@ -1,4 +1,6 @@
-class Rango
+# encoding: utf-8
+
+module Rango
   module Pagination
     module PaginationMixin
       # @since 0.0.2

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 class Page
   class << self
     # @since 0.0.2

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

@@ -1,7 +1,7 @@
-# coding: utf-8
+# encoding: utf-8
 Rango.import("contrib/pagination/page")
 
-class Rango
+module Rango
   module Pagination
     class Strategy
       # @since 0.0.2

data/lib/rango/contrib/syndication.rb

@@ -1 +1 @@
-# coding: utf-8
+# encoding: utf-8

data/lib/rango/controller.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+Rango.import("mixins/controller")
+Rango.import("helpers")
+
+module Rango
+  class Controller
+    include Rango::Helpers
+    include Rango::ControllerMixin
+    include Rango::Templates::TemplateHelpers
+
+    class << self
+      # @since 0.0.2
+      attribute :before_filters, Hash.new
+
+      # @since 0.0.2
+      attribute :after_filters,  Hash.new
+
+      # @since 0.0.2
+      attribute :autorendering, false
+
+      def inherited(subclass)
+        unless subclass.before_filters.empty? && subclass.after_filters.empty?
+          Rango.logger.debug("Inheritting filters from #{self.inspect} to #{subclass.inspect} (before: #{subclass.before_filters.inspect}, after: #{subclass.after_filters.inspect})")
+          subclass.before_filters = self.before_filters
+          subclass.after_filters = self.after_filters
+        end
+        subclass.autorendering = self.autorendering
+      end
+
+      # before :login
+      # before :login, actions: [:send]
+      # @since 0.0.2
+      def before(action = nil, options = Hash.new, &block)
+        self.before_filters[action || block] = options
+      end
+
+      # @since 0.0.2
+      def after(action = nil, options = Hash.new, &block)
+        self.after_filters[action || block] = options
+      end
+
+      # [master] Change Merb::Controller to respond to #call and return a Rack Array. (wycats)http://rubyurl.com/BhoY
+      # @since 0.0.2
+      def call(env)
+        Rango::Router.new.set_rack_env(env) # See rango/router/adapters/*
+        request = Rango::Request.new(env)
+        options = env["rango.router.params"] || raise("rango.router.params property has to be setup at least to empty hash")
+        method = options[:action] || :index
+        response = Rack::Response.new
+        controller = self.new(request, options.merge(request.params))
+        controller.response = response
+        Rango.logger.info("#{self.name}.call(env) with method #{method}")
+        # Rango.logger.inspect(before: ::Application.get_filters(:before), after: ::Application.get_filters(:after))
+        # Rango.logger.inspect(before: get_filters(:before), after: get_filters(:after))
+        controller.run_filters(:before, method.to_sym)
+        # If you don't care about arguments or if you prefer usage of params.
+        args = controller.params.map { |key, value| value }
+        if controller.method(method).arity.eql?(0)
+          Rango.logger.info("Calling method #{self.name}##{method} without arguments")
+          value = controller.method(method).call
+        else
+          Rango.logger.info("Calling method #{self.name}##{method} with arguments #{args.inspect}")
+          value = controller.method(method).call(*args)
+        end
+        controller.autorender if self.autorendering
+        controller.run_filters(:after, method)
+        response.body = proceed_value(value)
+        response.status = controller.status if controller.status
+        response.headers.merge!(controller.headers)
+        return response.finish
+      rescue HttpError => exception
+        rescue_http_error(exception)
+      end
+
+      # @experimental
+      def route_to(env, action, params = Hash.new)
+        env["rango.controller"] = self
+        env["rango.controller.action"] = action
+        env["rango.router.params"] = params
+        env["rango.action"] = action
+        Rango::Router::Dispatcher.route_to(env, self)
+      end
+
+      # for routers
+      def dispatcher(action)
+        lambda do |env|
+          env["rango.controller.action"] = action
+          return self.call(env)
+        end
+      end
+
+      def proceed_value(value)
+        case value
+        when true, false then value.to_s
+        when nil then String.new
+        else value
+        end
+      end
+
+      # @since 0.0.2
+      def get_filters(type)
+        self.send("#{type}_filters")
+      end
+    end
+
+    def initialize(request, params)
+      @request = request
+      @params  = params
+      @cookies = request.cookies
+      @session = request.session
+      Rango.logger.inspect(params: params, cookies: cookies, session: session)
+    end
+    attr_reader :session
+
+    def route_to(action, params = Hash.new)
+      self.class.route_to(request.env, action, params)
+    end
+
+    # redefine this method for your controller if you want to provide custom error pages
+    # returns response array for rack
+    # if you need to change just body of error message, define render_http_error method
+    # @api plugin
+    def rescue_http_error(exception)
+      if self.respond_to?(:render_http_error)
+        message = self.render_http_error(exception)
+        exception.message = message unless message.nil?
+      end
+      exception.to_response
+    end
+
+    # @since 0.0.2
+    def run_filters(name, method)
+      # Rango.logger.debug(self.class.instance_variables)
+      # Rango.logger.inspect(name: name, method: method)
+      self.class.get_filters(name).each do |filter_method, options|
+        unless options[:except] && options[:except].include?(method)
+          if filter_method.is_a?(Symbol) && self.respond_to?(filter_method)
+            Rango.logger.info("Calling filter #{filter_method} for controller #{self}")
+            self.send(filter_method)
+          elsif filter_method.respond_to?(:call)
+            Rango.logger.info("Calling filter #{filter_method.inspect} for controller #{self}")
+            self.instance_eval(&filter_method)
+          else
+            Rango.logger.error("Filter #{filter_method} doesn't exists!")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rango/exceptions.rb

@@ -1,12 +1,6 @@
-# coding: utf-8
+# encoding: utf-8
 
-require "erb"
-require "extlib"
-
-# TODO: documentation
-# TODO: specs
-class SettingsNotFound < StandardError
-end
+SettingsNotFound = Class.new(StandardError)
 
 class TemplateNotFound < StandardError
   # @since 0.0.2
@@ -19,251 +13,106 @@ class TemplateNotFound < StandardError
 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
+AnyStrategyMatched = Class.new(StandardError)
 
 # 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
+module Rango
+  class HttpError < StandardError
+    CONTENT_TYPE ||= "text/plain"
+
+    attr_accessor :content_type, :headers
+    def initialize(*args)
+      @headers = Hash.new
+      super(*args)
     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
+    def inspect
+      self.to_response.inspect
     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
+    # @returns [String]
+    # @example NotFound.new.to_snakecase # "not_found"
+    def to_snakecase
+      self.class.name.split("::").last.snake_case
     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
+    def status() self.class::STATUS end
+    def content_type
+      @content_type || self.class::CONTENT_TYPE
     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
+    def to_response
+      headers = self.headers.reverse_merge("Content-Type" => self.content_type)
+      [self.status, headers, [self.message]]
+    end
 
-        # 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
+    def self.const_missing(name)
+      if [:STATUS, :CONTENT_TYPE].include?(name)
+        raise NameError, "Every descendant of HttpError class has to have defined constant #{name}."
+      else
+        super(name)
       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
+
+  # http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+  # informational
+  class Informational               < Rango::HttpError; end
+  class Continue                    < Rango::Informational; STATUS ||= 100; end
+  class SwitchingProtocols          < Rango::Informational; STATUS ||= 101; end
+
+  # successful
+  class Successful                  < Rango::HttpError; end
+  class OK                          < Rango::Successful; STATUS ||= 200; end
+  class Created                     < Rango::Successful; STATUS ||= 201; end
+  class Accepted                    < Rango::Successful; STATUS ||= 202; end
+  class NonAuthoritativeInformation < Rango::Successful; STATUS ||= 203; end
+  class NoContent                   < Rango::Successful; STATUS ||= 204; end
+  class ResetContent                < Rango::Successful; STATUS ||= 205; end
+  class PartialContent              < Rango::Successful; STATUS ||= 206; end
+
+  # redirection
+  class Redirection                 < Rango::HttpError; end
+  class MultipleChoices             < Rango::Redirection; STATUS ||= 300; end
+  class MovedPermanently            < Rango::Redirection; STATUS ||= 301; end
+  class MovedTemporarily            < Rango::Redirection; STATUS ||= 302; end
+  class SeeOther                    < Rango::Redirection; STATUS ||= 303; end
+  class NotModified                 < Rango::Redirection; STATUS ||= 304; end
+  class UseProxy                    < Rango::Redirection; STATUS ||= 305; end
+  class TemporaryRedirect           < Rango::Redirection; STATUS ||= 307; end
+
+  # client error
+  class ClientError                 < Rango::HttpError; end
+  class BadRequest                  < Rango::ClientError; STATUS ||= 400; end
+  class MultiPartParseError         < Rango::BadRequest; end
+  class Unauthorized                < Rango::ClientError; STATUS ||= 401; end
+  class PaymentRequired             < Rango::ClientError; STATUS ||= 402; end
+  class Forbidden                   < Rango::ClientError; STATUS ||= 403; end
+  class NotFound                    < Rango::ClientError; STATUS ||= 404; end
+  class ActionNotFound              < Rango::NotFound; end
+  class TemplateNotFound            < Rango::NotFound; end
+  class LayoutNotFound              < Rango::NotFound; end
+  class MethodNotAllowed            < Rango::ClientError; STATUS ||= 405; end
+  class NotAcceptable               < Rango::ClientError; STATUS ||= 406; end
+  class ProxyAuthenticationRequired < Rango::ClientError; STATUS ||= 407; end
+  class RequestTimeout              < Rango::ClientError; STATUS ||= 408; end
+  class Conflict                    < Rango::ClientError; STATUS ||= 409; end
+  class Gone                        < Rango::ClientError; STATUS ||= 410; end
+  class LengthRequired              < Rango::ClientError; STATUS ||= 411; end
+  class PreconditionFailed          < Rango::ClientError; STATUS ||= 412; end
+  class RequestEntityTooLarge       < Rango::ClientError; STATUS ||= 413; end
+  class RequestURITooLarge          < Rango::ClientError; STATUS ||= 414; end
+  class UnsupportedMediaType        < Rango::ClientError; STATUS ||= 415; end
+  class RequestRangeNotSatisfiable  < Rango::ClientError; STATUS ||= 416; end
+  class ExpectationFailed           < Rango::ClientError; STATUS ||= 417; end
+
+  # server error
+  class ServerError                 < Rango::HttpError; end
+  class InternalServerError         < Rango::ServerError; STATUS ||= 500; end
+  class NotImplemented              < Rango::ServerError; STATUS ||= 501; end
+  class BadGateway                  < Rango::ServerError; STATUS ||= 502; end
+  class ServiceUnavailable          < Rango::ServerError; STATUS ||= 503; end
+  class GatewayTimeout              < Rango::ServerError; STATUS ||= 504; end
+  class HTTPVersionNotSupported     < Rango::ServerError; STATUS ||= 505; end
 end