rango 0.0.3

data/lib/rango/helpers/spec/time_dsl_spec.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "TimeDSL" do
+  it "Should do second/seconds" do
+    10.seconds.should == 10
+    1.second.should == 1
+  end
+
+  it "Should do minute/minutes" do
+    22.minutes.should == 22 * 60
+    1.minute.should == 60
+  end
+
+  it "Should do hour/hours" do
+    24.hours.should == 24 * 3600
+    1.hour.should == 3600
+  end
+
+  it "Should do day/days" do
+    7.days.should == 7 * 24 * 3600
+    1.day.should == 24 * 3600
+  end
+
+  it "Should do month/months" do
+    9.months.should == 9 * 30 * 24 * 3600
+    1.month.should == 30 * 24 * 3600
+  end
+
+  it "Should do year/years" do
+    3.years.should == 3 * 364.25 * 24 * 3600
+    1.year.should == 364.25 * 24 * 3600
+  end
+
+  it "Should do ago/until" do
+    5.seconds.ago.should be_close(Time.now - 5, 0.5)
+    8.minutes.until(3.minute.from_now).should be_close(3.minutes.from_now - 8 * 60, 0.5)
+  end
+
+  it "Should do from_now/since" do
+    3.seconds.from_now.should be_close(Time.now + 3, 0.5)
+    2.minutes.since(2.minutes.ago).should be_close(2.minutes.ago + 2 * 60, 0.5)
+  end
+end

data/lib/rango/helpers/syntax.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+class Rango
+  module Helpers
+    # @since 0.0.1
+    def textile(text)
+      require "redcloth"
+      RedCloth.new(text).to_html
+    end
+
+    # @since 0.0.1
+    def markdown(text)
+      require "bluecloth"
+    end
+
+    # @since 0.0.1
+    def maruku(text, options = Hash.new)
+      require "maruku"
+    end
+
+    # @since 0.0.1
+    def syntax(text, options = Hash.new)
+      require "syntax/convertors/html"
+      convertor = Syntax::Convertors::HTML.for_syntax(options[:language] || "ruby")
+      convertor.convert(text, false)
+    end
+  end
+end

data/lib/rango/loggers/fireruby.rb

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

data/lib/rango/loggers/logger.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+# TODO: documentation
+# TODO: specs
+require "logger"
+
+class Rango
+  class Logger < ::Logger
+    # @since 0.0.1
+    def initialize(output = STDERR)
+      super(output)
+      self.setup
+    end
+
+    # @since 0.0.1
+    def setup
+      self.level = ::Logger::DEBUG
+      self.datetime_format = "%H:%M:%S"
+      self.setup_format
+    end
+
+    # @since 0.0.1
+    def exception(exception)
+      self.error("#{exception.message} (#{exception.class})")
+      exception.backtrace.each do |line|
+        unless line.match(/thin|eventmachine/)
+          STDERR.puts("- #{line.colorize.cyan}")
+        end
+      end
+    end
+
+    # Logger methods can takes more arguments and they returns array with arguments
+    # NOTE: why we dup args each time? Because we colorize messages, but if logger method
+    # is used for handling requests, we just need to send noncolored messages as response.
+    # @since 0.0.1
+    def debug(*args)
+      original = args.dup
+      args.map { |arg| super(arg) }
+      return original
+    end
+
+    # @since 0.0.1
+    def info(*args)
+      original = args.dup
+      args.map { |arg| super(arg) }
+      return original
+    end
+
+    # @since 0.0.1
+    def warn(*args)
+      original = args.dup
+      args.map { |arg| super(arg) }
+      return original
+    end
+
+    # @since 0.0.1
+    def error(*args)
+      original = args.dup
+      args.map { |arg| super(arg) }
+      return original
+    end
+
+    # @since 0.0.1
+    def fatal(*args)
+      original = args.dup
+      args.map { |arg| super(arg) }
+      return original
+    end
+
+    # Project.logger.inspect(@posts, item)
+    # Project.logger.inspect("@post" => @post)
+    # @since 0.0.1
+    def inspect(*args)
+      if args.first.is_a?(Hash) && args.length.eql?(1)
+        args.first.each do |name, value|
+          self.debug("#{name}: #{value.inspect}")
+        end
+      else
+        args = args.map { |arg| arg.inspect }
+        self.debug(*args)
+      end
+    end
+
+    # @since 0.0.1
+    def setup_format
+      self.formatter = lambda do |severity, datetime, progname, msg|
+        # logger.debug(object_to_inspect)
+        msg = msg.inspect unless msg.is_a?(String)
+        datetime = datetime.strftime("[%H:%M:%S]")
+        case severity
+        when "DEBUG" then "#{datetime} #{msg.colorize.yellow}\n"
+        when "INFO"  then "#{datetime} #{msg.colorize.green}\n"
+        when "WARN"  then "#{datetime} #{msg.colorize.yellow}\n"
+        when "ERROR" then "#{datetime} #{msg.colorize.red}\n"
+        when "FATAL" then "#{datetime} #{msg.colorize.red.bold}\n"
+        end
+      end
+    end
+  end
+end

