vanilla 1.0.0

data/README

@@ -0,0 +1,52 @@
+--~::{ Vanilla.rb }::~---
+=========================
+
+  A wandering soul; a repo clone'd -
+  his meta_klass and methods honed.
+  But tarry he 'ponst what dark endeavour
+  with code of such unknowable terror?
+
+                              - H.P. Gemcraft, 1914
+
+A Preface; A Warning
+====================
+
+The base flavour. The classic ice cream. Except riddled through with blood-red gemstones - Ruby gemstones.
+This mad gelato will break your teeth.
+
+... and run the freakiest wiki-wonki-wiki-wonki-wiki-wonki-wickedy-wiki you've ever seen. 
+
+But you must not fear: fear is the mind-killer; fear is the little death that brings total oblivion; 
+fear is the chilling terror that makes you believe that *everything* is better when Model lays with 
+Controller and View in peace.
+
+Vanilla.rb cries "HERESY!" upon that layered orgy of filth. Vanilla.rb says "EMBRACE CHAOS!". Vanilla.rb
+says "EVERY SNIP FOR THEMSELVES!". Vanilla.rb waits quietly, in the dark corners.
+
+Use at your own risk; really. I showed it to a cat, and the cat started talking in French. 
+It was MESSED. UP.
+
+
+Thee Darke Invocation
+=====================
+
+$ gem install soup sqlite3-ruby rack ratom RedCloth BlueCloth
+
+$ rake setup
+
+... a bunch of stuff gets created
+
+$ rackup
+
+... the wonki starts. THE PAIN BEGINS. 
+
+(Try going to http://localhost:9292/vanilla-rb-tutorial to salve the chafing.)
+
+
+Working with Vanilla
+====================
+
+Currently unknowable; soon I hope to compile such a nercronomicon as to allow mortal kind to
+conjure up Snips and Dynasnips and Renderers...
+
+For the moment, see http://interblah.net/vanilla-rb-tutorial

data/Rakefile

@@ -0,0 +1,118 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'vanilla'
+
+require 'spec'
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = %w(--format specdoc --colour)
+  t.libs = ["spec"]
+end
+
+task :default => :spec
+
+
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+  
+  # Change these as appropriate
+  s.name              = "vanilla"
+  s.version           = "1.0.0"
+  s.summary           = "A bliki-type web content thing."
+  s.author            = "James Adam"
+  s.email             = "james@lazyatom.com.com"
+  s.homepage          = "http://github.com/lazyatom/vanilla-rb"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README)
+  s.rdoc_options      = %w(--main README)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(config.example.yml config.ru Rakefile README) + Dir.glob("{spec,lib,bin}/**/*")
+  s.executables       = ['vanilla']
+  s.require_paths     = ["lib"]
+  
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  # s.add_dependency("some_other_gem", "~> 0.1.0")
+  
+  s.add_development_dependency("rspec") # add any other gems for testing/development
+
+  # If you want to publish automatically to rubyforge, you'll may need
+  # to tweak this, and the publishing task below too.
+  s.rubyforge_project = "vanilla"
+end
+
+# This task actually builds the gem. We also regenerate a static 
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  
+  # Generate the gemspec file for github.
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end
+
+# If you want to publish to RubyForge automatically, here's a simple 
+# task to help do that. If you don't, just get rid of this.
+# Be sure to set up your Rubyforge account details with the Rubyforge
+# gem; you'll need to run `rubyforge setup` and `rubyforge config` at
+# the very least.
+begin
+  require "rake/contrib/sshpublisher"
+  namespace :rubyforge do
+    
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+    
+    namespace :release do
+      desc "Release a new version of this gem"
+      task :gem => [:package] do
+        require 'rubyforge'
+        rubyforge = RubyForge.new
+        rubyforge.configure
+        rubyforge.login
+        rubyforge.userconfig['release_notes'] = spec.summary
+        path_to_gem = File.join(File.dirname(__FILE__), "pkg", "#{spec.name}-#{spec.version}.gem")
+        puts "Publishing #{spec.name}-#{spec.version.to_s} to Rubyforge..."
+        rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version.to_s, path_to_gem)
+      end
+    
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+ 
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/vanilla-rb/" # Should be the same as the rubyforge project name
+        local_dir = 'rdoc'
+ 
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/bin/vanilla

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rake'
+load File.join(File.dirname(__FILE__), *%w[.. lib tasks vanilla.rake])
+
+mkdir(ARGV[0])
+cd(ARGV[0])
+
+Rake::Task['vanilla:setup'].invoke

