rango 0.0.3

data/lib/rango/mvc/controller.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+Rango.import("templates/template")
+Rango.import("mixins/controller")
+
+class Rango
+  class Controller
+    include Rango::HttpExceptions
+    include Rango::Helpers
+    include Rango::ControllerMixin
+    include Rango::Templates::TemplateHelpers
+
+    extend Rango::Router::Dispatcher
+
+    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)
+        Rango.logger.debug("Inheritting filters from #{self.inspect} to #{subclass.inspect}")
+        subclass.before_filters = self.before_filters
+        subclass.after_filters = self.after_filters
+        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)
+        self.set_rack_env(env)
+        request = Rango::Request.new(env)
+        options = env["rango.router.params"]
+        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
+      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
+
+      def proceed_value(value)
+        case value
+        when true, false then value.to_s
+        when nil then String.new
+        else value
+        end
+      end
+
+      def controller?
+        true
+      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
+
+    # @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|
+        begin
+          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
+        rescue SkipFilter
+          Rango.logger.info("Skipping #{name} filter")
+          next
+        end
+      end
+    end
+  end
+end

data/lib/rango/mvc/strategies.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+class Rango
+  module RenderMixin
+  end
+end

data/lib/rango/orm/adapters/datamapper/fields.rb

@@ -0,0 +1,3 @@
+# coding: utf-8
+
+# TODO: slugfield, file, image etc

data/lib/rango/orm/adapters/datamapper/setup.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+Rango.dependency "dm-core", gem: true
+require_relative "support"
+
+begin
+  adapter = Project.settings.database_adapter
+  path = Project.settings.database_name
+  DataMapper.setup(:default, "#{adapter}://#{Project.root}/#{path}")
+rescue Exception => exception
+  Rango.logger.exception(exception)
+  Rango.logger.fatal("Database connection can't be established, exiting")
+  exit 1
+end
+
+Rango.logger.info("DataMapper started with database #{path}")

data/lib/rango/orm/adapters/datamapper/support.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+class Rango
+  class ORM
+    class DataMapper
+      class << self
+        def models
+          ObjectSpace.classes.map do |klass|
+            klass.included(DataMapper::Resource)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rango/orm/adapters/datamapper/tasks.thor

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require "rango/ext/thor"
+
+class Db < Rango::Tasks
+  def initialize(*args)
+    self.boot
+    super(*args)
+  end
+
+  # @since 0.0.2
+  desc "automigrate", "Automigrate the database. It will destroy all the data!"
+  def automigrate
+    unless Rango.debug && @opts[:force]
+      abort "You are in production environment. This operation will destroy all your data. If you are sure what you are doing, use thor db:automigrate --force"
+    end
+    Rango.logger.info("Migrating database #{Project.settings.database_name} ...")
+    result = DataMapper.auto_migrate!
+    Rango.logger.debug("Result: #{result.inspect}")
+  end
+
+  # @since 0.0.2
+  desc "autoupgrade", "Autoupgrade the database structure. Data should stay untouched."
+  def autoupgrade
+    Rango.logger.info("Upgrading database #{Project.settings.database_name} ...")
+    result = DataMapper.auto_upgrade!
+    Rango.logger.debug("Result: #{result.inspect}")
+  end
+
+  # @since 0.0.2
+  desc "migrate", "Run migrations."
+  def migrate
+  end
+
+  desc "report", "Report count of objects in database"
+  def report
+    Rango::ORM::DataMapper.models.each do |model_class|
+      puts "#{model_class}: #{model_class.count}"
+    end
+  end
+end

data/lib/rango/orm/adapters/datamapper/types/unicode_string.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+require "dm-core/type"
+
+module DataMapper
+  module Types
+    class UnicodeString < DataMapper::Type
+      primitive String
+
+      def self.load(value, property)
+        value.to_s.force_encoding("utf-8")
+      end
+    end
+  end
+end

data/lib/rango/project.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+Rango.import("settings")
+Rango.import("mixins/application")
+Rango.import("mixins/configurable")
+
+class Project
+  class << self
+    include Rango::ImportMixin
+    include Rango::ApplicationMixin
+    include Rango::Configurable
+    # @since 0.0.1
+    # @return [String] String reprezentation of project root directory.
+    root = attribute :root, Dir.pwd
+
+    # @since 0.0.1
+    # @return [Rango::Settings::Framework] Project settings.
+    attribute :settings, Rango::Settings::Framework.new
+
+    # @since 0.0.1
+    # @return [Rango::Router] Project main router.
+    attribute :router
+
+    def bundled?
+      @bundled ||= File.directory?(File.join(Project.root, "gems"))
+    end
+  end
+end

