vanilla 1.17 → 1.17.1

data/Rakefile

@@ -7,12 +7,24 @@ require "vanilla"
 
 task :default => :test
 
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.ruby_opts << "-rubygems"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
+task :test => ["test:core", "test:app"]
+
+namespace :test do
+  require "rake/testtask"
+  Rake::TestTask.new(:core) do |t|
+    t.libs << "test/core"
+    t.ruby_opts << "-rubygems"
+    t.test_files = FileList["test/core/**/*_test.rb"]
+    t.verbose = true
+  end
+
+  require "rake/testtask"
+  Rake::TestTask.new(:app) do |t|
+    t.libs << "test/pristine_app"
+    t.ruby_opts << "-rubygems"
+    t.test_files = FileList["test/pristine_app/**/*_test.rb"]
+    t.verbose = true
+  end
 end
 
 if Object.const_defined?(:Gem)
@@ -42,7 +54,7 @@ if Object.const_defined?(:Gem)
 
     # All the other gems we need.
     s.add_dependency("rack", ">= 0.9.1")
-    s.add_dependency("soup", ">= 1.0.6")
+    s.add_dependency("soup", ">= 1.0.8")
     s.add_dependency("ratom", ">= 0.3.5")
     s.add_dependency("RedCloth", ">= 4.1.1")
     s.add_dependency("BlueCloth", ">= 1.0.0")
@@ -52,6 +64,8 @@ if Object.const_defined?(:Gem)
 
     s.add_development_dependency("kintama", ">= 0.1.6") # add any other gems for testing/development
     s.add_development_dependency("mocha")
+    s.add_development_dependency("capybara")
+    s.add_development_dependency("launchy")
 
     # If you want to publish automatically to rubyforge, you'll may need
     # to tweak this, and the publishing task below too.

data/bin/vanilla

@@ -15,10 +15,10 @@ end
 def upgrade
   require 'fileutils'
   soups_directory = File.join(Dir.pwd, "soups")
-  if File.directory(soups_directory)
+  if File.directory?(soups_directory)
     confirm("Upgrade system snips?") do
       pristine_system = File.expand_path("../../pristine_app/soups/system", __FILE__)
-      copy(pristine_system, system_directory)
+      copy(pristine_system, soups_directory)
     end
     confirm("Upgrade tutorial snips?") do
       pristine_system = File.expand_path("../../pristine_app/soups/tutorial", __FILE__)

data/lib/vanilla.rb

@@ -1,17 +1,20 @@
 module Vanilla
-  VERSION = "1.17"
+  VERSION = "1.17.1"
 
   autoload :Renderers, "vanilla/renderers"
   autoload :App, "vanilla/app"
+  autoload :Config, "vanilla/config"
   autoload :Dynasnip, "vanilla/dynasnip"
   autoload :Request, "vanilla/request"
-  autoload :Routes, "vanilla/routes"
+  autoload :Routing, "vanilla/routing"
   autoload :Static, "vanilla/static"
   autoload :SnipReferenceParser, "vanilla/snip_reference_parser"
   autoload :TestHelper, "vanilla/test_helper"
-end
 
-# Load all the base dynasnip classes
-Dir[File.join(File.dirname(__FILE__), 'vanilla', 'dynasnips', '*.rb')].each do |dynasnip|
-  require dynasnip
-end
+  class << self
+    # The set of currently loaded Vanilla::App subclasses
+    def apps
+      @apps ||= []
+    end
+  end
+end

data/lib/vanilla/app.rb

@@ -1,9 +1,11 @@
 require 'soup'
-require 'ostruct'
 
 module Vanilla
+
+  # This is the main App class for Vanilla applications; this should
+  # be subclassed for each instance of Vanilla that you want to run.
   class App
-    include Vanilla::Routes
+    include Vanilla::Routing
 
     class << self
       attr_reader :config
@@ -13,48 +15,23 @@ module Vanilla
         self
       end
       def reset!
