vanilla 1.0.2 → 1.2

data/Rakefile

@@ -1,122 +1,125 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
-require 'vanilla'
-load File.join(File.dirname(__FILE__), *%w[lib tasks vanilla.rake])
-
-require 'spec'
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new do |t|
-  t.spec_opts = %w(--format specdoc --colour)
-  t.libs = ["spec"]
-end
-
-task :default => :spec
-
-
 require "rubygems"
 require "rake/gempackagetask"
 require "rake/rdoctask"
 
-# This builds the actual gem. For details of what all these options
-# mean, and other ones you can add, check the documentation here:
-#
-#   http://rubygems.org/read/chapter/20
-#
-spec = Gem::Specification.new do |s|
-  
-  # Change these as appropriate
-  s.name              = "vanilla"
-  s.version           = "1.0.2"
-  s.summary           = "A bliki-type web content thing."
-  s.author            = "James Adam"
-  s.email             = "james@lazyatom.com.com"
-  s.homepage          = "http://github.com/lazyatom/vanilla-rb"
-
-  s.has_rdoc          = true
-  s.extra_rdoc_files  = %w(README)
-  s.rdoc_options      = %w(--main README)
-
-  # Add any extra files to include in the gem
-  s.files             = %w(config.example.yml config.ru Rakefile README) + Dir.glob("{spec,lib,bin,public}/**/*")
-  s.executables       = ['vanilla']
-  s.require_paths     = ["lib"]
-  
-  # All the other gems we need.
-  s.add_dependency("rack", ">= 0.9.1")
-  s.add_dependency("soup", ">= 0.2.1")
-  s.add_dependency("ratom", ">= 0.3.5")
-  s.add_dependency("RedCloth", ">= 4.1.1")
-  s.add_dependency("BlueCloth", ">= 1.0.0")
-  
-  s.add_development_dependency("rspec") # add any other gems for testing/development
-
-  # If you want to publish automatically to rubyforge, you'll may need
-  # to tweak this, and the publishing task below too.
-  s.rubyforge_project = "vanilla"
-end
+require "bundler/setup"
+require "vanilla"
 
-# This task actually builds the gem. We also regenerate a static 
-# .gemspec file, which is useful if something (i.e. GitHub) will
-# be automatically building a gem for this project. If you're not
-# using GitHub, edit as appropriate.
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-  
-  # Generate the gemspec file for github.
-  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
-  File.open(file, "w") {|f| f << spec.to_ruby }
-end
+task :default => :test
 
-# Generate documentation
-Rake::RDocTask.new do |rd|
-  rd.main = "README"
-  rd.rdoc_files.include("README", "lib/**/*.rb")
-  rd.rdoc_dir = "rdoc"
+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
 end
 
-desc 'Clear out RDoc and generated packages'
-task :clean => [:clobber_rdoc, :clobber_package] do
-  rm "#{spec.name}.gemspec"
-end
+if Object.const_defined?(:Gem)
+  # This builds the actual gem. For details of what all these options
+  # mean, and other ones you can add, check the documentation here:
+  #
+  #   http://rubygems.org/read/chapter/20
+  #
+  spec = Gem::Specification.new do |s|
 
