rango 0.0.4 → 0.0.6

data/CHANGELOG

@@ -1,8 +1,22 @@
-=== Version 0.0.1 Miracle Born ===
-Just basics
-
-=== Version 0.0.2 MVC Princess ===
-static files middleware
-MVC layer
-sessions, cookies
-integrated merb-auth
+= Version 0.0.1 Miracle Born
+  * Just basics
+
+= Version 0.0.2 MVC Princess
+  * static files middleware
+  * MVC layer
+  * sessions, cookies
+  * integrated merb-auth
+
+= Version 0.0.3
+
+= Version 0.0.4
+
+= Version 0.1
+  * [FEATURE] environments support
+  * [FEATURE] installation without RubyGems
+  * [FEATURE] Rip support
+  * [FEATURE] HTTP caching
+  * [FEATURE] Hooks for Rendering
+  * [SPECS]   Integration with RunCodeRun.com
+  * [SPECS]   All specs passing
+	* SimpleTemplater, RubyExts & CLI

data/README.textile

@@ -1,7 +1,7 @@
 h1. Installation
 
-* From RubyForge: @sudo gem install rango@
-* From GitHub: @sudo gem install botanicus-rango -s http://gems.github.com@
+* From RubyForge: @sudo gem install rango --development@
+* From Gemcutter: @sudo gem install rango -s http://gemcutter.org --development@
 
 h1. Documentation
 

data/Rakefile

@@ -0,0 +1,79 @@
+#!/usr/bin/env rake1.9
+# encoding: utf-8
+
+# http://support.runcoderun.com/faqs/builds/how-do-i-run-rake-with-trace-enabled
+Rake.application.options.trace = true
+
+task :setup => ["submodules:init"]
+
+namespace :submodules do
+  desc "Init submodules"
+  task :init do
+    sh "git submodule init"
+  end
+
+  desc "Update submodules"
+  task :update do
+    Dir["vendor/*"].each do |path|
+      if File.directory?(path) && File.directory?(File.join(path, ".git"))
+        Dir.chdir(path) do
+          puts "=> #{path}"
+          puts %x[git reset --hard]
+          puts %x[git fetch]
+          puts %x[git reset origin/master --hard]
+          puts
+        end
+      end
+    end
+  end
+end
+
+task :gem do
+  sh "gem build rango.gemspec"
+end
+
+namespace :gem do
+  task :prerelease do
+    require_relative "lib/rango"
+    gemspec = Dir["*.gemspec"].first
+    content = File.read(gemspec)
+    prename = "#{gemspec.split(".").first}.pre.gemspec"
+    version = Rango::VERSION.sub(/^(\d+)\.(\d+)\.\d+$/) { "#$1.#{$1.to_i + 1}" }
+    File.open(prename, "w") do |file|
+      file.puts(content.gsub(/(\w+::VERSION)/, "'#{version}.pre'"))
+    end
+    sh "gem build #{prename}"
+    rm prename
+  end
+end
+
+desc "Release new version of rango"
+task release: ["release:tag", "release:gemcutter"]
+
+namespace :release do
+  desc "Create Git tag"
+  task :tag do
+    require_relative "lib/rango"
+    puts "Creating new git tag #{Rango::VERSION} and pushing it online ..."
+    sh "git tag -a -m 'Version #{Rango::VERSION}' #{Rango::VERSION}"
+    sh "git push --tags"
+    puts "Tag #{Rango::VERSION} was created and pushed to GitHub."
+  end
+
+  desc "Push gem to Gemcutter"
+  task :gemcutter do
+    puts "Pushing to Gemcutter ..."
+    sh "gem push #{Dir["*.gem"].last}"
+  end
+  
+  desc "Create and push prerelease gem"
+  task :pre => ["gem:prerelease", :gemcutter]
+end
+
+desc "Run specs"
+task :default => :setup do
+  rubylib = (ENV["RUBYLIB"] || String.new).split(":")
+  libdirs = Dir["vendor/*/lib"]
+  ENV["RUBYLIB"] = (libdirs + rubylib).join(":")
+  exec "./script/spec --options spec/spec.opts spec"
+end

data/bin/rango

@@ -3,29 +3,61 @@
 
 base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
 libdir = File.expand_path(File.join(File.dirname(base), "..", "lib"))
-$:.unshift(libdir) unless $:.include?(libdir)
 
-def help(command, description, indentation = 40)
-  indentation = indentation - command.length
-  spaces = " " * indentation
-  STDERR.puts(command + spaces + description)
+vendor = File.join(File.dirname(__FILE__), "..", "vendor")
+if File.directory?(vendor)
+  Dir["#{vendor}/*"].each do |path|
+    if File.directory?(path) && Dir["#{path}/*"].empty?
+      warn "Dependency #{File.basename(path)} in vendor seems to be empty. Run git submodule init && git submodule update to checkout it."
+    elsif File.directory?(path) && File.directory?(File.join(path, "lib"))
+      $:.unshift(File.join(path, "lib"))
+    end
+  end
 end
 
