rango 0.1.1.2.10 → 0.1.1.2.11

data/CHANGELOG

@@ -33,3 +33,10 @@
   * Shebang is just ruby rather than ruby1.9, so it plays well with rvm
   * ImplicitRendering and ExplicitRendering mixins for using locals
     vs. rendering in context of current controller instance
+
+= Version 0.1.2, 10/12/2009, SHA1
+  * Sequel support
+  * Project generator renamed to stack generator
+  * Removed app and bigapp generators
+  * Added migration task for DataMapper
+  * Removed layer of ORM adapters

data/README.textile

@@ -31,11 +31,13 @@ rvm 1.9.1 ruby ./script/spec spec/rango/mixins/message_spec.rb
 h1. Documentation
 
 * "Wiki":http://wiki.github.com/botanicus/rango
+* Presentation "Introduction to Rango":http://www.slideshare.net/botanicus/rango
 * "Tutorial":http://wiki.github.com/botanicus/rango/tutorial
 * "RDoc.info API Docs":http://rdoc.info/projects/botanicus/rango
 * "Yardoc.org API Docs":http://yardoc.org/docs/botanicus-rango
 * "Examples":http://github.com/botanicus/rango-examples
 * "Bug reporting":http://github.com/botanicus/rango/issues
+* "Caliper Code Metrics":http://devver.net/caliper/project?repo=git%3A%2F%2Fgithub.com%2Fbotanicus%2Frango.git
 
 h1. Community
 

data/bin/rango

@@ -1,6 +1,10 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
+if RUBY_VERSION < "1.9.1"
+  abort "Rango requires at least Ruby 1.9.1. If you run JRuby, please ensure you used the --1.9 switch for JRuby command, for example jruby --1.9 -S rango create project blog"
+end
+
 base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
 libdir = File.expand_path(File.join(File.dirname(base), "..", "lib"))
 
@@ -34,12 +38,11 @@ def usage
 <<-HELP
 === Usage ===
 rango create project mycoolproject    Generate new site
-rango create app mycoolapp            Generate new application
 HELP
 end
 
 begin
-  ARGV.shift # create
+  ARGV.shift || usage # create
   generator_name = ARGV.shift
   SimpleTemplater.logger = Rango.logger
   templater = SimpleTemplater.new(:rango)

data/lib/rango.rb

@@ -1,104 +1,73 @@
 # encoding: utf-8
 
-require "ostruct"
-require "uri"
-require "media-path"
-require "rubyexts/logger"
-require "rango/mixins/application"
+if RUBY_VERSION < "1.9.1"
+  raise "Rango requires at least Ruby 1.9.1. If you run JRuby, please ensure you used the --1.9 switch for JRuby command."
+end
+
+require "rango/core_ext"
+require "rubyexts/attribute"
 
 rango_lib = File.dirname(__FILE__)
 unless $:.include?(rango_lib) || $:.include?(File.expand_path(rango_lib))
   $:.unshift(rango_lib)
 end
 
-if RUBY_VERSION < "1.9.1"
-  raise "Rango requires at least Ruby 1.9.1. If you run JRuby, please ensure you used the --1.9 switch for JRuby command, for example jruby --1.9 -S rango create project blog"
-end
-
 # It should solve problems with encoding in URL (flash messages) and templates
 Encoding.default_internal = "utf-8"
 
-module Rango
-  extend ApplicationMixin
-  def self.root
-    File.join(File.dirname(__FILE__), "rango")
-  end
-end
-
-require "rango/project"
-
 module Rango
   # all the helpers are in Rango::Helpers
   # so if you want to register your own, just
   # Rango::Helpers.send(:include, Pupu::Helpers)
   Helpers ||= Module.new
 
-  class << self
-    # @since 0.0.2
-    # @example
-    #   Rango.path
-    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
-    # @return [Path] Rango root path
-    def path
-      @path ||= MediaPath.new(self.root)
-    end
+  def self.root
+    File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  end
 
-    # @since 0.0.1
-    # @example
-    #   Rango.root
-    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
-    # @return [RubyExts::Logger] Logger for logging framework-related stuff. For logging project-relating stuff please use Project.logger.
-    # @see Project::logger
-    def logger
-      @logger ||= RubyExts::Logger.new
-    end
+  def self.lib_root
+    File.join(self.root, "lib")
+  end
 
-    # @since 0.0.1
-    # @example
-    #   Rango.boot # require init.rb
-    #   Rango.boot { require_relative "config/init.rb" } # custom boot
-    # @param [Hash] options You can specify flat: true for sinatra-like flat application.
-    # @return [Boolean] Returns true if boot succeed or false if not. If ARGV includes "-i", IRB interactive session will start.
-    def boot(options = Hash.new, &block)
-      self.environment = options[:environment] if options[:environment]
-      block.call if block_given?
-      self.bootloaders.each do |name, bootloader|
-        logger.debug "Calling bootloader #{name}"
-        bootloader.call
-      end
-    end
+  def self.logger
+    @@logger
+  rescue
+    raise NameError, "You have to assign a logger to Rango.logger"
+  end
 