-        @config = OpenStruct.new
+        @config = Vanilla::Config.new
+      end
+      def inherited(app)
+        Vanilla.apps << app
       end
     end
 
-    attr_reader :request, :response, :config, :soup
-
-    def class_config
-      if self.class.config
-        {:soup => self.class.config.soup,
-         :soups => self.class.config.soups,
-         :root => self.class.config.root,
-         :root_snip => self.class.config.root_snip,
-         :renderers => self.class.config.renderers,
-         :default_layout_snip => self.class.config.default_layout_snip,
-         :default_renderer => self.class.config.default_renderer}
-      else
-        {}
-      end
+    attr_reader :request, :response, :soup
+
+    def initialize
+      @renderers = Hash.new { config.default_renderer }
+      @soup = prepare_soup
+      prepare_renderers
     end
 
-    # Create a new Vanilla application
-    # Configuration options:
-    #
-    #  :soup - provide the path to the soup data
-    #  :soups - provide an array of paths to soup data
-    #  :root - the directory that the soup paths are relative to;
-    #          defaults to Dir.pwd
-    #  :renderers - a hash of names to classes
-    #  :default_renderer - the class to use when no renderer is provided;
-    #                      defaults to 'Vanilla::Renderers::Base'
-    #  :default_layout_snip - the snip to use as a layout when rendering to HTML;
-    #                         defaults to 'layout'
-    #  :root_snip - the snip to load for the root ('/') url;
-    #               defaults to 'start'
-    def initialize(additional_configuration={})
-      @config = class_config.merge(additional_configuration)
-      @root_directory = @config[:root] || Dir.pwd
-      if @config[:soup].nil? && @config[:soups].nil?
-        @config[:soup] = File.expand_path("soup", @root_directory)
-      end
-      @soup = prepare_soup(config)
-      prepare_renderers(config[:renderers])
+    def config
+      self.class.config
     end
 
     # Returns a Rack-appropriate 3-element array (via Rack::Response#finish)
@@ -64,7 +41,7 @@ module Vanilla
       @response = Rack::Response.new
 
       begin
-        output = formatted_render(request.snip, request.part, request.format)
+        output = render_in_format(request.snip, request.part, request.format)
       rescue => e
         @response.status = 500
         output = e.to_s + e.backtrace.join("\n")
@@ -76,29 +53,14 @@ module Vanilla
       @response.finish # returns the array
     end
 
-    def formatted_render(snip, part=nil, format=nil)
-      case format
-      when 'html', nil
-        layout = layout_for(snip)
-        if layout == snip
-          "Rendering of the current layout would result in infinite recursion."
-        else
-          render(layout)
-        end
-      when 'raw', 'css', 'js'
-        Renderers::Raw.new(self).render(snip, part)
-      when 'text', 'atom', 'xml'
-        render(snip, part)
-      else
-        raise "Unknown format '#{format}'"
-      end
-    end
-
     # render a snip using either the renderer given, or the renderer
     # specified by the snip's "render_as" property, or Render::Base
     # if nothing else is given.
+    #
+    # This method can be useful if a dynasnip or other part of the
+    # system needs to get a fully rendered version of a snip.
     def render(snip, part=:content, args=[], enclosing_snip=snip)
-      rendering(snip) do |renderer|
+      rendering_and_handling_errors(snip) do |renderer|
         renderer.render(snip, part, args, enclosing_snip)
       end
     end
@@ -108,24 +70,12 @@ module Vanilla
       if snip
         find_renderer(snip.render_as || snip.extension)
       else
-        default_renderer
+        config.default_renderer
       end
     end
 
     def default_layout_snip
-      soup[config[:default_layout_snip] || 'layout']
-    end
-
-    def layout_for(snip)
-      if snip
-        renderer_for(snip).new(self).layout_for(snip)
-      else
-        default_layout_snip
-      end
-    end
-
-    def snip(attributes)
-      @soup << attributes
+      soup[config.default_layout_snip]
     end
 
     def register_renderer(klass, *types)
@@ -139,31 +89,15 @@ module Vanilla
 
     private
 
