rmails 0.1.1

data/system/recipes/05_setup_nginx.rb

@@ -0,0 +1,29 @@
+
+etc_nginx = '/etc/nginx'
+
+if tagged?('debian|ubuntu')
+  sites_available = 'sites-available'
+  sites_enabled = 'sites-enabled'
+end
+
+
+site_path = "#{etc_nginx}/#{sites_available}/rmails"
+locals = {
+    :hostnames => lookup('hostname')
+}
+render(
+    :file   => "#{dist}nginx/rmails.erb",
+    :to     => site_path,
+    :mode   => 0664,
+    :locals => locals
+)
+shell_manager.chown('root', 'rmails', site_path)
+# make path for access.log
+shell_manager.mkdir_p "/var/log/nginx/#{lookup('hostname')}"
+
+
+unless File.symlink? "#{etc_nginx}/#{sites_enabled}/0_rmails"
+  shell_manager.ln_s  "#{etc_nginx}/#{sites_available}/rmails",
+                      "#{etc_nginx}/#{sites_enabled}/0_rmails"
+end
+

data/system/recipes/06_setup_dspam.rb

@@ -0,0 +1,24 @@
+
+etc_dspam = '/etc/dspam'
+
+
+locals = {
+  :database_port => lookup('database#port'),
+  :database_user => lookup('dspam#database#user'),
+  :database_pass => lookup('dspam#database#password'),
+  :database => lookup('dspam#database#name'),
+  :hostname => lookup('postfix#myhostname')
+}
+render(
+    :file   => "#{dist}dspam/conf.erb",
+    :to     => "#{etc_dspam}/dspam.conf",
+    :mode   => 0660,
+    :locals => locals
+)
+shell_manager.chown('root', 'rmails', "#{etc_dspam}/dspam.conf")
+
+
+shell_manager.chown_R('dspam', 'www', "/var/spool/dspam")
+#shell_manager.chmod_R('4555', "/var/spool/dspam")
+
+

data/system/recipes/07_setup_amavis.rb

@@ -0,0 +1,16 @@
+
+etc_amavis = '/etc/amavis'
+
+locals = {
+  :mydomain => lookup('postfix#mydomain')
+}
+render(
+    :file   => "#{dist}amavis/user.erb",
+    :to     => "#{etc_amavis}/conf.d/50-user",
+    :mode   => 0660,
+    :owner  => 'root',
+    :group  => 'rmails',
+    :locals => locals
+)
+
+

data/system/recipes/08_setup_spamassassin.rb

@@ -0,0 +1,22 @@
+
+etc_sa = '/etc/spamassassin'
+
+
+
+locals = {
+  :hostname => lookup('postfix#myhostname')
+}
+render(
+    :file   => "#{dist}amavis/spamassassin.cf.erb",
+    :to     => "#{etc_sa}/local.cf",
+    :mode   => 0660,
+    :owner  => 'root',
+    :group  => 'rmails',
+    :locals => locals
+)
+
+if tagged?('ubuntu')
+  edit "/etc/default/spamassassin" do
+    replace /^ENABLED\s*=\s*0\s*$/, 'ENABLED=1'
+  end
+end

data/system/recipes/09_setup_awstats.rb

