danwrong-evil 0.1 → 0.1.1

data/lib/evil/plugin/tag.rb

@@ -0,0 +1,81 @@
+module Evil
+  module Plugin
+    
+    class TagExecution
+      
+      def initialize(tag, options, context, &block)
+        @options = evaluate(options, context)
+        @context = context
+        @tag = tag
+        @proc = block
+      end
+      
+      def body(locals={})
+        @context.stack do
+          locals.each { |k, v| @context[k.to_s] = v }
+          return @tag.render_body(@context).to_s
+        end
+      end
+      
+      def execute
+        self.instance_exec(@options, &@proc)
+      end
+      
+      def to_s
+        execute.to_s
+      end
+      
+      private
+      
+      def evaluate(options, context)
+        options.inject({}) do |evaluated, pair| 
+          opt, value = pair
+          evaluated[opt] = context[value]; evaluated
+        end
+      end
+    end
+    
+    class Tag < Liquid::Block
+      Syntax = /((#{Liquid::TagAttributes}\s?,?\s?)*)/
+      
+      class << self
+        attr_accessor :tag_proc
+        attr_accessor :plugin
+        
+        def from(&block)
+          tag = Class.new(self)
+          tag.tag_proc = block; tag
+        end
+      end
+
+      def initialize(tag_name, markup, tokens)
+        super
+        
+        if markup =~ Syntax
+          @options = parse_options($1)
+        else
+          raise Liquid::SyntaxError.new("Syntax Error in tag '#{tagname}' - Valid syntax: #{tagname} [ opt : 'val', opt : 'val' ]")
+        end
+      end
+      
+      def render(context)
+        TagExecution.new(self, @options, context, &self.class.tag_proc).to_s
+      end
+      
+      def render_body(context)
+        render_all(@nodelist, context)
+      end
+
+      private
+
+      def parse_options(opt_string)
+        pairs = opt_string.split(',')
+        pairs.inject({}) do |opts, pair|
+          opt, value = pair.split(':')
+          opts[opt.strip.to_sym] = value.strip; opts
+        end
+      end
+    end
+    
+  end
+end

data/lib/evil/plugin.rb

@@ -0,0 +1,21 @@
+module Evil
+  module Plugin
+    autoload :Base, 'evil/plugin/base'
+    autoload :Tag, 'evil/plugin/tag'
+    autoload :Environment, 'evil/plugin/environment'
+    autoload :Filesystem, 'evil/plugin/filesystem'
+    autoload :Configuration, 'evil/plugin/configuration'
+    
+    def self.evaluate(plugin_source)
+      Environment.module_eval plugin_source
+    end
+    
+    def self.from_file(file)
+      evaluate(File.read(file))
+    end
+    
+    def self.find_plugin(name)
+      Environment.plugins.find { |p| p.name == name }
+    end
+  end
+end

data/lib/evil/setup/generator.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'evil/models'
 require 'evil/setup/migration'
+require 'digest/sha1'
 
 module Evil
   module Setup
@@ -14,11 +15,14 @@ module Evil
         public/images
         public/stylesheets
         public/javascripts
+        plugins
       }
     
       ASSETS = [
         ['evil.css', 'public/stylesheets/evil.css'],
         ['evil.js', 'public/javascripts/evil.js'],
+        ['evil-lib.js', 'public/javascripts/evil-lib.js'],
+        ['logo.png', 'public/images/logo.png'],
         ['config.ru', 'config.ru']
       ]
 
@@ -30,12 +34,14 @@ module Evil
         puts "Generating Evil application..."
         create_dir_tree!
         copy_assets!
+        set_cookie_secret!
         puts "Initializing database..."
         create_database!
       end
 
       def create_dir_tree!
         DIR_LAYOUT.each do |dir|
+          puts "Directory #{@path}/#{dir}"
           mkdir_p "#{@path}/#{dir}"
         end
       end
@@ -51,10 +57,16 @@ module Evil
     
       def copy_assets!
         ASSETS.each do |file, dest|
+          puts "File #{File.join(@path, dest)}"
           cp File.join(ASSET_PATH, file), File.join(@path, dest)
         end
       end
-
+      
+      def set_cookie_secret!
+        rackup = File.read(File.join(@path, 'config.ru'))
+        rackup.gsub!(/__SECRET__/, Digest::SHA1.hexdigest("__EVIL__#{Time.now.to_s}__#{rand(999999)}"))
+        File.open(File.join(@path, 'config.ru'), 'w') { |f| f.write(rackup) }
+      end
     end
   end
 end

data/lib/evil/setup/migration.rb

@@ -8,27 +8,20 @@ module Evil
       def create_evil_tables
         create_table :evil_templates do |t|
           t.integer :ttl, :position
-          t.string  :title, :route
+          t.string  :title, :route, :content_type, :encoding
           t.text    :source
           t.timestamps
-        end unless Evil::Models::Template.table_exists?
-        
-        create_table :evil_plugins do |t|
-          t.string  :name, :description, :author
-          t.text    :source, :url
-          t.boolean :enabled
-          t.timestamps
-        end unless Evil::Models::Plugin.table_exists?
+        end unless Evil::Models::Template.table_exists? 
         
         unless Evil::Models::ConfigPair.table_exists?
           create_table :evil_config_pairs do |t|
-            t.integer :plugin_id
+            t.string  :plugin
             t.string  :key
             t.text    :value
             t.timestamps
           end
           
-          add_index :evil_config_pairs, :plugin_id
+          add_index :evil_config_pairs, :plugin
         end
         
         create_table :evil_whitelists do |t|

data/lib/evil.rb

@@ -1,3 +1,7 @@
+require 'liquid'
+require 'liquid_inheritance'
+require 'httparty'
+
 module Evil
   module Setup
     autoload :DbTool, 'evil/setup/db_tool'
@@ -5,11 +9,40 @@ module Evil
     autoload :Migration, 'evil/setup/migration'
   end
   
+  autoload :OpenID, 'evil/open_id'
+  autoload :Helpers, 'evil/helpers'
+  autoload :Extensions, 'evil/extensions'
+  
+  autoload :Plugin, 'evil/plugin'
+  
   autoload :Application, 'evil/application'
   
   class << self
     attr_accessor :gem_root, :app_root
+    
+    def heroku?
+      Object.const_defined?(:Heroku)
+    end
   end
 end
 
-Evil.gem_root = File.join(File.dirname(__FILE__), '..')
+Evil.gem_root = File.join(File.dirname(__FILE__), '..')
+
+class Proc 
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end
+
+class Object
+  def instance_exec(*arguments, &block)
+    block.bind(self)[*arguments]
+  end
+end

data/test/app/evil_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require 'evil/application'
+
+class EvilTest < Test::Unit::TestCase
+  include Sinatra::Test
+  
+  context 'running the evil application' do
+    setup do
+      @app = Evil::Application
+    end
+  
+    context 'while not logged in' do
+      
+        context 'GET /admin' do
+          setup do
+            get '/admin'
+          end
+        
+          should 'not be authorized' do
+            assert_equal 401, response.status
+            assert_match /openid_url/, response.body
+          end
+        end
+      
+      end
+    
+      context 'while logged in' do 
+        setup do
+          @env = { 'rack.session' => { :identity_url => 'www.danwebb.net' } }
+        end
+             
+        context 'GET /admin' do
+          setup do
+            get '/admin', {}, @env
+          end
+
+          should 'be successful' do
+            assert response.ok?
+          end
+        end
+        
+        context 'GET /admin/templates/1 with existing template' do
+          setup do
+            get '/admin/templates/1', {}, @env
+          end
+          
+          should 'be successful' do
+            assert response.ok?
+          end
+        end
+        
+        context 'GET /admin/templates/nothinghere with non-existing template' do
+          setup do
+            get '/admin/templates/nothinghere', {}, @env
+          end
+          
+          should 'be not found' do
+            assert_equal 404, response.status
+          end
+        end
+      end
+    end
+  
+end

data/test/dev_env.rb

@@ -0,0 +1,10 @@
+$:.unshift('./lib')
+require 'evil'
+require 'evil/models'
+
+Evil.app_root = './test/example'
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', 
+                                        :database => File.join(Evil.app_root, 'evil.db')
+                                        
+include Evil::Models

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.join(File.dirname(__FILE__), '../lib'))
+require 'rubygems'
+require 'evil'
+require 'test/unit'
+require 'shoulda'
+require 'sinatra/test'
+require 'mocha'
+
+require 'redgreen' rescue nil
+
+Sinatra::Default.set :environment, 'test'
+Evil.app_root = File.join(File.dirname(__FILE__), 'example')