-case command = ARGV.shift
-when "create"
-  # we can't use require_relative because it can be symlinked to
-  # /usr/bin or just be located in different place than we expect
-  require "rango/cli/generator"
-  Rango::CLI::Generator.new(*ARGV).create
-when "-i"
-  require "rango"
-  Rango.boot
-  Rango.interactive
-else
-  # TODO: Generators.each { |generator| puts generator.help }
-  STDERR.puts("=== Usage ===")
-  help "rango create project mycoolproject", "Generate new site"
-  help "rango create app mycoolapp", "Generate new application"
-  help "rango -i", "Start Rango console"
-  exit 1
+# because of system installation, there is bin/../lib, but not bin/../lib/rango
+if File.directory?(File.join(libdir, "rango"))
+  $:.unshift(libdir) unless $:.include?(libdir)
+end
+
+begin
+  require "simple-templater"
+rescue LoadError
+  abort "You have to install simple-templater first!"
+end
+
+require "rango"
+
+# === Helpers === #
+# TODO: Generators.each { |generator| puts generator.help }
+def usage
+<<-HELP
+=== Usage ===
+rango create project mycoolproject    Generate new site
+rango create app mycoolapp            Generate new application
+HELP
+end
+
+begin
+  ARGV.shift # create
+  generator_name = ARGV.shift
+  SimpleTemplater.logger = Rango.logger
+  templater = SimpleTemplater.new(:rango)
+  # This enables you to create custom generators for Rango
+  load File.join(File.dirname(base), "..", "simple-templater.scope") # neccesary if we run rango locally and not from RubyGems
+  templater.discover!
+  generator_set = templater.find(generator_name)
+  if generator_set.nil?
+    abort "Generator #{generator_name} doesn't exist. Available generators are: #{templater.generators.map { |set| set.name }.inspect}"
+  else
+    begin
+      generator_set.run(ARGV)
+    rescue SimpleTemplater::TargetAlreadyExist => exception
+      abort exception.message
+    rescue Interrupt
+      exit
+    rescue Exception => exception
+      abort "Exception #{exception.inspect} occured during running generator #{generator_set.inspect}\n#{exception.backtrace.join("\n")}"
+    end
+  end
 end

data/deps.rip

@@ -0,0 +1,8 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+git://github.com/botanicus/media-path.git
+git://github.com/botanicus/rubyexts.git
+git://github.com/botanicus/simple-templater.git
+git://github.com/rack/rack.git 1.0.1

data/lib/rango.rb

@@ -2,7 +2,8 @@
 
 require "ostruct"
 require "uri"
-require "path"
+require "media-path"
+require "rubyexts"
 
 rango_lib = File.dirname(__FILE__)
 unless $:.include?(rango_lib) || $:.include?(File.expand_path(rango_lib))
@@ -12,12 +13,11 @@ end
 # It should solve problems with encoding in URL (flash messages) and templates
 Encoding.default_internal = "utf-8"
 
-require_relative "rango/ext"
 require_relative "rango/mixins/import"
 require_relative "rango/mixins/application"
 
 module Rango
-  VERSION  ||= "0.0.4"
+  VERSION ||= "0.0.6"
   extend ImportMixin
   extend ApplicationMixin
 
@@ -26,7 +26,7 @@ module Rango
   end
 
   # realoder
-  # Rango.import("reloader")
+  # require "rango/reloader"
   # cattr_reader :reloader
   # @@reloader = Rango::Reloader.new
 end

data/lib/rango/boot.rb

@@ -1,15 +1,12 @@
 # encoding: utf-8
 
 # dependencies
-Rango.bundle "rango"
-Rango.dependency "rack"
-Rango.dependency "extlib"
+require "rack"
 
 # imports
-Rango.import("project")
-Rango.import("rack/request")
-Rango.import("helpers")
-Rango.import("router")
+require "rango/project"
+require "rango/rack/request"
+require "rango/router"
 
 # === Boot sequence:
 # 1) logger
@@ -32,13 +29,6 @@ end
 # can bypass loading of init.rb and ORM setup.
 # This is useful mostly for one file applications
 
-# Ruby Enterprise Edition doesn't support Ruby 1.9 yet, but when it will, we will ready
-if GC.respond_to?(:copy_on_write_friendly=)
-  GC.copy_on_write_friendly = true
-end
-
-# Rango.reloader.setup_signals
-
 module Rango
   class BootLoader
     def load_settings

data/lib/rango/contrib/pagination.rb

@@ -1,15 +1,13 @@
 # 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")
+require "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"}")
+require "rango/contrib/pagination/page"
+require "rango/contrib/pagination/strategies"
+require "rango/contrib/pagination/helpers"
+require "rango/contrib/pagination/adapters/#{Project.settings.orm || "datamapper"}"
 
