vanilla 1.0.2 → 1.2

data/lib/vanilla/console.rb

@@ -1,3 +1,23 @@
 require 'vanilla'
-Soup.prepare
-puts "The Soup is simmering."
+
+module Vanilla
+  class RackShim
+    def run(app)
+      app # return it
+    end
+    def use(*args)
+      # ignore
+    end
+    def get_binding
+      binding
+    end
+  end
+end
+
+def app(reload=false)
+  if !@__vanilla_console_app || reload
+    shim_binding = Vanilla::RackShim.new.get_binding
+    @__vanilla_console_app = eval File.read("config.ru"), shim_binding
+  end
+  @__vanilla_console_app
+end

data/lib/vanilla/dynasnip.rb

@@ -29,48 +29,16 @@ class Dynasnip < Vanilla::Renderers::Base
     attribute :usage, escape_curly_braces(str).strip
   end
   
-  def self.persist_all!(overwrite=false)
-    all.each do |dynasnip|
-      dynasnip.persist!(overwrite)
-    end
-  end
-  
-  def self.build_snip
-    Snip.new(snip_attributes)
-  end
-  
   def self.snip_attributes
     full_snip_attributes = {:name => snip_name, :content => self.name, :render_as => "Ruby"}
     @attributes ? full_snip_attributes.merge!(@attributes) : full_snip_attributes
   end
   
-  def self.persist!(overwrite=false)
-    if overwrite
-      snip = Soup[snip_name]
-      if snip
-        if snip.is_a?(Array)
-          snip.each { |s| s.destroy }
-        else
-          snip.destroy
-        end
-      end
-    end
-    snip = Soup[snip_name]
-    snip = snip[0] if snip.is_a?(Array)    
-    if snip
-      snip_attributes.each do |name, value|
-        snip.set_value(name, value)
-      end
-    else
-      snip = build_snip
-    end
-    snip.save
-    snip
-  end
+  attr_accessor :enclosing_snip
   
   def method_missing(method, *args)
-    if snip = Vanilla.snip(snip_name)
-      snip.get_value(method)
+    if snip
+      snip.__send__(method)
     elsif part = self.class.attribute(method)
       part
     else
@@ -88,7 +56,7 @@ class Dynasnip < Vanilla::Renderers::Base
   end
   
   def snip
-    Snip[snip_name]
+    app.soup[snip_name]
   end
   
   def show_usage

data/lib/vanilla/renderers.rb

@@ -0,0 +1,12 @@
+module Vanilla
+  module Renderers
+    autoload :Base, "vanilla/renderers/base"
+    autoload :Bold, "vanilla/renderers/bold"
+    autoload :Erb, "vanilla/renderers/erb"
+    autoload :Haml, "vanilla/renderers/haml"
+    autoload :Markdown, "vanilla/renderers/markdown"
+    autoload :Raw, "vanilla/renderers/raw"
+    autoload :Ruby, "vanilla/renderers/ruby"
+    autoload :Textile, "vanilla/renderers/textile"
+  end
+end

data/lib/vanilla/renderers/base.rb

@@ -1,74 +1,98 @@
-require 'vanilla/app'
+require 'vanilla/snip_reference_parser'
 
 module Vanilla
   module Renderers
     class Base
-      
+      include Routes
+
       # Render a snip.
       def self.render(snip, part=:content)
         new(app).render(snip, part)
       end
-      
+
       def self.escape_curly_braces(str)
         str.gsub("{", "{").gsub("}", "}")
       end
-      
+
       attr_reader :app
-    
+
       def initialize(app)
         @app = app
       end
-      
+
+      # defined for the routes
+      def soup
+        @app.soup
+      end
+
       def self.snip_regexp
