vanilla 1.2 → 1.9.9

data/Rakefile

@@ -1,20 +1,20 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'vanilla'
+load File.join(File.dirname(__FILE__), *%w[lib tasks vanilla.rake])
+
+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"
 
-require "bundler/setup"
-require "vanilla"
-
-task :default => :test
-
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.ruby_opts << "-rubygems"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
-end
-
 if Object.const_defined?(:Gem)
   # This builds the actual gem. For details of what all these options
   # mean, and other ones you can add, check the documentation here:
@@ -25,7 +25,7 @@ if Object.const_defined?(:Gem)
 
     # Change these as appropriate
     s.name              = "vanilla"
-    s.version           = Vanilla::VERSION
+    s.version           = "1.9.9"
     s.summary           = "A bliki-type web content thing."
     s.author            = "James Adam"
     s.email             = "james@lazyatom.com.com"
@@ -36,58 +36,37 @@ if Object.const_defined?(:Gem)
     s.rdoc_options      = %w(--main README)
 
     # Add any extra files to include in the gem
-    s.files             = %w(Rakefile README) + Dir.glob("{test,lib,bin,pristine_app}/**/*")
+    s.files             = %w(config.example.yml config.ru Rakefile README) + Dir.glob("{spec,lib,bin,public}/**/*")
     s.executables       = ['vanilla']
     s.require_paths     = ["lib"]
 
     # All the other gems we need.
     s.add_dependency("rack", ">= 0.9.1")
-    s.add_dependency("soup", ">= 1.0.6")
+    s.add_dependency("soup", ">= 0.9.9")
     s.add_dependency("ratom", ">= 0.3.5")
     s.add_dependency("RedCloth", ">= 4.1.1")
     s.add_dependency("BlueCloth", ">= 1.0.0")
-    s.add_dependency("haml")
-    s.add_dependency("parslet", ">= 1.2.0")
+    s.add_dependency("treetop", ">= 1.4.1")
 
-    s.add_development_dependency("kintama", ">= 0.1.6") # add any other gems for testing/development
-    s.add_development_dependency("mocha")
+    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
+  # 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.
-  #
-  # To publish your gem online, install the 'gemcutter' gem; Read more 
-  # about that here: http://gemcutter.org/pages/gem_docs
   Rake::GemPackageTask.new(spec) do |pkg|
     pkg.gem_spec = spec
-  end
-
-  # Stolen from jeweler
-  def prettyify_array(gemspec_ruby, array_name)
-    gemspec_ruby.gsub(/s\.#{array_name.to_s} = \[.+?\]/) do |match|
-      leadin, files = match[0..-2].split("[")
-      leadin + "[\n    #{files.split(",").join(",\n   ")}\n  ]"
-    end
-  end
 
-  task :gemspec do
-    output = spec.to_ruby
-    output = prettyify_array(output, :files)
-    output = prettyify_array(output, :test_files)
-    output = prettyify_array(output, :extra_rdoc_files)
-
-    file = File.expand_path("../#{spec.name}.gemspec", __FILE__)
-    File.open(file, "w") {|f| f << output }
+    # Generate the gemspec file for github.
+    file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+    File.open(file, "w") {|f| f << spec.to_ruby }
   end
 
-  task :package => :gemspec
-
   # Generate documentation
   Rake::RDocTask.new do |rd|
     rd.main = "README"
@@ -100,25 +79,47 @@ if Object.const_defined?(:Gem)
     rm "#{spec.name}.gemspec"
   end
 
-  desc 'Tag the repository in git with gem version number'
-  task :tag => [:gemspec, :package] do
-    if `git diff --cached`.empty?
-      if `git tag`.split("\n").include?("v#{spec.version}")
-        raise "Version #{spec.version} has already been released"
+  # 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
-      `git add #{File.expand_path("../#{spec.name}.gemspec", __FILE__)}`
-      `git commit -m "Released version #{spec.version}"`
-      `git tag v#{spec.version}`
-      `git push --tags`
-      `git push`
-    else
-      raise "Unstaged changes still waiting to be committed"
     end
-  end
-
-  desc "Tag and publish the gem to rubygems.org"
-  task :publish => :tag do
-    `gem push pkg/#{spec.name}-#{spec.version}.gem`
+  rescue LoadError
+    puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
   end
 else
   puts "Gem management tasks unavailable, as rubygems was not fully loaded."

data/bin/vanilla

@@ -1,38 +1,9 @@
 #!/usr/bin/env ruby
+require 'rubygems'
+require 'rake'
+load File.join(File.dirname(__FILE__), *%w[.. lib tasks vanilla.rake])
 
-def create(new_app_dir)
-  require 'fileutils'
-  pristine_app = File.expand_path("../../pristine_app", __FILE__)
-  FileUtils.cp_r(pristine_app, new_app_dir)
-  FileUtils.mkdir_p(File.join(new_app_dir, "tmp"))
-  require 'vanilla'
-  File.open(File.join(new_app_dir, "Gemfile"), "w") do |f|
-    f.write "source :rubygems\n\n# Vanilla itself.\ngem 'vanilla', '#{Vanilla::VERSION}'"
-  end
-  puts File.readlines(File.join(new_app_dir, "README"))[0..16].join
-end
+mkdir(ARGV[0])
+cd(ARGV[0])
 
-def console
-  $LOAD_PATH << "lib"
-  require "rubygems"
-  require "bundler/setup"
-  require "irb"
-  require "vanilla/console"
-  ARGV.clear
-  puts "The Soup is simmering."
-  IRB.start 
-end
-
-def upgrade
-  # TODO
-  puts "TODO, but should be easier thanks to multi-space soup."
-end
-
-case ARGV[0]
-when "console"
-  console
-when "upgrade"
-  upgrade
-else
-  create(ARGV[0])
-end
+Rake::Task['vanilla:setup'].invoke

data/config.example.yml

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

data/config.ru

@@ -0,0 +1,10 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[lib])
+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,173 @@
+$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 :load_snips do
+    app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+    Dynasnip.all.each { |ds| app.soup << ds.snip_attributes }
+  
+    Dir[File.join(File.dirname(__FILE__), '..', 'vanilla', 'snips', '*.rb')].each do |f|
+      load f
+    end  
+  
+    puts "The soup is simmering."
+  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 do
+      app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+      Dynasnip.all.each do |dynasnip|
+        print "Upgrading #{dynasnip.snip_name}... "
+        # TODO: our confused Soup interface might return an array.
+        snip = app.soup[dynasnip.snip_name]
+        if snip.empty? || snip.nil?
+          # it's a new dyna
+          app.soup << dynasnip.snip_attributes
+          puts "(new)"
+        elsif snip.created_at == snip.updated_at
+          # it's not been changed, let's upgrade
+          snip.destroy
+          app.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::SHA1.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.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. config.ru])), 'config.ru'
+    cp_r File.expand_path(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