-Rango.import("controller") # TODO: it should not works just with controller
-Rango::Controller.send(:include, Rango::Pagination::PaginationMixin)
+Rango::Helpers.send(:include, Rango::Pagination::PaginationMixin)
 # require code that must be loaded before the application
 
 # default route rule

data/lib/rango/contrib/pagination/README.textile

@@ -3,8 +3,8 @@ h1. About
 h1. Usage
 
 <pre>
-dependency "rango-haml"
-dependency "rango-pagination"
+require "haml"
+require "rango/contrib/pagination"
 </pre>
 
 <pre>

data/lib/rango/contrib/pagination/_pagination.html.haml

@@ -4,8 +4,8 @@
 / 6  7  8  9 10 <11> 12 13 14 15 16
 - unless page.max.eql?(1)
   - if page.previous
-    /= link_to "<< Předchozí", "?page=#{page.previous.number}"
-    != link_to "<< Předchozí", Page.route(request, page, page.previous.number)
+    /= link_to "<< Previous", "?page=#{page.previous.number}"
+    != link_to "<< Previous", Page.route(request, page, page.previous.number)
   - if page.max <= 11
     - (1..page.max).each do |pagenum|
       - if page.number.eql?(pagenum)
@@ -35,5 +35,5 @@
         /= link_to pagenum, "?page=#{pagenum}"
         != link_to pagenum, Page.route(request, page, pagenum)
   - if page.next
-    /= link_to "Další >>", "?page=#{page.next.number}"
-    != link_to "Další >>", Page.route(request, page, page.next.number)
+    /= link_to "Next >>", "?page=#{page.next.number}"
+    != link_to "Next >>", Page.route(request, page, page.next.number)

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

@@ -1,24 +1,23 @@
 # encoding: utf-8
 
 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
+  module Model
+    # @since 0.0.2
+    # @example Post.paginate(page, order: [:updated_at.desc])
+    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(options.merge!(offset: offset, limit: page.per_page))
+    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
+    # @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

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

@@ -9,6 +9,16 @@ module Rango
         template = File.join(root, "pagination")
         partial template, page: page
       end
+
+      # @since 0.0.7
+      def previous_page(text, page = Page.current)
+        link_to text, Page.route(request, page, page.previous.number)
+      end
+
+      # @since 0.0.7
+      def next_page(text, page = Page.current)
+        link_to text, Page.route(request, page, page.previous.number)
+      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
 # encoding: utf-8
-Rango.import("contrib/pagination/page")
+require "rango/contrib/pagination/page"
 
 module Rango
   module Pagination

data/lib/rango/controller.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-Rango.import("mixins/controller")
-Rango.import("helpers")
+require "rango/mixins/render"
+require "rango/helpers"
 
 module Rango
   class Controller
     include Rango::Helpers
-    include Rango::ControllerMixin
+    include Rango::RenderMixin
     include Rango::Templates::TemplateHelpers
 
     class << self
@@ -16,16 +16,17 @@ module Rango
       # @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
+        inherit_filters(subclass, :before)
+        inherit_filters(subclass, :after)
+        inherit_filters(subclass, :before_render)
+        inherit_filters(subclass, :after_render)
+        inherit_filters(subclass, :before_display)
+        inherit_filters(subclass, :after_display)
+      end
+
+      def inherit_filters(subclass, name)
+        subclass.send("#{name}_filters=", self.send("#{name}_filters").dup)
       end
 
       # before :login
@@ -40,37 +41,39 @@ module Rango
         self.after_filters[action || block] = options
       end
 
+      attribute :before_render_filters, Array.new
+      attribute :after_render_filters, Array.new
+
+      attribute :before_display_filters, Array.new
+      attribute :after_display_filters, Array.new
+
       # [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
+        method = env["rango.controller.action"].to_sym
         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)
+        begin
+          unless controller.respond_to?(method) # TODO: what about method_missing?
+            raise NotFound, "Controller #{self.name} doesn't have method #{method}"
+          end
+          controller.run_filters(:before, method.to_sym)
+          # If you don't care about arguments or if you prefer usage of params.
+          if controller.method(method).arity.eql?(0)
+            Rango.logger.debug("Calling method #{self.name}##{method} without arguments")
+            controller.response.body = controller.method(method).call
+          else
+            args = controller.params.values
+            Rango.logger.debug("Calling method #{self.name}##{method} with arguments #{args.inspect}")
+            controller.response.body = controller.method(method).call(*args)
+          end
+          controller.run_filters(:after, method)
+          return controller.response.finish
+        rescue HttpError => exception
+          controller.rescue_http_error(exception)
         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
@@ -85,19 +88,12 @@ module Rango
       # for routers
       def dispatcher(action)
         lambda do |env|
+          Rango.logger.info("Dispatching to #{self}##{action} [#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}]")
           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")
@@ -106,6 +102,7 @@ module Rango
 
     def initialize(request, params)
       @request = request
+      @response = Rack::Response.new
       @params  = params
       @cookies = request.cookies
       @session = request.session