-# If you want to publish to RubyForge automatically, here's a simple 
-# task to help do that. If you don't, just get rid of this.
-# Be sure to set up your Rubyforge account details with the Rubyforge
-# gem; you'll need to run `rubyforge setup` and `rubyforge config` at
-# the very least.
-begin
-  require "rake/contrib/sshpublisher"
-  namespace :rubyforge do
-    
-    desc "Release gem and RDoc documentation to RubyForge"
-    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
-    
-    namespace :release do
-      desc "Release a new version of this gem"
-      task :gem => [:package] do
-        require 'rubyforge'
-        rubyforge = RubyForge.new
-        rubyforge.configure
-        rubyforge.login
-        rubyforge.userconfig['release_notes'] = spec.summary
-        path_to_gem = File.join(File.dirname(__FILE__), "pkg", "#{spec.name}-#{spec.version}.gem")
-        puts "Publishing #{spec.name}-#{spec.version.to_s} to Rubyforge..."
-        rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version.to_s, path_to_gem)
-      end
-    
-      desc "Publish RDoc to RubyForge."
-      task :docs => [:rdoc] do
-        config = YAML.load(
-            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-        )
- 
-        host = "#{config['username']}@rubyforge.org"
-        remote_dir = "/var/www/gforge-projects/vanilla-rb/" # Should be the same as the rubyforge project name
-        local_dir = 'rdoc'
- 
-        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+    # Change these as appropriate
+    s.name              = "vanilla"
+    s.version           = Vanilla::VERSION
+    s.summary           = "A bliki-type web content thing."
+    s.author            = "James Adam"
+    s.email             = "james@lazyatom.com.com"
+    s.homepage          = "http://github.com/lazyatom/vanilla-rb"
+
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = %w(README)
+    s.rdoc_options      = %w(--main README)
+
+    # Add any extra files to include in the gem
+    s.files             = %w(Rakefile README) + Dir.glob("{test,lib,bin,pristine_app}/**/*")
+    s.executables       = ['vanilla']
+    s.require_paths     = ["lib"]
+
+    # All the other gems we need.
+    s.add_dependency("rack", ">= 0.9.1")
+    s.add_dependency("soup", ">= 1.0.6")
+    s.add_dependency("ratom", ">= 0.3.5")
+    s.add_dependency("RedCloth", ">= 4.1.1")
+    s.add_dependency("BlueCloth", ">= 1.0.0")
+    s.add_dependency("haml")
+    s.add_dependency("parslet", ">= 1.2.0")
+
+    s.add_development_dependency("kintama", ">= 0.1.6") # add any other gems for testing/development
+    s.add_development_dependency("mocha")
+
+    # If you want to publish automatically to rubyforge, you'll may need
+    # to tweak this, and the publishing task below too.
+    s.rubyforge_project = "vanilla"
+  end
+
+  # This task actually builds the gem. We also regenerate a static
+  # .gemspec file, which is useful if something (i.e. GitHub) will
+  # be automatically building a gem for this project. If you're not
+  # using GitHub, edit as appropriate.
+  #
+  # To publish your gem online, install the 'gemcutter' gem; Read more 
+  # about that here: http://gemcutter.org/pages/gem_docs
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.gem_spec = spec
+  end
+
+  # Stolen from jeweler
+  def prettyify_array(gemspec_ruby, array_name)
+    gemspec_ruby.gsub(/s\.#{array_name.to_s} = \[.+?\]/) do |match|
+      leadin, files = match[0..-2].split("[")
+      leadin + "[\n    #{files.split(",").join(",\n   ")}\n  ]"
+    end
+  end
+
+  task :gemspec do
+    output = spec.to_ruby
+    output = prettyify_array(output, :files)
+    output = prettyify_array(output, :test_files)
+    output = prettyify_array(output, :extra_rdoc_files)
+
+    file = File.expand_path("../#{spec.name}.gemspec", __FILE__)
+    File.open(file, "w") {|f| f << output }
+  end
+
+  task :package => :gemspec
+
+  # Generate documentation
+  Rake::RDocTask.new do |rd|
+    rd.main = "README"
+    rd.rdoc_files.include("README", "lib/**/*.rb")
+    rd.rdoc_dir = "rdoc"
+  end
+
+  desc 'Clear out RDoc and generated packages'
+  task :clean => [:clobber_rdoc, :clobber_package] do
+    rm "#{spec.name}.gemspec"
+  end
+
+  desc 'Tag the repository in git with gem version number'
+  task :tag => [:gemspec, :package] do
+    if `git diff --cached`.empty?
+      if `git tag`.split("\n").include?("v#{spec.version}")
+        raise "Version #{spec.version} has already been released"
       end
+      `git add #{File.expand_path("../#{spec.name}.gemspec", __FILE__)}`
+      `git commit -m "Released version #{spec.version}"`
+      `git tag v#{spec.version}`
+      `git push --tags`
+      `git push`
+    else
+      raise "Unstaged changes still waiting to be committed"
     end
   end
-rescue LoadError
-  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+
+  desc "Tag and publish the gem to rubygems.org"
+  task :publish => :tag do
+    `gem push pkg/#{spec.name}-#{spec.version}.gem`
+  end
+else
+  puts "Gem management tasks unavailable, as rubygems was not fully loaded."
 end

data/bin/vanilla

@@ -1,9 +1,38 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'rake'
-load File.join(File.dirname(__FILE__), *%w[.. lib tasks vanilla.rake])
 
-mkdir(ARGV[0])
-cd(ARGV[0])
+def create(new_app_dir)
+  require 'fileutils'
+  pristine_app = File.expand_path("../../pristine_app", __FILE__)
+  FileUtils.cp_r(pristine_app, new_app_dir)
+  FileUtils.mkdir_p(File.join(new_app_dir, "tmp"))
+  require 'vanilla'
+  File.open(File.join(new_app_dir, "Gemfile"), "w") do |f|
+    f.write "source :rubygems\n\n# Vanilla itself.\ngem 'vanilla', '#{Vanilla::VERSION}'"
+  end
+  puts File.readlines(File.join(new_app_dir, "README"))[0..16].join
+end
 
-Rake::Task['vanilla:setup'].invoke
+def console
+  $LOAD_PATH << "lib"
+  require "rubygems"
+  require "bundler/setup"
+  require "irb"
+  require "vanilla/console"
+  ARGV.clear
+  puts "The Soup is simmering."
+  IRB.start 
+end
+
+def upgrade
+  # TODO
+  puts "TODO, but should be easier thanks to multi-space soup."
+end
+
+case ARGV[0]
+when "console"
+  console
+when "upgrade"
+  upgrade
+else
+  create(ARGV[0])
+end

data/lib/vanilla.rb

@@ -1,20 +1,16 @@
-require 'rubygems'
-
-gem 'soup', '>= 0.1.4'
-require 'soup'
-require 'vanilla/snip_handling'
-
 module Vanilla
-  include SnipHandling
-end
+  VERSION = "1.2"
 
-# Load all the other renderer subclasses
-Dir[File.join(File.dirname(__FILE__), 'vanilla', 'renderers', '*.rb')].each { |f| require f }  
-
-# Load the routing information
-require 'vanilla/routes'
+  autoload :Renderers, "vanilla/renderers"
+  autoload :App, "vanilla/app"
+  autoload :Dynasnip, "vanilla/dynasnip"
+  autoload :Request, "vanilla/request"
+  autoload :Routes, "vanilla/routes"
+  autoload :Static, "vanilla/static"
+  autoload :SnipReferenceParser, "vanilla/snip_reference_parser"
+end
 
 # Load all the base dynasnip classes
 Dir[File.join(File.dirname(__FILE__), 'vanilla', 'dynasnips', '*.rb')].each do |dynasnip|
   require dynasnip
-end
+end

data/lib/vanilla/app.rb

@@ -1,28 +1,45 @@
-require 'vanilla'
-require 'vanilla/request'
+require 'soup'
 
 module Vanilla
   class App
-    
-    attr_reader :request, :response, :config
-    
-    def initialize(config_file=nil)
-      prepare_configuration(config_file)
-      Soup.prepare
+    include Vanilla::Routes
+
+    attr_reader :request, :response, :config, :soup
+
+    # Create a new Vanilla application
+    # Configuration options:
+    #
+    #  :soup - provide the path to the soup data
+    #  :soups - provide an array of paths to soup data
+    #  :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(config={})
+      @config = config
+      if @config[:soup].nil? && @config[:soups].nil?
+        @config.merge!(:soup => File.expand_path("soup"))
+      end
+      @soup = prepare_soup(config)
+      prepare_renderers(config[:renderers])
     end
-    
+
     # Returns a Rack-appropriate 3-element array (via Rack::Response#finish)
     def call(env)
-      @request = Vanilla::Request.new(env)
+      env['vanilla.app'] = self
+      @request = Vanilla::Request.new(env, self)
       @response = Rack::Response.new
 
       begin
         output = formatted_render(request.snip, request.part, request.format)
       rescue => e
         @response.status = 500
-        output = e.to_s
+        output = e.to_s + e.backtrace.join("\n")
       end
-      response_format = request.format      
+      response_format = request.format
       response_format = 'plain' if response_format == 'raw'
       @response['Content-Type'] = "text/#{response_format}"
       @response.write(output)
@@ -32,11 +49,16 @@ module Vanilla
     def formatted_render(snip, part=nil, format=nil)
       case format
       when 'html', nil
-        Renderers::Erb.new(self).render(Vanilla.snip('system'), :main_template)
+        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 || :content)
+        Renderers::Raw.new(self).render(snip, part)
       when 'text', 'atom', 'xml'