data/lib/rango/mixins/application.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+class Rango
+  module ApplicationMixin
+    include Rango::ImportMixin
+    # @since 0.0.1
+    # @see Path
+    # @return [Path] Path reprezentation of project root directory.
+    def path
+      Path.new(self.root)
+    end
+
+    # @since 0.0.1
+    # @return [String] Name of the project. Taken from basename of project directory.
+    def name
+      path.basename
+    end
+
+    # @since 0.0.1
+    # @return [Rango::Logger] Logger for project related stuff.
+    def logger
+      @logger ||= Rango::Logger.new
+    end
+  end
+end

data/lib/rango/mixins/configurable.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+class Rango
+  module Configurable
+    # @since 0.0.1
+    # @example
+    #   Project.configure do
+    #     self.property = "value"
+    #   end
+    # @yield [block] Block which will be evaluated in Project.setttings object.
+    # @return [Rango::Settings::Framework] Returns project settings.
+    def configure(&block)
+      self.settings.instance_eval(&block)
+    end
+
+    def customize(&block)
+      self.settings.instance_eval(&block)
+    end
+  end
+end

data/lib/rango/mixins/controller.rb

@@ -0,0 +1,113 @@
+# coding: utf-8
+
+# This mixin should be included to the all objects which are supposed to return response for Rack, so not just ControllerStrategy, but also CallableStrategy
+class Rango
+  module ControllerMixin
+    include Rango::HttpExceptions
+    # @since 0.0.1
+    # @return [Rango::Request]
+    # @see Rango::Request
+    attr_accessor :request, :params, :cookies, :response
+    # @since 0.0.1
+    # @return [Hash] Hash with params from request. For example <code>{messages: {success: "You're logged in"}, post: {id: 2}}</code>
+    attr_accessor :params
+
+    attribute :status
+    attribute :headers, Hash.new
+
+    # @since 0.0.1
+    # @return [Rango::Logger] Logger for logging project related stuff.
+    # @see Rango::Logger
+    attribute :logger, Project.logger
+
+    # The rails-style flash messages
+    # @since 0.0.2
+    def message
+      @message ||= (request.GET[:msg] || Hash.new)
+    end
+
+    # @since 0.0.2
+    def redirect(url, options = Hash.new)
+      self.status = 302
+
+      # for example ?msg[error]=foo
+      [:error, :success, :notice].each do |type|
+        if msg = (options[type] || message[type])
+          url.concat("?msg[#{type}]=#{msg}")
+        end
+      end
+
+      self.headers["Location"] = URI.escape(url)
+      return String.new
+    end
+
+    # Calls the capture method for the selected template engine.
+    #
+    # ==== Parameters
+    # *args:: Arguments to pass to the block.
+    # &block:: The block to call.
+    #
+    # ==== Returns
+    # String:: The output of a template block or the return value of a non-template block converted to a string.
+    #
+    # :api: public
+    def capture(*args, &block)
+      ret = nil
+
+      captured = send("capture_#{Project.settings.template_engine}", *args) do |*args|
+        ret = yield *args
+      end
+
+      # return captured value only if it is not empty
+      captured.empty? ? ret.to_s : captured
+    end
+
+    # Calls the concatenate method for the selected template engine.
+    #
+    # ==== Parameters
+    # str<String>:: The string to concatenate to the buffer.
+    # binding<Binding>:: The binding to use for the buffer.
+    #
+    # :api: public
+    def concat(str, binding)
+      self.send("concat_#{Project.settings.template_engine}", str, binding)
+    end
+
+    # view:
+    # render "index"
+    # template:
+    # extends "base.html" if layout
+    # This is helper can works as render layout: false for AJAX requests when you probably would like to render just the page without layout
+    def layout
+      request.ajax?
+    end
+
+    # RENDERING #
+    def template_location
+      # TODO
+    end
+
+    # TODO: default option for template
+    # @since 0.0.2
+    def render(template, locals = Hash.new)
+      Rango::Templates::Template.new(template, self, locals).render
+    end
+
+    # TODO: default option for template
+    # @since 0.0.2
+    def display(object, template, locals = Hash.new)
+      render(template)
+    rescue Error406
+      # TODO: provides API
+      format = Project.settings.mime_formats.find do |format|
+        object.respond_to?("to_#{format}")
+      end
+      format ? object.send("to_#{format}") : raise(Error406.new(self.params))
+    end
+
+    #
+    def autorender(locals = Hash.new)
+      self.__render__(template_location, locals)
+    end
+  end
+end

