vanilla 1.0.2 → 1.2

data/lib/vanilla/snip_reference_parser.rb

@@ -0,0 +1,94 @@
+require "parslet"
+
+module Vanilla
+  class SnipReferenceParser
+    class Reference
+      def initialize(attributes)
+        @attributes = attributes
+      end
+      def snip
+        @attributes[:snip]
+      end
+      def attribute
+        @attributes[:attribute]
+      end
+      def arguments
+        @attributes[:arguments] || []
+      end
+    end
+
+    def parse(string)
+      Reference.new(SnipTransform.new.apply(SnipParser.new.parse(string)))
+    end
+
+    class SnipParser < Parslet::Parser
+      rule(:spaces) { match('\s').repeat(1) }
+      rule(:spaces?) { spaces.maybe }
+      rule(:comma)  { match(',') }
+      rule(:dot)    { str(".") }
+      rule(:squote) { str("'") }
+      rule(:dquote) { str('"') }
+      rule(:escaped_dquote) { str('"') }
+      rule(:left_brace) { str("{") }
+      rule(:right_brace) { str("}") }
+
+      rule(:word) { match("[a-zA-Z0-9_\\-]").repeat(1) }
+      rule(:quotables) { word | comma | spaces }
+      rule(:double_quoted_string) do
+        dquote >> (quotables | squote).repeat(1).as(:string) >> dquote
+      end
+      rule(:single_quoted_string) do
+        squote >> (quotables | dquote).repeat(1).as(:string) >> squote
+      end
+      rule(:string) do
+        single_quoted_string | double_quoted_string | str("nil").as(:nil) | word.as(:string)
+      end
+      rule(:symbol) { str(":") >> string }
+
+      rule(:comma_separator) { spaces? >> comma >> spaces? }
+      rule(:hash_separator) { spaces? >> str("=>") >> spaces? }
+      rule(:named_separator) { spaces? >> str(":") >> spaces? }
+
+      rule(:hash_arg) { (symbol | string).as(:key) >> hash_separator >> string.as(:value) }
+      rule(:named_arg) { string.as(:key) >> named_separator >> string.as(:value) }
+
+      rule(:string_arg_list) { (string.as(:string_arg) >> further_string_args.repeat).as(:string_arg_list) }
+      rule(:further_string_args) { comma_separator >> string.as(:string_arg) }
+
+      rule(:hash_arg_list) { (hash_arg.as(:hash_arg) >> further_hash_args.repeat).as(:key_value_arg_list) }
+      rule(:further_hash_args) { comma_separator >> hash_arg.as(:hash_arg) }
+
+      rule(:named_arg_list) { (named_arg.as(:named_arg) >> further_named_args.repeat).as(:key_value_arg_list) }
+      rule(:further_named_args) { comma_separator >> named_arg.as(:named_arg) }
+
+      rule(:arguments) { hash_arg_list | named_arg_list | string_arg_list }
+      rule(:snip_part) { string.as(:snip) >> (dot >> string.as(:attribute)).maybe }
+
+      rule(:snip_reference) do
+        left_brace >> spaces? >>
+          snip_part >> (spaces >> arguments.as(:arguments)).maybe >>
+          spaces? >> right_brace
+      end
+
+      root(:snip_reference)
+    end
+
+    class SnipTransform < Parslet::Transform
+      rule(:nil => simple(:x)) { nil }
+      rule(:string => simple(:x)) { x.to_s }
+      rule(:string_arg => simple(:x)) { x }
+      rule(:string_arg_list => simple(:x)) { [x] }
+      rule(:string_arg_list => sequence(:x)) { x }
+
+      class Arg
+        def initialize(k, v); @k, @v = k, v; end
+        def to_h; {@k.to_sym => @v}; end
+      end
+
+      rule(:hash_arg => subtree(:x)) { Arg.new(x[:key], x[:value]) }
+      rule(:named_arg => subtree(:x)) { Arg.new(x[:key], x[:value]) }
+      rule(:key_value_arg_list => simple(:x)) { x.to_h }
+      rule(:key_value_arg_list => sequence(:x)) { x.inject({}) { |h, kv| h.merge(kv.to_h) } }
+    end
+  end
+end

