rango 0.1.1.2.10 → 0.1.1.2.11

data/lib/rango/mixins/render.rb

@@ -8,11 +8,11 @@ module Rango
     extend self # so you can use Rango::RenderMixin.render
 
     # @since 0.0.2
-    def render(path, context = Object.new, locals = Hash.new)
-      context, locals = Object.new, context if locals.empty? && context.is_a?(Hash)
-      Rango.logger.inspect(locals: locals)
-      template = Rango::Templates::Template.new(path, context)
-      return template.render(locals)
+    def render(path, scope = Object.new, context = Hash.new)
+      scope, context = Object.new, scope if context.empty? && scope.is_a?(Hash)
+      Rango.logger.inspect(context: context)
+      template = Rango::Template.new(path, scope)
+      return template.render(context)
     end
   end
 end

data/lib/rango/mixins/rendering.rb

@@ -5,12 +5,12 @@ require "rango/mixins/render"
 module Rango
   module ExplicitRendering
     include Rango::RenderMixin
-    def render(template, locals = Hash.new)
-      super(template, self.context, self.locals.merge!(locals))
+    def render(template, context = Hash.new)
+      super(template, self.scope, self.context.merge!(context))
     end
 
     # class Posts < Rango::Controller
-    #   def context
+    #   def scope
     #     Object.new
     #   end
     #
@@ -22,29 +22,29 @@ module Rango
     # end
     #
     # Context for rendering templates
-    # This context will be extended by same crucial methods from template mixin
-    # We are in context of current controller by default
-    def context
+    # This scope will be extended by same crucial methods from template mixin
+    # We are in scope of current controller by default
+    def scope
       Object.new.extend(Rango::Helpers)
     end
 
     # def show
-    #   locals[:post] = Post.get(params[:id])
-    #   render "show.html", locals
+    #   context[:post] = Post.get(params[:id])
+    #   render "show.html", context
     # end
-    def locals
-      @locals ||= {request: self.request}
+    def context
+      @context ||= {request: self.request}
     end
   end
 
   module ImplicitRendering
     include Rango::RenderMixin
-    def context
+    def scope
       self
     end
 
-    def render(template) # so you can't specify locals
-      super template, self.context
+    def render(template) # so you can't specify context
+      super template, self.scope
     end
   end
 end

data/lib/rango/orm/README.textile

@@ -0,0 +1,24 @@
+h1. Kinds of Support
+
+h2. Core Support
+
+- Tasks for migrations, creating db etc
+
+h2. Extended Support
+
+- Custom fields (SlugField, ImageField etc)
+- Whatever else
+
+h1. Why not ...
+
+h2. Save Used ORM in Project.orm or somewhere?
+
+Because if you need have aditional support for each ORM, it's part of setup to put @load "myplugin/tasks.rake"@ to user's Rakefile etc, so there is no need for this.
+
+h2. Support @config/database.yml@
+
+Because it has no point. You can use API of your ORM directly.
+
+h2. Define @form_for@
+
+It's job of your helpers.

data/lib/rango/orm/tasks/datamapper.rake

@@ -3,9 +3,8 @@
 namespace :db do
   # @since 0.0.2
   desc "Automigrate the database. It will destroy all the data!"
-  task :automigrate, :environment do |task, args|
+  task :automigrate, :environment, :needs => :environment do |task, args|
     RANGO_ENV = args.environment || ENV["RANGO_ENV"] || "development"
-    Rake::Task[:environment].invoke
     Rango.logger.info("[#{Rango.environment}] Migrating databases ...")
     result = DataMapper.auto_migrate!
     Rango.logger.debug("Result: #{result.inspect}")
@@ -13,29 +12,56 @@ namespace :db do
 
   # @since 0.0.2
   desc "Autoupgrade the database structure. Data should stay untouched."
-  task :autupgrade, :environment do |task, args|
+  task :autupgrade, :environment, :needs => :environment do |task, args|
     RANGO_ENV = args.environment || ENV["RANGO_ENV"] || "development"