-    def prepare_renderers(additional_renderers={})
-      @renderers = Hash.new { config[:default_renderer] || Vanilla::Renderers::Base }
-      @renderers.merge!({
-        "base" => Vanilla::Renderers::Base,
-        "markdown" => Vanilla::Renderers::Markdown,
-        "bold" => Vanilla::Renderers::Bold,
-        "erb" => Vanilla::Renderers::Erb,
-        "rb" => Vanilla::Renderers::Ruby,
-        "ruby" => Vanilla::Renderers::Ruby,
-        "haml" => Vanilla::Renderers::Haml,
-        "raw" => Vanilla::Renderers::Raw,
-        "textile" => Vanilla::Renderers::Textile
-      })
-      additional_renderers.each { |name, klass| register_renderer(klass, name) } if additional_renderers
+    def prepare_renderers
+      config.renderers.each { |name, klass| register_renderer(klass, name) }
     end
 
     def find_renderer(name)
       @renderers[(name ? name.downcase : nil)]
     end
 
-    def default_renderer
-      @renderers[nil]
-    end
-
-    def rendering(snip)
+    def rendering_and_handling_errors(snip)
       renderer_instance = renderer_for(snip).new(self)
       yield renderer_instance
     rescue Exception => e
@@ -173,14 +107,40 @@ module Vanilla
         e.backtrace.join("\n").gsub("<", "&lt;").gsub(">", "&gt;") + "</pre>"
     end
 
-    def prepare_soup(config)
-      if config[:soups]
-        backends = [config[:soups]].flatten.map do |path| 
-          ::Soup::Backends::FileBackend.new(File.expand_path(path, @root_directory))
+    def render_in_format(snip, part=nil, format=nil)
+      case format
+      when 'html', nil
+        layout = layout_for(snip)
+        if layout == snip
+          "Rendering of the current layout would result in infinite recursion."
+        else
+          render(layout)
+        end
+      when 'raw', 'css', 'js'
+        Renderers::Raw.new(self).render(snip, part)
+      when 'text', 'atom', 'xml'
+        render(snip, part)
+      else
+        raise "Unknown format '#{format}'"
+      end
+    end
+
+    def layout_for(snip)
+      if snip
+        renderer_for(snip).new(self).layout_for(snip)
+      else
+        default_layout_snip
+      end
+    end
+
+    def prepare_soup
+      if config.soups
+        backends = [config.soups].flatten.map do |path|
+          ::Soup::Backends::FileBackend.new(File.expand_path(path, config.root))
         end
         ::Soup.new(::Soup::Backends::MultiSoup.new(*backends))
       else
-        ::Soup.new(::Soup::Backends::FileBackend.new(File.expand_path(config[:soup], @root_directory)))
+        raise "No soups defined!"
       end
     end
   end

data/lib/vanilla/config.rb

@@ -0,0 +1,46 @@
+require "vanilla"
+
+module Vanilla
+
+  # Create a new Vanilla application
+  # Configuration options:
+  #
+  #  :soup - provide the path to the soup data
+  #  :soups - provide an array of paths to soup data
+  #  :root - the directory that the soup paths are relative to;
+  #          defaults to Dir.pwd
+  #  :renderers - a hash of names to classes
+  #  :default_renderer - the class to use when no renderer is provided;
+  #                      defaults to 'Vanilla::Renderers::Base'
+  #  :default_layout_snip - the snip to use as a layout when rendering to HTML;
+  #                         defaults to 'layout'
+  #  :root_snip - the snip to load for the root ('/') url;
+  #               defaults to 'start'
+  class Config
+    attr_accessor :root,
+                  :root_snip,
+                  :soups,
+                  :renderers,
+                  :default_layout_snip,
+                  :default_renderer
+
+    def initialize
+      @root = Dir.pwd
+      @root_snip = "start"
+      @soups = ["soups/base", "soups/system"]
+      @default_layout_snip = "layout"
+      @default_renderer = Vanilla::Renderers::Base
+      @renderers = {
+        "base" => Vanilla::Renderers::Base,
+        "markdown" => Vanilla::Renderers::Markdown,
+        "bold" => Vanilla::Renderers::Bold,
+        "erb" => Vanilla::Renderers::Erb,
+        "rb" => Vanilla::Renderers::Ruby,
+        "ruby" => Vanilla::Renderers::Ruby,
+        "haml" => Vanilla::Renderers::Haml,
+        "raw" => Vanilla::Renderers::Raw,
+        "textile" => Vanilla::Renderers::Textile
+      }
+    end
+  end
+end