-        %r{ \{
-          ([\w\-]+) (?: \.([\w\-]+) )?
-          (?: \s+ ([\w\-,]+) )?
-        \} }x
+        %r{(\{[\w\-_\d\.\"\'\s]+(\s+[^\}.]+)?\})}
+      end
+
+      def default_layout_snip
+        app.default_layout_snip
+      end
+
+      def layout_for(snip)
+        layout_snip = (snip && snip.layout) ? soup[snip.layout] : default_layout_snip
       end
-    
+
       # Default behaviour to include a snip's content
-      def include_snips(content)
+      def include_snips(content, enclosing_snip)
         content.gsub(Vanilla::Renderers::Base.snip_regexp) do
-          snip_name = $1
-          snip_attribute = $2
-          snip_args = $3 ? $3.split(',') : []
-          
-          # Render the snip or snip part with the given args, and the current
-          # context, but with the default renderer for that snip. We dispatch
-          # *back* out to the root Vanilla.render method to do this.
-          snip = Vanilla.snip(snip_name)
-          if snip
-            app.render(snip, snip_attribute, snip_args)
+          snip_tree = parse_snip_reference($1)
+          if snip_tree
+            snip_name = snip_tree.snip
+            snip_attribute = snip_tree.attribute
+            snip_args = snip_tree.arguments
+
+            # Render the snip or snip part with the given args, and the current
+            # context, but with the default renderer for that snip. We dispatch
+            # *back* out to the root Vanilla.render method to do this.
+            if snip = soup[snip_name]
+              app.render(snip, snip_attribute, snip_args, enclosing_snip)
+            else
+              render_missing_snip(snip_name)
+            end
           else
-            app.render_missing_snip(snip_name)
+            "malformed snip reference: #{$1.inspect}"
           end
         end
       end
-      
+
+      def parse_snip_reference(string)
+        @parser ||= Vanilla::SnipReferenceParser.new
+        @parser.parse(string)
+      end
+
+      def render_missing_snip(snip_name)
+        "[snip '#{snip_name}' cannot be found]"
+      end
+
       # Default rendering behaviour. Subclasses shouldn't really need to touch this.
-      def render(snip, part=:content, args=[])
-        prepare(snip, part, args)
+      def render(snip, part=:content, args=[], enclosing_snip=snip)
+        prepare(snip, part, args, enclosing_snip)
         processed_text = render_without_including_snips(snip, part)
-        include_snips(processed_text)
+        include_snips(processed_text, snip)
       end
-      
+
       # Subclasses should override this to perform any actions required before
       # rendering
-      def prepare(snip, part, args)
+      def prepare(snip, part, args, enclosing_snip)
         # do nothing, by default
       end
-      
+
       def render_without_including_snips(snip, part=:content)
         process_text(raw_content(snip, part))
       end
-      
-      # Handles processing the text of the content. 
-      # Subclasses should override this method to do fancy text processing 
+
+      # Handles processing the text of the content.
+      # Subclasses should override this method to do fancy text processing
       # like markdown, or loading the content as Ruby code.
       def process_text(content)
         content
       end
-      
+
       # Returns the raw content for the selected part of the selected snip
       def raw_content(snip, part)
         snip.__send__((part || :content).to_sym)

data/lib/vanilla/renderers/bold.rb

@@ -1,5 +1,3 @@
-require 'vanilla/renderers/base'
-
 module Vanilla::Renderers
   class Bold < Base
     def process_text(content)

data/lib/vanilla/renderers/erb.rb

@@ -1,11 +1,9 @@
-require 'vanilla/renderers/base'
-
 require 'erb'
 include ERB::Util
 
 module Vanilla::Renderers
   class Erb < Base
-    def prepare(snip, part=:content, args=[])
+    def prepare(snip, part=:content, args=[], enclosing_snip=snip)
       @snip = snip
     end
     

data/lib/vanilla/renderers/haml.rb

@@ -0,0 +1,13 @@
+require 'haml'
+
+module Vanilla::Renderers
+  class Haml < Base
+    def prepare(snip, part=:content, args=[], enclosing_snip=snip)
+      @snip = snip
+    end
+    
+    def process_text(content)
+      ::Haml::Engine.new(content).render(binding)
+    end
+  end
+end

data/lib/vanilla/renderers/markdown.rb

@@ -1,5 +1,3 @@
-require 'vanilla/renderers/base'
-
 require 'rubygems'
 gem 'BlueCloth' # from http://www.deveiate.org/projects/BlueCloth
 require 'bluecloth'

data/lib/vanilla/renderers/raw.rb

@@ -1,5 +1,3 @@
-require 'vanilla/renderers/base'
-
 module Vanilla::Renderers
   class Raw < Base
     def render(snip, part=:content)

data/lib/vanilla/renderers/ruby.rb

@@ -1,5 +1,3 @@
-require 'vanilla/renderers/base'
-
 module Vanilla::Renderers
   # Snips that render_as "Ruby" should define a class.
   # The class should have instance methods for any HTTP request methods that the dynasnip
@@ -13,9 +11,10 @@ module Vanilla::Renderers
   # itself), it should be a subclass of Dynasnip (or define an initializer
   # that accepts the context as its first argument).
   class Ruby < Base
-    def prepare(snip, part=:content, args=[])
+    def prepare(snip, part=:content, args=[], enclosing_snip=snip)
       @args = args
       @snip = snip
+      @enclosing_snip = enclosing_snip
     end
     
     def process_text(content)
@@ -25,10 +24,17 @@ module Vanilla::Renderers
       else
         handler_klass.new
       end
-      if (method = app.request.method) && instance.respond_to?(method)
-        instance.send(method, *@args).to_s
+      instance.enclosing_snip = @enclosing_snip if instance.respond_to?(:enclosing_snip)
+
+      if app.request && (method = app.request.method) && instance.respond_to?(method)
+        message = method
+      else
+        message = :handle
+      end
+      if @args.is_a?(Array)
+        instance.send(message, *@args).to_s
       else
-        instance.handle(*@args).to_s
+        instance.send(message, @args).to_s
       end
     end
   end

data/lib/vanilla/renderers/textile.rb

@@ -1,5 +1,3 @@
-require 'vanilla/renderers/base'
-
 require 'rubygems'
 gem 'RedCloth'
 require 'redcloth'

data/lib/vanilla/request.rb

@@ -4,10 +4,12 @@ module Vanilla
   # Create a request with symbolised access to the params, and some special
   # accessors to the snip, part and format based on our routing.
   class Request
-    attr_reader :snip_name, :part, :format, :method
-    
-    def initialize(env)
+    attr_reader :snip_name, :part, :format, :method, :env
+
+    def initialize(env, app)
+      @env = env
       @rack_request = Rack::Request.new(env)
+      @app = app
       determine_request_uri_parts
     end
 
@@ -15,46 +17,46 @@ module Vanilla
       # 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 }
     end
-    
+
     # Returns the snip referenced by the request's URL. Performs no exception
     # handling, so if the snip does not exist, an exception will be thrown.
     def snip
-      Vanilla.snip(snip_name)
+      @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"]
     end
-    
+
     private
-    
+
     def determine_request_uri_parts
       @snip_name, @part, @format = request_uri_parts(@rack_request)
       @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. /
+
+    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
-        ['start', nil, 'html']
+        [@app.config[:root_snip] || 'start', nil, 'html']
       when URL_SNIP
         [$1, nil, $3]
       when URL_SNIP_AND_PART
@@ -63,6 +65,6 @@ module Vanilla
         []
       end
     end
-    
+
   end
-end  
+end

data/lib/vanilla/routes.rb

@@ -1,29 +1,18 @@
 module Vanilla
+  # Expects to be able to call 'soup' on whatever it is included into
   module Routes
     def link_to(link_text, snip_name=link_text, part=nil)
-      %{<a href="#{Vanilla::Routes.url_to(snip_name, part)}">#{link_text}</a>}
+      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 url_to(snip_name, part=nil)
-      url = "/#{snip_name}"
+      url = "/#{snip_name.gsub(" ", "+")}"
       url += "/#{part}" if part
       url
     end
-
-    def url_to_raw(snip_name, part=nil)
-      url = "/#{snip_name}"
-      url += "/#{part}" if part
-      url += ".raw"
-    end
-  
-    def edit_link(snip_name, link_text)
-      %[<a href="/edit?name=#{snip_name}">#{link_text}</a>]
-    end
-  
-    def new_link(snip_name="New")
-      %[<a href="/new?name=#{snip_name}" class="new">#{snip_name}</a>]
-    end
-  
-    extend self
   end
-end
+end