-    Rake::Task[:environment].invoke
     Rango.logger.info("[#{Rango.environment}] Upgrading databases ...")
     result = DataMapper.auto_upgrade!
     Rango.logger.debug("Result: #{result.inspect}")
   end
 
+  desc "Report count of objects in database"
+  task :report, :environment, :needs => :environment do |task, args|
+    RANGO_ENV = args.environment || ENV["RANGO_ENV"] || "development"
+    ObjectSpace.classes.each do |klass|
+      if klass.included(DataMapper::Resource)
+        puts "#{model_class}: #{model_class.count}"
+      end
+    end
+  end
+
   # @since 0.0.2
   desc "Run migrations"
-  task :migrate, :environment do |task, args|
+  task :migrate, :environment, :needs => :environment do |task, args|
     RANGO_ENV = args.environment || ENV["RANGO_ENV"] || "development"
-    Rake::Task[:environment].invoke
-    abort "This task isn't implemented so far! You might want to use db:automigrate or db:autoupgrade instead."
+    abort "Use rake db:migrate:up[version] or db:migrate:down[version]"
   end
 
-  desc "Report count of objects in database"
-  task :report, :environment do |task, args|
-    RANGO_ENV = args.environment || ENV["RANGO_ENV"] || "development"
-    Rake::Task[:environment].invoke
-    require "rango/orm/adapters/datamapper" # should be loaded in runtime, but isn't at the moment
-    Rango::ORM::Datamapper.models.each do |model_class|
-      puts "#{model_class}: #{model_class.count}"
+  namespace :migrate do
+    task :load => :environment do
+      begin
+        require "dm-migrations/migration_runner"
+      rescue LoadError
+        abort "You have to install dm-migrations gem for this!"
+      end
+      FileList["db/migrations/*.rb"].each do |migration|
+        load migration
+      end
+    end
+
+    # rake db:migrate:up[version]
+    # rake db:migrate:up[,environment]
+    desc "Migrate up using migrations"
+    task :up, :version, :environment, :needs => :load do |task, args|
+      version = args.version || ENV['VERSION']
+      raise ArgumentError, "You have to specify version!" if version.nil?
+      migrate_up!(version)
+    end
+
+    desc "Migrate down using migrations"
+    task :down, :version, :environment, :needs => :load do |task, args|
+      version = args.version || ENV['VERSION']
+      raise ArgumentError, "You have to specify version!" if version.nil?
+      migrate_down!(version)
     end
   end
 end

data/lib/rango/orm/tasks/sequel.rake

@@ -1,3 +1,23 @@
 # encoding: utf-8
 
-raise "Sequel isn't supported so far!"
+namespace :db do
+  desc "Perform migration using migrations in schema/migrations"
+  task :migrate, :version, :environment, :needs => :environment do |task, args|
+    require "sequel/extensions/migration"
+    version = args.version || (ENV["VERSION"].to_i unless ENV["VERSION"].nil?) || nil
+    Sequel::Migrator.apply(Sequel::Model.db, "db/migrations", version)
+  end
+
+  desc "Drop all tables"
+  task :drop_tables => :sequel_env do
+    Sequel::Model.db.drop_table *Sequel::Model.db.tables
+  end
+
+  desc "Drop all tables and perform migrations"
+  task :reset => [:sequel_env, :drop_tables, :migrate]
+
+  desc "Truncate all tables in database"
+  task :truncate => :sequel_env do
+    Sequel::Model.db << "TRUNCATE #{db.tables.join(', ')} CASCADE;"
+  end
+end

data/lib/rango/path.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require "rango"
+require_gem "media-path"
+
+# @since 0.0.2
+# @example
+#   Rango.path
+#   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+# @return [Path] Rango root path
+def Rango.path
+  @path ||= MediaPath.new(self.root)
+end

data/lib/rango/rack/request.rb

