kodiak 0.0.1

data/lib/kodiak/generator.rb

@@ -0,0 +1,38 @@
+module Kodiak
+  class Generator
+
+		attr_accessor :options
+
+		def initialize(options)
+			@options = options
+		end
+
+		def generate
+			if config_exists? && ! options[:force]
+        Kodiak::Notification.new "Kodiak config already exists in this directory. Use --force to overwrite.\n", "failure"
+			elsif (!config_exists?) || (config_exists? && options[:force])
+				copy_config
+			end
+		end
+
+		# check to see if Kodiak.yaml already exists in directory
+		def config_exists?
+			File.exists? Kodiak::CONFIG_FILENAME
+		end
+
+		# copy sample Kodiak.yaml to directory
+		def copy_config
+			FileUtils.cp_r "#{Kodiak::CONFIG_PATH}/#{Kodiak::CONFIG_FILENAME}", "#{Kodiak::CONFIG_FILENAME}", :remove_destination => true
+
+			# if logs exist already, don't overwrite them. Not even in force mode. Never ever.
+			if not File.exists? Kodiak::LOG_FILENAME
+				FileUtils.cp_r "#{Kodiak::CONFIG_PATH}/#{Kodiak::LOG_FILENAME}", "#{Kodiak::LOG_FILENAME}", :remove_destination => true
+			end
+
+			Kodiak::Notification.new "Kodiak configuration created at #{Kodiak::CONFIG_FILENAME}\n", "success"
+			system("open #{Kodiak::CONFIG_FILENAME}")
+			exit
+		end
+
+  end
+end

data/lib/kodiak/notification.rb

@@ -0,0 +1,65 @@
+require 'appscript'
+require 'term/ansicolor'
+include Term::ANSIColor
+
+module Kodiak
+  class Notification
+
+		attr_accessor :growl, :application, :icon, :default_notifications, :notifications, :type, :message
+
+		def initialize(message, type = "message")
+      @message = message
+      @type = type
+			
+			console_notify
+			
+			if Config::CONFIG['target_os'] =~ /darwin/i
+				@growl = Appscript.app("GrowlHelperApp");
+			
+				if @growl.is_running?
+					growl_register
+					growl_notify
+				end
+			end
+		end
+
+
+    def console_notify
+    	case @type
+    	when "success"
+        print @message.green
+    	when "warning"
+        print @message.yellow
+      when "failure"
+        print @message.red
+    	else
+        print @message.white
+    	end
+    end
+
+
+		# trigger a growl notification
+		def growl_notify
+			options = { :title => @application,
+									:description => @message.gsub(/[\n]+/, ""),
+									:application_name => @application,
+									:image_from_location => @icon,
+									:sticky => false,
+									:priority => 0,
+									:with_name => notifications.first }
+      @growl.notify options			
+		end	
+
+
+		# register Kodiak as an application with Growl
+    def growl_register
+			@application = Kodiak::APP_NAME
+			@icon = "#{Kodiak::CONFIG_PATH}/#{Kodiak::CONFIG_ICON}"
+	    @default_notifications = ["Kodiak Success"]
+	    @notifications = ["Kodiak Success", "Kodiak Failure"]
+      @growl.register(:as_application => @application, :all_notifications => @notifications, :default_notifications => @default_notifications)
+    end
+
+
+	end
+end

data/lib/kodiak/transporter.rb