data/lib/vanilla/static.rb

@@ -0,0 +1,28 @@
+require 'rack/utils'
+
+# Heavily based on ActionDispatch::Static
+module Vanilla
+  class Static
+    def initialize(app, root)
+      @app = app
+      @file_server = ::Rack::File.new(root)
+    end
+
+    def call(env)
+      path   = env['PATH_INFO'].chomp('/')
+      method = env['REQUEST_METHOD']
+
+      if %w(GET HEAD).include?(method) && file_exist?(path)
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+      def file_exist?(path)
+        full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+        File.file?(full_path) && File.readable?(full_path)
+      end
+  end
+end

data/pristine_app/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gem 'vanilla', :path => File.expand_path("../..", __FILE__)

data/pristine_app/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: /Users/james/Code/lazyatom/vanilla-rb
+  specs:
+    vanilla (1.14.1)
+      BlueCloth (>= 1.0.0)
+      RedCloth (>= 4.1.1)
+      haml
+      rack (>= 0.9.1)
+      ratom (>= 0.3.5)
+      soup (>= 1.0.6)
+      treetop (>= 1.4.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    BlueCloth (1.0.1)
+    RedCloth (4.2.7)
+    haml (3.1.1)
+    libxml-ruby (2.0.2)
+    polyglot (0.3.1)
+    rack (1.2.2)
+    ratom (0.6.7)
+      libxml-ruby (>= 1.1.2)
+    soup (1.0.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  vanilla!

data/pristine_app/README

@@ -0,0 +1,47 @@
+                      WELCOME IN VANILLA
+                                 Vanilla
+                                 vanilla
+                                 .........vanillaaaaaAAAAAAAAAAA
+
+What you've got:
+
+  Gemfile    - specifying your dependencies
+  config.ru  - this is the rack configuration, which is used to start
+               the application by your webserver
+  soup/      - the default soup directory, where your snips are stored
+
+
+For an overview of vanilla, start your site and look at the tutorial:
+
+  $ rackup   # then open http://localhost:9292/tutorial
+
+
+Editing snips
+-------------
+You can edit any file in the soup directory using your favourite editor,
+and the changes will be reflected automatically. The snip files are
+slightly modified YAML files. Here's an example, which you might save
+in a file called 'soup.snip':
+
+
+    Soup is a data store supporting the {link_to snip}-space that 
+    {link_to vanilla-rb} expects.
+
+    It's hosted on github [here](http://github.com/lazyatom/soup).
+
+    :created_at: 2011-05-23 14:14:16 +01:00
+    :updated_at: 2009-05-23 15:23:22 +01:00
+    :render_as: Markdown
+
+
+The 'content' of the snip is at the top of the file, followed by the
+rest of the snip attributes on lines starting with ':'.
+
+
+The console
+-----------
+
+Within a vanilla app directory, you can run `vanilla console` to start
+an IRB session and interact with your app and snips. The `app` method
+returns your application object, and `app.soup['start']` will return
+the start snip from your soup(s).

data/pristine_app/config.ru

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift File.join(File.dirname(__FILE__), *%w[lib])
+
+require 'vanilla'
+
+# You can partition your snips into subdirectories to keep things tidy. This
+# doesn't affect their URL structure on the site (everything is flat).
+soups = [
+  "soups/base",
+  "soups/dynasnips"
+]
+
+# If you don't want the tutorial on your site, remove this and delete the directory
+soups << "soups/tutorial"
+
+# This is a dumping ground of ideas at the moment
+# soups << "soups/extras"
+
+app = Vanilla::App.new(:soups => soups)
+
+# If you running your site under a proper webserver, you probably don't need this.
+require 'vanilla/static'
+use Vanilla::Static, File.join(File.dirname(__FILE__), 'public')
+
+run app

data/pristine_app/public/vanilla.css

@@ -0,0 +1,15 @@
+#controls {
+  padding-left: 0;
+}
+
+#controls li {
+  background: #eee;
+  display: inline;
+  padding: 0.2em 0.5em;
+}
+
+pre {
+  margin-left: 1em;
+  background-color: #ddd;
+  padding: 1em;
+}