data/lib/rango/mixins/import.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+# boot: after rango.rb
+
+class Rango
+  # This mixin will be included also to project or your custom app main namespace
+  module ImportMixin
+    # class Project
+    #   extend Rango::ImportMixin
+    # end
+    def self.extended(base)
+      unless base.respond_to?(:root)
+        class << base
+          def root
+            File.dirname(caller[1].split(":").first)
+          end
+        end
+      end
+    end
+
+    # class Project
+    #   class << self
+    #     extend Rango::ImportMixin
+    #   end
+    # end
+    def self.included(base)
+      unless base.respond_to?(:root)
+        base.class_eval do
+          def root
+            File.dirname(caller.last.split(":").first)
+          end
+        end
+      end
+    end
+
+    # @since 0.0.1
+    # @example
+    #   Project.import("blog/views")
+    #   Project.import("blog/views", soft: true)
+    # @param [String] path Path to file which will be loaded using +Kernel#load+ if +Project.settings.debug+ is true or +Kernel#require+ if not.
+    # @param [Hash[soft: Boolean(default true)], @optional] options
+    # @raise [LoadError] Unless <tt>soft: true</tt> option is used, it will raise +LoadError+ if the file wasn't found.
+    # @return [Boolean] If loading suceed.
+    def import(path, options = Hash.new)
+      # it is better than rescue LoadError, because
+      # LoadError can be raise inside the required file
+      fullpath = self.find_absolute(path)
+      if fullpath.nil? && options[:soft]   # any file found and soft importing enabled
+        # do nothing
+      elsif fullpath.nil? && !options[:soft]            # any file found and soft importing disabled
+        raise LoadError, "File #{path.inspect} (treated as #{fullpath.inspect}) doesn't exist"
+      elsif !fullpath.nil?                     # the file was found
+        Kernel.load(fullpath)
+      elsif !fullpath.nil?                    # the file was found
+        Kernel.require(fullpath)
+      end
+    end
+
+    # @since 0.0.2
+    def import_first(paths, options = Hash.new)
+      paths.each do |path|
+        fullpath = self.find_absolute(path)
+        next if fullpath.nil?
+        return self.import(fullpath, options)
+      end
+      raise LoadError unless options[:soft]
+    end
+
+    # @since 0.0.1
+    # @param [String] path Path to loaded file.
+    # @return [Boolean] If the loading was successful.
+    def import!(path)
+      path = File.join(self.root, path)
+      file = self.find_absolute(path)
+      Kernel.load(file)
+    end
+
+    def find(file)
+      ["#{file}.rb", file].find do |file|
+        File.exist?(file)
+      end
+    end
+
+    def find_absolute(file)
+      file = File.join(self.root, file) unless file.match(%r[^/])
+      self.find(file)
+    end
+  end
+end

data/lib/rango/mixins/strategy.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+# Include this module to strategy superclass
+class Rango
+  module StrategyMixin
+    class << self
+      attribute :strategies, Array.new
+
+      def register
+        self.strategies.push(self)
+      end
+
+      def find(*args)
+        self.strategies.find { |strategy| strategy.match?(*args) }
+      end
+    end
+
+    def match?(*args)
+      raise "This method must be redefined in subclasses"
+    end
+
+    def run(*args)
+      raise "This method must be redefined in subclasses"
+    end
+
+    # define setup method if you need it
+  end
+end