@@ -0,0 +1,129 @@
+module Kodiak
+  class Transporter
+
+		attr_accessor :config, :options, :files, :pushed, :ignored
+
+		def initialize(config, options)
+			@config 	= config
+			@files 		= @config.files
+			@files 		= @config.files
+			@options 	= options
+		end
+
+
+		def transport(files = nil)
+			@pushed = []
+			@ignored = []
+			@files = files || @files
+			if @config.ftp?
+				ftp
+			else
+				local
+			end
+		end
+
+
+		def local
+			puts "\nPushing to [#{@options[:environment]}]"
+
+			@files.each do |file|
+
+				if @options[:force]
+					push file
+
+				elsif File.exists? file[:destination]
+					source_changed 			= File.ctime(file[:source])
+					destination_changed = File.ctime(file[:destination])
+
+					# check if destination is older than source
+					if (destination_changed <=> source_changed) == -1
+						push file
+					else
+						ignore file, "Destination file was newer than source."
+					end
+
+				else
+					push file
+				end
+			end
+
+			if ! @options[:quiet]
+		  	Kodiak::Notification.new "\nPushed #{@pushed.length} files, Ignored #{@ignored.length} files\n\n", "success"
+			else
+				puts "\nPushed #{@pushed.length} files, Ignored #{@ignored.length} files\n\n"
+			end
+
+			if @options[:verbose] && @ignored.length > 0
+				puts "Some files were ignored. Use --force to force overwrite.\n\n"
+			end
+			
+			Kodiak.log :pushed => @pushed, :ignored => @ignored
+			
+		end
+
+
+		def ftp
+			require 'net/ftp'
+			credentials = @config.ftp
+
+			puts "Connecting to #{credentials['server']}..."
+
+		  Net::FTP.open credentials['server'] do |ftp|
+		    ftp.login credentials['username'], credentials['password']
+		    ftp.chdir credentials['path']
+
+				@files.each do |file|
+					source 			= file[:source]
+					destination = file[:destination]
+
+					if not File.directory? source
+						folders = destination.split("/")
+						filename = folders.pop
+
+						folders.each do |folder|
+							if not ftp.nlst.index(folder)
+								puts "- /#{folder} not found. Creating."
+								ftp.mkdir folder
+							end
+							puts "- opening directory /#{folder}"
+							ftp.chdir folder
+						end
+
+						puts "+ pushing #{filename}"
+						if File.directory? filename
+							ftp.mkdir filename
+						else
+							ftp.put source, filename
+						end
+						folders.length.times { ftp.chdir("..") }
+					end
+				end
+		  end
+		end
+
+
+		def push(file)
+			FileUtils.cp_r file[:source], file[:destination], :remove_destination => true
+			
+			if @options[:verbose] 
+		  	Kodiak::Notification.new "Pushed #{file[:source]} --> #{file[:destination]}\n"
+			else
+				puts " - Pushed #{file[:source]} --> #{file[:destination]}\n"
+			end
+
+			@pushed.push file
+		end
+
+		def ignore(file, reason)
+			file[:reason] = reason
+			if @options[:verbose] 
+	  		Kodiak::Notification.new "Ignored #{file[:source]}\n     - #{file[:reason]}\n"
+			else
+	  		puts "Ignored #{file[:source]}\n     - #{file[:reason]}\n"	
+			end
+			
+			@ignored.push file
+		end
+
+  end
+end

data/lib/kodiak/utils.rb

@@ -0,0 +1,29 @@
+module Kodiak
+	
+	def self.log(params={})
+		pushed = params[:pushed]
+		ignored = params[:ignored]
+
+		file = File.open("#{Kodiak::LOG_FILENAME}", "a+")
+
+   	time = Time.now.strftime("%A, %m/%d/%Y at %I:%M:%3N %p")
+		message = "#{time} | #{Kodiak.user['name']} (#{Kodiak.user['email']})\n"
+		message += "---------------------------------------------------------------------------------\n"
+		message += "Pushed #{pushed.length} files and ignored #{ignored.length} files\n"
+		message += "---------------------------------------------------------------------------------\n"
+		
+		pushed.each do |file|
+			message += "Pushed [#{file[:source]}] --> [#{file[:destination]}]\n"			
+		end
+		
+		ignored.each do |file|
+			message += "Ignored #{file[:source]} because #{file[:reason].downcase}\n"			
+		end		
+
+		message += "\n\n\n"
+		
+		file.write(message)
+		file.close
+	end
+	
+end

data/lib/kodiak/watcher.rb

@@ -0,0 +1,37 @@
+require 'directory_watcher'
+
+module Kodiak
+  class Watcher
+
+		attr_accessor :config, :options, :files
+		
+		def initialize(config, options)
+			@config = config
+			@files = config.files
+			@options = options
+			watch
+		end
+
+		def watch
+			transporter = Kodiak::Transporter.new(config, options)
+
+			dw = []
+			@files.each do |file|
+				dw = DirectoryWatcher.new '.', :glob => file[:source], :pre_load => true
+				dw.add_observer do |*args| 
+					args.each do |event| 
+						if event.type == :stable then transporter.transport [file] end
+					end
+				end
+				dw.interval = 0.25 	# polling interval
+				dw.stable = 2 			# mutiple of interval for 'stable' events
+				dw.start
+			end		
+			
+			puts "Kodiak server started"
+			STDIN.gets
+			dw.stop			
+		end
+		
+	end
+end

data/test/app/scripts/javascript/application/application.js