data/test/units/plugin/base_test.rb

@@ -0,0 +1,47 @@
+class BaseTest < Test::Unit::TestCase
+  should 'initialize with a name and a block that recieves the new instance' do
+    plugin = Evil::Plugin::Base.new 'Test Plugin' do |p|
+      assert_instance_of Evil::Plugin::Base, p
+    end
+    
+    assert_equal 'Test Plugin', plugin.name
+  end
+  
+  context 'given a plugin instance with a description and setup set' do
+    setup do
+      @setup_proc = Proc.new {}
+      
+      @plugin = Evil::Plugin::Base.new 'Test Plugin' do |p|
+        p.description 'A plugin for testing plugins'
+        
+        p.setup &@setup_proc
+
+      end
+    end
+    
+    should 'have a description set' do
+      assert_equal 'A plugin for testing plugins', @plugin.description
+    end
+    
+    should 'call the setup proc when init called' do
+      @setup_proc.expects(:call)
+      
+      @plugin.init
+    end
+    
+  end
+  
+  should 'create and register a tag instance when plugin initialize with a tag call' do
+    Evil::Plugin::Tag.expects(:from).returns(t = Class.new(Liquid::Tag))
+    Liquid::Template.expects(:register_tag).with(:thing, t)
+    
+    Evil::Plugin::Base.new 'Test Plugin' do |p|
+      p.tag :thing do 
+        'a tag'
+      end
+    end
+    
+  end
+  
+  
+end