@@ -0,0 +1,49 @@
+etc_awstats   = '/etc/awstats'
+log_awstats   = '/var/log/mail.log'
+awstats_tools = '/usr/share/awstats/tools'
+awstats_out   = '/var/lib/awstats/outputs'
+bin = '/usr/bin'
+
+render(
+    :file   => "#{dist}awstats/prepflog.pl",
+    :to     => "#{bin}/prepflog.pl",
+    :mode   => 400,
+    :owner  => 'root',
+    :group  => 'rmails'
+)
+unless File.symlink?("#{bin}/maillogconvert.pl")
+  shell_manager.ln_s "#{awstats_tools}/maillogconvert.pl", "#{bin}/maillogconvert.pl"
+end
+unless File.symlink?("#{bin}/awstats_buildstaticpages.pl")
+  shell_manager.ln_s "#{awstats_tools}/awstats_buildstaticpages.pl", "#{bin}/awstats_buildstaticpages.pl"
+end
+
+locals = {
+    :logfile => log_awstats,
+    :domain  => lookup('hostname'),
+    :outputs => awstats_out
+
+}
+render(
+    :file   => "#{dist}awstats/awstats.mail.conf.erb",
+    :to     => "#{etc_awstats}/awstats.mail.conf",
+    :locals => locals,
+    :mode   => 400,
+    :owner  => 'root',
+    :group  => 'rmails'
+)
+
+
+
+
+#shell_manager.chmod '400', "#{etc_awstats}/*.conf"
+
+#sudo /usr/local/awstats/tools/awstats_buildstaticpages.pl -update -config=www.example.com -dir=/home/demo/public_html/example.com/public/webstats -awstatsprog=/usr/local/awstats/wwwroot/cgi-bin/awstats.pl
+
+#shell_manager.sh "(crontab -l; echo '00 1 * * * /usr/bin/perl /usr/lib/cgi-bin/awstats.pl -update -config=mail') | crontab -"
+
+#shell_manager.sh "(crontab -l; echo '00 1 * * * /usr/bin/perl #{bin}/awstats_buildstaticpages.pl -update -config=mail' -dir=/var/www/mailstats -awstatsprog=/usr/lib/cgi-bin/awstats.pl) | crontab -"
+
+
+shell_manager.sh "(echo '00 1 * * * /usr/bin/perl #{bin}/awstats_buildstaticpages.pl -update -config=mail -dir=/var/www/mailstats -awstatsprog=/usr/lib/cgi-bin/awstats.pl
+00 1 * * * /usr/bin/perl /usr/lib/cgi-bin/awstats.pl -update -config=mail') | crontab -"

data/system/recipes/XX_start_services.rb

@@ -0,0 +1,5 @@
+service_manager.start("nginx")
+service_manager.start("postfix")
+service_manager.start("postgresql-8.4")
+service_manager.start("dovecot")
+

data/test/functional/aliases_controller_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class AliasesControllerTest < ActionController::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/test/functional/domains_controller_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class DomainsControllerTest < ActionController::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/test/functional/users_controller_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class UsersControllerTest < ActionController::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
+  #                          :output => 'tmp/performance', :formats => [:flat] }
+
+  def test_homepage
+    get '/'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/unit/helpers/aliases_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class AliasesHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/domains_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class DomainsHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/users_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class UsersHelperTest < ActionView::TestCase
+end

data/vendor/assets/javascripts/canjs/can.construct.proxy.js

@@ -0,0 +1,60 @@
+(function(can, window, undefined){
+var isFunction = can.isFunction,
+	isArray = can.isArray,
+	makeArray = can.makeArray,
+
+proxy = function( funcs ) {
+
+			//args that should be curried
+			var args = makeArray(arguments),
+				self;
+
+			// get the functions to callback
+			funcs = args.shift();
+
+			// if there is only one function, make funcs into an array
+			if (!isArray(funcs) ) {
+				funcs = [funcs];
+			}
+			
+			// keep a reference to us in self
+			self = this;
+			
+			
+			return function class_cb() {
+				// add the arguments after the curried args
+				var cur = args.concat(makeArray(arguments)),
+					isString, 
+					length = funcs.length,
+					f = 0,
+					func;
+				
+				// go through each function to call back
+				for (; f < length; f++ ) {
+					func = funcs[f];
+					if (!func ) {
+						continue;
+					}
+					
+					// set called with the name of the function on self (this is how this.view works)
+					isString = typeof func == "string";
+					
+					// call the function
+					cur = (isString ? self[func] : func).apply(self, cur || []);
+					
+					// pass the result to the next function (if there is a next function)
+					if ( f < length - 1 ) {
+						cur = !isArray(cur) || cur._use_call ? [cur] : cur
+					}
+				}
+				return cur;
+			}
+		}
+	can.Construct.proxy = can.Construct.prototype.proxy = proxy;
+	
+	
+
+
+
+
+})(this.can, this )

data/vendor/assets/javascripts/canjs/can.construct.super.js