data/lib/rango/rack/dispatcher.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+require_relative "middlewares/encoding"
+
+class Rango::Dispatcher
+  class << self
+    def app
+      Rack::Builder.new do
+        use Rango::Middlewares::Encoding
+        use Rack::ContentLength
+        use Rack::MethodOverride # _method: put etc
+
+        # serve static files
+        if Project.settings.media_prefix
+          # use Rack::Static, :urls => ["/media"]
+          # will serve all requests beginning with /media from the "media" folder
+          # located in the current directory (ie media/*).
+
+          # use Rack::Static, :urls => ["/css", "/images"], :root => "public"
+          # will serve all requests beginning with /css or /images from the folder
+          # "public" in the current directory (ie public/css/* and public/images/*)
+          Rango.logger.info("Media files are available on #{Project.settings.media_prefix}")
+          options = {urls: [Project.settings.media_prefix]}
+          use Rack::Static, options
+        else
+          Rango.logger.info("Media files are routed directly to the /")
+          Rango.import("rack/middlewares/static.rb")
+          use Rango::Static
+        end
+
+        # cookies
+        use Rack::Session::Cookie, path: '/'
+        #, key: 'rack.session', domain: 'foo.com', path: '/', expire_after: 2592000, secret: 'change_me'
+
+        # use Rack::Reloader
+        run Rango::Dispatcher.new
+      end
+    end
+  end
+
+  attr_reader :request
+
+  # @since 0.0.2
+  def call(env)
+    request = Rango::Request.new(env)
+    route = Project.router.find(request.path)
+    return route.call(request)
+  rescue Rango::HttpExceptions::Error404 => exception
+    return [exception.status, exception.headers, exception.body]
+  # Let other error except 404 handle rack
+  # rescue Rango::HttpExceptions::HttpError => exception
+  #   return [exception.status, exception.headers, exception.body]
+  # rescue Exception => exception
+  #   Project.logger.exception(exception)
+  #   @body = ["<h1>#{exception.message}</h1>"]
+  #   exception.backtrace.each do |trace|
+  #     @body.push("<li>#{trace}</li>")
+  #   end
+  #   return ["500", headers, self.body]
+  end
+end

data/lib/rango/rack/middlewares/emails.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+# TODO: it can be in rack-contrib
+# @
+class EmailEscaper
+  # TODO: how to write after processing middleware?
+end

data/lib/rango/rack/middlewares/encoding.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+# rack seems to have problems with encoding, so this middleware enforce UTF-8 for all the strings in rack env
+class Rango
+  module Middlewares
+    class Encoding
+      def initialize(app, encoding = ::Encoding.default_external)
+        @app = app
+        @encoding = encoding
+      end
+
+      def call(env)
+        env.each do |key, value|
+          env[try_force_encoding(key)] = try_force_encoding(value)
+        end
+        return @app.call(env)
+      end
+
+      protected
+      def try_force_encoding(object)
+        object.respond_to?(:force_encoding) ? object.dup.force_encoding(@encoding) : object
+      end
+    end
+  end
+end

data/lib/rango/rack/middlewares/static.rb