data/lib/vanilla/console.rb

@@ -6,7 +6,7 @@ end
 def app(reload=false)
   if !@__vanilla_console_app || reload
     load "application.rb"
-    @__vanilla_console_app = Application.new
+    @__vanilla_console_app = Vanilla.apps.first.new
   end
   @__vanilla_console_app
 end

data/lib/vanilla/renderers/base.rb

@@ -3,7 +3,6 @@ require 'vanilla/snip_reference_parser'
 module Vanilla
   module Renderers
     class Base
-      include Routes
 
       # Render a snip.
       def self.render(snip, part=:content)
@@ -20,11 +19,22 @@ module Vanilla
         @app = app
       end
 
-      # defined for the routes
       def soup
         @app.soup
       end
 
+      def url_to(*args)
+        @app.url_to(*args)
+      end
+
+      def link_to(link_text, snip_name=link_text, part=nil)
+        if soup[snip_name]
+          %{<a href="#{url_to(snip_name, part)}">#{link_text}</a>}
+        else
+          %{<a class="missing" href="#{url_to(snip_name, part)}">#{link_text}</a>}
+        end
+      end
+
       def self.snip_regexp
         %r{(\{[\w\-_\d\.\"\' ]+( +[^\}.]+)?\})}
       end

data/lib/vanilla/request.rb

@@ -13,6 +13,7 @@ module Vanilla
       determine_request_uri_parts
     end
 
+    # returns the parameters of the request, with every key as a symbol
     def params
       # Don't you just love how terse functional programming tends to look like maths?
       @symbolised_params ||= @rack_request.params.inject({}) { |p, (k,v)| p[k.to_sym] = v; p }
@@ -24,47 +25,21 @@ module Vanilla
       @app.soup[snip_name]
     end
 
-    def cookies
-      @rack_request.cookies
-    end
-
-    def ip
-      @rack_request.env["REMOTE_ADDR"]
-    end
-
-    def session
-      @rack_request.env["rack.session"]
+    def method_missing(name, *args)
+      if @rack_request.respond_to?(name)
+        @rack_request.send(name, *args)
+      else
+        super
+      end
     end
 
     private
 
     def determine_request_uri_parts
-      @snip_name, @part, @format = request_uri_parts(@rack_request)
+      @snip_name, @part, @format = Vanilla::Routing.parse(@rack_request.path_info)
+      @snip_name ||= @app.config.root_snip
       @format ||= 'html'
       @method = (params.delete(:_method) || @rack_request.request_method).downcase
     end
-
-    def uri_path(request)
-      request.path_info
-    end
-
-    URL_ROOT          = /\A\/?\Z/                                  # i.e. / or nothing
-    URL_SNIP          = /\A\/([\w\-\s]+)(\/|\.(\w+))?\Z/            # i.e. /start, /start.html
-    URL_SNIP_AND_PART = /\A\/([\w\-\s]+)\/([\w\-\s]+)(\/|\.(\w+))?\Z/ # i.e. /blah/part, /blah/part.raw
-
-    # Returns an array of the requested snip, part and format
-    def request_uri_parts(request)
-      case CGI.unescape(uri_path(request))
-      when URL_ROOT
-        [@app.config[:root_snip] || 'start', nil, 'html']
-      when URL_SNIP
-        [$1, nil, $3]
-      when URL_SNIP_AND_PART
-        [$1, $2, $4]
-      else
-        []
-      end
-    end
-
   end
 end