@@ -0,0 +1,44 @@
+(function(can, window, undefined){
+
+// tests if we can get super in .toString()
+	var isFunction = can.isFunction,
+		
+		fnTest = /xyz/.test(function() {
+			xyz;
+		}) ? /\b_super\b/ : /.*/;
+		
+		// overwrites a single property so it can still call super
+		can.Construct._overwrite = function(addTo, base, name, val){
+			// Check if we're overwriting an existing function
+			addTo[name] = isFunction(val) && 
+							  isFunction(base[name]) && 
+							  fnTest.test(val) ? (function( name, fn ) {
+					return function() {
+						var tmp = this._super,
+							ret;
+
+						// Add a new ._super() method that is the same method
+						// but on the super-class
+						this._super = base[name];
+
+						// The method only need to be bound temporarily, so we
+						// remove it when we're done executing
+						ret = fn.apply(this, arguments);
+						this._super = tmp;
+						return ret;
+					};
+				})(name, val) : val;
+		}
+		// overwrites an object with methods, sets up _super
+		//   newProps - new properties
+		//   oldProps - where the old properties might be
+		//   addTo - what we are adding to
+		can.Construct._inherit = function( newProps, oldProps, addTo ) {
+			addTo = addTo || newProps
+			for ( var name in newProps ) {
+				can.Construct._overwrite(addTo, oldProps, name, newProps[name]);
+			}
+		}
+
+
+})(this.can, this )

data/vendor/assets/javascripts/canjs/can.control.plugin.js