@@ -0,0 +1,451 @@
+// require utils.hash
+// require jquery
+
+var Application = Application || function(data){
+
+	var self = this;
+	var fxspeed = 200;
+	var hash = new Utils.Hash();
+	var $loading = $("#loading");
+
+//
+
+	self.initialize = function(){
+		self.map = new Map(data.map, "map");		
+		self.panels.init();
+		self.layers.init();
+		self.overlays.init();
+		self.observe();
+		return self;
+	}
+
+//
+
+	self.observe = function(){
+
+		$("a.flyout-trigger").live('click',function(e){
+			e.preventDefault();
+			var href = $(this).attr("href");
+			var $remote = $(href);
+
+
+
+
+			if( $remote.is(':hidden') ){
+				$remote.siblings('.flyout').slideUp(fxspeed);
+				$remote.slideDown(fxspeed);				
+			}
+			else {
+				$remote.slideUp(fxspeed);
+			}
+		});
+		return self;
+	}
+
+
+
+
+
+
+//
+
+	self.panels = {
+
+		init : function(){
+			this.build();
+			this.observe();
+		},
+
+		build : function(){
+
+			if( hash.element() ) {
+				var $panel = $(hash.element());
+				self.panels.show($panel);
+			} else {
+				$panel = $('#panel .panel').eq(0);
+				self.panels.show($panel);
+			}
+
+		},
+
+		observe : function(){
+
+			hash.onChange( function(){
+				var $panel = $(hash.element());
+				self.panels.show($panel);
+			});
+
+			$('.hash-trigger').live('click', function(e){
+				e.preventDefault();
+				e.stopPropagation();
+				var href = $(this).attr("href");
+				hash.set(href);
+			});
+
+			$('.panel').live('click',function(e){
+				if ( $(this).hasClass("active") ) {
+					e.stopPropagation();
+
+					var id = $(this).attr("id");
+
+					if ( id ) {
+						hash.set(id);
+					}
+
+				} else {
+					return false;
+				}
+			});
+		},
+
+		show : function($panel){
+			var fxs = 200;
+			var animation = {};
+			var css = {};
+
+			if ( $panel.parents('.panel').length ) {
+				animation.opacity = 1;
+
+				if ( $panel.parents('.panel').length == 1 ){
+					animation.left = "80px";
+				}
+				else {
+					animation.left = "20px";
+				}
+
+				if( $panel.is(':hidden') ){
+					css.display = "block";
+					css.opacity = 0;
+				}
+			}
+
+			$panel.parents('.panel').each(function(){
+				var css = {
+					display : 'block',
+					opacity : 1
+				};
+				if ( $(this).parents('.panel').length == 1 ){
+					css.left = "80px";
+				}
+				else {
+					css.left = "0px";
+				}
+				$(this).css(css).addClass("inactive");
+			});
+
+			$panel.css(css).animate(animation, fxs, function(){
+				$panel.removeClass("inactive").addClass("active");
+			});
+
+			$panel.siblings('.panel').each(function(){
+				$(this).removeClass("active").addClass("inactive").fadeOut(fxs, function(){
+					$(this).css("left","-100%");
+				});
+			});
+
+			$panel.children('.panel').each(function(){
+				$(this).removeClass("active").addClass("inactive").fadeOut(fxs, function(){
+					$(this).css("left","-100%");
+				});
+			});
+		}
+
+	};
+
+//
+
+	self.layers = {
+
+		init : function(){
+			this.build();
+			this.observe();
+		},
+		
+		build : function(){
+			
+			self.loader.start();
+			
+			var layers = self.map.layers;
+			self.map.layers = {};
+
+			for ( var index in layers ) {
+				var layer = layers[index];
+				self.map.layers[layer.id] = new Layer(layer);
+			}
+
+			self.layers.refresh();
+		},
+
+
+		observe : function(){
+
+			$(".layer-toggle").live('click', function(e){
+				e.preventDefault();
+				var id = $(this).attr("rel");
+				var layer = self.map.layers[id];
+				self.layers.toggle(layer, $(this));
+			});
+
+			$('.delete-layer').live('click', function(e){
+				e.preventDefault();
+				e.stopPropagation();
+				var href 	= $(this).attr("href");
+				var id 		= $(this).attr("data-layer-id");
+				var layer = self.map.layers[id];
+				if (confirm("Are you sure?")) {
+					self.layers.remove(layer, href);
+				}
+			});
+
+			$('#new-layer form').submit(function(e){
+				e.preventDefault();
+				self.loader.start();
+				var $map_id = $(this).children("input[name='map_id']");
+				var $name = $(this).children("input[name='name']");
+
+				var data = {
+					map_id : $map_id.val(),
+					name	 : $name.val()
+				} 
+
+				$.post("/api/layers/create", data,
+					function(layer) {
+						self.map.layers[layer.id] = new Layer(layer);						
+						$('#new-layer').slideUp(fxspeed);
+						$name.val('');
+						self.layers.refresh();
+					}, 'json'
+				);
+
+			});
+
+		},
+
+		
+		refresh : function(){
+			self.loader.start();
+			
+			$("#layers > ul.nav").fadeOut(fxspeed, function(){
+				$(this).remove();
+			});
+			
+			$("#layers > .panel").fadeOut(fxspeed, function(){
+				$(this).remove();
+			});			
+			
+			$.post("/api/layers/index", {},
+				function(response) {
+					$("#layers").append(response);
+					self.panels.build();
+					self.loader.stop();
+				}
+			);			
+		},
+
+
+		toggle : function(layer, $element){
+
+			if ( layer.hidden ) {
+				layer.show();
+				$element.addClass('active');
+			}
+			else {
+				layer.hide();
+				$element.removeClass('active');
+			}
+
+		},
+
+		remove : function(layer, href){
+			self.loader.start();
+			layer.hide();
+			var url = "/api/layers/delete/" + layer.id;
+			$.post(url, {}, function(response){
+				self.loader.stop();
+				hash.set(href);
+				var $anchor = $("#layers > ul.nav > li > a[rel='" + layer.id + "']");
+				var $li = $anchor.parent('li');
+				$li.delay(fxspeed).fadeOut(fxspeed);
+			});
+		}
+
+	};
+
+//
+
+	self.overlays = {
+
+		init : function(){
+			this.build();
+			this.observe();
+		},
+		
+		build : function(){
+			for ( var index in self.map.layers ) {
+				var layer = self.map.layers[index];
+				
+				console.log(layer);
+				
+
+				var overlays = layer.overlays;
+
+				layer.overlays = {};
+				
+				for ( var index in overlays ) {
+					var overlay = overlays[index];
+					switch ( overlay.type ) {
+						case 'polygon' :
+							layer.overlays[overlay.id] = new Polygon(overlay);						
+							break;							
+						case 'marker' : 
+							layer.overlays[overlay.id] = new Marker(overlay);						
+							break;							
+						case 'line' : 
+							layer.overlays[overlay.id] = new Line(overlay);						
+							break;						
+					}
+				}
+			}
+
+					
+		},
+
+		observe : function(){
+
+			$(".draw-overlay").click(function(e){
+				e.preventDefault();
+
+				var layer_id = $(this).siblings("input[name='layer_id']").val();
+
+				overlay = map.layers[layer_id].addOverlay({
+					layer_id : layer_id,
+					points: [{ lat: 0, lng: 0 },{ lat: 0, lng: 0 }],
+			    strokeColor: "#FF00FF",
+			    strokeOpacity: 0,
+			    strokeWeight: 0,
+			    fillColor: "#F0F",
+			    fillOpacity: 0.5
+				});
+
+				overlay.draw();
+			});
+
+			$(".clear-overlay").click(function(e){
+				e.preventDefault();
+				overlay.remove();
+			});
+
+			$(".save-overlay").click(function(e){
+				e.preventDefault();
+				var name = $(this).siblings("input[name='name']").val();
+				if ( name == "" ){
+					alert("Please provide a name for this overlay");
+					return false;
+				}
+				else {
+					overlay.name = name;
+					self.overlays.save(overlay);
+				}
+			});
+
+		},
+
+		save : function(overlay){
+			self.loader.start();
+
+			var data = {
+				name : overlay.name,
+				layer_id : overlay.data.layer_id
+			};
+
+			$.post("/api/overlays/create", data,
+				function(data) {
+					overlay.id = data.id;
+
+					var points = overlay.data.points;
+
+					for ( var index in points ) {
+						points[index].overlay_id = overlay.id;
+					}
+
+					$.post("/api/points/create", { points: points },
+						function(response) {
+							self.loader.stop();
+						}
+					);
+				}
+			);
+		},
+
+		remove : function(overlay){
+
+		}
+
+	};
+
+
+
+
+//
+
+	self.loader = {
+
+		start : function(){
+			$loading.fadeIn(fxspeed);
+		},
+
+		stop : function(){
+			$loading.delay(500).fadeOut(fxspeed);
+		}
+
+	};
+
+//
+
+
+
+
+// self.map.canvas.setOptions({ draggableCursor: 'crosshair' });
+// 
+// self.data.paths = [];		
+// self.data.points = [];
+// 
+// google.maps.event.addListener(self.map.canvas, 'click', function(mdEvent) {
+// 
+// 	google.maps.event.addListener(self.map.canvas, 'mousemove', function(event) {
+// 		self.addPoint({ lat: event.latLng.lat(), lng: event.latLng.lng() });
+//   });
+// 
+// 	google.maps.event.addListener(self.map.canvas, 'click', function(event) {
+// 		google.maps.event.clearListeners(self.map.canvas);
+// 		google.maps.event.clearListeners(self.polygon);				
+//   });
+// 
+// 	google.maps.event.addListener(self.polygon, 'mousemove', function(event) {
+// 		self.addPoint({ lat: event.latLng.lat(), lng: event.latLng.lng() });
+//   });
+// 
+// 	google.maps.event.addListener(self.polygon, 'click', function(event) {
+// 		google.maps.event.clearListeners(map.canvas);
+// 		google.maps.event.clearListeners(self.polygon);				
+//   });
+// 
+// });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	return self.initialize();
+};