danwrong-evil 0.1.1 → 0.1.2

data/CHANGELOG

@@ -1,2 +1,3 @@
+v0.1.2 Barebones but useable
 v0.1.1 It's damn close to being useful!
 v0.1 Initial release

data/Manifest

@@ -15,9 +15,11 @@ lib/evil/models/whitelist.rb
 lib/evil/models.rb
 lib/evil/open_id.rb
 lib/evil/plugin/base.rb
+lib/evil/plugin/block_tag.rb
 lib/evil/plugin/configuration.rb
 lib/evil/plugin/environment.rb
 lib/evil/plugin/filesystem.rb
+lib/evil/plugin/singleton_tag.rb
 lib/evil/plugin/tag.rb
 lib/evil/plugin.rb
 lib/evil/setup/db_tool.rb
@@ -28,10 +30,18 @@ LICENSE
 Manifest
 Rakefile
 README.textile
-test/app/evil_test.rb
+test/application/frontend_test.rb
+test/application/openid_test.rb
+test/application/plugin_config_test.rb
+test/application/template_test.rb
 test/dev_env.rb
 test/test_helper.rb
+test/units/models/template_test.rb
+test/units/models/whitelist_test.rb
 test/units/plugin/base_test.rb
+test/units/plugin/configuration_test.rb
+test/units/plugin/environment_test.rb
+test/units/plugin/filesystem_test.rb
 test/units/plugin/tag_test.rb
 views/_banner.haml
 views/_errors.haml

data/README.textile

@@ -2,19 +2,57 @@ h1. EVIL
 
 Author: Dan Webb (dan@danwebb.net)
 
-Evil is going to be a quick and easy tool for bringing together data from all over the web into a cunning little website.  It's going to be easy to set up, easy to extend with plugins using any web API and be a good citzen in the Ruby web dev world by being a standard Rack app that you can deploy with Passenger, on Heroku or whatever you feel like. Hopefully it'll be mountable as part of a Rails or Merb app.
+Evil is a tool for very easily putting together sites that take advantage of data from around the web.  Grab your blog entries from an ATOM or RSS feed, your recent links from Delicious, your projects from Github or whatever.  If it's got an API you can use pull it in to Evil and twist it together with other data and make a site.  Evil does all the frustrating stuff like caching template processing and handling HTTP requests to APIs.
 
-To create an Evil site:
+NB.  It's 'working' at the moment and has decent test coverage but it's still very bare bones so it's probably not worth using until it approaches 1.0.
 
-<pre><code>sudo gem install evil
+Here's an overview of how to use it:
 
-evil init {your_app_root}
-evil whitelist {your_openid}</pre></code>
+1. Install the gem
 
-Then point Passenger at it, send it up to Heruko or run it on your grandad's ZX Spectrum then go to /admin and get going.
+@sudo gem install danwrong-evil@
 
-h2. Planned features
+2. Generate a site skeleton
 
-  * Caching via Rack::Cache
-  * Plugin architecture that makes it easy to interact with web APIs (probably based on HTTParty)
-  * Simple OpenID whitelist for access to the admin interface
+@evil init {path}@
+
+This will give you the files and dirs that you need for your site including a public directory to add static files to if you need them.
+
+3. Whitelist your OpenID
+
+<code><pre>cd {path}
+evil whitelist {your OpenID URL}</pre></code>
+
+You can use wildcards in here if you want so if you wanted to let in all subdomains of danwebb.net you could do *.danwebb.net.
+
+4. Upload the whole directory to your server and point passenger at it.  Something like this in your Apache config should do it:
+
+<code><pre><VirtualHost *:80>
+  ServerName www.example.com
+  DocumentRoot "/var/www/example/public"
+</VirtualHost></pre></code>
+
+5. Go to the admin site and start writing templates.  It will be at /admin.  Just log in with your OpenID.
+
+6.  Mess around.  Create templates using liquid syntax, give them routes using the Sinatra/Rails syntax eg. /mythings/:id.  
+
+That's all for now.  More detail later.
+
+h2. Acknowledgements
+
+Evil is built, as all good software is, on the efforts of lots of brilliant projects:
+
+* Sinatra
+* Rack::Cache
+* Liquid
+* HTTParty
+* jQuery
+* HAML
+
+So thanks to all the authors.
+
+h2. In the works...
+
+There will be a suite of built in plugins covering all of the popular services and protocols (Flickr, Twitter, ATOM/RSS, Github, Upcoming, Delicious, YQL, Last.fm + loads more).  Also, I'll be adding documentation to write your own plugins and easy handling of OAuth.  This is just the very start.
+
+Feedback welcome.

