eduardo-vanilla 1.0.2

data/lib/vanilla/app.rb

@@ -0,0 +1,87 @@
+require 'vanilla'
+require 'vanilla/request'
+
+module Vanilla
+  class App
+    
+    attr_reader :request, :response, :config
+    
+    def initialize(config_file=nil)
+      prepare_configuration(config_file)
+      Soup.prepare
+    end
+    
+    # Returns a Rack-appropriate 3-element array (via Rack::Response#finish)
+    def call(env)
+      @request = Vanilla::Request.new(env)
+      @response = Rack::Response.new
+
+      begin
+        output = formatted_render(request.snip, request.part, request.format)
+      rescue => e
+        @response.status = 500
+        output = e.to_s
+      end
+      response_format = request.format      
+      response_format = 'plain' if response_format == 'raw'
+      @response['Content-Type'] = "text/#{response_format}"
+      @response.write(output)
+      @response.finish # returns the array
+    end
+
+    def formatted_render(snip, part=nil, format=nil)
+      case format
+      when 'html', nil
+        Renderers::Erb.new(self).render(Vanilla.snip('system'), :main_template)
+      when 'raw', 'css', 'js'
+        Renderers::Raw.new(self).render(snip, part || :content)
+      when 'text', 'atom', 'xml'
+        render(snip, part || :content)
+      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.
+    def render(snip, part=:content, args=[])
+      rendering(snip) do |renderer|
+        renderer.render(snip, part, args)
+      end
+    end
+
+    # Given the snip and parameters, yield an instance of the appropriate 
+    # Vanilla::Render::Base subclass
+    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" + 
+        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 }
+      end
+    end
+  end
+end

data/lib/vanilla/console.rb

@@ -0,0 +1,3 @@
+require 'vanilla'
+Soup.prepare
+puts "The Soup is simmering."

data/lib/vanilla/dynasnip.rb

@@ -0,0 +1,110 @@
+require 'vanilla/renderers/base'
+require 'enumerator'
+
+class Dynasnip < Vanilla::Renderers::Base
+  
+  def self.all
+    ObjectSpace.enum_for(:each_object, class << self; self; end).to_a - [self]
+  end
+  
+  def self.snip_name(new_name=nil)
+    if new_name
+      @snip_name = new_name.to_s
+    else
+      # borrowed from ActiveSupport
+      @snip_name ||= self.name.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+  end
+  
+  def self.attribute(attribute_name, attribute_value=nil)
+    @attributes ||= {}
+    @attributes[attribute_name.to_sym] = attribute_value if attribute_value
+    @attributes[attribute_name.to_sym]
+  end
+  
+  def self.usage(str)
+    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
+  
+  def method_missing(method, *args)
+    if snip = Vanilla.snip(snip_name)
+      snip.get_value(method)
+    elsif part = self.class.attribute(method)
+      part
+    else
+      super
+    end
+  end
+  
+  # dynasnips gain access to the app in the same way as Render::Base
+  # subclasses
+  
+  protected
+  
+  def snip_name
+    self.class.snip_name
+  end
+  
+  def snip
+    Snip[snip_name]
+  end
+  
+  def show_usage
+    if snip.usage
+      Vanilla::Renderers::Markdown.render(snip_name, :usage)
+    else
+      "No usage information for #{snip_name}"
+    end
+  end
+  
+  def cleaned_params
+    p = app.request.params.dup
+    p.delete(:snip)
+    p.delete(:format)
+    p.delete(:method)
+    p.delete(:part)
+    p
+  end
+end

data/lib/vanilla/dynasnips/code.rb

@@ -0,0 +1,16 @@
+require 'vanilla/dynasnip'
+require 'syntax/convertors/html'
+
+class CodeHighlighter < Dynasnip
+  snip_name "code"
+  
+  def handle(language, snip_to_render, part_to_render='content')
+    snip = Vanilla.snip(snip_to_render)
+    text = snip.__send__(part_to_render.to_sym)
+    convertor = Syntax::Convertors::HTML.for_syntax(language)
+    code = convertor.convert(text, false)
+    %(<span class="code ) + language + %("><code>) + code + %(</code></span>)
+  end
+
+  self
+end

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