-    # @since 0.0.2
-    def reboot(options = Hash.new)
-      self.boot(options.merge(force: true))
-    end
+  def self.logger=(logger)
+    require "rango/mixins/logger"
+    @@logger = logger.extend(LoggerMixin)
+  end
 
-    attribute :bootloaders, Hash.new
-    def after_boot(name, &block)
-      self.bootloaders[name] = block
+  # @since 0.0.1
+  # @example
+  #   Rango.boot # require init.rb
+  #   Rango.boot { require_relative "config/init.rb" } # custom boot
+  # @param [Hash] options You can specify flat: true for sinatra-like flat application.
+  # @return [Boolean] Returns true if boot succeed or false if not. If ARGV includes "-i", IRB interactive session will start.
+  def self.boot(options = Hash.new, &block)
+    self.environment = options[:environment] if options[:environment]
+    block.call if block_given?
+    self.bootloaders.each do |name, bootloader|
+      logger.debug "Calling bootloader #{name}"
+      bootloader.call
     end
+  end
 
-    # Rango.loaded?("environments.rb")
-    def loaded?(relative_path) # would work just with Kernel#require, not with Kernel#load, I know that the name may be misleading, but better than required?
-      full_path = File.expand_path(File.join(File.dirname(__FILE__), relative_path))
-      $LOADED_FEATURES.any? { |file| file == full_path }
-    end
+  # @since 0.0.2
+  def self.reboot(options = Hash.new)
+    self.boot(options.merge(force: true))
+  end
 
-    # Start IRB interactive session
-    # @since 0.0.1
-    def interactive
-      require "rango/utils"
-      require "rubyexts"
-      ARGV.delete("-i") # otherwise irb will read it
-      ENV["RACK_ENV"] = Rango.environment # for racksh
-      unless try_require("racksh/boot")
-        Rango.logger.info("For more goodies install racksh gem")
-        try_require "irb/completion" # some people can have ruby compliled without readline
-        Rango::Utils.load_rackup # so you can use Project.router etc
-      end
-      require "irb"
-      require "rango/utils"
-      IRB.start
-    end
+  attribute :bootloaders, Hash.new
+  def self.after_boot(name, &block)
+    self.bootloaders[name] = block
+  end
+
+  # Rango.loaded?("environments.rb")
+  def self.loaded?(relative_path) # would work just with Kernel#require, not with Kernel#load, I know that the name may be misleading, but better than required?
+    full_path = File.expand_path(File.join(File.dirname(__FILE__), relative_path))
+    $LOADED_FEATURES.any? { |file| file == full_path }
   end
 end

data/lib/rango/core_ext.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Kernel
+  # @since 0.1.1.3
+  # @example
+  #   try_require "term/ansicolor"
+  # @param [String] library Library to require.
+  # @return [Boolean] True if require was successful, false otherwise.
+  def try_require(library)
+    require library
+  rescue LoadError
+    return false
+  end
+
+  # @example require_gem "rubyexts", "rubyexts/logger"
+  def require_gem(gemname, library = gemname)
+    require library
+  rescue LoadError
+    raise LoadError, "You have to install #{gemname}!"
+  end
+end

data/lib/rango/gv/router.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require "rango/gv"
+require "rango/mini"
+
+# get("/").to(Rango::GV.defer do |request, response|
+#   if request.session[:user]
+#     LandingPages.dispatcher(:registered_user)
+#   else
+#     LandingPages.dispatcher(:unregistered_user)
+#   end
+# end)
+#
+# - redirect in router
+# - different action for iPhone vs. desktop
+module Rango
+  module GV
+    def self.defer(&hook)
+      Rango::Mini.app do |request, response|
+        value = hook.call(request, response)
+        if value.respond_to?(:call)
+          return value.call(request.env)
+        elsif value.is_a?(Array) && value.length.eql?(3)
+          return value # if we use redirect
+        else
+          raise "Value returned from Rango::GV.defer has to be Rack response or Rack application. Returned value: #{value.inspect}"
+        end
+      end
+    end
+
+    # Usher has support for redirect, but Rango doesn't depend on
+    # any particular router and your router might not provide this
+    # functionality. In this case you can always use this generic view.
+    # get("/index.php").to(Rango::GV.redirect("/"))
+    def self.redirect(url, status = 302)
+      Rango::Mini.app do |request, response|
+        response.redirect(url, status)
+        return String.new
+      end
+    end
+  end
+end