data/test/units/plugin/tag_test.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+require 'liquid'
+
+class TagTest < Test::Unit::TestCase
+  context 'with a custom tag defined that returns a string' do
+    setup do
+      Liquid::Template.register_tag('test', Evil::Plugin::Tag.from { |params|
+        'hello'
+      })
+    end
+    
+    should 'output the string' do
+      template = Liquid::Template.parse('{% test %}{% endtest %}')
+
+      assert_equal 'hello', template.render
+    end
+  end
+  
+  context 'with a custom tag defined that returns a parameter' do
+    setup do
+      Liquid::Template.register_tag('test', Evil::Plugin::Tag.from { |params|
+        params[:a]
+      })
+    end
+    
+    should 'output that parameter if passed as a constant' do
+      template = Liquid::Template.parse('{% test a: "thing" %}{% endtest %}')
+      
+      assert_equal 'thing', template.render
+    end
+    
+    should 'output that parameter if passed as a variable' do
+      template = Liquid::Template.parse('{% test a: var %}{% endtest %}')
+      
+      assert_equal 'thing', template.render('var' => 'thing')
+    end
+  end
+  
+  context 'with a custom tag defined that uses the body method' do
+    setup do
+      Liquid::Template.register_tag('test', Evil::Plugin::Tag.from { |params|
+        times = params[:times] || 1
+        out = ''
+        times.times { |i| out << body(:i => i) }
+        out
+      })
+    end
+    
+    should 'output the contents of the tag' do
+      template = Liquid::Template.parse('{% test %}a{% endtest %}')
+      
+      assert_equal 'a', template.render
+    end
+    
+    should 'remember the i variable passed to body' do
+      template = Liquid::Template.parse('{% test %}{{ i }}{% endtest %}')
+      
+      assert_equal '0', template.render
+    end
+    
+    should 'be different value of i for each repetition of body' do
+      template = Liquid::Template.parse('{% test times: 10 %}{{ i }}{% endtest %}')
+      
+      assert_equal '0123456789', template.render
+    end
+  end
+  
+  context 'with 2 custom tags defined' do
+    setup do
+      Liquid::Template.register_tag('test', Evil::Plugin::Tag.from { |params|
+        times = params[:times] || 1
+        out = ''
+        times.times { |i| out << body(:i => i) }
+        out
+      })
+      
+      Liquid::Template.register_tag('test2', Evil::Plugin::Tag.from { |params|
+        params[:a]
+      })
+    end
+    
+    should 'be able to nest tags' do
+      template = Liquid::Template.parse("{% test times: 2 %}{% test2 a: 4 %}{% endtest2 %}{% endtest %}")
+      
+      assert_equal '44', template.render
+    end
+    
+    should 'be able to use vars from outer tag in inner tag' do
+      template = Liquid::Template.parse("{% test times: 2 %}{% test2 a: i %}{% endtest2 %}{% endtest %}")
+      
+      assert_equal '01', template.render
+    end
+  end
+  
+  context 'with a custom tag with more than one parameter defined' do
+    setup do
+      Liquid::Template.register_tag('test', Evil::Plugin::Tag.from { |params|
+        [params[:a], params[:b]].join('|')
+      })
+    end
+    
+    should 'output both parameters' do
+      template = Liquid::Template.parse("{% test a: 'g', b: 'a' %}{% endtest %}")
+      
+      assert_equal 'g|a', template.render
+    end
+  end
+end

