vanilla 1.0.0

data/lib/vanilla/dynasnips/comments.rb

@@ -0,0 +1,108 @@
+require 'vanilla/dynasnip'
+require 'defensio'
+require 'date'
+
+class Comments < Dynasnip
+  usage %|
+    Embed comments within snips!
+    
+    {comments <snip-name>}
+    
+    This will embed a list of comments, and a comment form, in a snip
+    If the snip is being rendered within another snip, it will show a link to the snip,
+    with the number of comments.
+  |
+
+  def get(snip_name=nil, disable_new_comments=false)
+    snip_name = snip_name || app.request.params[:snip]
+    return usage if self.class.snip_name == snip_name
+    comments = Soup.sieve(:commenting_on => snip_name)
+    comments_html = if app.request.snip_name == snip_name
+      rendered_comments = render_comments(comments)
+      rendered_comments += comment_form.gsub('SNIP_NAME', snip_name) unless disable_new_comments
+      rendered_comments
+    else
+     %{<a href="#{Vanilla::Routes.url_to(snip_name)}">#{comments.length} comments for #{snip_name}</a>}
+    end
+    return comments_html
+  end
+  
+  def post(*args)
+    snip_name = app.request.params[:snip]
+    existing_comments = Soup.sieve(:commenting_on => snip_name)
+    comment = app.request.params.reject { |k,v| ![:author, :email, :website, :content].include?(k) }
+    
+    return "You need to add some details!" if comment.empty?
+    
+    comment = check_for_spam(comment)
+    
+    if comment[:spam]
+      "Sorry - your comment looks like spam, according to Defensio :("
+    else
+      return "No spam today, thanks anyway" unless app.request.params[:human] == 'human'
+      Soup << comment.merge({
+       :name => "#{snip_name}-comment-#{existing_comments.length + 1}", 
+       :commenting_on => snip_name,
+       :created_at => Time.now
+      })
+      "Thanks for your comment! Back to {link_to #{snip_name}}"
+    end
+  end
+  
+  def render_comments(comments)
+    "<h2>Comments</h2><ol class='comments'>" + comments.map do |comment|
+      rendered_comment = comment_template.gsub('COMMENT_CONTENT', app.render(comment)).
+                                          gsub('COMMENT_DATE', comment.created_at)
+      author = comment.author
+      author = "Anonymous" unless author && author != ""
+      if comment.website && comment.website != ""
+        rendered_comment.gsub!('COMMENT_AUTHOR', "<a href=\"#{comment.website}\">#{author}</a>")
+      else
+        rendered_comment.gsub!('COMMENT_AUTHOR', author)
+      end
+      rendered_comment
+    end.join + "</ol>"    
+  end
+  
+  def check_for_spam(comment)
+    snip_date = Date.parse(Soup[app.request.params[:snip]].updated_at)
+    Defensio.configure(app.config[:defensio])
+    defensio_params = {
+      :comment_author_email => comment[:email], 
+      :comment_author => comment[:author], 
+      :comment_author_url => comment[:website],
+      :comment_content => comment[:content],
+      :comment_type => "comment", 
+      :user_ip => app.request.ip, 
+      :article_date => snip_date.strftime("%Y/%m/%d")
+    }
+    audit = Defensio.audit_comment(defensio_params)
+    
+    # Augment the comment hash
+    comment[:user_ip] = app.request.ip
+    comment[:spamminess] = audit["defensio_result"]["spaminess"]
+    comment[:spam] = audit["defensio_result"]["spam"]
+    comment[:defensio_signature] = audit["defensio_result"]["signature"]
+    comment[:defensio_message] = audit["defensio_result"]["message"] if audit["defensio_result"]["message"]
+    comment[:defensio_status] = audit["defensio_result"]["status"]
+    comment
+  end
+  
+  attribute :comment_template, %{
+    <li>
+      <p>COMMENT_AUTHOR (COMMENT_DATE)</p>
+      <div>COMMENT_CONTENT</div>
+    </li>
+  }
+  
+  attribute :comment_form, %{
+    <form class="comments" action="/#{snip_name}?snip=SNIP_NAME" method="POST">
+      <label>Name: <input type="text" name="author"></input></label>
+      <label>Email: <input type="text" name="email"></input></label>
+      <label>Website: <input type="text" name="website"></input></label>
+      <textarea name="content"></textarea>
+      <label class="human">Type 'human' if you are one: <input type="text" name="human"></input></label>
+      <button>Submit</button>
+    </form>
+  }
+end

data/lib/vanilla/dynasnips/current_snip.rb

@@ -0,0 +1,32 @@
+require 'vanilla/dynasnip'
+
+class CurrentSnip < Dynasnip
+  usage %|
+    The current_snip dyna normally returns the result of rendering the snip named by the 
+    'snip' value in the parameters. This way, it can be used in templates to place the currently
+    requested snip, in its rendered form, within the page.
+    
+    It can also be used to determine the name of the current snip in a consistent way:
+    
+      {current_snip name}
+      
+    will output the name of the current snip, or the name of the snip currently being edited.
+  |
+  
+  def handle(*args)
+    if args[0] == 'name'
+      if app.request.snip_name == 'edit' # we're editing so don't use this name
+        app.request.params[:snip_to_edit]
+      else
+        app.request.snip_name
+      end
+    else
+      if app.request.snip
+        app.render(app.request.snip, app.request.part)
+      else
+        app.response.status = 404
+        "Couldn't find snip {link_to #{app.request.snip_name}}"
+      end
+    end
+  end
+end

data/lib/vanilla/dynasnips/debug.rb

@@ -0,0 +1,13 @@
+require 'vanilla/dynasnip'
+
+# If the dynasnip is a subclass of Dynasnip, it has access to the request hash
+# (or whatever - access to some object outside of the snip itself.)
+class Debug < Dynasnip
+  def get(*args)
+    app.request.inspect
+  end
+  
+  def post(*args)
+    "You posted! " + app.request.inspect
+  end
+end

data/lib/vanilla/dynasnips/edit.rb

@@ -0,0 +1,63 @@
+require 'vanilla/dynasnip'
+require 'vanilla/dynasnips/login'
+
+# The edit dyna will load the snip given in the 'snip_to_edit' part of the
+# params
+class EditSnip < Dynasnip
+  include Login::Helper
+  
+  snip_name "edit"
+  
+  def get(snip_name=nil)
+    return login_required unless logged_in?
+    snip = Vanilla.snip(snip_name || app.request.params[:name])
+    edit(snip)
+  end
+  
+  def post(*args)
+    return login_required unless logged_in?
+    snip_attributes = cleaned_params
+    snip_attributes.delete(:save_button)
+    return 'no params' if snip_attributes.empty?
+    snip = Vanilla.snip(snip_attributes[:name])
+    snip_attributes[:updated_at] = Time.now
+    snip_attributes.each do |name, value|
+      snip.__send__(:set_value, name, value)
+    end
+    snip.save
+    %{Saved snip #{Vanilla::Routes.link_to snip_attributes[:name]} ok}
+  rescue Exception => e
+    snip_attributes[:created_at] ||= Time.now
+    Soup << snip_attributes
+    %{Created snip #{Vanilla::Routes.link_to snip_attributes[:name]} ok}
+  end
+  
+  def edit(snip)
+    renderer = Vanilla::Renderers::Erb.new(app)
+    renderer.instance_eval { @snip_to_edit = snip } # hacky!
+    snip_in_edit_template = renderer.render_without_including_snips(Vanilla.snip('edit'), :template)
+    prevent_snip_inclusion(snip_in_edit_template)
+  end
+  
+  private
+  
+  def prevent_snip_inclusion(content)
+    content.gsub("{", "&#123;").gsub("}" ,"&#125;")
+  end
+  
+  attribute :template, %{
+    <form action="<%= Vanilla::Routes.url_to 'edit' %>" method="post">
+    <dl class="attributes">
+      <% @snip_to_edit.attributes.each do |name, value| %>
+      <dt><%= name %></dt>
+      <% num_rows = (value || "").split("\n").length + 1 %>
+      <dd><textarea name="<%= name %>" class="<%= name %>" rows="<%= num_rows %>"><%=h value %></textarea></dd>
+      <% end %>
+      <dt><input class="attribute_name" type="text"></input></dt>
+      <dd><textarea></textarea></dd>
+    </dl>
+    <a href="#" id="add">Add</a>
+    <button name='save_button'>Save</button>
+    </form>
+  }
+end

data/lib/vanilla/dynasnips/edit_link.rb

@@ -0,0 +1,24 @@
+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)
+    if args.length < 2
+      show_usage
+    else
+      snip_name = args[0]
+      link_text = args[1]
+      Vanilla::Routes.edit_link(snip_name, link_text)
+    end
+  end
+end

data/lib/vanilla/dynasnips/index.rb

@@ -0,0 +1,11 @@
+require 'vanilla/dynasnip'
+
+class Index < Dynasnip
+  def get(*args)
+    # TODO: figure out a way around calling Soup/AR methods directly.
+    list = Soup.tuple_class.find_all_by_name('name').map { |tuple| 
+      "<li>#{Vanilla::Routes.link_to tuple.value}</li>"
+    }
+    "<ol>#{list}</ol>"
+  end
+end

data/lib/vanilla/dynasnips/kind.rb

@@ -0,0 +1,70 @@
+require 'vanilla/dynasnip'
+require 'atom'
+require 'date'
+
+class Kind < Dynasnip
+  def handle(kind, limit=10, as=:html)
+    as = as.to_sym
+    snips = 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 = prepare_snip_contents(snip)
+    case as
+    when :html
+      snip_template.
+        gsub('SNIP_KIND', kind).
+        gsub('SNIP_NAME', snip.name).
+        gsub('CREATED_AT', snip.created_at || '').
+        gsub('SNIP_CONTENT', rendered_contents)
+    when :xml
+      Atom::Entry.new do |e|
+        e.published = DateTime.parse(snip.created_at)
+        e.updated = DateTime.parse(snip.updated_at || snip.created_at)
+        e.content = Atom::Content::Html.new(rendered_contents)
+        e.title = snip.name
+        e.authors = [Atom::Person.new(:name => snip.author || domain)]
+        e.links << Atom::Link.new(:href => "http://#{domain}#{Vanilla::Routes.url_to(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)
+    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
+      entries.join
+    when :xml
+      Atom::Feed.new do |f|
+        f.title = feed_title
+        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, %{
+    <div class="snip SNIP_KIND">
+      <div class="details">
+        #{Vanilla::Routes.link_to '#', 'SNIP_NAME'}
+        <p class="created_at">CREATED_AT</p>
+      </div>
+      <div class="content">
+        SNIP_CONTENT
+      </div>
+    </div>
+  }
+end

data/lib/vanilla/dynasnips/link_to.rb

@@ -0,0 +1,14 @@
+require 'vanilla/dynasnip'
+
+class LinkTo < Dynasnip
+  usage %|
+The link_to dyna lets you create links between snips: 
+
+  {link_to blah} 
+
+would insert a link to the blah snip.|
+
+  def handle(snip_name)
+    Vanilla.snip_exists?(snip_name) ? Vanilla::Routes.link_to(snip_name) : Vanilla::Routes.new_link(snip_name)
+  end
+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
+      Vanilla::Routes.link_to app.request.params[:snip_to_edit]
+    else
+      Vanilla::Routes.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 = Vanilla::Routes.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/lib/vanilla/dynasnips/pre.rb

@@ -0,0 +1,19 @@
+require 'vanilla/dynasnip'
+
+class ShowContentInPreTag < Dynasnip
+  snip_name "pre"
+
+  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>#{Vanilla.snip(snip_name).__send__(part || :content)}</pre>}
+  end
+end

data/lib/vanilla/dynasnips/rand.rb

@@ -0,0 +1,27 @@
+require 'vanilla/dynasnip'
+
+class RandomNumber < Dynasnip
+  snip_name "rand"
+  
+  usage %|
+    Returns a random number, normally between 1 and 100. 
+    The range can be limited:
+    
+    {rand 50} renders a random number between 1 and 50
+    {rand 2,19} renders a random number between 2 and 19
+  |
+  
+  def handle(*args)
+    min = 1
+    max = 100
+    max = args[0] if args.length == 1
+    if args.length == 2
+      min = args[0]
+      max = args[1]
+    end
+    # arguments come in as strings, so we need to convert them.
+    min = min.to_i
+    max = max.to_i
+    (rand(max-min) + min)
+  end
+end

data/lib/vanilla/dynasnips/raw.rb

@@ -0,0 +1,19 @@
+require 'vanilla/dynasnip'
+
+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)
+    %{<pre>#{Dynasnip.escape_curly_braces(Vanilla.snip(snip_name).__send__(part || :content))}</pre>}
+  end
+end

data/lib/vanilla/dynasnips/url_to.rb

@@ -0,0 +1,7 @@
+require 'vanilla/dynasnip'
+
+class UrlTo < Dynasnip
+  def handle(snip_name)
+    Snip[snip_name] ? Vanilla::Routes.url_to(snip_name) : "[Snip '#{snip_name}' not found]"
+  end
+end

data/lib/vanilla/renderers/base.rb

@@ -0,0 +1,78 @@
+require 'vanilla/app'
+
+module Vanilla
+  module Renderers
+    class Base
+      
+      # 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
+      
+      def self.snip_regexp
+        %r{ \{
+          ([\w\-]+) (?: \.([\w\-]+) )?
+          (?: \s+ ([\w\-,]+) )?
+        \} }x
+      end
+    
+      # Default behaviour to include a snip's content
+      def include_snips(content)
+        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)
+          else
+            app.render_missing_snip(snip_name)
+          end
+        end
+      end
+      
+      # Default rendering behaviour. Subclasses shouldn't really need to touch this.
+      def render(snip, part=:content, args=[])
+        prepare(snip, part, args)
+        processed_text = render_without_including_snips(snip, part)
+        include_snips(processed_text)
+      end
+      
+      # Subclasses should override this to perform any actions required before
+      # rendering
+      def prepare(snip, part, args)
+        # 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 
+      # 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)
+      end
+    end
+  end
+end

data/lib/vanilla/renderers/bold.rb

@@ -0,0 +1,9 @@
+require 'vanilla/renderers/base'
+
+module Vanilla::Renderers
+  class Bold < Base
+    def process_text(content)
+      "<b>#{content}</b>" 
+    end
+  end
+end

data/lib/vanilla/renderers/erb.rb

@@ -0,0 +1,16 @@
+require 'vanilla/renderers/base'
+
+require 'erb'
+include ERB::Util
+
+module Vanilla::Renderers
+  class Erb < Base
+    def prepare(snip, part=:content, args=[])
+      @snip = snip
+    end
+    
+    def process_text(content)
+      ERB.new(content).result(binding)
+    end
+  end
+end

data/lib/vanilla/renderers/markdown.rb

@@ -0,0 +1,13 @@
+require 'vanilla/renderers/base'
+
+require 'rubygems'
+gem 'BlueCloth' # from http://www.deveiate.org/projects/BlueCloth
+require 'bluecloth'
+
+module Vanilla::Renderers
+  class Markdown < Base
+    def process_text(content)
+      BlueCloth.new(content).to_html
+    end
+  end
+end

data/lib/vanilla/renderers/raw.rb

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