creationix-milk 0.0.9

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.bzr
+.bzrignore

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009, Tim Caswell
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    * Neither the name of the Creationix nor the names of its contributors may
+      be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= milk
+
+Milk is a super simple cms for small sites that want a no nonsense way to edit webpages.
+
+== Copyright
+
+Copyright (c) 2009 Tim Caswell. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "milk"
+    gem.summary = %Q{Milk is a rack based content management system built for ease of use and simplicity. Milk tastes great with and without cookies.}
+    gem.email = "tim@creationix.com"
+    gem.homepage = "http://github.com/creationix/milk"
+    gem.authors = ["Tim Caswell"]
+    gem.rubyforge_project = "milk"
+    gem.required_ruby_version = '>=1.9'
+    gem.add_dependency('rack', '>= 1.0.0')
+    gem.add_dependency('maruku', '>= 0.6.0')
+    gem.add_dependency('haml', '>= 2.0.9')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "milk #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.9

data/bin/milk

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+if ARGV.length != 1
+  puts "\nMilk site generator\n"
+  puts "\nUsage:\n\tmilk [target project]\n\n"
+  exit 1
+end
+
+target_path = File.absolute_path(ARGV[0])
+if File.directory?(target_path)
+  puts "\nERROR: there already exists a folder #{target_path}\n"
+  exit 1
+end
+
+puts "\nCreating milk site at #{target_path}\n"
+FileUtils.mkdir_p(target_path, :verbose => true)
+MILK_ROOT = target_path
+require 'milk'
+FileUtils.cp_r(Milk::TEMPLATE_DIR+"/.", target_path, :verbose => true)
+puts "\nDone!\n\n"

data/lib/milk.rb