-        render(snip, part || :content)
+        render(snip, part)
       else
         raise "Unknown format '#{format}'"
       end
@@ -45,42 +67,88 @@ module Vanilla
     # 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.
-    def render(snip, part=:content, args=[])
+    def render(snip, part=:content, args=[], enclosing_snip=snip)
       rendering(snip) do |renderer|
-        renderer.render(snip, part, args)
+        renderer.render(snip, part, args, enclosing_snip)
+      end
+    end
+
+    # Returns the renderer class for a given snip
+    def renderer_for(snip)
+      if snip
+        find_renderer(snip.render_as || snip.extension)
+      else
+        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
+    end
+
+    def register_renderer(klass, *types)
+      types.each do |type|
+        if klass.is_a?(String)
+          klass = klass.split("::").inject(Object) { |o, name| o.const_get(name) }
+        end
+        @renderers[type.to_s] = klass
       end
     end
 
-    # Given the snip and parameters, yield an instance of the appropriate 
-    # Vanilla::Render::Base subclass
+    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
+    end
+
+    def find_renderer(name)
+      @renderers[(name ? name.downcase : nil)]
+    end
+
+    def default_renderer
+      @renderers[nil]
+    end
+
     def rendering(snip)
       renderer_instance = renderer_for(snip).new(self)
       yield renderer_instance
     rescue Exception => e
