vanilla 1.2 → 1.9.9

data/lib/vanilla/dynasnips/edit_link.rb

@@ -0,0 +1,20 @@
+require 'vanilla/dynasnip'
+
+class EditLink < Dynasnip
+  usage %|
+You can use the edit_link snip to insert links for editing other snips. For example: 
+
+  &#123;edit_link blah&#125; 
+  
+would insert a link to an editor for the blah snip.
+
+You can also give a custom piece of text for the link, like this:
+
+  &#123;edit_link blah,link-name&#125;|
+  
+  def handle(*args)
+    snip_name = args[0] || app.request.snip_name
+    link_text = args[1] || "Edit"
+    edit_link(snip_name, link_text)
+  end
+end

data/{pristine_app/soups → lib/vanilla}/dynasnips/index.rb

@@ -2,11 +2,9 @@ require 'vanilla/dynasnip'
 
 class Index < Dynasnip
   def get(*args)
-    list = app.soup.instance_eval { @backend }.send(:all_snips).sort_by { |a| a.updated_at || Time.at(0) }.reverse.map { |snip|
+    list = app.soup.all_snips.sort_by { |a| a.updated_at || Time.at(0) }.reverse.map { |snip|
       "<li>#{link_to snip.name}</li>"
     }
     "<ol>#{list}</ol>"
   end
-
-  self
-end
+end

data/{pristine_app/soups/extras → lib/vanilla/dynasnips}/kind.rb

@@ -5,15 +5,15 @@ require 'date'
 class Kind < Dynasnip
   def handle(kind, limit=10, as=:html)
     as = as.to_sym
-    snips = app.soup.with(:kind => kind)
-    entries = snips.sort_by { |s| s.created_at || Time.at(0) }.reverse[0...limit.to_i].map do |snip|
+    snips = app.soup.sieve(:kind => kind)
+    entries = snips.sort_by { |s| s.created_at || '' }.reverse[0...limit.to_i].map do |snip|
       render_entry_in_template(snip, as, kind)
     end
     render_entry_collection(snips, entries, as, kind)
   end
-
+  
   def render_entry_in_template(snip, as, kind)
-    rendered_contents = externalise_links(prepare_snip_contents(snip))
+    rendered_contents = prepare_snip_contents(snip)
     case as
     when :html
       snip_template.
@@ -29,19 +29,17 @@ class Kind < Dynasnip
         e.title = snip.name
         e.authors = [Atom::Person.new(:name => snip.author || domain)]
         e.links << Atom::Link.new(:href => "http://#{domain}#{url_to(snip.name)}")
-        e.id = "tag:#{domain},#{(snip.created_at.to_s || Date.today.to_s).split[0]}:/#{snip.name}"
+        e.id = "tag:#{domain},#{(snip.created_at || Date.today.to_s).split[0]}:/#{snip.name}"
       end
     end
   end
-
+  
   def prepare_snip_contents(snip)
-    app.render(snip)
-  end
-
-  def externalise_links(content)
-    content.gsub(/href="\//, "href=\"http://#{domain}/").gsub(/src="\//, "src=\"http://#{domain}/")
+    rendered_snip = app.render(snip)
+    # make all the links absolute
+    rendered_snip.gsub(/href="\//, "href=\"http://#{domain}/")
   end
-
+  
   def render_entry_collection(snips, entries, as, kind)
     case as
     when :html
@@ -49,13 +47,13 @@ class Kind < Dynasnip
     when :xml
       Atom::Feed.new do |f|
         f.title = feed_title
-        f.updated = snips[0].updated_at
+        f.updated = DateTime.parse(snips[0].updated_at)
         f.id = "tag:#{domain},2008-06-01:kind/#{kind}"
         f.entries = entries
       end.to_xml
     end
   end
-
+  
   attribute :feed_title, "Your Blog"
   attribute :domain, "yourdomain.com"
   attribute :snip_template, %{

data/{pristine_app/soups → lib/vanilla}/dynasnips/link_to.rb

@@ -11,6 +11,4 @@ would insert a link to the blah snip.|
   def handle(snip_name, link_text=snip_name, part=nil)
     link_to(link_text, snip_name, part)
   end
-
-  self
 end

data/lib/vanilla/dynasnips/link_to_current_snip.rb

@@ -0,0 +1,16 @@
+require 'vanilla/dynasnip'
+
+class LinkToCurrentSnip < Dynasnip
+  usage %|
+    Renders a link to the current snip, or the snip currently being edited 
+    (if we're currently editing)
+  |
+  
+  def handle(*args)
+    if app.request.snip_name == 'edit' # we're editing so don't use this name
+      link_to app.request.params[:name]
+    else
+      link_to app.request.snip_name
+    end
+  end    
+end

data/lib/vanilla/dynasnips/login.rb

@@ -0,0 +1,56 @@
+require 'vanilla/dynasnip'
+require 'yaml'
+require 'md5'
+
+class Login < Dynasnip
+  module Helper
+    def logged_in?
+      !current_user.nil?
+    end
+    
+    def current_user
+      app.request.session['logged_in_as']
+    end
+  
+    def login_required
+      "You need to <a href='/login'>login</a> to do that."
+    end
+  end
+  include Helper
+  
+  def get(*args)
+    if logged_in?
+      login_controls
+    else
+      render(self, 'template')
+    end
+  end
+  
+  def post(*args)
+    if app.config[:credentials][cleaned_params[:name]] == MD5.md5(cleaned_params[:password]).to_s
+      app.request.session['logged_in_as'] = cleaned_params[:name]
+      login_controls
+    else
+      "login fail!"
+    end
+  end
+  
+  def delete(*args)
+    app.request.session['logged_in_as'] = nil
+    "Logged out"
+  end
+  
+  attribute :template, <<-EHTML
+    <form action='/login' method='post'>
+    <label>Name: <input type="text" name="name"></input></label>
+    <label>Password: <input type="password" name="password"></input></label>
+    <button>login</button>
+    </form>
+  EHTML
+  
+  private
+  
+  def login_controls
+    "logged in as {link_to #{app.request.session['logged_in_as']}}; <a href='/login?_method=delete'>logout</a>"
+  end
+end

data/lib/vanilla/dynasnips/new.rb

@@ -0,0 +1,14 @@
+require 'vanilla/dynasnip'
+require 'vanilla/dynasnips/login'
+
+class NewSnip < Dynasnip
+  include Login::Helper
+  
+  snip_name :new
+  
+  def handle(*arg)
+    return login_required unless logged_in?
+    base_params = {:render_as => '', :content => '', :author => current_user}.update(app.request.params)
+    editor = EditSnip.new(app).edit(Snip.new(base_params))
+  end
+end

data/lib/vanilla/dynasnips/notes.rb

@@ -0,0 +1,42 @@
+require 'vanilla/dynasnip'
+
+class Notes < Dynasnip
+  def get(*args)
+    all_notes_content = all_notes.map { |snip| 
+      render_note(snip) 
+    }.join("")
+    snip.main_template.gsub('[notes]', all_notes_content)
+  end
+
+  def post(*args)
+    new_note = Snip.new(cleaned_params)
+    new_note.name = "note_#{snip.next_note_id}"
+    new_note.kind = "note"
+    new_note.save
+    increment_next_id
+    get(*args)
+  end
+  
+  private 
+  
+  def all_notes
+    Snip.with(:kind, "= 'note'")
+  end
+  
+  def increment_next_id
+    s = snip
+    s.next_note_id = s.next_note_id.to_i + 1
+    s.save
+  end
+
+  def render_note(note)
+    note_link = link_to(note.name)
+    note_content = Vanilla.render(note.name, nil, context, [])
+    snip.note_template.gsub('[note]', note_content).gsub('[link]', note_link)
+  end
+  
+  attribute :next_note_id, 1
+  
+  attribute :note_template, %{<dt>[link]</dt><dd>[note]</dd>}
+  attribute :main_template, %{<dl>[notes]</dl>}
+end

data/{pristine_app/soups → lib/vanilla}/dynasnips/pre.rb

@@ -5,17 +5,15 @@ class ShowContentInPreTag < Dynasnip
 
   usage %|
     Wraps the contents of the given snip in &lt;pre&gt; tags, e.g.
-
+    
       {pre my_snip}
-
+      
     You can specify a part to render in pre tags, should you wish:
-
+    
       {pre my_snip,specific_part}
   |
-
+  
   def handle(snip_name, part=:content)
     %{<pre>#{app.soup[snip_name].__send__(part || :content)}</pre>}
   end
-
-  self
 end

data/{pristine_app/soups/extras → lib/vanilla/dynasnips}/rand.rb

@@ -24,6 +24,4 @@ class RandomNumber < Dynasnip
     max = max.to_i
     (rand(max-min) + min)
   end
-
-  self
 end

data/{pristine_app/soups → lib/vanilla}/dynasnips/raw.rb

@@ -1,22 +1,19 @@
 require 'vanilla/dynasnip'
-require 'cgi'
 
 class ShowRawContent < Dynasnip
   snip_name "raw"
 
   usage %|
     Displays the raw contents of a snip in &lt;pre&gt; tags, e.g.
-
+    
       {raw my_snip}
-
+      
     You can specify a part to show, should you wish:
-
+    
       {raw my_snip,specific_part}
   |
-
+  
   def handle(snip_name, part=:content)
-    %{#{Dynasnip.escape_curly_braces(CGI.escapeHTML(app.soup[snip_name].__send__(part || :content)))}}
+    %{<pre>#{Dynasnip.escape_curly_braces(app.soup[snip_name].__send__(part || :content))}</pre>}
   end
-
-  self
 end

data/lib/vanilla/renderers/base.rb

@@ -1,42 +1,35 @@
+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\-_\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
+        %r{(\{[^\}.]+\})}
       end
-
+    
       # Default behaviour to include a snip's content
       def include_snips(content, enclosing_snip)
         content.gsub(Vanilla::Renderers::Base.snip_regexp) do
@@ -45,54 +38,51 @@ module Vanilla
             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]
+            snip = soup[snip_name]
+            if snip
               app.render(snip, snip_attribute, snip_args, enclosing_snip)
             else
-              render_missing_snip(snip_name)
+              app.render_missing_snip(snip_name)
             end
           else
             "malformed snip reference: #{$1.inspect}"
           end
         end
       end
-
+      
       def parse_snip_reference(string)
-        @parser ||= Vanilla::SnipReferenceParser.new
+        @parser ||= 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=[], enclosing_snip=snip)
         prepare(snip, part, args, enclosing_snip)
         processed_text = render_without_including_snips(snip, part)
         include_snips(processed_text, snip)
       end
-
+      
       # Subclasses should override this to perform any actions required before
       # rendering
       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,3 +1,5 @@
+require 'vanilla/renderers/base'
+
 module Vanilla::Renderers
   class Bold < Base
     def process_text(content)

data/lib/vanilla/renderers/erb.rb

@@ -1,3 +1,5 @@
+require 'vanilla/renderers/base'
+
 require 'erb'
 include ERB::Util
 

data/lib/vanilla/renderers/markdown.rb

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

data/lib/vanilla/renderers/raw.rb

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