data/views/_banner.haml

@@ -0,0 +1,8 @@
+- if session[:identity_url]
+  #banner
+    %a{ :href => '/admin' }
+      %img#logo{ :src => '/images/logo.png', :alt => 'Evil' } 
+    %form{ :method => 'post', :action => '/admin/openid/logout', :id => 'logout' }
+      Logged in as 
+      %em= session[:identity_url]
+      %input.submit{ :type => 'submit', :value => 'Log out' }

data/views/_errors.haml

@@ -0,0 +1,9 @@
+- unless model.errors.empty?
+  %div.errors 
+    %h3 
+      There were problems saving this 
+      = "#{name}:"
+    %ul
+      -  model.errors.full_messages.each do |error|
+        %li= error
+    

data/views/index.haml

@@ -0,0 +1,41 @@
+#overview
+  %table#template-overview
+    %thead
+      %tr.title
+        %th{ :colspan => 3 } Templates
+      %tr
+        %th Name
+        %th URL Pattern
+        %th TTL
+        %th 
+    %tbody
+      - @templates.each_with_index do |template, i|
+        %tr{ :class => ('alt' if i % 2 == 1) }
+          %td= template.title
+          %td= template.route
+          %td= template.route.empty? ? 'N/A' : template.ttl
+          %td.tools
+            %a{ :href => "/admin/templates/#{template.id}"} Edit
+    %tfoot
+      %tr
+        %td{ :colspan => 4 }
+          %a{ :href => '/admin/templates/new' } Add Template...
+      
+  %table#plugin-overview
+    %thead
+      %tr.title
+        %th{ :colspan => 3 } Plugin Configuration
+      %tr
+        %th Name
+        %th 
+    %tbody
+      - @plugins.each_with_index do |plugin, i|
+        %tr{ :class => ('alt' if i % 2 == 1) }
+          %td= plugin
+          %td.tools
+            %a{ :href => "/admin/plugins/#{urlencode(plugin)}"} Edit
+    %tfoot
+      %tr
+        %td{ :colspan => 3 }
+          %a{ :href => '/admin/plugins/new' } Add Configuration...
+  

data/views/layout.haml