data/pristine_app/soups/base/layout.snip

@@ -0,0 +1,18 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+  <title>{page_title}</title>
+  <link rel="stylesheet" href="/vanilla.css" type="text/css" media="screen" title="no title" charset="utf-8">
+</head>
+<body>
+  <ul id="controls">
+    <li><a href="/">home</a></li>
+    <li>{link_to index}</li>
+    <li>you are viewing: {link_to_current_snip}</li>
+  </ul>
+  <div id="content">
+    {current_snip}
+  </div>
+</body>
+</html>

data/pristine_app/soups/base/start.snip

@@ -0,0 +1,19 @@
+<h1>Welcome to Vanilla.rb</h1>
+
+<p>Vanilla.rb is a web-experiment (a <em>websperiment</em>?) about storing and reusing data on a website. It can also function as a <a href="http://www.wikipedia.com/wiki/Bliki">bliki</a>.</p>
+
+<p>From a technical perspective, vanilla is a Ruby rack application, and should play well within the rack ecosystem. It uses a simple document store called `soup` to store data.</p>
+
+<h2>What now?</h2>
+
+<p>If this is your first time using vanilla, you should investigate the {link_to tutorial} for some orientation.</p>
+
+<h2>What next?</h2>
+
+<p>This is the {link_to start} snip, which is the default home page. You can find this content in `start.snip`.</p>
+
+<p>You should replace this content with whatever you want on your site's home page.</p>
+
+<p>Once your site is ready to run, you'll probably want to remove the tutorial; you can do this by editing the configuration in `config.ru`, and deleting the `soups/tutorial` directory.</p>
+
+<p>Good luck!</p>

data/pristine_app/soups/dynasnips/current_snip.rb

@@ -0,0 +1,29 @@
+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 an attribute of the current snip in a consistent way:
+
+      {current_snip name}
+
+    will output the name of the current snip.
+  |
+
+  def handle(attribute=nil)
+    if app.request.snip
+      if attribute ||= app.request.part
+        "{#{app.request.snip_name}.#{attribute}}"
+      else
+        "{#{app.request.snip_name}}"
+      end
+    else
+      app.response.status = 404
+      %{Couldn't find snip "#{app.request.snip_name}"}
+    end
+  end
+  self
+end

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

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

data/pristine_app/soups/dynasnips/index.rb

@@ -0,0 +1,12 @@
+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|
+      "<li>#{link_to snip.name}</li>"
+    }
+    "<ol>#{list}</ol>"
+  end
+
+  self
+end

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

@@ -8,7 +8,9 @@ The link_to dyna lets you create links between snips:
 
 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)
+  def handle(snip_name, link_text=snip_name, part=nil)
+    link_to(link_text, snip_name, part)
   end
+
+  self
 end

data/pristine_app/soups/dynasnips/link_to_current_snip.rb

@@ -0,0 +1,14 @@
+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)
+    link_to app.request.snip_name
+  end
+
+  self
+end

data/pristine_app/soups/dynasnips/page_title.rb

@@ -0,0 +1,9 @@
+require 'vanilla/dynasnip'
+
+class PageTitle < Dynasnip
+  def handle
+    app.request.snip.page_title || app.request.snip.name
+  end
+
+  self
+end

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

@@ -5,15 +5,17 @@ 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>#{Vanilla.snip(snip_name).__send__(part || :content)}</pre>}
+    %{<pre>#{app.soup[snip_name].__send__(part || :content)}</pre>}
   end
+
+  self
 end

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

@@ -1,19 +1,22 @@
 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)
-    %{<pre>#{Dynasnip.escape_curly_braces(Vanilla.snip(snip_name).__send__(part || :content))}</pre>}
+    %{#{Dynasnip.escape_curly_braces(CGI.escapeHTML(app.soup[snip_name].__send__(part || :content)))}}
   end
+
+  self
 end