@@ -0,0 +1,49 @@
+# stolen from rails
+require 'rack/utils'
+
+class Rango
+  class Static
+    FILE_METHODS = %w(GET HEAD).freeze
+
+    # @since 0.0.2
+    def initialize(app)
+      @app = app
+      @file_server = ::Rack::File.new(Project.settings.media_root)
+    end
+
+    # @since 0.0.2
+    def call(env)
+      path        = env['PATH_INFO'].chomp('/')
+      method      = env['REQUEST_METHOD']
+
+      prefix = Project.settings.media_prefix.chomp("/")
+      prefix_regexp = Regexp.new(%r[^#{prefix}/])
+      if path.match(prefix_regexp) && FILE_METHODS.include?(method)
+        if file_exist?(path)
+          return @file_server.call(env)
+          # else
+          # cached_path = directory_exist?(path) ? "#{path}/index" : path
+          # cached_path += ::ActionController::Base.page_cache_extension
+          #
+          # if file_exist?(cached_path)
+          #   env['PATH_INFO'] = cached_path
+          #   return @file_server.call(env)
+          # end
+        end
+      end
+
+      @app.call(env)
+    end
+
+    private
+    def file_exist?(path)
+      full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+      File.file?(full_path) && File.readable?(full_path)
+    end
+
+    def directory_exist?(path)
+      full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+      Dir.exist?(full_path) && File.readable?(full_path)
+    end
+  end
+end

data/lib/rango/rack/request.rb

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+# Rack env keys (localhost, url /test):
+# SERVER_SOFTWARE: thin 1.0.0 codename That's What She Said
+# rack.input: #<StringIO:0x44cb7c>
+# rack.version: [0, 3]
+# rack.errors: #<IO:<STDERR>>
+# rack.multithread: false
+# rack.multiprocess: false
+# rack.run_once: false
+# REQUEST_METHOD: GET
+# PATH_INFO: /test
+# PATH_INFO: /test
+# REQUEST_URI: /test
+# HTTP_VERSION: HTTP/1.1
+# HTTP_HOST: localhost:3000
+# HTTP_USER_AGENT: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.7) Gecko/2009021906 Firefox/3.0.7
+# HTTP_ACCEPT: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+# HTTP_ACCEPT_LANGUAGE: en-us,en;q=0.5
+# HTTP_ACCEPT_ENCODING: gzip,deflate
+# HTTP_ACCEPT_CHARSET: UTF-8,*
+# HTTP_KEEP_ALIVE: 300
+# HTTP_CONNECTION: keep-alive
+# HTTP_COOKIE: _session_id=BAh7CCIJdXNlciIbYWRtaW5AbWVnYXNhbW9sZXBreS5jeiIeYXV0aGVudGlj%250AYXRpb25fc3RyYXRlZ2llczAiDnJldHVybl90bzA%253D--e22dfc52e97832a60c396b743d03c1c48a4ca294
+# HTTP_X_FIRELOGGER: 0.3
+# GATEWAY_INTERFACE: CGI/1.2
+# SERVER_NAME: localhost
+# SERVER_PORT: 3000
+# QUERY_STRING:
+# SERVER_PROTOCOL: HTTP/1.1
+# rack.url_scheme: http
+# SCRIPT_NAME:
+# REMOTE_ADDR: 127.0.0.1
+
+# TODO: specs
+# http://rack.rubyforge.org/doc/
+# http://rack.rubyforge.org/doc/classes/Rack/Request.html
+
+class Rango
+  module Session
+  end
+
+  class Request < Rack::Request
+    # @since 0.0.1
+    # @return [Hash] Original Rack environment.
+    attr_reader :env
+
+    # @since 0.0.2
+    attribute :message, Hash.new
+
+    # @since 0.0.1
+    # @example: blog/post/rango-released
+    # @return [Hash] Original Rack environment.
+    attr_reader :path
+
+    # @since 0.0.1
+    # @param [Hash] env Rack environment.
+    def initialize(env)
+      @env  = env
+      # /path will be transformed to path/
+      @path = env["PATH_INFO"]
+      @path.chomp!("/") if @path.length > 1 # so let the / just if the path is only /
+      @method = env["REQUEST_METHOD"].downcase
+      self.extend_session
+    end
+
+    def GET
+      super.deep_symbolize_keys.except(:_method)
+    end
+
+    def POST
+      super.deep_symbolize_keys.except(:_method) if self.post?
+    end
+
+    def PUT
+      if self.put?
+        if @env["rack.request.form_input"].eql? @env["rack.input"]
+          @env["rack.request.form_hash"]
+        elsif form_data?
+          @env["rack.request.form_input"] = @env["rack.input"]
+          unless @env["rack.request.form_hash"] =
+              Utils::Multipart.parse_multipart(env)
+            @env["rack.request.form_vars"] = @env["rack.input"].read
+            @env["rack.request.form_hash"] = Utils.parse_query(@env["rack.request.form_vars"])
+            @env["rack.input"].rewind if @env["rack.input"].respond_to?(:rewind)
+          end
+          @env["rack.request.form_hash"].deep_symbolize_keys.except(:_method)
+        else
+          {}
+        end
+      end
+    end
+
+    def DELETE
+      {}.deep_symbolize_keys.except(:_method)
+    end
+
+    def params
+      @params = Hash.new
+      [self.GET, self.POST, self.PUT, self.DELETE].each do |data|
+        @params.merge!(data) if data.respond_to?(:merge) # Hash, Mash and friends
+      end
+      @params.deep_symbolize_keys.except(:msg, :_method)
+    end
+
+    def cookies
+      super.except("rack.session").symbolize_keys
+    end
+
+    def form
+      data = env["rack.request.form_hash"] || Hash.new
+      data.deep_symbolize_keys.except(:_method)
+    end
+
+    def session
+      # Rango.logger.inspect(session: @env['rack.session'])
+      @env['rack.session'] ||= {}
+    end
+
+    def ajax?
+      env["HTTP_X_REQUESTED_WITH"] == "XMLHttpRequest"
+    end
+
+    # TODO: use extend method
+    def extend_session
+      class << session
+        include Rango::Session
+      end
+    end
+
+    # @since 0.0.1
+    # @example: "cz"
+    # @return [String] Top level domain.
+    def tld
+      host.match(/^localhost/) ? nil : host.split(".").last
+    end
+
+    # @since 0.0.1
+    # @example: "101ideas.cz"
+    # @return [String] Domain name.
+    def domain
+      if host.match(/^localhost/)
+        return host.split(".").last
+      else
+        return host.split(".").last(2).join(".")
+      end
+    end
+
+    # @since 0.0.1
+    # @example: "blog" or "user.blog"
+    # @return [String] Subdomain name.
+    def subdomain
+      parts = host.split(".")
+      index = parts.index(self.domain)
+      parts[0..(index - 1)]
+    end
+
+    def base_url
+      require "uri"
+      fragments = URI.split("http://localhost:2000/foo/bar?q=foo")
+      fragments = fragments[0..4]
+      5.times { fragments.push(nil) }
+      URI::HTTP.new(*fragments).to_s
+    end
+  end
+end