data/config.example.yml

@@ -0,0 +1,5 @@
+--- 
+:filename: config.example.yml
+:secret: a6bc097eff86cabd92ee72ba4687c3f057b7556deaa3e4a6b284460871056b87ba3e91548c37dcc44fbc10241cee5b386556e6bcc2946fd9b609dc3bc1b24488
+:credentials: 
+  admin: 5f4dcc3b5aa765d61d8327deb882cf99

data/config.ru

@@ -0,0 +1,9 @@
+require 'vanilla'
+
+app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+use Rack::Session::Cookie, :key => 'vanilla.session',
+                           :path => '/',
+                           :expire_after => 2592000,
+                           :secret => app.config[:secret]
+use Rack::Static, :urls => ["/public"], :root => File.join(File.dirname(__FILE__))
+run app

data/lib/defensio.rb

@@ -0,0 +1,59 @@
+class Defensio
+  class << self
+    attr_accessor :format
+    attr_accessor :service_type
+    attr_accessor :api_version
+    attr_accessor :api_key
+    attr_accessor :owner_url
+  end
+  
+  self.format = :xml
+  self.service_type = :app # Can be :blog
+  self.api_version = '1.2'
+  
+  def self.configure(confhash)
+    if confhash['test']
+      @mock = true
+      self.owner_url = 'http://www.example.com'
+      return
+    else
+      confhash.each do |prop, val|
+        self.send("#{prop}=", val)
+      end
+    end
+  end
+  
+  def self.method_missing(name, *args)
+    self.post(name.to_s.dasherize, *args)
+  end
+  
+  private
+    def self.connection
+      uri = URI.parse('http://api.defensio.com/')
+      Net::HTTP.start(uri.host, uri.port)
+    end
+  
+    def self.post(action, params = {})
+      resp = connection.post(real_path(action), params_from_hash(params))
+      raise "Problem with request: #{action}" unless resp.code == '200'
+      parse_response(resp.body)
+    end
+  
+    def self.real_path(action)
+      "/#{service_type}/#{api_version}/#{action}/#{api_key}.#{format}"
+    end
+  
+    def self.params_from_hash(params = {})
+      # Thanks Net::HTTPHeader
+      params.stringify_keys.merge('owner-url' => owner_url).map {|k,v| "#{CGI.escape(k.dasherize.to_s)}=#{CGI.escape(v.to_s)}" }.join('&') 
+    end
+  
+    def self.parse_response(body)
+      case format
+      when :yaml
+        YAML.load(body)
+      when :xml
+        Hash.from_xml(body)
+      end
+    end
+end

data/lib/tasks/vanilla.rake