data/lib/rango/gv/scaffolding.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require "rango/gv"
+require "rango/mini"
+require "rango/mixins/render"
+
+require "rango" # Rango.root
+require "rango/project"
+Rango::Template.template_paths.push(File.join(Rango.root, "templates"))
+
+# NOTE: this is just proof of concept, do not use it so far!
+# However this is the way how we can use CRUD in Rango.
+module Rango
+  module GV
+    module Scaffolding
+      extend Rango::RenderMixin
+      def self.list(klass)
+        Rango::Mini.app do |request, response|
+          objects = klass.all
+          render "scaffolding/list.html", objects: objects
+        end
+      end
+
+      def self.show(klass)
+        Rango::Mini.app do |request, response|
+          object = klass.get(params[:id])
+          render "scaffolding/show.html", object: object
+        end
+      end
+
+      def self.new(klass)
+        Rango::Mini.app do |request, response|
+          render "scaffolding/new.html", object: klass.new
+        end
+      end
+
+      def self.create(klass, show_url)
+        Rango::Mini.app do |request, response|
+          klass.create!(params[:post])
+          response.redirect show_url
+        end
+      end
+
+      def self.destroy(klass, list_url)
+        Rango::Mini.app do |request, response|
+          object = klass.get(params[:id])
+          object.destroy
+          response.redirect list_url
+        end
+      end
+    end
+  end
+end

data/lib/rango/gv/static.rb

@@ -5,17 +5,16 @@ require "rango/mini"
 require "rango/mixins/render"
 
 module Rango
-  extend Rango::RenderMixin
   module GV
-    def self.static(template, locals = nil, &hook)
+    def self.static(template, scope = Object.new, context = Hash.new, &hook)
       Rango::Mini.app do |request, response|
         path = template || request.env["rango.router.params"][:template]
         path = hook.call(path) unless hook.nil?
         path = "#{path}.html" unless path.match(/\./)
         Rango.logger.debug("Rendering '#{path}'")
-        # Rango::RenderMixin.context
-        locals = locals.call(request) if locals.respond_to?(:call) # lambda { |request| {msg: request.message} }
-        render path, locals
+        # Rango::RenderMixin.scope
+        context = context.call(request) if context.respond_to?(:call) # lambda { |request| {msg: request.message} }
+        Rango::RenderMixin.render path, scope, context
       end
     end
 

data/lib/rango/interactive.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require "irb"
+require "rango/utils"
+require "rubyexts"
+
+# Start IRB interactive session
+# @since 0.0.1
+def Rango.interactive
+  ARGV.delete("-i") # otherwise irb will read it
+  ENV["RACK_ENV"] = Rango.environment # for racksh
+  unless try_require("racksh/boot")
+    Rango.logger.info("For more goodies install racksh gem")
+    try_require "irb/completion" # some people can have ruby compliled without readline
+    Rango::Utils.load_rackup # so you can use Project.router etc
+  end
+  IRB.start
+end

data/lib/rango/logger.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require "rango"
+require_gem "rubyexts", "rubyexts/logger"
+
+# @since 0.0.1
+# @example
+#   Rango.root
+#   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+# @return [RubyExts::Logger] Logger for logging framework-related stuff. For logging project-relating stuff please use Project.logger.
+# @see Project::logger
+def Rango.logger
+  @@logger ||= RubyExts::Logger.new
+end

data/lib/rango/mini.rb

@@ -1,16 +1,10 @@
 # encoding: utf-8
 
-# Rango::Mini is the most low-level part which can render
-# templates standalone. More low-level is only the RenderMixin.
-# See http://wiki.github.com/botanicus/rango/template-rendering
-
 require "rango/router"
-require "rango/mixins/render"
 require "rango/rack/request"
 
 module Rango
   module Mini
-    include Rango::RenderMixin
     extend self # so you can run Rango::Mini.app
     def app(&block)
       raise ArgumentError, "Block is required" unless block_given?

data/lib/rango/mini_render.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+# Rango::Mini is the most low-level part which can render
+# templates standalone. More low-level is only the RenderMixin.
+# See http://wiki.github.com/botanicus/rango/template-rendering
+
+require "rango/mini"
+require "rango/mixins/render"
+
+module Rango
+  module MiniRender
+    include Rango::Mini
+    include Rango::RenderMixin
+    extend self # so you can run Rango::MiniRender.app
+  end
+end

data/lib/rango/mixins/logger.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rango
+  module LoggerMixin
+    # 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
+  end
+end

data/lib/rango/mixins/message.rb

@@ -8,10 +8,10 @@ module Rango
     def self.included(controller)
       # How to determine
       # respond to not, it's a class
-      # if controller.instance_methods.include?(:locals)
+      # if controller.instance_methods.include?(:context)
       controller.class_eval do
-        def locals
-          @locals ||= super.merge!(message: self.message)
+        def context
+          @context ||= super.merge!(message: self.message)
         end
       end
     end