@@ -0,0 +1,13 @@
+!!!
+%html
+  %head
+    %title Evil Admin
+    %link{ :rel => 'stylesheet', :href => '/stylesheets/evil.css', :type => 'text/css' }
+  %body
+    = partial(:banner)
+    #content
+      = yield
+    %script{ :type => 'text/javascript', :src => 'http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js' }
+    %script{ :type => 'text/javascript', :src => '/javascripts/evil-lib.js' }
+    %script{ :type => 'text/javascript', :src => '/javascripts/evil.js' }
+      

data/views/login.haml

@@ -0,0 +1,5 @@
+%form{ :action => '/admin/openid/login', :id => 'login' }
+  %p
+    %img{ :src => '/images/logo.png', :alt => 'Evil' }
+    %input#openid_url{ :name => 'openid_url' }
+    %input.submit{ :type => 'submit', :value => 'Login' }

data/views/plugins/_fields.haml

@@ -0,0 +1,7 @@
+%h2= "Configure #{@plugin.name} Plugin" 
+
+- @plugin.configurator.fields.each do |field|
+  %input{ :type => 'hidden', :name => 'plugin', :value => @plugin.name }
+  = render_config_field(field)
+%p
+  %input.submit{ :value => 'Save', :type => 'submit' }

data/views/plugins/edit.haml

@@ -0,0 +1,2 @@
+%form{ :action => "/admin/plugins/#{urlencode(@plugin.name)}", :method => 'post' }
+  = partial(:"plugins/fields")

data/views/plugins/fields/_password.haml

@@ -0,0 +1,3 @@
+%p
+  %label{ :for => field.name }= field.label
+  %input.text{ :name => "config[#{field.name}]", :type => 'password', :id => field.name, :value => @plugin.config[field.name] }

data/views/plugins/fields/_text.haml

@@ -0,0 +1,3 @@
+%p
+  %label{ :for => field.name }= field.label
+  %input.text{ :name => "config[#{field.name}]", :id => field.name, :value => @plugin.config[field.name] }

data/views/plugins/new.haml

@@ -0,0 +1,6 @@
+%h2 Choose a plugin
+
+%ul
+  - Evil::Plugin::Environment.plugins.each do |p|
+    %li{ :selected => (params[:plugin] == p.name ) }
+      %a{ :href => "/admin/plugins/#{urlencode(p.name)}" }= p.name

data/views/templates/_fields.haml

@@ -0,0 +1,23 @@
+%p
+  %label{ :for => 'template_title' }
+    Title *
+  %input#template_title.text{ :name => 'template[title]', :value => @template.title }
+%p
+  %label{ :for => 'template_route' }
+    Route
+  %input#template_route.text{ :name => 'template[route]', :value => @template.route }
+%p
+  %label{ :for => 'template_source' }
+    Source *
+  %textarea#template_source{ :name => 'template[source]' }= @template.source
+%p
+  %label{ :for => 'template_ttl' }
+    Expires every (seconds)
+  %input#template_ttl.text{ :name => 'template[ttl]', :value => @template.ttl || 600 }
+%p
+  %label{ :for => 'template_content_type' }
+    Content Type
+  %input#template_content_type.short{ :name => 'template[content_type]', :value => @template.content_type || 'text/html' }
+  %input#template_encoding.short{ :name => 'template[encoding]', :value => @template.encoding || 'utf-8' }
+%p
+  %input.submit{ :value => 'Save', :type => 'submit' }

data/views/templates/edit.haml

@@ -0,0 +1,3 @@
+%form{ :action => "/admin/templates/#{@template.id}", :method => 'post' }
+  = partial(:errors, :locals => { :model => @template, :name => 'template' })
+  = partial(:"templates/fields")

data/views/templates/new.haml

@@ -0,0 +1,3 @@
+%form{ :action => '/admin/templates', :method => 'post' }
+  = partial(:errors, :locals => { :model => @template, :name => 'template' })
+  = partial(:"templates/fields")