data/Rakefile

@@ -13,7 +13,8 @@ Echoe.new("evil") do |p|
                             
   p.development_dependencies = ['shoulda']
   p.retain_gemspec = true
-  p.ignore_pattern = ['test/example/**/*']
+  p.ignore_pattern = ['test/example/**/*', 'test/evil.db']
+  p.rcov_options = "--exclude 'gems/*'"
 end
 
 desc 'Move assets from text/example to assets'

data/assets/evil-lib.js

@@ -213,10 +213,309 @@
     }
   });
   
-  $.ajaxSetup({ 
-    beforeSend: function(xhr) {
-      xhr.setRequestHeader("Accept", "text/javascript, text/html, application/xml, text/xml, */*");
-    } 
-  });
-  
-})(jQuery);
+})(jQuery);
+
+jQuery.tableDnD = {
+    /** Keep hold of the current table being dragged */
+    currentTable : null,
+    /** Keep hold of the current drag object if any */
+    dragObject: null,
+    /** The current mouse offset */
+    mouseOffset: null,
+    /** Remember the old value of Y so that we don't do too much processing */
+    oldY: 0,
+
+    /** Actually build the structure */
+    build: function(options) {
+        // Set up the defaults if any
+
+        this.each(function() {
+            // This is bound to each matching table, set up the defaults and override with user options
+            this.tableDnDConfig = jQuery.extend({
+                onDragStyle: null,
+                onDropStyle: null,
+				// Add in the default class for whileDragging
+				onDragClass: "tDnD_whileDrag",
+                onDrop: null,
+                onDragStart: null,
+                scrollAmount: 5,
+				serializeRegexp: /[^\-]*$/, // The regular expression to use to trim row IDs
+				serializeParamName: null, // If you want to specify another parameter name instead of the table ID
+                dragHandle: null // If you give the name of a class here, then only Cells with this class will be draggable
+            }, options || {});
+            // Now make the rows draggable
+            jQuery.tableDnD.makeDraggable(this);
+        });
+
+        // Now we need to capture the mouse up and mouse move event
+        // We can use bind so that we don't interfere with other event handlers
+        jQuery(document)
+            .bind('mousemove', jQuery.tableDnD.mousemove)
+            .bind('mouseup', jQuery.tableDnD.mouseup);
+
+        // Don't break the chain
+        return this;
+    },
+
+    /** This function makes all the rows on the table draggable apart from those marked as "NoDrag" */
+    makeDraggable: function(table) {
+        var config = table.tableDnDConfig;
+		if (table.tableDnDConfig.dragHandle) {
+			// We only need to add the event to the specified cells
+			var cells = jQuery("td."+table.tableDnDConfig.dragHandle, table);
+			cells.each(function() {
+				// The cell is bound to "this"
+                jQuery(this).mousedown(function(ev) {
+                    jQuery.tableDnD.dragObject = this.parentNode;
+                    jQuery.tableDnD.currentTable = table;
+                    jQuery.tableDnD.mouseOffset = jQuery.tableDnD.getMouseOffset(this, ev);
+                    if (config.onDragStart) {
+                        // Call the onDrop method if there is one
+                        config.onDragStart(table, this);
+                    }
+                    return false;
+                });
+			})
+		} else {
+			// For backwards compatibility, we add the event to the whole row
+	        var rows = jQuery("tr", table); // get all the rows as a wrapped set
+	        rows.each(function() {
+				// Iterate through each row, the row is bound to "this"
+				var row = jQuery(this);
+				if (! row.hasClass("nodrag")) {
+	                row.mousedown(function(ev) {
+	                    if (ev.target.tagName == "TD") {
+	                        jQuery.tableDnD.dragObject = this;
+	                        jQuery.tableDnD.currentTable = table;
+	                        jQuery.tableDnD.mouseOffset = jQuery.tableDnD.getMouseOffset(this, ev);
+	                        if (config.onDragStart) {
+	                            // Call the onDrop method if there is one
+	                            config.onDragStart(table, this);
+	                        }
+	                        return false;
+	                    }
+	                }).css("cursor", "move"); // Store the tableDnD object
+				}
+			});
+		}
+	},
+
+	updateTables: function() {
+		this.each(function() {
+			// this is now bound to each matching table
+			if (this.tableDnDConfig) {
+				jQuery.tableDnD.makeDraggable(this);
+			}
+		})
+	},
+
+    /** Get the mouse coordinates from the event (allowing for browser differences) */
+    mouseCoords: function(ev){
+        if(ev.pageX || ev.pageY){
+            return {x:ev.pageX, y:ev.pageY};
+        }
+        return {
+            x:ev.clientX + document.body.scrollLeft - document.body.clientLeft,
+            y:ev.clientY + document.body.scrollTop  - document.body.clientTop
+        };
+    },
+
+    /** Given a target element and a mouse event, get the mouse offset from that element.
+        To do this we need the element's position and the mouse position */
+    getMouseOffset: function(target, ev) {
+        ev = ev || window.event;
+
+        var docPos    = this.getPosition(target);
+        var mousePos  = this.mouseCoords(ev);
+        return {x:mousePos.x - docPos.x, y:mousePos.y - docPos.y};
+    },
+
+    /** Get the position of an element by going up the DOM tree and adding up all the offsets */
+    getPosition: function(e){
+        var left = 0;
+        var top  = 0;
+        /** Safari fix -- thanks to Luis Chato for this! */
+        if (e.offsetHeight == 0) {
+            /** Safari 2 doesn't correctly grab the offsetTop of a table row
+            this is detailed here:
+            http://jacob.peargrove.com/blog/2006/technical/table-row-offsettop-bug-in-safari/
+            the solution is likewise noted there, grab the offset of a table cell in the row - the firstChild.
+            note that firefox will return a text node as a first child, so designing a more thorough
+            solution may need to take that into account, for now this seems to work in firefox, safari, ie */
+            e = e.firstChild; // a table cell
+        }
+
+        while (e.offsetParent){
+            left += e.offsetLeft;
+            top  += e.offsetTop;
+            e     = e.offsetParent;
+        }
+
+        left += e.offsetLeft;
+        top  += e.offsetTop;
+
+        return {x:left, y:top};
+    },
+
+    mousemove: function(ev) {
+        if (jQuery.tableDnD.dragObject == null) {
+            return;
+        }
+
+        var dragObj = jQuery(jQuery.tableDnD.dragObject);
+        var config = jQuery.tableDnD.currentTable.tableDnDConfig;
+        var mousePos = jQuery.tableDnD.mouseCoords(ev);
+        var y = mousePos.y - jQuery.tableDnD.mouseOffset.y;
+        //auto scroll the window
+	    var yOffset = window.pageYOffset;
+	 	if (document.all) {
+	        // Windows version
+	        //yOffset=document.body.scrollTop;
+	        if (typeof document.compatMode != 'undefined' &&
+	             document.compatMode != 'BackCompat') {
+	           yOffset = document.documentElement.scrollTop;
+	        }
+	        else if (typeof document.body != 'undefined') {
+	           yOffset=document.body.scrollTop;
+	        }
+
+	    }
+		    
+		if (mousePos.y-yOffset < config.scrollAmount) {
+	    	window.scrollBy(0, -config.scrollAmount);
+	    } else {
+            var windowHeight = window.innerHeight ? window.innerHeight
+                    : document.documentElement.clientHeight ? document.documentElement.clientHeight : document.body.clientHeight;
+            if (windowHeight-(mousePos.y-yOffset) < config.scrollAmount) {
+                window.scrollBy(0, config.scrollAmount);
+            }
+        }
+
+
+        if (y != jQuery.tableDnD.oldY) {
+            // work out if we're going up or down...
+            var movingDown = y > jQuery.tableDnD.oldY;
+            // update the old value
+            jQuery.tableDnD.oldY = y;
+            // update the style to show we're dragging
+			if (config.onDragClass) {
+				dragObj.addClass(config.onDragClass);
+			} else {
+	            dragObj.css(config.onDragStyle);
+			}
+            // If we're over a row then move the dragged row to there so that the user sees the
+            // effect dynamically
+            var currentRow = jQuery.tableDnD.findDropTargetRow(dragObj, y);
+            if (currentRow) {
+                // TODO worry about what happens when there are multiple TBODIES
+                if (movingDown && jQuery.tableDnD.dragObject != currentRow) {
+                    jQuery.tableDnD.dragObject.parentNode.insertBefore(jQuery.tableDnD.dragObject, currentRow.nextSibling);
+                } else if (! movingDown && jQuery.tableDnD.dragObject != currentRow) {
+                    jQuery.tableDnD.dragObject.parentNode.insertBefore(jQuery.tableDnD.dragObject, currentRow);
+                }
+            }
+        }
+
+        return false;
+    },
+
+    /** We're only worried about the y position really, because we can only move rows up and down */
+    findDropTargetRow: function(draggedRow, y) {
+        var rows = jQuery.tableDnD.currentTable.rows;
+        for (var i=0; i<rows.length; i++) {
+            var row = rows[i];
+            var rowY    = this.getPosition(row).y;
+            var rowHeight = parseInt(row.offsetHeight)/2;
+            if (row.offsetHeight == 0) {
+                rowY = this.getPosition(row.firstChild).y;
+                rowHeight = parseInt(row.firstChild.offsetHeight)/2;
+            }
+            // Because we always have to insert before, we need to offset the height a bit
+            if ((y > rowY - rowHeight) && (y < (rowY + rowHeight))) {
+                // that's the row we're over
+				// If it's the same as the current row, ignore it
+				if (row == draggedRow) {return null;}
+                var config = jQuery.tableDnD.currentTable.tableDnDConfig;
+                if (config.onAllowDrop) {
+                    if (config.onAllowDrop(draggedRow, row)) {
+                        return row;
+                    } else {
+                        return null;
+                    }
+                } else {
+					// If a row has nodrop class, then don't allow dropping (inspired by John Tarr and Famic)
+                    var nodrop = jQuery(row).hasClass("nodrop");
+                    if (! nodrop) {
+                        return row;
+                    } else {
+                        return null;
+                    }
+                }
+                return row;
+            }
+        }
+        return null;
+    },
+
+    mouseup: function(e) {
+        if (jQuery.tableDnD.currentTable && jQuery.tableDnD.dragObject) {
+            var droppedRow = jQuery.tableDnD.dragObject;
+            var config = jQuery.tableDnD.currentTable.tableDnDConfig;
+            // If we have a dragObject, then we need to release it,
+            // The row will already have been moved to the right place so we just reset stuff
+			if (config.onDragClass) {
+	            jQuery(droppedRow).removeClass(config.onDragClass);
+			} else {
+	            jQuery(droppedRow).css(config.onDropStyle);
+			}
+            jQuery.tableDnD.dragObject   = null;
+            if (config.onDrop) {
+                // Call the onDrop method if there is one
+                config.onDrop(jQuery.tableDnD.currentTable, droppedRow);
+            }
+            jQuery.tableDnD.currentTable = null; // let go of the table too
+        }
+    },
+
+    serialize: function() {
+        if (jQuery.tableDnD.currentTable) {
+            return jQuery.tableDnD.serializeTable(jQuery.tableDnD.currentTable);
+        } else {
+            return "Error: No Table id set, you need to set an id on your table and every row";
+        }
+    },
+
+	serializeTable: function(table) {
+        var result = "";
+        var tableId = table.id;
+        var rows = table.rows;
+        for (var i=0; i<rows.length; i++) {
+            if (result.length > 0) result += "&";
+            var rowId = rows[i].id;
+            if (rowId && rowId && table.tableDnDConfig && table.tableDnDConfig.serializeRegexp) {
+                rowId = rowId.match(table.tableDnDConfig.serializeRegexp)[0];
+            }
+
+            result += tableId + '[]=' + rowId;
+        }
+        return result;
+	},
+
+	serializeTables: function() {
+        var result = "";
+        this.each(function() {
+			// this is now bound to each matching table
+			result += jQuery.tableDnD.serializeTable(this);
+		});
+        return result;
+    }
+
+}
+
+jQuery.fn.extend(
+	{
+		tableDnD : jQuery.tableDnD.build,
+		tableDnDUpdate : jQuery.tableDnD.updateTables,
+		tableDnDSerialize: jQuery.tableDnD.serializeTables
+	}
+);

data/assets/evil.css

@@ -180,6 +180,10 @@ input.submit {
   margin: 0 2% 2em 0;
 }
 
+#overview table#templates tr.dragging {
+  background: #444;
+}
+
 #content form {
   width: 50%;
   margin: 0 auto;
@@ -193,12 +197,16 @@ form p {
   margin: 1em 0;
 }
 
-form input.text, form textarea {
+form input.text, form textarea, form input.short {
   width: 100%;
   font-family: Verdana, Helvetica, Arial, sans-serif;
   font-size: 1em;
 }
 
+form input.short {
+  width: 30%;
+}
+
 form div.errors {
   border: 1px solid red;
   font-size: 0.8em;