@@ -0,0 +1,178 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+require 'vanilla'
+
+namespace :vanilla do
+  desc "Open an irb session preloaded with this library"
+  task :console do
+    sh "irb -Ilib -rubygems -rvanilla -rvanilla/console"
+  end
+
+  task :clean do
+    # TODO: get the database name from Soup
+    FileUtils.rm "soup.db" if File.exist?("soup.db")
+  end
+
+  task :prepare do
+    Soup.prepare
+  end
+
+  task :load_snips => :prepare do  
+    Dynasnip.persist_all!(overwrite=true)
+  
+    Dir[File.join(File.dirname(__FILE__), '..', 'vanilla', 'snips', '*.rb')].each do |f|
+      p "loading #{f}"
+      load f
+    end  
+  
+    load File.join(File.dirname(__FILE__), *%w[.. vanilla test_snips.rb])
+  
+    puts "The soup is simmering. Loaded #{Soup.tuple_class.count} tuples"
+  end
+
+  desc 'Resets the soup to contain the base snips only. Dangerous!'
+  task :reset => [:clean, :load_snips]
+
+  namespace :upgrade do
+    desc 'Upgrade the dynasnips'
+    task :dynasnips => :prepare do
+      Dynasnip.all.each do |dynasnip|
+        print "Upgrading #{dynasnip.snip_name}... "
+        # TODO: our confused Soup interface might return an array.
+        snip = Soup[dynasnip.snip_name]
+        if snip.empty? || snip.nil?
+          # it's a new dyna
+          Soup << dynasnip.snip_attributes
+          puts "(new)"
+        elsif snip.created_at == snip.updated_at
+          # it's not been changed, let's upgrade
+          snip.destroy
+          Soup << dynasnip.snip_attributes
+          puts "(unedited)"
+        else
+          # the dyna exists and has been changed
+          dynasnip.snip_attributes.each do |name, value|
+            unless (existing_value = snip.get_value(name)) == value
+              puts "Conflict in attribute '#{name}':"
+              puts "> Your soup: '#{existing_value}'"
+              puts ">  New soup: '#{value}"
+              print "Upgrade? [Y/n]: "
+              upgrade_value = ["Y", "y", ""].include? STDIN.gets.chomp.strip
+              snip.set_value(name, value) if upgrade_value
+            end
+          end
+          snip.save
+        end
+      end
+    end
+  end
+
+  desc 'Upgrade dynasnips and system snips'
+  task :upgrade => ["upgrade:dynasnips"]
+
+  desc 'Add a user (or change an existing password)'
+  task :add_user => :prepare do
+    puts "Adding a new user"
+    # config_file = ENV['VANILLA_CONFIG'] || 'config.yml'
+    # config_file = YAML.load(File.open(config_file)) rescue {}
+    app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+    print "Username: "
+    username = STDIN.gets.chomp.strip
+    print "Password: "
+    password = STDIN.gets.chomp.strip
+    print "Confirm password: "
+    confirm_password = STDIN.gets.chomp.strip
+    if password != confirm_password
+      raise "Passwords don't match!"
+    else
+      app.config[:credentials] ||= {}
+      app.config[:credentials][username] = MD5.md5(password).to_s
+      app.config.save!
+      puts "User '#{username}' added."
+    end
+  end
+
+  desc 'Generate file containing secret for cookie-based session storage'
+  task :generate_secret do
+    # Adapted from old rails secret generator.
+    require 'openssl'
+    if !File.exist?("/dev/urandom")
+      # OpenSSL transparently seeds the random number generator with
+      # data from /dev/urandom. On platforms where that is not
+      # available, such as Windows, we have to provide OpenSSL with
+      # our own seed. Unfortunately there's no way to provide a
+      # secure seed without OS support, so we'll have to do with
+      # rand() and Time.now.usec().
+      OpenSSL::Random.seed(rand(0).to_s + Time.now.usec.to_s)
+    end
+    data = OpenSSL::BN.rand(2048, -1, false).to_s
+    secret = OpenSSL::Digest::SHA512.new(data).hexdigest
+    app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+    app.config[:secret] = secret
+    app.config.save!
+    puts "Secret generated."
+  end
+
+  desc 'Prepare standard files to run Vanilla'
+  task :prepare_files do
+    cp File.join(File.dirname(__FILE__), *%w[.. .. config.ru]), 'config.ru'
+    cp_r File.join(File.dirname(__FILE__), *%w[.. .. public]), 'public'
+    mkdir 'tmp'
+    File.open("Rakefile", "w") do |f|
+      rakefile =<<-EOF
+require 'vanilla'
+load 'tasks/vanilla.rake'
+
+# Add any other tasks here.
+EOF
+      f.write rakefile.strip
+    end
+  end
+
+
+  desc 'Prepare a new vanilla.rb installation'
+  task :setup do
+    puts <<-EOM
+
+  ===================~ Vanilla.rb ~====================
+
+  Congratulations! You have elected to try out the weirdest web thing ever.
+  Lets get started. Firstly, I'm going to cook you some soup:
+
+
+  EOM
+    Rake::Task['vanilla:load_snips'].invoke
+  
+    puts <<-EOM
+  
+  Now I'm going to generate your configuration. This will be stored either in
+  'config.yml' in the current directory, or in the path you provide via the
+  environment variable VANILLA_CONFIG.  
+
+  Generating the secret for cookie-based session storage.
+  EOM
+    Rake::Task['vanilla:prepare_files'].invoke
+    Rake::Task['vanilla:generate_secret'].invoke
+  
+    puts <<-EOM
+
+
+  Now that we've got our broth, you'll want to add a user, so you can edit stuff.
+  Lets do that now:
+
+
+  EOM
+    Rake::Task['vanilla:add_user'].invoke
+    puts <<-EOM
+
+
+  OK! You're ready to go. To start vanilla.rb, you'll want to get it running under
+  a webserver that supports Rack. The easiest way to do this locally is via 'rackup':
+  
+    $ rackup
+  
+  Then go to http://localhost:9292
+
+  I'm going now, Goodbye!
+  EOM
+  end
+end

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