vanilla 1.2 → 1.9.9

data/lib/vanilla.rb

@@ -1,14 +1,7 @@
-module Vanilla
-  VERSION = "1.2"
+require 'vanilla/app'
 
-  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 other renderer subclasses
+Dir[File.join(File.dirname(__FILE__), 'vanilla', 'renderers', '*.rb')].each { |f| require f }  
 
 # Load all the base dynasnip classes
 Dir[File.join(File.dirname(__FILE__), 'vanilla', 'dynasnips', '*.rb')].each do |dynasnip|

data/lib/vanilla/app.rb

@@ -1,35 +1,26 @@
-require 'soup'
+require 'vanilla/request'
+require 'vanilla/routes'
+require 'vanilla/soup_with_timestamps'
+
+# Require the base set of renderers
+require 'vanilla/renderers/base'
+require 'vanilla/renderers/raw'
+require 'vanilla/renderers/erb'
+
 
 module Vanilla
   class App
-    include Vanilla::Routes
-
+    include 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])
+    
+    def initialize(config_file=nil)
+      prepare_configuration(config_file)
+      @soup = SoupWithTimestamps.new(config[:soup])
     end
-
+    
     # Returns a Rack-appropriate 3-element array (via Rack::Response#finish)
     def call(env)
-      env['vanilla.app'] = self
       @request = Vanilla::Request.new(env, self)
       @response = Rack::Response.new
 
@@ -37,9 +28,9 @@ module Vanilla
         output = formatted_render(request.snip, request.part, request.format)
       rescue => e
         @response.status = 500
-        output = e.to_s + e.backtrace.join("\n")
+        output = e.to_s
       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)
@@ -49,16 +40,11 @@ module Vanilla
     def formatted_render(snip, part=nil, format=nil)
       case format
       when 'html', nil
-        layout = layout_for(snip)
-        if layout == snip
-          "Rendering of the current layout would result in infinite recursion."
-        else
-          render(layout)
-        end
+        Renderers::Erb.new(self).render(soup['system'], :main_template)
       when 'raw', 'css', 'js'
-        Renderers::Raw.new(self).render(snip, part)
+        Renderers::Raw.new(self).render(snip, part || :content)
       when 'text', 'atom', 'xml'
-        render(snip, part)
+        render(snip, part || :content)
       else
         raise "Unknown format '#{format}'"
       end
@@ -73,82 +59,40 @@ module Vanilla
       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)
-      if snip
-        find_renderer(snip.render_as || snip.extension)
-      else
-        default_renderer
-      end
-    end
-
-    def default_layout_snip
-      soup[config[:default_layout_snip] || 'layout']
+      return Renderers::Base unless snip.render_as && !snip.render_as.empty?
+      Vanilla::Renderers.const_get(snip.render_as)
     end
-
-    def layout_for(snip)
-      if snip
-        renderer_for(snip).new(self).layout_for(snip)
-      else
-        default_layout_snip
-      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
-
+    
     def snip(attributes)
-      @soup << attributes
+      @soup.new_snip(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
-
+    
     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
-      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
-
-    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]))
+    
+    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

data/lib/vanilla/console.rb

@@ -1,23 +1,9 @@
 require 'vanilla'
+require 'irb'
 
-module Vanilla
-  class RackShim
-    def run(app)
-      app # return it
-    end
-    def use(*args)
-      # ignore
-    end
-    def get_binding
-      binding
-    end
-  end
+def app(reload=false)
+  @__vanilla_console_app = nil if reload
+  @__vanilla_console_app ||= Vanilla::App.new(ENV['VANILLA_CONFIG'])
 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
+puts "The Soup is simmering."

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 = app.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="#{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 = app.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'
+      app.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(app.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/{pristine_app/soups → lib/vanilla}/dynasnips/debug.rb

@@ -1,15 +1,13 @@
 require 'vanilla/dynasnip'
-require 'cgi'
 
 # 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)
-    CGI.escapeHTML(app.request.inspect)
+    app.request.inspect
   end
-
+  
   def post(*args)
-    "You posted! " + CGI.escapeHTML(app.request.inspect)
+    "You posted! " + app.request.inspect
   end
-  self
 end

data/lib/vanilla/dynasnips/edit.rb

@@ -0,0 +1,60 @@
+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 = app.soup[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 = app.soup[snip_attributes[:name]]
+    snip_attributes.each do |name, value|
+      snip.__send__(:set_value, name, value)
+    end
+    snip.save
+    %{Saved snip #{link_to snip_attributes[:name]} ok}
+  rescue Exception => e
+    app.soup << snip_attributes
+    %{Created snip #{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(app.soup['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="<%= url_to 'edit' %>" method="post">
+    <dl class="attributes">
+      <% @snip_to_edit.attributes.each do |name, value| %>
+      <dt><%= name %></dt>
+      <dd><textarea name="<%= name %>" class="<%= name %>"><%=h value %></textarea></dd>
+      <% end %>
+      <dt><input class="attribute_name" type="text"></dt>
+      <dd><textarea></textarea></dd>
+    </dl>
+    <a href="#" id="add">Add</a>
+    <button name='save_button'>Save</button>
+    </form>
+  }
+end