@@ -0,0 +1,82 @@
+# Autoload some useful libraries
+autoload 'Haml', 'haml'
+autoload 'Sass', 'sass'
+autoload 'Maruku', 'maruku'
+autoload 'YAML', 'yaml'
+autoload 'FileUtils', 'fileutils'
+
+# Set up our main namespace with autoloaded parts
+module Milk
+  VERSION = '0.0.5'
+
+  LIB_DIR = File.dirname(__FILE__)
+  BIN_DIR ||= File.absolute_path(File.dirname(__FILE__)+"/../../local/bin")
+  TEMPLATE_DIR = File.absolute_path(LIB_DIR+"/../site_template")
+  def self.get_milk_root
+    c = caller(1).collect { |line| line.split(':').first }
+    c = c.select { |line| line !~ /\/gems\// }
+    File.absolute_path(File.dirname(c.first))
+  end
+  MILK_ROOT ||= get_milk_root 
+  CONFIG_DIR = MILK_ROOT + "/config"
+  
+  # Load overrides from config file
+  config_file = CONFIG_DIR+"/config.yaml"
+  YAML.load(open(CONFIG_DIR+"/config.yaml")).each_pair do |key, value|
+    eval("#{key} = #{value.inspect}")
+  end if File.file?(config_file)
+  
+  # Set defaults otherwise
+  COMPONENTS_DIR ||= MILK_ROOT + "/design"
+  PAGES_DIR ||= MILK_ROOT + "/pages"
+  PUBLIC_DIR ||= MILK_ROOT + "/public"
+  FIELDS_DIR ||= LIB_DIR + "/milk/fields"
+  
+  $LOAD_PATH.unshift(LIB_DIR) unless $LOAD_PATH.include?(LIB_DIR)
+  autoload :Application, "milk/application"
+  autoload :Component, "milk/component"
+  autoload :Page, "milk/page"
+  autoload :Haxe, "milk/haxe"
+  autoload :Field, "milk/field"
+  autoload :Fields, "milk/field"
+  
+end
+
+# Autoload the components of the user space app into the root namespace for easy use
+Dir.glob(Milk::COMPONENTS_DIR + "/*.rb").each do |c|
+  name = c.split('/').last.gsub(/(.*)\.rb/) { $1 }
+  class_name = name.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  path = c.gsub(/(.*)\.rb/) { $1 }
+  autoload class_name.to_sym, path
+end
+
+# Include metaid for easy metaclass management
+class Object
+ # The hidden singleton lurks behind everyone
+ def metaclass; class << self; self; end; end
+ def meta_eval &blk; metaclass.instance_eval &blk; end
+
+ # Adds methods to a metaclass
+ def meta_def name, &blk
+   meta_eval { define_method name, &blk }
+ end
+
+ # Defines an instance method within a class
+ def class_def name, &blk
+   class_eval { define_method name, &blk }
+ end
+end
+
+# Add ability to get constants from a string name.
+# WARNING: this is akin to eval for security concerns.
+class String
+  def constantize
+    const = Object
+    self.split("::").each do |part|
+      const = const.const_get(part)
+    end
+    const
+  end
+end
+
+

data/lib/milk/application.rb

@@ -0,0 +1,227 @@
+module Milk
+  class Application 
+    
+    PAGE_PATH_REGEX = /^\/([a-zA-Z0-9_]+(\/[a-zA-Z0-9_]+)*)+\/*$/
+    EDIT_PATH_REGEX = /^\/([a-zA-Z0-9_]+(\/[a-zA-Z0-9_]+)*)+\/edit\/*$/
+    
+    attr_reader :req
+    
+    def initialize(require_ssl=false)
+      @require_ssl = require_ssl
+    end
+    
+    def route
+      path = @req.path_info
+      
+      if path == '/'
+        # Special case for root
+        path = '/Home'
+      end
+      
+      # Fallback to match everything
+      regex = /(.*)/
+      
+      # Route the request to the right callback
+      https = @req.env['HTTPS'] == 'on'
+      action = case 
+        when @req.get?
+          case
+            when path == "/logout"
+              :logout
+            when path =~ EDIT_PATH_REGEX
+              regex = EDIT_PATH_REGEX
+              if @require_ssl && !https
+                :https_redirect
+              else
+                :edit
+              end
+            when path =~ PAGE_PATH_REGEX
+              regex = PAGE_PATH_REGEX
+              :view
+          end
+        when @req.delete?
+          if path =~ PAGE_PATH_REGEX
+            regex = PAGE_PATH_REGEX
+            :delete
+          end
+        when @req.post?
+          if path == '/login'
+            :login
+          elsif path =~ PAGE_PATH_REGEX
+            regex = PAGE_PATH_REGEX
+            :preview
+          end
+        when @req.put?
+          if path =~ PAGE_PATH_REGEX
+            regex = PAGE_PATH_REGEX
+            :save
+          end
+      end || :not_found
+      
+      page_name = regex.match(path)[1]
+      
+      if (action == :view || action == :edit)
+        begin 
+          page = Milk::Page.find(page_name)
+        rescue Milk::PageNotFoundError
+          action = :not_found
+        end
+      end
+
+      if (action == :preview || action == :save)
+        page = Milk::Page.json_unserialize(YAML.load(@req.body.read), page_name)
+      end
+      
+      if !@user && [:edit, :save, :delete].include?(action)
+        action = :login_form
+      end
+
+      return action, page_name, page
+    end
+    
+    def obfuscate(value)
+      require 'base64'
+      len = Milk::SECRET.length
+      result = (0...value.length).collect { |i| value[i].ord ^ Milk::SECRET[i%len].ord }
+      Base64.encode64(result.pack("C*"))
+    end
+    
+    def decode(code)
+      require 'base64'
+      len = Milk::SECRET.length
+      value = Base64.decode64(code)
+      result = (0...value.length).collect { |i| value[i].ord ^ Milk::SECRET[i%len].ord }
+      result.pack("C*")
+    end
+    
+    def hash(email, password)
+      require 'digest/md5'
+      Digest::MD5.hexdigest("#{password}")
+    end
+    
+    def logout()
+      @resp.delete_cookie('auth', :path => "/")
+      @resp.redirect(@req.params['dest'])
+    end
+    
+    def flash(message=nil)
+      @resp.delete_cookie('flash', :path => "/") unless message
+      @resp.set_cookie('flash', :path => "/", :value => message) if message
+      @req.cookies['flash']
+    end
+    
+    def login()
+      email = @req.params['email']
+      if email.length > 0
+        user = users[email]
+        if user
+          expected = user["hash"]
+          actual = hash(email, @req.params['password'])
+          if actual == expected
+            @resp.set_cookie('auth', :path => "/", :value => obfuscate(email), :secure=>@require_ssl, :httponly=>true)
+          else
+            flash "Incorrect password for user #{email}"
+          end
+        else
+          flash "User #{email} not found"
+        end
+      else
+        flash "Please enter user email and password"
+      end
+      @resp.redirect(@req.params['dest'])
+    end
+    
+    def users
+      users_file = Milk::CONFIG_DIR+"/users.yaml"
+      YAML.load(open(users_file).read)
+    end
+    
+    def load_user
+      @user = nil
+      if current = @req.cookies['auth']
+        email = decode(current)
+        @user = users[email]
+        @resp.delete_cookie('auth', :path => "/") unless @user
+      end
+    end
+    
+    # Rack call interface
+    def call(env)
+      @req = Rack::Request.new(env)
+      @resp = Rack::Response.new
+      load_user
+      
+      # Route the request
+      action, page_name, @page = route
+      
+      # Send proper mime types for browsers that claim to accept it
+      @resp["Content-Type"] = 
+      if env['HTTP_ACCEPT'].include? "application/xhtml+xml"
+        "application/xhtml+xml"
+        "text/html"
+      else
+        "text/html"
+      end
+
+      case action
+        when :not_found
+          @resp.status = 404
+          page = Milk::Page.find('NotFound')
+          Milk::Application.join_tree(page, self)
+          @resp.write page.view
+        when :view
+          Milk::Application.join_tree(@page, self)
+          html = @page.view
+          @page.save_to_cache(html) if Milk::USE_CACHE
+          @resp.write html
+        when :https_redirect
+          @resp.redirect('https://' +  @req.host + @req.fullpath)
+        when :http_redirect
+          @resp.redirect('http://' +  @req.host + @req.fullpath)
+        when :edit
+          Milk::Application.join_tree(@page, self)
+          @resp.write @page.edit
+        when :save
+          Milk::Application.join_tree(@page, self)
+          @resp.write @page.save
+        when :preview
+          Milk::Application.join_tree(@page, self)
+          @resp.write @page.preview
+        when :login_form
+          filename = FIELDS_DIR + "/login.haml"
+          @resp.write(::Haml::Engine.new(File.read(filename), :filename => filename).render(self))
+        when :login
+          login
+        when :logout
+          logout
+        when :access_denied
+          @resp.staus = 403
+          @resp.write "Access Denied"
+        else
+          @resp.status = 500
+          @resp.write action.to_s
+      end
+      @resp.finish
+    end    
+
+    # method that walks an object linking Milk objects to eachother
+    def self.join_tree(obj, parent)
+      if [Milk::Page, Milk::Component, Milk::Application].any? {|klass| obj.kind_of? klass}
+        obj.parent = parent
+        obj.instance_variables.each do |name|
+          var = obj.instance_variable_get(name)
+          if var.class == Array
+            var.each do |subvar|
+              join_tree(subvar, obj)
+            end
+          end
+        end
+      end
+    end
+    
+  end
+  
+  class PageNotFoundError < Exception
+  end
+end
+