danwrong-evil 0.1 → 0.1.1

data/evil.gemspec

@@ -2,17 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{evil}
-  s.version = "0.1"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dan Webb"]
-  s.date = %q{2009-03-18}
+  s.date = %q{2009-04-17}
   s.default_executable = %q{evil}
   s.description = %q{A simple framework for creating sites from 3rd party data and services}
   s.email = %q{dan@danwebb.net}
   s.executables = ["evil"]
-  s.extra_rdoc_files = ["bin/evil", "CHANGELOG", "lib/evil/application.rb", "lib/evil/models/config_pair.rb", "lib/evil/models/plugin.rb", "lib/evil/models/template.rb", "lib/evil/models/whitelist.rb", "lib/evil/models.rb", "lib/evil/setup/db_tool.rb", "lib/evil/setup/generator.rb", "lib/evil/setup/migration.rb", "lib/evil.rb"]
-  s.files = ["assets/config.ru", "assets/evil.css", "assets/evil.js", "bin/evil", "CHANGELOG", "lib/evil/application.rb", "lib/evil/models/config_pair.rb", "lib/evil/models/plugin.rb", "lib/evil/models/template.rb", "lib/evil/models/whitelist.rb", "lib/evil/models.rb", "lib/evil/setup/db_tool.rb", "lib/evil/setup/generator.rb", "lib/evil/setup/migration.rb", "lib/evil.rb", "Rakefile", "test/harness/config.ru", "test/harness/evil.db", "test/harness/public/javascripts/evil.js", "test/harness/public/stylesheets/evil.css", "test/harness/tmp/restart.txt", "Manifest", "evil.gemspec"]
+  s.extra_rdoc_files = ["bin/evil", "CHANGELOG", "lib/evil/application.rb", "lib/evil/extensions.rb", "lib/evil/helpers.rb", "lib/evil/models/config_pair.rb", "lib/evil/models/template.rb", "lib/evil/models/whitelist.rb", "lib/evil/models.rb", "lib/evil/open_id.rb", "lib/evil/plugin/base.rb", "lib/evil/plugin/configuration.rb", "lib/evil/plugin/environment.rb", "lib/evil/plugin/filesystem.rb", "lib/evil/plugin/tag.rb", "lib/evil/plugin.rb", "lib/evil/setup/db_tool.rb", "lib/evil/setup/generator.rb", "lib/evil/setup/migration.rb", "lib/evil.rb", "LICENSE", "README.textile"]
+  s.files = ["assets/config.ru", "assets/evil-lib.js", "assets/evil.css", "assets/evil.js", "assets/logo.png", "bin/evil", "CHANGELOG", "evil.gemspec", "lib/evil/application.rb", "lib/evil/extensions.rb", "lib/evil/helpers.rb", "lib/evil/models/config_pair.rb", "lib/evil/models/template.rb", "lib/evil/models/whitelist.rb", "lib/evil/models.rb", "lib/evil/open_id.rb", "lib/evil/plugin/base.rb", "lib/evil/plugin/configuration.rb", "lib/evil/plugin/environment.rb", "lib/evil/plugin/filesystem.rb", "lib/evil/plugin/tag.rb", "lib/evil/plugin.rb", "lib/evil/setup/db_tool.rb", "lib/evil/setup/generator.rb", "lib/evil/setup/migration.rb", "lib/evil.rb", "LICENSE", "Manifest", "Rakefile", "README.textile", "test/app/evil_test.rb", "test/dev_env.rb", "test/test_helper.rb", "test/units/plugin/base_test.rb", "test/units/plugin/tag_test.rb", "views/_banner.haml", "views/_errors.haml", "views/index.haml", "views/layout.haml", "views/login.haml", "views/plugins/_fields.haml", "views/plugins/edit.haml", "views/plugins/fields/_password.haml", "views/plugins/fields/_text.haml", "views/plugins/new.haml", "views/templates/_fields.haml", "views/templates/edit.haml", "views/templates/new.haml"]
   s.has_rdoc = true
   s.homepage = %q{http://www.evilmashups.com}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Evil", "--main", "README.textile"]
@@ -20,29 +20,42 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{evil}
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{A simple framework for creating sites from 3rd party data and services}
+  s.test_files = ["test/app/evil_test.rb", "test/test_helper.rb", "test/units/plugin/base_test.rb", "test/units/plugin/tag_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 2
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sinatra>, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
-      s.add_runtime_dependency(%q<sqlite3-ruby>, [">= 0"])
-      s.add_runtime_dependency(%q<clip>, [">= 0"])
-      s.add_runtime_dependency(%q<haml>, [">= 0"])
+      s.add_runtime_dependency(%q<sinatra>, [">= 0", "= 0.9.1.1"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0", "= 2.3.2"])
+      s.add_runtime_dependency(%q<sqlite3-ruby>, [">= 0", "= 1.2.1"])
+      s.add_runtime_dependency(%q<clip>, [">= 0", "= 1.0.0"])
+      s.add_runtime_dependency(%q<haml>, [">= 0", "= 2.0.9"])
+      s.add_runtime_dependency(%q<liquid>, [">= 0", "= 2.0.0"])
+      s.add_runtime_dependency(%q<danwrong-liquid-inheritance>, [">= 0", "= 0.1.1"])
+      s.add_runtime_dependency(%q<rack-cache>, [">= 0", "= 0.4"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
     else
-      s.add_dependency(%q<sinatra>, [">= 0"])
-      s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
-      s.add_dependency(%q<clip>, [">= 0"])
-      s.add_dependency(%q<haml>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0", "= 0.9.1.1"])
+      s.add_dependency(%q<activerecord>, [">= 0", "= 2.3.2"])
+      s.add_dependency(%q<sqlite3-ruby>, [">= 0", "= 1.2.1"])
+      s.add_dependency(%q<clip>, [">= 0", "= 1.0.0"])
+      s.add_dependency(%q<haml>, [">= 0", "= 2.0.9"])
+      s.add_dependency(%q<liquid>, [">= 0", "= 2.0.0"])
+      s.add_dependency(%q<danwrong-liquid-inheritance>, [">= 0", "= 0.1.1"])
+      s.add_dependency(%q<rack-cache>, [">= 0", "= 0.4"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
     end
   else
-    s.add_dependency(%q<sinatra>, [">= 0"])
-    s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
-    s.add_dependency(%q<clip>, [">= 0"])
-    s.add_dependency(%q<haml>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0", "= 0.9.1.1"])
+    s.add_dependency(%q<activerecord>, [">= 0", "= 2.3.2"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 0", "= 1.2.1"])
+    s.add_dependency(%q<clip>, [">= 0", "= 1.0.0"])
+    s.add_dependency(%q<haml>, [">= 0", "= 2.0.9"])
+    s.add_dependency(%q<liquid>, [">= 0", "= 2.0.0"])
+    s.add_dependency(%q<danwrong-liquid-inheritance>, [">= 0", "= 0.1.1"])
+    s.add_dependency(%q<rack-cache>, [">= 0", "= 0.4"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
   end
 end

data/lib/evil/application.rb

@@ -1,21 +1,89 @@
-require 'sinatra'
-require 'evil/models'
-
-configure do
-  Sinatra.register Evil::Models
-  
-  set :sessions => true,
-      :static   => File.join(Evil.app_root, 'public'),
-      :views    => File.join(Evil.gem_root, 'views'),
-      :haml     => { :format => :html5 }
-      
-  connect_to_database
-end
+require 'sinatra/base'
+
+module Evil
+  class Application < Sinatra::Base
+    configure do
+      register(Evil::Extensions)
+      helpers(Evil::Helpers, Evil::OpenID::Helpers)
+
+      initialize_evil
+    end
+
+    require_whitelisted_openid(/^\/admin/)
+    load_template_routes
+
+    get '/admin/openid/login' do
+      attempt_openid_authentication do |identity_url|
+        session[:identity_url] = identity_url
+        redirect session[:destination_url]
+      end
+    end
+
+    post '/admin/openid/logout' do
+      session[:identity_url] = nil
+      redirect '/admin'
+    end
+
+    get '/admin' do
+      @templates = Evil::Models::Template.in_order
+      @plugins = Evil::Models::ConfigPair.plugins
+
+      haml :index
+    end
+
+    get '/admin/templates/new' do
+      @template = Evil::Models::Template.new
 
-include Evil::Models
+      haml :"templates/new"
+    end
 
-get '/admin' do
-  @thing = Whitelist.find(:first).pattern
-  haml :index
+    post '/admin/templates' do
+      @template = Evil::Models::Template.new params[:template]
+
+      if @template.save
+        self.class.reload!
+        redirect '/admin'
+      else
+        haml :"templates/new"
+      end
+    end
+
+    get '/admin/templates/:id' do
+      @template = Evil::Models::Template.find(params[:id]) rescue not_found
+
+      haml :"templates/edit"
+    end
+
+    post '/admin/templates/:id' do
+      @template = Evil::Models::Template.find(params[:id]) rescue not_found
+
+      @template.attributes = params[:template]
+
+      if @template.save
+        self.class.reload!
+        redirect '/admin'
+      else
+        haml :"templates/edit"
+      end
+    end
+    
+    get '/admin/plugins/new' do
+      haml :"plugins/new"
+    end
+    
+    get '/admin/plugins/:id' do
+      @plugin = Evil::Plugin.find_plugin(params[:id]) rescue not_found
+
+      haml :"plugins/edit"
+    end
+    
+    post '/admin/plugins/:id' do
+      @plugin = Evil::Plugin.find_plugin(params[:id]) rescue not_found
+      
+      @plugin.config.set(params[:config])
+      
+      redirect '/admin'
+    end
+  end
 end
       

data/lib/evil/extensions.rb

@@ -0,0 +1,71 @@
+require 'evil/models'
+
+module Evil
+  module Extensions
+    
+    def initialize_evil
+      set :public   => File.join(Evil.app_root, 'public'),
+          :views    => File.join(Evil.gem_root, 'views'),
+          :haml     => { :format => :html5 },
+          :logging  => true,
+          :static   => true,
+          :dump_errors => true
+          
+      Liquid::Template.file_system = Evil::Plugin::Filesystem.new
+
+      connect_to_database
+      load_all_plugins
+    end
+    
+    def reload!
+      @reloading = true
+      reset!
+      Kernel.load 'evil/application.rb'
+      @reloading = false
+    end
+    
+    def connect_to_database
+      if Evil.heroku?
+        dbconfig = YAML.load(File.read(File.join(Evil.app_root, 'config/database.yml')))
+        ActiveRecord::Base.establish_connection dbconfig['production']
+      else
+        ActiveRecord::Base.establish_connection :adapter => 'sqlite3', 
+                                                :database => File.join(Evil.app_root, 'evil.db')
+      end
+    end
+    
+    def load_template_routes
+      Evil::Models::Template.in_order.each do |template|
+        get(template.route, &proc_for(template)) unless template.route.nil? || template.route.empty?
+      end
+    end
+    
+    def load_all_plugins
+      Dir[File.join(Evil.gem_root, 'lib', 'plugin/builtin', '*.rb')].each do |plugin|
+        Evil::Plugin.from_file(plugin)
+      end
+      
+      Dir[File.join(Evil.app_root, 'plugins', '*.evil')].each do |plugin|
+        Evil::Plugin.from_file(plugin)
+      end
+    end
+    
+    def require_whitelisted_openid(pattern)
+      before do
+        if request.path_info =~ pattern && !params[:openid_url]
+          unless whitelisted_openid?
+            session[:destination_url] = request.url
+            not_authorized
+          end
+        end
+      end
+    end
+    
+    protected
+    
+    def proc_for(template)
+      lambda { serve template }
+    end
+    
+  end
+end

data/lib/evil/helpers.rb

@@ -0,0 +1,62 @@
+module Evil
+  module Helpers
+    include Evil::Models
+    
+    def serve(template)
+      initialize_plugins
+      
+      liquid_template = Liquid::Template.parse(template.reload.source)
+      
+      content_type(template.content_type || 'text/html', :charset => template.encoding || 'utf-8')
+      
+      if template.ttl
+        headers 'Cache-Control' => "public, max-age=#{template.ttl}"
+      end
+      
+      liquid_template.render 'params' => params
+    end
+    
+    def partial(template, options={})
+      haml(partial_name(template), options.merge( :layout => false ))
+    end
+    
+    def render_config_field(field)
+      partial("plugins/fields/#{field.type}", :locals => { :field => field })
+    end
+    
+    def not_authorized(message=nil)
+      status 401
+      halt haml(:login)
+    end
+    
+    def whitelisted_openid?
+      session[:identity_url] && Whitelist.authorize(session[:identity_url])
+    end
+    
+    def attempt_openid_authentication
+      openid_authenticate do |result, identity_url|
+        if result == :successful
+          yield identity_url
+        else
+          not_authorized
+        end
+      end
+    end
+    
+    def urlencode(str)
+      URI.escape(str)
+    end
+    
+    protected
+    
+    def initialize_plugins
+      Plugin::Environment.plugins.each { |p| p.init }
+    end
+    
+    def partial_name(template_path)
+      parts = template_path.to_s.split('/')
+      parts[-1] = "_#{parts.last}"
+      parts.join('/').to_sym
+    end
+  end
+end

data/lib/evil/models/config_pair.rb

@@ -4,6 +4,13 @@ module Evil
     
     class ConfigPair < ActiveRecord::Base
       set_table_name :evil_config_pairs
+      
+      def self.plugins
+        find_by_sql('SELECT DISTINCT(plugin) from evil_config_pairs').collect do |p|
+          p.plugin
+        end
+      end
+      
     end
     
   end

data/lib/evil/models/template.rb

@@ -5,21 +5,22 @@ module Evil
     class Template < ActiveRecord::Base
       set_table_name :evil_templates
       
-      validates_presence_of   :route, :source
-      validates_uniqueness_of :route
-      validates_format_of     :route, :with => /^((\/)|(((\/|\.):?[a-z0-9\_]+)+))$/
-      
-      after_save    :reload_template_routes
-      after_destroy :reload_template_routes
+      validates_presence_of   :title, :source
+      validates_uniqueness_of :route, :if => lambda { |template| !(template.route.empty? || template.route.nil?) }
+      validates_format_of     :route, :with => /^((\/)|(((\/|\.):?[a-z0-9\_]+)+))$/, 
+                                      :allow_blank => true, :allow_nil => true
+      validate :liquid_syntax
       
       has_many :cached_pages
       
       named_scope :in_order, :order => 'position ASC'
       
-      protected
+      private
       
-      def reload_template_routes
-        Evil::Routes.reload_template_routes
+      def liquid_syntax
+        Liquid::Template.parse(source)
+      rescue Liquid::SyntaxError => error
+        errors.add(:source, "has syntax error: #{error.message}")
       end
     end
     

data/lib/evil/models.rb

@@ -1,17 +1,5 @@
 require 'activerecord'
 require 'evil/models/config_pair'
-require 'evil/models/plugin'
 require 'evil/models/template'
 require 'evil/models/whitelist'
 
-module Evil
-  module Models
-
-    def connect_to_database
-      ActiveRecord::Base.establish_connection :adapter => 'sqlite3', 
-                                              :database => File.join(Evil.app_root, 'evil.db')
-    end
-
-  end
-end
-

data/lib/evil/open_id.rb

@@ -0,0 +1,101 @@
+require 'openid'
+require 'openid/extensions/sreg'
+require 'openid/store/memory'
+
+module Evil
+  module OpenID    
+    module Helpers
+  
+      def openid_request?(open_id_param=params[:openid_url])
+        !!((open_id_param && !open_id_param.strip.empty?) || params[:openid_complete])
+      end
+  
+      def openid_authenticate(options={}, &block)
+        open_id_param = options.delete(:open_id_param) || params[:openid_url]
+
+        unless params[:openid_complete]
+          begin_openid_authentication(open_id_param, options, &block)
+        else
+          complete_openid_authentication(&block)
+        end
+      end
+
+      private
+
+      def openid_consumer
+        @@openid_consumer ||= ::OpenID::Consumer.new session, ::OpenID::Store::Memory.new
+      end
+
+      def begin_openid_authentication(openid_url, options={})
+        fields = options[:sreg] || {}
+        immediate = (options[:immediate] === true)
+
+        request = openid_consumer.begin(openid_url)
+
+        add_sreg_fields(request, fields)
+
+        redirect openid_provider_url(request, immediate)
+
+      rescue ::OpenID::OpenIDError, Timeout::Error
+        yield :missing
+      end
+
+      def complete_openid_authentication
+        query_string_params = request.GET
+
+        begin
+          response = openid_consumer.complete(query_string_params, openid_return_to)
+          identity_url = response.endpoint.claimed_id
+
+          case response.status
+            when ::OpenID::Consumer::SUCCESS
+              yield :successful, identity_url, ::OpenID::SReg::Response.from_success_response(response)
+            when ::OpenID::Consumer::CANCEL
+              yield :cancelled, identity_url, nil
+            when ::OpenID::Consumer::FAILURE
+              yield :failed, identity_url, nil
+            when ::OpenID::Consumer::SETUP_NEEDED
+              # get around ruby openid 2.x bug
+              yield :setup_needed, identity_url, response.instance_variable_get(:@setup_url)
+          end
+        rescue Timeout::Error
+          yield :failed
+        end
+      end
+
+      def add_sreg_fields(request, fields)
+        if fields.is_a?(Array)
+          required, optional = fields, []
+        else
+          required = fields[:required] || []
+          optional = fields[:optional] || []
+        end
+
+        sreg = ::OpenID::SReg::Request.new
+
+        sreg.request_fields(required.collect { |f| f.to_s }, true) unless required.empty?
+        sreg.request_fields(optional.collect { |f| f.to_s }, false) unless optional.empty?
+
+        request.add_extension(sreg)
+      end
+
+      def openid_provider_url(request, immediate)
+        request.return_to_args['openid_complete'] = '1'
+        request.redirect_url(openid_trust_root, openid_return_to, immediate)
+      end
+
+      def openid_trust_root
+        @openid_trust_root ||= [
+          request.scheme, '://', 
+          request.host, 
+          (":#{request.port}" if request.port), "/"
+        ].compact.join
+      end
+
+      def openid_return_to
+        @openid_return_to ||= request.url
+      end
+  
+    end
+  end
+end

data/lib/evil/plugin/base.rb

@@ -0,0 +1,56 @@
+module Evil
+  module Plugin  
+    class Base
+      attr_reader :name, :configurator
+      
+      def initialize(name, &block)
+        @name = name
+        @configurator = Configuration::Configurator.new
+        block.call(self)
+      end
+
+      def init
+        @setup_proc.call if @setup_proc
+      end
+      
+      def description(desc=nil)
+        @description = desc if desc
+        @description
+      end
+      
+      def setup(&block)
+        @setup_proc = block
+      end
+                  
+      def tag(name, &block)
+        tag = Tag.from(&block)
+        Liquid::Template.register_tag(name, tag)
+      end
+      
+      def filter(fname, &block)
+        mod = Module.new do
+          define_method(fname, &block)
+        end
+        
+        mod.module_eval "def self.name; \"_filter_#{fname}\"; end"
+        
+        Liquid::Template.register_filter(mod)
+      end
+      
+      def http
+        @http ||= Module.new do
+          include HTTParty
+        end
+      end
+      
+      def configure
+        yield @configurator
+      end
+      
+      def config
+        @config ||= Configuration::Config.new(self)
+      end
+    end
+    
+  end
+end

data/lib/evil/plugin/configuration.rb

@@ -0,0 +1,77 @@
+module Evil
+  module Plugin
+    module Configuration
+      
+      class ConfigField
+        
+        attr_accessor :name, :type, :options
+        
+        def initialize(type, name, options={})
+          @type, @name, @options = type, name, options
+        end
+        
+        def label
+          options[:label] || name.to_s.capitalize
+        end
+        
+      end
+      
+      class Configurator
+        
+        attr_reader :fields
+        
+        def initialize
+          @fields = []
+        end
+        
+        def text(field, options={})
+          @fields << ConfigField.new(:text, field, options)
+        end
+        
+        def password(field, options={})
+          @fields << ConfigField.new(:password, field, options)
+        end
+        
+      end
+      
+      class Config
+        include Evil::Models
+      
+        def initialize(plugin)
+          @plugin = plugin
+          
+          load_config!
+        end
+        
+        def [](val)
+          @values[val.to_sym]
+        end
+        
+        def set(values)
+          values.each do |k, v|
+            c = ConfigPair.find_or_create_by_plugin_and_key(@plugin.name, k)
+            c.update_attribute :value, v
+          end if values
+          
+          load_config!
+        end
+        
+        protected
+        
+        def load_config!
+          pairs = Evil::Models::ConfigPair.find_all_by_plugin(@plugin.name)
+          
+          if pairs
+            @values = pairs.inject(Hash.new('')) do |m, pair|
+              m[pair.key.to_sym] = pair.value; m
+            end
+          else
+            @values = Hash.new('')
+          end
+        end
+      
+      end
+
+    end
+  end
+end

data/lib/evil/plugin/environment.rb

@@ -0,0 +1,15 @@
+module Evil
+  module Plugin
+    module Environment
+      class << self
+        attr_reader :plugins
+    
+        def plugin(name, &block)
+          @plugins ||= []
+          @plugins << Base.new(name, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/evil/plugin/filesystem.rb

@@ -0,0 +1,18 @@
+module Evil
+  module Plugin
+    
+    class Filesystem
+      
+      def read_template_file(title)
+        if template = Evil::Models::Template.find_by_title(title)
+          template.source
+        else
+          raise FileSystemError, "No such template '#{title}'"
+        end
+      end
+      
+    end
+    
+  end
+  
+end