@@ -0,0 +1,245 @@
+(function(can, window, undefined){
+	
+
+
+//used to determine if a control instance is one of controllers
+//controllers can be strings or classes
+var i, 
+	isAControllerOf = function( instance, controllers ) {
+		for ( i = 0; i < controllers.length; i++ ) {
+			if ( typeof controllers[i] == 'string' ? instance.constructor._shortName == controllers[i] : instance instanceof controllers[i] ) {
+				return true;
+			}
+		}
+		return false;
+	},
+	data = function(el, data){
+		return $el.data('controls');
+	},
+	makeArray = can.makeArray,
+	old = can.Control.setup;
+
+/*
+ * static
+ */
+can.Control.setup = function() {
+	// if you didn't provide a name, or are control, don't do anything
+	if ( this !== can.Control ) {
+
+		/**
+		 * @attribute can.Control.plugin.static.pluginName
+		 * @parent can.Control.plugin
+		 *
+		 * Setting the static `pluginName` property allows you to override the default name
+		 * with your own.
+		 *
+		 *		var Filler = can.Control({
+		 *		  pluginName: 'fillWith'
+		 *		},{});
+		 * 
+		 *		$("#foo").fillWith();
+		 *
+		 * If you don't provide a `pluginName`, the control falls back to the
+		 * [can.Construct.fullName fullName] attribute:
+		 *
+		 *		can.Control('Ui.Layout.FillWith', {}, {});
+		 *		$("#foo").ui_layout_fill_with();
+		 *
+		 */
+		var pluginName = this.pluginName || this._fullName;
+			
+		// create jQuery plugin
+		if(pluginName !== 'can_control'){
+			this.plugin(pluginName);
+		}
+			
+		old.apply(this, arguments);
+	}
+};
+
+/*
+ * prototype
+ */
+$.fn.extend({
+
+	/**
+	 * @function jQuery.fn.controls
+	 * @parent can.Control.plugin
+	 * 
+	 * When the widget is initialized, the plugin control creates an array 
+	 * of control instance(s) with the DOM element it was initialized on using 
+	 * [can.data] method.
+	 *
+	 * The `controls` method allows you to get the control instance(s) for any element.  
+	 *
+	 *		//- Inits the widgets
+	 *		$('.widgets:eq(0)').my_box();
+	 *		$('.widgets:eq(1)').my_clock();
+	 *
+	 *		<div class="widgets my_box" />
+	 *		<div class="widgets my_clock" />
+	 *
+	 *		$('.widgets').controls() //-> [ MyBox, MyClock ]
+	 *
+	 * Additionally, you can invoke it passing the name of a control
+	 * to fetch a specific instance(s).
+	 *
+	 *		//- Inits the widgets
+	 *		$('.widgets:eq(0)').my_box();
+	 *		$('.widgets:eq(1)').my_clock();
+	 *
+	 *		<div class="widgets my_box" />
+	 *		<div class="widgets my_clock" />
+	 *
+	 *		$('.widgets').controls('MyBox') //-> [ MyBox ]
+	 *
+	 * @param {Object} control (optional) if exists the control instance(s) with that constructor function or type will be returned.
+	 * @return {Array} an array of control instance(s).
+	 */
+	controls: function() {
+		var controllerNames = makeArray(arguments),
+			instances = [],
+			controls, c, cname;
+		//check if arguments
+		this.each(function() {
+
+			controls = can.$(this).data("controls");
+			if(!controls){
+				return;
+			}
+			for(var i=0; i<controls.length; i++){
+				c = controls[i];
+				if (!controllerNames.length || isAControllerOf(c, controllerNames) ) {
+					instances.push(c);
+				}
+			}
+		});
+		return instances;
+	},
+	
+	/**
+	 * @function jQuery.fn.control
+	 * @parent can.Control.plugin
+	 * 
+	 * The `control` does the same as [jQuery.fn.controls controls] execept it only 
+	 * returns the first instance found.
+	 *
+	 *		//- Init MyBox widget
+	 *		$('.widgets').my_box();
+	 *
+	 *		<div class="widgets my_box" />
+	 *
+	 *		$('.widgets').controls() //-> MyBox
+	 *
+	 * @param {Object} control (optional) if exists the first control instance with that constructor function or type will be returned.
+	 * @return {can.Control} the first control.
+	 */
+	control: function( control ) {
+		return this.controls.apply(this, arguments)[0];
+	}
+});
+
+can.Control.plugin = function(pluginname){
+	var control = this;
+
+	if (!$.fn[pluginname]) {
+		$.fn[pluginname] = function(options){
+		
+			var args = makeArray(arguments),   //if the arg is a method on this control
+			isMethod = typeof options == "string" && $.isFunction(control.prototype[options]), meth = args[0];
+			return this.each(function(){
+				//check if created
+				var plugin = can.$(this).control(control);
+				
+				if (plugin) {
+					if (isMethod) {
+						// call a method on the control with the remaining args
+						plugin[meth].apply(plugin, args.slice(1));
+					}
+					else {
+						// call the plugin's update method
+						plugin.update.apply(plugin, args);
+					}
+				}
+				else {
+					//create a new control instance
+					control.newInstance.apply(control, [this].concat(args));
+				}
+			});
+		};
+	}
+}
+
+/**
+ * @function can.Control.prototype.update
+ * @parent can.Control.plugin
+ * 
+ * Update extends [can.Control.prototype.options options] 
+ * with the `options` argument and rebinds all events.  It 
+ * re-configures the control.
+ * 
+ * For example, the following control wraps a recipe form. When the form
+ * is submitted, it creates the recipe on the server.  When the recipe
+ * is `created`, it resets the form with a new instance.
+ * 
+ *		var Creator = can.Control({
+ *		  "{recipe} created" : function(){
+ *		    this.update({recipe : new Recipe()});
+ *		    this.element[0].reset();
+ *		    this.element.find("[type=submit]").val("Create Recipe")
+ *		  },
+ *		  "submit" : function(el, ev){
+ *		    ev.preventDefault();
+ *		    var recipe = this.options.recipe;
+ *			recipe.attrs( this.element.formParams() );
+ *			this.element.find("[type=submit]").val("Saving...")
+ *			recipe.save();
+ *		  }
+ *		});
+ *
+ *		$('#createRecipes').creator({ recipe : new Recipe() })
+ * 
+ * *Update* is called if a control's plugin helper is called with the plugin options on an element
+ * that already has a control instance of the same type. If you want to implement your
+ * own update method make sure to call the old one either using the [can.Construct.super super] plugin or
+ * by calling `can.Control.prototype.update.apply(this, arguments);`.
+ * For example, you can change the content of the control element every time the options change:
+ * 
+ *		var Plugin = can.Control({
+ *		    pluginName: 'myPlugin'
+ *		  }, {
+ *		    init : function(el, options) {
+ *			  this.updateCount = 0;
+ *			  this.update({
+ *			    text : 'Initialized'
+ *			  });
+ *			},
+ *			update : function(options) {
+ *			  // Call the can.Control update first.
+ *			  // Use this._super when using can/construct/super
+ *			  can.Control.prototype.update.call(this, options);
+ *			  this.element.html(this.options.text + ' ' +
+ *			    (++this.updateCount) + ' times');
+ *			}
+ *		});
+ *
+ *		$('#control').myPlugin();
+ *		$('#control').html();
+ *		// Initialized. Updated 1 times
+ *
+ *		$('#control').myPlugin({ text : 'Calling update. Updated' });
+ *		$('#control').html();
+ *		// Calling update. Updated 2 times
+ *
+ * @demo can/control/plugin/demo-update.html
+ * 
+ * @param {Object} options A list of options to merge with 
+ * [can.Control.prototype.options this.options].  Often this method
+ * is called by the [can.Control.plugin jQuery helper function].
+ */
+can.Control.prototype.update = function( options ) {
+		can.extend(this.options, options);
+		this.on();
+};
+
+})(this.can, this )