-      "<pre>[Error rendering '#{snip.name}' - \"" + 
-        e.message.gsub("<", "&lt;").gsub(">", "&gt;") + "\"]\n" + 
+      snip_name = snip ? snip.name : nil
+      "<pre>[Error rendering '#{snip_name}' - \"" +
+        e.message.gsub("<", "&lt;").gsub(">", "&gt;") + "\"]\n" +
         e.backtrace.join("\n").gsub("<", "&lt;").gsub(">", "&gt;") + "</pre>"
     end
-    
-    # Returns the renderer class for a given snip
-    def renderer_for(snip)
-      return Renderers::Base unless snip.render_as && !snip.render_as.empty?
-      Vanilla::Renderers.const_get(snip.render_as)
-    end
-    
-    # Other things can call this when a snip cannot be loaded.
-    def render_missing_snip(snip_name)
-      "[snip '#{snip_name}' cannot be found]"
-    end
-    
-    private
-    
-    def prepare_configuration(config_file)
-      config_file ||= "config.yml"
-      @config = YAML.load(File.open(config_file)) rescue {}
-      @config[:filename] = config_file
-      def @config.save!
-        File.open(self[:filename], 'w') { |f| f.puts self.to_yaml }
+
+    def prepare_soup(config)
+      if config[:soups]
+        backends = [config[:soups]].flatten.map { |path| ::Soup::Backends::FileBackend.new(path) }
+        ::Soup.new(::Soup::Backends::MultiSoup.new(*backends))
+      else
+        ::Soup.new(::Soup::Backends::FileBackend.new(config[:soup]))
       end
     end
   end