@@ -153,10 +153,14 @@ module Rango
     # @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)]
+    def subdomains(tld_length = 1) # we set tld_length to 1, use 2 for co.uk or similar
+      # cache the result so we only compute it once.
+      @env['rack.env.subdomains'] ||= begin
+        # check if the current host is an IP address, if so return an empty array
+        return [] if (host.nil? ||
+                      /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+        host.split('.')[0...(1 - tld_length - 2)] # pull everything except the TLD
+      end
     end
 
     def base_url

data/lib/rango/templates/helpers.rb

@@ -3,105 +3,103 @@
 require "rango"
 
 module Rango
-  module Templates
-    module TemplateHelpers
-      def self.extended(scope)
-        class << scope
-          attr_accessor :_template
-          # @example Capture being used in a .html.erb page:
-          #   <% @foo = capture do %>
-          #     <p>Some Foo content!</p>
-          #   <% end %>
-          #
-          # @params [*args]  Arguments to pass to the block.
-          # @params [&block] The template block to call.
-          # @return [String] The output of the block.
-          # @api private
-          def capture(*args, &block)
-            capture_method = "capture_#{self._template.adapter}"
-            if self.respond_to?(capture_method) # tilt doesn't support @_out_buf for haml
-              self.send("capture_#{self._template.adapter}", *args, &block)
-            else
-              # @_out_buf comes from tilt
-              unless self.instance_variable_defined?("@_out_buf")
-                raise "Adapter #{self._template.adapter} doesn't support capturing"
-              end
-              _old_buf, @_out_buf = @_out_buf, ""
-              block.call(*args)
-              @_out_buf = _old_buf.chomp.strip
+  module TemplateHelpers
+    def self.extended(scope)
+      class << scope
+        attr_accessor :_template
+        # @example Capture being used in a .html.erb page:
+        #   <% @foo = capture do %>
+        #     <p>Some Foo content!</p>
+        #   <% end %>
+        #
+        # @params [*args]  Arguments to pass to the block.
+        # @params [&block] The template block to call.
+        # @return [String] The output of the block.
+        # @api private
+        def capture(*args, &block)
+          capture_method = "capture_#{self._template.adapter}"
+          if self.respond_to?(capture_method) # tilt doesn't support @_out_buf for haml
+            self.send("capture_#{self._template.adapter}", *args, &block)
+          else
+            # @_out_buf comes from tilt
+            unless self.instance_variable_defined?("@_out_buf")
+              raise "Adapter #{self._template.adapter} doesn't support capturing"
             end
+            _old_buf, @_out_buf = @_out_buf, ""
+            block.call(*args)
+            @_out_buf = _old_buf.chomp.strip
           end
+        end
 
-          def concat(string)
-            concat_method = "concat_#{self._template.adapter}"
-            if self.respond_to?(concat_method) # tilt doesn't support @_out_buf for haml
-              self.send("concat_#{self._template.adapter}", string)
-            else
-              # @_out_buf comes from tilt
-              unless self.instance_variable_defined?("@_out_buf")
-                raise "Adapter #{self._template.adapter} doesn't support concating"
-              end
-              @_out_buf << string
+        def concat(string)
+          concat_method = "concat_#{self._template.adapter}"
+          if self.respond_to?(concat_method) # tilt doesn't support @_out_buf for haml
+            self.send("concat_#{self._template.adapter}", string)
+          else
+            # @_out_buf comes from tilt
+            unless self.instance_variable_defined?("@_out_buf")
+              raise "Adapter #{self._template.adapter} doesn't support concating"
             end
+            @_out_buf << string
           end
         end
       end
+    end
 
-      def self.included(scope_class)
-        scope_class.class_eval { attr_accessor :_template}
-      end
+    def self.included(scope_class)
+      scope_class.class_eval { attr_accessor :_template}
+    end
 
-      # post/show.html: it's block is the block we like to see in output
-      # post/base.html
-      # base.html: here it will be rendered, so we need block to returns the correct block code
-      # @since 0.0.2
-      def block(name, value = nil, &block)
-        value = self._template.scope.capture(&block) if value.nil? && block
-        self._template.blocks[name] ||= value
-        return self._template.blocks[name]
-      end
+    # post/show.html: it's block is the block we like to see in output
+    # post/base.html
+    # base.html: here it will be rendered, so we need block to returns the correct block code
+    # @since 0.0.2
+    def block(name, value = nil, &block)
+      value = self._template.scope.capture(&block) if value.nil? && block
+      self._template.blocks[name] ||= value
+      return self._template.blocks[name]
+    end
 
-      # - extend_block(:head) do
-      #   != pupu :lighter, syntax: "html", theme: "standard"
-      #   != block(:head)
-      #
-      # TODO: something more intuitive like:
-      # - block(:head) do
-      #   != pupu :lighter, syntax: "html", theme: "standard"
-      #   != block(:head)
-      #
-      # OR even:
-      # - block(:head) do
-      #   != pupu :lighter, syntax: "html", theme: "standard"
-      #   = superblock
-      def extend_block(name, value = nil, &block)
-        value = self._template.scope.capture(&block) if value.nil? && block
-        self._template.blocks[name] += value
-        return self._template.blocks[name]
-      end
+    # - extend_block(:head) do
+    #   != pupu :lighter, syntax: "html", theme: "standard"
+    #   != block(:head)
+    #
+    # TODO: something more intuitive like:
+    # - block(:head) do
+    #   != pupu :lighter, syntax: "html", theme: "standard"
+    #   != block(:head)
+    #
+    # OR even:
+    # - block(:head) do
+    #   != pupu :lighter, syntax: "html", theme: "standard"
+    #   = superblock
+    def extend_block(name, value = nil, &block)
+      value = self._template.scope.capture(&block) if value.nil? && block
+      self._template.blocks[name] += value
+      return self._template.blocks[name]
+    end
 
-      # partial "products/list"
-      # @since 0.0.2
-      def partial(template, locals = Hash.new)
-        if template.match(%r[/])
-          path, last = File.split(template)[0..-1]
-          template = File.join(path, "_#{last}")
-        else
-          template = "_#{template}"
-        end
-        template = Rango::Templates::Template.new(template, self._template.scope, locals)
-        template.partial = true
-        # TODO: #block in partial templates
-        output = template.render
-        return output
+    # partial "products/list"
+    # @since 0.0.2
+    def partial(template, context = Hash.new)
+      if template.match(%r[/])
+        path, last = File.split(template)[0..-1]
+        template = File.join(path, "_#{last}")
+      else
+        template = "_#{template}"
       end
+      template = Rango::Template.new(template, self._template.scope, context)
+      template.partial = true
+      # TODO: #block in partial templates
+      output = template.render
+      return output
+    end
 
-      # extends "base.html"
-      # @since 0.0.2
-      def extends(path)
-        # we can't just create a new template, because it has to do it after it reads the whole file
-        self._template.supertemplate = path
-      end
+    # extends "base.html"
+    # @since 0.0.2
+    def extends(path)
+      # we can't just create a new template, because it has to do it after it reads the whole file
+      self._template.supertemplate = path
     end
   end
 end

data/lib/rango/templates/template.rb

@@ -3,6 +3,7 @@
 require "rango/templates/exts/tilt"
 require "rubyexts/attribute"
 require "rubyexts/string" # String#snake_case
+require "rubyexts/class" # cattr_accessor
 require "rango/templates/helpers"
 require "rango/exceptions"
 
@@ -11,70 +12,66 @@ module Rango
     TemplateNotFound = Class.new(NotFound)
   end
 
-  module Templates
-    class Template
-      # template -> supertemplate is the same relationship as class -> superclass
-      # @since 0.0.2
-      attr_accessor :path, :scope, :supertemplate
+  class Template
+    cattr_accessor :template_paths
 
-      # @since 0.0.2
-      attribute :blocks, Hash.new
+    # template -> supertemplate is the same relationship as class -> superclass
+    # @since 0.0.2
+    attr_accessor :path, :scope, :supertemplate
 
-      # @since 0.0.2
-      def initialize(path, scope = Object.new)
-        self.path    = path#[scope.class.template_prefix.chomp("/"), template].join("/")
-        self.scope = scope.extend(TemplateHelpers)
-        self.scope._template = self
-      end
+    # @since 0.0.2
+    attribute :blocks, Hash.new
 
-      # @since 0.0.2
-      def fullpath
-        @fullpath ||= begin
-          if self.path.match(/^(\/|\.)/) # /foo or ./foo
-            Dir[self.path, "#{self.path}.*"].first
-          else
-            self.find_in_template_dirs
-          end
-        end
-      end
+    # @since 0.0.2
+    def initialize(path, scope = Object.new)
+      self.path    = path#[scope.class.template_prefix.chomp("/"), template].join("/")
+      self.scope = scope.extend(TemplateHelpers)
+      self.scope._template = self
+    end
 
-      def adapter
-        self.template.class.name.split("::").last.snake_case.sub("_template", "")
+    # @since 0.0.2
+    def fullpath
+      @fullpath ||= begin
+        if self.path.match(/^(\/|\.)/) # /foo or ./foo
+          Dir[self.path, "#{self.path}.*"].first
+        else
+          self.find_in_template_paths
+        end
       end
+    end
 
-      def extension # haml, erb ...
-        File.extname(path)[1..-1]
-      end
+    def adapter
+      self.template.class.name.split("::").last.snake_case.sub("_template", "")
+    end
 
-      def options
-        @options ||= Project.settings.send(self.extension) rescue Hash.new
-      end
+    def extension # haml, erb ...
+      File.extname(path)[1..-1]
+    end
 
-      def template
-        @template ||= Tilt.new(self.fullpath, nil, self.options)
-      end
+    def template(options = Hash.new)
+      @template ||= Tilt.new(self.fullpath, nil, options)
+    end
 
-      # @since 0.0.2
-      def render(locals = Hash.new)
-        raise Errors::TemplateNotFound.new("Template #{self.path} wasn't found in these template_dirs: #{Project.settings.template_dirs.inspect}") if self.fullpath.nil?
-        value = self.template.render(self.scope, locals)
-        Rango.logger.info("Rendering template #{self.path}")
-        Rango.logger.inspect(self.blocks)
-        if self.supertemplate
-          Rango.logger.debug("Extends call: #{self.supertemplate}")
-          supertemplate = self.class.new(self.supertemplate, self.scope)
-          supertemplate.blocks = self.blocks
-          return supertemplate.render(locals)
-        end
-        value
+    # @since 0.0.2
+    def render(context = Hash.new)
+      raise Errors::TemplateNotFound.new("Template #{self.path} wasn't found in these template_paths: #{self.template_paths.inspect}") if self.fullpath.nil?
+      value = self.template.render(self.scope, context)
+      Rango.logger.info("Rendering template #{self.path}")
+      # Rango.logger.inspect(self.blocks)
+      if self.supertemplate
+        Rango.logger.debug("Extends call: #{self.supertemplate}")
+        supertemplate = self.class.new(self.supertemplate, self.scope)
+        supertemplate.blocks = self.blocks
+        return supertemplate.render(context)
       end
+      value
+    end
 
-      protected
-      def find_in_template_dirs
-        Project.settings.template_dirs.each do |directory|
-          path = File.join(directory, self.path)
-          return Dir[path, "#{path}.*"].first
-        end
+    protected
+    def find_in_template_paths
+      self.template_paths.each do |directory|
+        path = File.join(directory, self.path)
+        return Dir[path, "#{path}.*"].first
       end
     end
   end