rigup 0.1.0 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95b30c63738163b65a0865b0f1a9d254c609640c
-  data.tar.gz: d31adf3237a4c76ff0cf5fb623cd4c608edcb1a1
+  metadata.gz: 53fa8f63e51425add51231d1d1d544c56d151beb
+  data.tar.gz: f5d4c4574b1564804186da641f96b660c1388207
 SHA512:
-  metadata.gz: 88c817645adfdf47a9f0ff3f4749763ce279904c936120777c701ea6524034e3d8b0efb0fe411548dbc65da874cd44b18ee92e250c9d303b4fcc8379706086bb
-  data.tar.gz: a66440a2d61f0753977d20894b4ba20bf01753c206762c3dfc1e3abc894d5e5c7e10879f2da6213eb6f9fb592ce6c6607b7e982b7f5154b045a66440a5c2b141
+  metadata.gz: 3e9f97961dfdf05271284723c8d7d6cdf2cac4d11c9790fe6c86fd4968bacca54cbedba9e94b812c501f567acc93be9c395fcb8fef726c057d819beabb6c3163
+  data.tar.gz: 6397a477957a80e3833fddce8b43fc29b6c482758a85710dc72689a23d09a5243c33aad3bd46af8971b5210daa0fb5343535ad16f5a9830d45d7e42191b8b7ad

data/bin/rigup

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
-#require "rubygems" - checkout rake for an interesting example of the bin command
+
+# from rake
+begin
+  require 'rubygems'
+  gem 'rigup'
+rescue LoadError
+end
 require 'rigup'
 Rigup::Cli.start(ARGV)

data/lib/rigup/base.rb

@@ -1,48 +1,41 @@
 module Rigup
 	module Base
 
-		def self.included(aClass)
-	    aClass.class_eval do
-		    no_commands do
+    def logger
+	    @logger ||= ::Logger.new(STDOUT)
+    end
+
+    def config
+	    unless @config
+		    @config = {}
+				if ::File.exists?(f=::File.join(release_path,'rigup.yml'))
+					file_config = ::YAML.load(String.from_file(f))
+					@config.merge!(file_config)
+					@config = ::Rigup::Config.new(@config)
+				end
+		  end
+	    @config
+    end
+
+    def context
+	    @context ||= ::Rigup::Context.new({
+				:config => config,
+				:logger => logger,
+				:pwd => ::Dir.pwd
+	    })
+    end
+
+    def release_path
+	    @release_path ||= ::File.expand_path('.')
+    end
+
+    def site_dir
+	    @site_dir ||= ::File.expand_path('../..',release_path)
+    end
+
+    def shared_path
+      @shared_path ||= ::File.expand_path('shared',site_dir)
+    end
 
-			    def logger
-				    @logger ||= ::Logger.new(STDOUT)
-			    end
-
-			    def config
-				    unless @config
-					    @config = {}
-							if File.exists?(f=File.join(release_path,'rigup.yml'))
-								file_config = YAML.load(String.from_file(f))
-								@config.merge!(file_config)
-								@config = Rigup::Config.new(@config)
-							end
-					  end
-				    @config
-			    end
-
-			    def context
-				    @context ||= Rigup::Context.new(
-							config: config,
-							logger: logger,
-							pwd: Dir.pwd,
-						)
-			    end
-
-			    def release_path
-				    @release_path ||= File.expand_path('.')
-			    end
-
-			    def site_dir
-				    @site_dir ||= File.expand_path('../..',release_path)
-			    end
-
-			    def shared_path
-			      @shared_path ||= File.expand_path('shared',site_dir)
-			    end
-			  end
-	    end
-
-		end
 	end
 end

data/lib/rigup/cli.rb

@@ -1,139 +1,145 @@
 module Rigup
-	class Cli < Thor
-
-		include Rigup::Utils::Run
-		include Rigup::Utils::Install
-
-		no_commands do
+	module CliMethods
 
-			def logger
-		    @logger ||= ::Logger.new(STDOUT)
-      end
+		def logger
+		  @logger ||= ::Logger.new(STDOUT)
+		end
+		#remove_command :logger
 
-			def config
-				@context.config
+		def config
+			@context.config
+		end
+		#remove_command :config
+
+		def init(aPath=nil,aConfig={})
+			return if @initialised
+			@initialised = true
+			aPath ||= aConfig[:site_dir] || ::Dir.pwd
+			@site_dir = ::Rigup::Utils::File.real_path(aPath) rescue ::File.expand_path(aPath)
+			@releases_path = ::File.join(@site_dir,'releases')
+			if ::File.exists?(f=::File.join(@site_dir,'rigup.yml'))
+				file_config = ::YAML.load(String.from_file(f))
+				aConfig.merge!(file_config)
 			end
+			aConfig = aConfig.merge(:site_dir => @site_dir)
+			aConfig[:user] ||= ENV['USER']
+			config = ::Rigup::Config.new(aConfig)
+			@context = ::Rigup::Context.new({
+				:config => config,
+				:logger => ::Logger.new(STDOUT),
+				:pwd => ::Dir.pwd
+			})
+		end
 
-			def init(aPath=nil,aConfig={})
-				return if @initialised
-				@initialised = true
-				aPath ||= aConfig[:site_dir] || Dir.pwd
-				@site_dir = Buzztools::File.real_path(aPath) rescue File.expand_path(aPath)
-				@releases_path = File.join(@site_dir,'releases')
-				if File.exists?(f=File.join(@site_dir,'rigup.yml'))
-					file_config = YAML.load(String.from_file(f))
-					aConfig.merge!(file_config)
-				end
-				aConfig = aConfig.merge(site_dir: @site_dir)
-				aConfig[:user] ||= ENV['USER']
-				config = Rigup::Config.new(aConfig)
-				@context = Rigup::Context.new(
-					config: config,
-					logger: ::Logger.new(STDOUT),
-					pwd: Dir.pwd
-				)
-			end
+		attr_reader :context, :release_path, :site_dir
 
-			attr_reader :context, :release_path, :site_dir
+		def shared_path
+		   @shared_path ||= ::File.expand_path('shared',site_dir)
+		end
+		#remove_command :shared_path
 
-			def shared_path
-        @shared_path ||= File.expand_path('shared',site_dir)
-      end
+		def cache_dir
+			::File.join(site_dir,'shared','cached-copy')
+		end
 
-			def cache_dir
-				File.join(site_dir,'shared','cached-copy')
-			end
+		def repo
+			@repo ||= ::Rigup::GitRepo.new(context)
+		end
 
-			def repo
-				@repo ||= GitRepo.new(context)
+		# Prepares repo in cache dir for site
+		# requires params: repo_url,site
+		def prepare_cache # {:url=>'git://github.com/ddssda', :branch=>'master', :commit=>'ad452bcd'}
+			url = config[:git_url]
+			wd = cache_dir
+
+			suitable = if ::File.exists?(wd)
+				repo.open wd
+				repo.origin.url==url
+			else
+				false
 			end
 
-			# Prepares repo in cache dir for site
-			# requires params: repo_url,site
-			def prepare_cache # {:url=>'git://github.com/ddssda', :branch=>'master', :commit=>'ad452bcd'}
-				url = config[:git_url]
-				wd = cache_dir
-
-				suitable = if File.exists?(wd)
-					repo.open wd
-					repo.origin.url==url
-				else
-					false
-				end
-
-				if suitable
-					repo.fetch
-				else
-					if File.exists? wd
-						#raise RuntimeError.new('almost did bad delete') if !@core.cache_dir || @core.cache_dir.length<3 || !wd.begins_with?(@core.cache_dir)
-						FileUtils.rm_rf wd
-					end
-					repo.clone(url, wd)
+			if suitable
+				repo.fetch
+			else
+				if ::File.exists? wd
+					#raise RuntimeError.new('almost did bad delete') if !@core.cache_dir || @core.cache_dir.length<3 || !wd.begins_with?(@core.cache_dir)
+					::FileUtils.rm_rf wd
 				end
+				repo.clone(url, wd)
 			end
+		end
 
-			# Switches @repo to given branch and/or commit
-			# Should call prepare_cache first to create @repo
-			# requires params: branch and/or commit
-			def checkout_branch_commit
-				branch = config[:branch] || 'master'
-				commit = config[:commit]
-				repo.open(cache_dir)
-				repo.checkout(commit,branch)
-				#perhaps use reset --hard here
-				if (commit)
-					repo.merge(commit,['--ff-only'])
-				else
-					repo.merge('origin/'+branch,['--ff-only'])
-				end
+		# Switches @repo to given branch and/or commit
+		# Should call prepare_cache first to create @repo
+		# requires params: branch and/or commit
+		def checkout_branch_commit
+			branch = config[:branch] || 'master'
+			commit = config[:commit]
+			repo.open(cache_dir)
+			repo.checkout(commit,branch)
+			#perhaps use reset --hard here
+			if (commit)
+				repo.merge(commit,['--ff-only'])
+			else
+				repo.merge('origin/'+branch,['--ff-only'])
 			end
+		end
 
-		  def update_cache(aPath=nil)
-				prepare_cache
-			  checkout_branch_commit
-		  end
+		def update_cache(aPath=nil)
+			prepare_cache
+		  checkout_branch_commit
+		end
 
-			def release
-				release = Time.now.strftime('%Y%m%d%H%M%S')
-				@release_path = File.expand_path(release,@releases_path)
-				repo.open(cache_dir)
-				repo.export(@release_path)
-				release_config = context.config.to_hash
-				release_config[:commit] = repo.head.sha
-				release_config[:branch] = repo.branch
-				release_config.to_yaml.to_file(File.join(@release_path,'rigup.yml'))
-				return @release_path
-			end
+		def release
+			release = ::Time.now.strftime('%Y%m%d%H%M%S')
+			@release_path = ::File.expand_path(release,@releases_path)
+			repo.open(cache_dir)
+			repo.export(@release_path)
+			release_config = context.config.to_hash
+			release_config[:commit] = repo.head.sha
+			release_config[:branch] = repo.branch
+			release_config.to_yaml.to_file(::File.join(@release_path,'rigup.yml'))
+			return @release_path
+		end
 
-			def link_live
-				ensure_link(release_path,File.expand_path(File.join(site_dir,'current')),"#{config[:user]}:#{config[:group]}")
-			end
+		def link_live
+			ensure_link(release_path,::File.expand_path(::File.join(site_dir,'current')),"#{config[:user]}:#{config[:group]}")
+		end
 
-			def cleanup
-				@releases = run("ls -x #{@releases_path}").split.sort
-		    count = (@keep_releases || 3).to_i
-		    if count >= @releases.length
-		      logger.info "no old releases to clean up"
-		    else
-			    logger.info "keeping #{count} of #{@releases.length} deployed releases"
+		def cleanup
+			@releases = run("ls -x #{@releases_path}").split.sort
+		  count = (@keep_releases || 3).to_i
+		  if count >= @releases.length
+		    logger.info "no old releases to clean up"
+		  else
+		    logger.info "keeping #{count} of #{@releases.length} deployed releases"
 
-		      directories = (@releases - @releases.last(count)).map { |r|
-		        File.join(@releases_path, r)
-					}.join(" ")
+		    directories = (@releases - @releases.last(count)).map { |r|
+		      File.join(@releases_path, r)
+				}.join(" ")
 
-		      run "rm -rf #{directories}"
-		    end
-			end
+		    run "rm -rf #{directories}"
+		  end
+		end
 
-			def call_release_command(aCommand)
-				return unless cmdline = config["#{aCommand}_command".to_sym].to_s.strip.to_nil
-				cd release_path do
-					run cmdline
-				end
+		def call_release_command(aCommand)
+			return unless cmdline = config["#{aCommand}_command".to_sym].to_s.strip.to_nil
+			cd release_path do
+				run cmdline
 			end
 		end
+	end
+end
+
+module Rigup
+	class Cli < Thor
+
+		include Rigup::Utils::Run
+		include Rigup::Utils::Install
+		include Rigup::CliMethods
 
-		public
+		#public
 
 		desc "new GIT_URL [PATH]", "setup new site"
 		def new(aGitUrl,aPath=nil)
@@ -141,23 +147,26 @@ module Rigup
 			aPath ||= app_name
 			init(
 				aPath,
-				git_url: aGitUrl,
-				app_name: app_name,
-				user: ENV['USER']
+				{
+				:git_url => aGitUrl,
+				:app_name => app_name,
+				:user => ENV['USER']
+				}
 			)
 			FileUtils.mkdir_p(site_dir)
 			FileUtils.mkdir_p(File.join(site_dir,'releases'))
 			FileUtils.mkdir_p(File.join(site_dir,'shared'))
 
 			#+ create rigup.yml if doesn't exist, including option values
-			context.config.to_hash.filter_exclude(:site_dir).to_yaml.to_file(File.join(site_dir,'rigup.yml'))
+			h = context.config.to_hash
+			h.delete :site_dir
+			h.to_yaml.to_file(File.join(site_dir,'rigup.yml'))
 		end
 
 		desc "deploy [PATH]", "deploy the given site"
 		def deploy(aPath=nil)
 			init(aPath)
 			update_cache
-			#gem 'debugger'; require 'debugger'; debugger
 			release
 			call_release_command(:install)     # call install_command if defined eg. defaults to "thor deploy:install" eg. make changes to files
 			call_release_command(:block)

data/lib/rigup/config.rb

@@ -1,21 +1,22 @@
 module Rigup
 
-	class Config < Buzztools::Config
+	class Config < Rigup::Utils::Config
 
 		DEFAULTS = {
-			app_name: String,
-			user: String,
-			group: 'www',
-			site_dir: String,
-			git_url: String,
-			branch: String,
-			commit: String,
-			stage: 'live',    # or 'staging' or 'development'
-			sudo: 'sudo',
-			block_command: nil,
-			install_command: 'thor deploy:install',
-			restart_command: 'thor deploy:restart',
-			unblock_command: nil,
+			:app_name => String,
+			:user => String,
+			:group => 'www',
+			:site_dir => String,
+			:git_url => String,
+			:branch => String,
+			:commit => String,
+			:stage => 'live',    # or 'staging' or 'development'
+			:sudo => 'sudo',    # deprecated
+			:sudo_available => true,
+			:block_command => nil,
+			:install_command => 'bundle exec thor deploy:install',
+			:restart_command => 'bundle exec thor deploy:restart',
+			:unblock_command => nil
 		}
 
 		def initialize(aValues=nil)

data/lib/rigup/context.rb

@@ -9,7 +9,7 @@ module Rigup
 
 			#is_client = !!(aValues[:key_chain] || aValues[:global_options] || aValues[:options])
 			@config = aValues[:config]
-			@pwd = Buzztools::File.real_path(aValues[:pwd] || (@config && @config[:folder]) || Dir.pwd)
+			@pwd = Rigup::Utils::File.real_path(aValues[:pwd] || (@config && @config[:folder]) || Dir.pwd)
 			@options = aValues[:options]
 			@argv = aValues[:argv]
 			@env = aValues[:env]
@@ -47,7 +47,7 @@ module Rigup
     end
 
 		def find_git_root
-			git_folder = BuzzTools::File.find_upwards(@pwd,'.git')
+			git_folder = Rigup::Utils::File.find_upwards(@pwd,'.git')
 			return git_folder && git_folder.chomp('/.git')
 		end
 

data/lib/rigup/utils/config.rb

@@ -0,0 +1,133 @@
+module Rigup
+	module Utils
+		class Config < Hash
+
+			attr_reader :default_values
+
+			def initialize(aDefaultValues, aNewValues=nil, &aBlock)
+				@default_values = aDefaultValues.clone
+				reset()
+				if aNewValues
+					block_given? ? read(aNewValues, &aBlock) : read(aNewValues)
+				end
+			end
+
+			# aBlock allows values to be filtered based on key,default and new values
+			def read(aSource, &aBlock)
+				default_values.each do |k, v|
+					done = false
+					if block_given? && ((newv = yield(k, v, aSource && aSource[k])) != nil)
+						self[k] = newv
+						done = true
+					end
+					copy_item(aSource, k) if !done && aSource && !aSource[k].nil?
+				end
+				self
+			end
+
+			# reset values back to defaults
+			def reset
+				self.clear
+				me = self
+				@default_values.each { |n, v| me[n] = v.is_a?(Class) ? nil : v }
+			end
+
+			def set_int(aKey, aValue)
+				case aValue
+					when String then
+						self[aKey] = aValue.to_integer(self[aKey]);
+					when Fixnum then
+						self[aKey] = aValue;
+					when Float then
+						self[aKey] = aValue.to_i;
+				end
+			end
+
+			def set_float(aKey, aValue)
+				case aValue
+					when String then
+						self[aKey] = aValue.to_float(self[aKey]);
+					when Fixnum then
+						self[aKey] = aValue.to_f;
+					when Float then
+						self[aKey] = aValue;
+				end
+			end
+
+			def set_boolean(aKey, aValue)
+				case aValue
+					when TrueClass, FalseClass then
+						self[aKey] = aValue;
+					when String then
+						self[aKey] = (['1', 'yes', 'y', 'true', 'on'].include?(aValue.downcase))
+					else
+						set_boolean(aKey, aValue.to_s)
+				end
+			end
+
+			def set_symbol(aKey, aValue)
+				case aValue
+					when String then
+						self[aKey] = (aValue.to_sym rescue nil);
+					when Symbol then
+						self[aKey] = aValue;
+				end
+			end
+
+			def copy_item(aHash, aKey)
+				d = default_values[aKey]
+				d_class = (d.is_a?(Class) ? d : d.class)
+				cname = d_class.name.to_sym
+				case cname
+					when :NilClass then
+						self[aKey] = aHash[aKey];
+					when :String then
+						self[aKey] = aHash[aKey].to_s unless aHash[aKey].nil?
+					when :Float then
+						set_float(aKey, aHash[aKey]);
+					when :Fixnum then
+						set_int(aKey, aHash[aKey]);
+					when :TrueClass, :FalseClass then
+						set_boolean(aKey, aHash[aKey]);
+					when :Symbol then
+						self[aKey] = (aHash[aKey].to_sym rescue nil)
+					when :Proc then
+						self[aKey] = aHash[aKey] if aHash[aKey].is_a?(Proc)
+					else
+						raise StandardError.new('unsupported type')
+				end
+			end
+
+			def copy_strings(aHash, *aKeys)
+				aKeys.each do |k|
+					self[k] = aHash[k].to_s unless aHash[k].nil?
+				end
+			end
+
+			def copy_ints(*aDb)
+				aHash = aDb.shift
+				aKeys = aDb
+				aKeys.each do |k|
+					set_int(k, aHash[k])
+				end
+			end
+
+			def copy_floats(aHash, *aKeys)
+				aKeys.each do |k|
+					set_float(k, aHash[k])
+				end
+			end
+
+			def copy_booleans(aHash, *aKeys)
+				aKeys.each do |k|
+					set_boolean(k, aHash[k])
+				end
+			end
+
+			def to_hash
+				{}.merge(self)
+			end
+
+		end
+	end
+end

data/lib/rigup/utils/extend_stdlib.rb

@@ -0,0 +1,293 @@
+unless defined? Buzztools
+
+	Array.class_eval do
+		def to_nil
+			self.empty? ? nil : self
+		end
+	end
+
+	Bignum.class_eval do
+		def to_nil
+			self==0 ? nil : self
+		end
+	end
+
+	Float.class_eval do
+		def to_nil
+			(self==0 || !self.finite?) ? nil : self
+		end
+	end
+
+	Fixnum.class_eval do
+		def to_nil
+			self==0 ? nil : self
+		end
+	end
+
+	Hash.class_eval do
+		def to_nil
+			self.empty? ? nil : self
+		end
+	end
+
+	TrueClass.class_eval do
+		def to_nil
+			self
+		end
+	end
+
+	FalseClass.class_eval do
+		def to_nil
+			nil
+		end
+	end
+
+	NilClass.class_eval do
+		def to_nil
+			nil
+		end
+	end
+
+	Symbol.class_eval do
+		def to_nil
+			self
+		end
+	end
+
+	String.class_eval do
+		def to_nil(aPattern=nil)
+			return nil if self.empty?
+			if aPattern
+				return nil if (aPattern.is_a? Regexp) && (self =~ aPattern)
+				return nil if aPattern.to_s == self
+			end
+			self
+		end
+	end
+
+	String.class_eval do
+
+		def self.random_word(min=4,max=8)
+			len = min + rand(max-min+1)
+			result = ' '*len
+			(len-1).downto(0) {|i| result[i] = (?a.ord + rand(?z.ord-?a.ord+1)).chr}
+			return result
+		end
+
+		def pad_left(value)
+			increase = value-self.length
+			return self if increase==0
+			if increase > 0
+				return self + ' '*increase
+			else
+				return self[0,value]
+			end
+		end
+
+		def pad_right(value)
+			increase = value-self.length
+			return self if increase==0
+			if increase > 0
+				return ' '*increase + self
+			else
+				return self[0,value]
+			end
+		end
+
+		# Like bite, but returns the first match instead of the subject, and removes the match from the subject, modifying it
+		def extract!(aValue=$/,aString=self)
+			if aValue.is_a? String
+				if i = aString.index(aValue)
+					aString[i,aValue.length] = ''
+					return aValue
+				else
+					return nil
+				end
+			elsif aValue.is_a? Regexp
+				if md = aValue.match(aString)
+					aString[md.begin(0),md.end(0)-md.begin(0)] = ''
+					return md.to_s
+				else
+					return nil
+				end
+			else
+				return aString
+			end
+		end
+
+		def extract(aValue=$/)
+			extract!(aValue,self.clone)
+		end
+
+		# Like chomp! but operates on the leading characters instead.
+		# The aString parameter would not normally be used.
+		def bite!(aValue=$/,aString=self)
+			if aValue.is_a? String
+				if aString[0,aValue.length] == aValue
+					aString[0,aValue.length] = ''
+					return aString
+				else
+					return aString
+				end
+			elsif aValue.is_a? Regexp
+				return aString.sub!(aValue,'') if aString.index(aValue)==0
+			else
+				return aString
+			end
+		end
+
+		def bite(aValue=$/)
+			bite!(aValue,self.clone)
+		end
+
+		def deprefix!(aPrefix=$/,aString=self)
+			if aString[0,aPrefix.length] == aPrefix
+				aString[0,aPrefix.length] = ''
+				return aString
+			else
+				return aString
+			end
+		end
+
+		def deprefix(aValue=$/)
+			deprefix!(aValue,self.clone)
+		end
+
+		def desuffix!(aString,aSuffix)
+			if aString[-aSuffix.length,aSuffix.length] == aSuffix
+				aString[-aSuffix.length,aSuffix.length] = ''
+				return aString
+			else
+				return aString
+			end
+		end
+
+		def desuffix(aValue=$/)
+			desuffix!(aValue,self.clone)
+		end
+
+		def begins_with?(aString)
+			self[0,aString.length]==aString
+		end
+
+		def ends_with?(aString)
+			self[-aString.length,aString.length]==aString
+		end
+
+		def ensure_prefix!(aPrefix=$/,aString=self)
+			aString[0,0]=aPrefix unless aString.begins_with?(aPrefix)
+			aString
+		end
+
+		def ensure_prefix(aValue=$/)
+			ensure_prefix!(aValue,self.clone)
+		end
+
+		def ensure_suffix!(aSuffix=$/,aString=self)
+			aString.insert(-1,aSuffix) unless aString.ends_with?(aSuffix)
+			aString
+		end
+
+		def ensure_suffix(aValue=$/)
+			ensure_suffix!(aValue,self.clone)
+		end
+
+		def to_integer(aDefault=nil)
+			t = self.strip
+			return aDefault if t.empty? || !t.index(/^-{0,1}[0-9]+$/)
+			return t.to_i
+		end
+
+		def is_i?
+			self.to_integer(false) and true
+		end
+
+		def to_float(aDefault=nil)
+			t = self.strip
+			return aDefault if !t =~ /(\+|-)?([0-9]+\.?[0-9]*|\.[0-9]+)([eE](\+|-)?[0-9]+)?/
+			return t.to_f
+		end
+
+		def is_f?
+			self.to_float(false) and true
+		end
+
+		# like scan but returns array of MatchData's.
+		# doesn't yet support blocks
+		def scan_md(aPattern)
+			result = []
+			self.scan(aPattern) {|s| result << $~ }
+			result
+		end
+
+		def to_b(aDefault=false)
+			return true if ['1','yes','y','true','on'].include?(self.downcase)
+			return false if ['0','no','n','false','off'].include?(self.downcase)
+			aDefault
+		end
+
+		# "...Only alphanumerics [0-9a-zA-Z], the special characters "$-_.+!*'()," [not including the quotes - ed], and reserved characters used for their reserved purposes may be used unencoded within a URL."
+
+		URLIZE_SEPARATORS = /[ \\\(\)\[\]\.*,]/	# was /[ \\\(\)\[\]\.*,]/
+		URLIZE_EXTENSIONS = %w(html htm jpg jpeg png gif bmp mov avi mp3 zip pdf css js doc xdoc)
+		URLIZE_REMOVE = /[^a-z0-9\_\-+~\/]/ # was 'a-z0-9_-+~/'
+		# aKeepExtensions may be an array of extensions to keep, or :none (will remove periods) or :all (any extension <= 4 chars)
+		def urlize(aSlashChar='+',aRemove=nil,aKeepExtensions=nil)
+			aKeepExtensions=URLIZE_EXTENSIONS if !aKeepExtensions
+			aRemove=URLIZE_REMOVE if !aRemove
+			return self if self.empty?
+			result = self.downcase
+			ext = nil
+			if (aKeepExtensions!=:none) && last_dot = result.rindex('.')
+				if (ext_len = result.length-last_dot-1) <= 4	# preserve extension without dot if <= 4 chars long
+					ext = result[last_dot+1..-1]
+					ext = nil unless aKeepExtensions==:all || (aKeepExtensions.is_a?(Array) && aKeepExtensions.include?(ext))
+					result = result[0,last_dot] if ext
+				end
+			end
+
+			result = result.gsub(URLIZE_SEPARATORS,'-')
+			result = result.gsub(aRemove,'').sub(/-+$/,'').sub(/^-+/,'')
+			result.gsub!('/',aSlashChar) unless aSlashChar=='/'
+			result.gsub!(/-{2,}/,'-')
+			result += '.'+ext if ext
+			result
+		end
+
+		def has_tags?
+			index(/<[a-zA-Z\-:0-9]+(\b|>)/) && (index('/>') || index('</'))		# contains an opening and closing tag
+		end
+
+		def snake_case
+			underscore.tr(' ','_')
+		end
+
+		def relative_url?
+			!begins_with?('http') || !begins_with?('/')
+		end
+
+		def to_file(aFilename)
+			File.open(aFilename,'wb') {|file| file.write self }
+		end
+
+		def self.from_file(aFilename)
+			File.open(aFilename, "rb") { |f| f.read }
+		end
+
+		# given ('abcdefg','c.*?e') returns ['ab','cde','fg'] so you can manipulate the head, match and tail seperately, and potentially rejoin
+		def split3(aPattern,aOccurence=0)
+			aString = self
+			matches = aString.scan_md(aPattern)
+			match = matches[aOccurence]
+			parts = (match ? [match.pre_match,match.to_s,match.post_match] : [aString,nil,''])
+
+			if !block_given?	# return head,match,tail
+				parts
+			else						# return string
+				parts[1] = yield *parts if match
+				parts.join
+			end
+		end
+	end
+
+end

data/lib/rigup/utils/file.rb

@@ -0,0 +1,127 @@
+require 'pathname'
+
+module Rigup
+	module Utils
+		module File
+
+			module_function
+
+			def sniff_seperator(aPath)
+				result = 0.upto(aPath.length-1) do |i|
+					char = aPath[i, 1]
+					break char if char=='\\' || char=='/'
+				end
+				result = ::File::SEPARATOR if result==0
+				return result
+			end
+
+			def append_slash(aPath, aSep=nil)
+				aSep = sniff_seperator(aPath) unless aSep
+				aPath.ensure_suffix(aSep)
+			end
+
+			def remove_slash(aPath)
+				last_char = aPath[-1, 1]
+				aPath = aPath[0..-2] if last_char=='\\' || last_char=='/'
+				return aPath
+			end
+
+			#def ensure_prefix(aString,aPrefix)
+			#	aString.begins_with?(aPrefix) ? aString : aPrefix+aString
+			#end
+			#
+			#def ensure_suffix(aString,aSuffix)
+			#	aString.ends_with?(aSuffix) ? aString : aString+aSuffix
+			#end
+
+			# Remove base dir from given path. Result will be relative to base dir and not have a leading or trailing slash
+			#'/a/b/c','/a' = 'b/c'
+			#'/a/b/c','/' = 'a/b/c'
+			#'/','/' = ''
+			def path_debase(aPath, aBase)
+				aBase = append_slash(aBase)
+				aPath = remove_slash(aPath) unless aPath=='/'
+				aPath[0, aBase.length]==aBase ? aPath[aBase.length, aPath.length-aBase.length] : aPath
+			end
+
+			def path_rebase(aPath, aOldBase, aNewBase)
+				rel_path = path_debase(aPath, aOldBase)
+				append_slash(aNewBase)+rel_path
+			end
+
+			def path_combine(aBasePath, aPath)
+				return aBasePath if !aPath
+				return aPath if !aBasePath
+				return path_relative?(aPath) ? ::File.join(aBasePath, aPath) : aPath
+			end
+
+			# make path real according to file system
+			def real_path(aPath)
+				(path = Pathname.new(::File.expand_path(aPath))) && path.realpath.to_s
+			end
+
+			# takes a path and combines it with a root path (which defaults to Dir.pwd) unless it is absolute
+			# the final result is then expanded
+			def canonize_path(aPath, aRootPath=nil)
+				path = path_combine(aRootPath, aPath)
+				path = real_path(path) if path
+				path
+			end
+
+			def find_upwards(aStartPath, aPath)
+				curr_path = ::File.expand_path(aStartPath)
+				while curr_path && !(test_path_exists = ::File.exists?(test_path = ::File.join(curr_path, aPath))) do
+					curr_path = path_parent(curr_path)
+				end
+				curr_path && test_path_exists ? test_path : nil
+			end
+
+			# allows special symbols in path
+			# currently only ... supported, which looks upward in the filesystem for the following relative path from the basepath
+			def expand_magic_path(aPath, aBasePath=nil)
+				aBasePath ||= Dir.pwd
+				path = aPath
+				if path.begins_with?('...')
+					rel_part = path.split3(/\.\.\.[\/\\]/)[2]
+					path = find_upwards(aBasePath, rel_part)
+				end
+			end
+
+			def path_parent(aPath)
+				return nil if is_root_path?(aPath)
+				append_slash(::File.dirname(remove_slash(expand_path(aPath))))
+			end
+
+			def simple_dir_name(aPath)
+				::File.basename(remove_slash(aPath))
+			end
+
+			def simple_file_name(aPath)
+				f = ::File.basename(aPath)
+				dot = f.index('.')
+				return dot ? f[0, dot] : f
+			end
+
+			def path_parts(aPath)
+				sep = sniff_seperator(aPath)
+				aPath.split(sep)
+			end
+
+			def extension(aFile, aExtended=true)
+				f = ::File.basename(aFile)
+				dot = aExtended ? f.index('.') : f.rindex('.')
+				return dot ? f[dot+1..-1] : f
+			end
+
+			def no_extension(aFile, aExtended=true)
+				ext = extension(aFile, aExtended)
+				return aFile.chomp('.'+ext)
+			end
+
+			def change_ext(aFile, aExt, aExtend=false)
+				no_extension(aFile, false)+(aExtend ? '.'+aExt+'.'+extension(aFile, false) : '.'+aExt)
+			end
+
+		end
+	end
+end

data/lib/rigup/utils/install.rb

@@ -3,11 +3,11 @@ module Rigup
 		module Install
 
 			def select_suffixed_file(aFile,aExtendedExtension=false)
-				ext = Buzztools::File.extension(aFile,aExtendedExtension)
-				no_ext = Buzztools::File.no_extension(aFile,aExtendedExtension)
-				dir = File.dirname(aFile)
-				run "#{context.config[:sudo]} mv -f #{no_ext}.#{context.config[:stage]}.#{ext} #{aFile}"
-				run "#{context.config[:sudo]} rm -f #{no_ext}.*.#{ext}"
+				ext = Rigup::Utils::File.extension(aFile,aExtendedExtension)
+				no_ext = Rigup::Utils::File.no_extension(aFile,aExtendedExtension)
+				dir = ::File.dirname(aFile)
+				run "mv -f #{no_ext}.#{context.config[:stage]}.#{ext} #{aFile}"
+				run "rm -f #{no_ext}.*.#{ext}"
 			end
 
 			# Especially for modifiying behaviour eg. of FCKEditor without upsetting the standard files
@@ -18,8 +18,8 @@ module Rigup
 			def override_folder(aFolder,aOverrideFolder=nil,aRemove=true)
 				aFolder = aFolder.desuffix('/')
 				aOverrideFolder ||= (aFolder+'_override')
-				run "#{context.config[:sudo]} cp -vrf #{aOverrideFolder}/* #{aFolder}/"
-				run "#{context.config[:sudo]} rm -rf #{aOverrideFolder}" if aRemove
+				run "cp -vrf #{aOverrideFolder}/* #{aFolder}/"
+				run "rm -rf #{aOverrideFolder}" if aRemove
 			end
 
 
@@ -28,7 +28,7 @@ module Rigup
 				aUser ||= @user
 				aGroup ||= @group
 
-				run "#{context.config[:sudo]} chown -R #{aUser}:#{aGroup} #{aPath.ensure_suffix('/')}"
+				sudo? "chown -R #{aUser}:#{aGroup} #{aPath.ensure_suffix('/')}"
 				run_for_all("chmod 755",aPath,:dirs)									# !!! perhaps reduce other permissions
 				run_for_all("chmod 644",aPath,:files)
 				run_for_all("chmod g+s",aPath,:dirs)
@@ -39,7 +39,7 @@ module Rigup
 
 			# run this after permissions_for_web() on dirs that need to be writable by group (apache)
 			def permissions_for_web_writable(aPath)
-				run "chmod -R g+w #{aPath.ensure_suffix('/')}"
+				sudo? "chmod -R g+w #{aPath.ensure_suffix('/')}"
 				run_for_all("chmod -R 700",aPath,:dirs,"*/.svn")
 			end
 
@@ -60,7 +60,7 @@ module Rigup
 						#permissions_for_web_writable("#{aPath}/tmp")
 						make_public_cache_dir("#{aPath}/tmp")
 
-						run "#{context.config[:sudo]} chown #{@user} #{aPath}/config/environment.rb" #unless DEV_MODE	# very important for passenger, which uses the owner of this file to run as
+						sudo "chown #{@user} #{aPath}/config/environment.rb" #unless DEV_MODE	# very important for passenger, which uses the owner of this file to run as
 
 					when 'spree' then
 						internal_permissions(aPath,'rails')
@@ -75,17 +75,16 @@ module Rigup
 				internal_permissions(aPath, aKind)
 			end
 
-			def ensure_link(aTo,aFrom,aUserGroup=nil,aSudo='')
-				raise "Must supply from" if !aFrom
+			def ensure_link(aTo,aFrom,aUserGroup=nil)
 				cmd = []
-				cmd << "#{aSudo} rm -rf #{aFrom}"
-				cmd << "#{aSudo} ln -sf #{aTo} #{aFrom}"
-				cmd << "#{aSudo} chown -h #{aUserGroup} #{aFrom}" if aUserGroup
-				run(cmd.join(' && '),raise: false)
+				cmd << "#{sudo_s}rm -rf #{aFrom}"
+				cmd << "#{sudo_s}ln -sf #{aTo} #{aFrom}"
+				cmd << "#{sudo_s}chown -h #{aUserGroup} #{aFrom}" if aUserGroup
+				run(cmd.join(' && '),{:raise => false})
 			end
 
 			def make_public_cache_dir(aStartPath)
-				run "#{context.config[:sudo]} mkdir -p #{aStartPath}"
+				sudo? "mkdir -p #{aStartPath}"
 				permissions_for_web(aStartPath)
 				permissions_for_web_writable(aStartPath)
 			end

data/lib/rigup/utils/run.rb

@@ -7,7 +7,7 @@ module Rigup
 			end
 
 			def pwd
-				bash.execute("pwd", stdout: nil).first.strip
+				bash.execute("pwd", {:stdout => nil}).first.strip
 			end
 
 			def cd(aPath,&block)
@@ -22,28 +22,56 @@ module Rigup
 						cd(before_path)
 					end
 				else
-					aPath = File.expand_path(aPath)
+					aPath = ::File.expand_path(aPath)
 					Dir.chdir(aPath)
 					bash.execute("cd \"#{aPath}\"")
 				end
 				aPath
 			end
 
+			# execute the given command in the bash session
 			def run(aCommand,aOptions=nil)
 				aOptions ||= {}
 				logger.debug aCommand
-				response,errout = bash.execute(aCommand,stdout: STDOUT)  #   ::POpen4::shell(aCommand,aDir || @context.pwd)
+				response,errout = bash.execute(aCommand,:stdout => STDOUT)  #   ::POpen4::shell(aCommand,aDir || @context.pwd)
 				logger.debug errout if errout.to_nil
 				logger.debug response if response.to_nil
 				raise "Command Failed" unless bash.exit_status==0 or aOptions[:raise]==false
 				return response
 			end
 
-			def run_for_all(aCommand,aPath,aFilesOrDirs,aPattern=nil,aInvertPattern=false,aSudo=false)
+			# returns true if sudo is available for the current user, otherwise false. Default = true
+			def sudo_available?
+				return !!config[:sudo_available] if config.has_key?(:sudo_available)
+				return false if !config[:sudo].to_nil   # false if old config item blank
+				true
+			end
+
+			# execute the command using sudo. Raises an exception if sudo is not available
+			def sudo(aCommand,aOptions=nil)
+				raise "sudo not available" unless sudo_available?
+				run('sudo '+aCommand,aOptions)
+			end
+
+			# uses sudo if available, otherwise plain run
+			def sudo?(aCommand,aOptions=nil)
+				if sudo_available?
+					sudo(aCommand,aOptions)
+				else
+					run(aCommand,aOptions)
+				end
+			end
+
+			# for embedding into command line strings
+			def sudo_s
+				sudo_available? ? 'sudo ' : ''
+			end
+
+			def run_for_all(aCommand,aPath,aFilesOrDirs,aPattern=nil,aInvertPattern=false)
 				#run "#{sudo} find . -wholename '*/.svn' -prune -o -type d -print0 |xargs -0 #{sudo} chmod 750"
 				#sudo find . -type f -exec echo {} \;
 				cmd = []
-				cmd << "sudo" if aSudo
+				cmd << sudo_s
 				cmd << "find #{aPath.ensure_suffix('/')}"
 				cmd << "-wholename '#{aPattern}'" if aPattern
 				cmd << "-prune -o" if aInvertPattern

data/lib/rigup/version.rb

@@ -1,3 +1,3 @@
 module Rigup
-  VERSION = "0.1.0"
+  VERSION = "0.2.10"
 end

data/lib/rigup.rb

@@ -1,16 +1,19 @@
 require 'thor'
-require 'buzztools'
 require 'logger'
 require 'yaml'
 require 'session'
-#require 'buzztools/extras/shell_extras'
 
-require_relative "rigup/version"
-require_relative "rigup/config"
-require_relative "rigup/context"
-require_relative "rigup/utils/run"
-require_relative "rigup/utils/install"
-require_relative "rigup/git_repo"
-require_relative "rigup/cli"
-require_relative "rigup/base"
-require_relative "rigup/deploy_base"
+Dir.chdir(File.dirname(__FILE__)) do 
+	require "rigup/version"
+	require "rigup/utils/extend_stdlib"
+	require "rigup/utils/config"
+	require "rigup/utils/file"
+	require "rigup/utils/run"
+	require "rigup/utils/install"
+	require "rigup/config"
+	require "rigup/context"
+	require "rigup/git_repo"
+	require "rigup/cli"
+	require "rigup/base"
+	require "rigup/deploy_base"
+end

data/rigup.gemspec

@@ -20,29 +20,10 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'bundler'#, '~>1.5.3'
   s.add_dependency 'thor'#, '~> 0.19.1'
-
-
-  s.add_development_dependency 'rspec', '~>2.14.0'
-  #s.add_development_dependency('rspec')
-
-  s.add_development_dependency('rake')
-  #s.add_development_dependency('rspec-core')
-  #s.add_development_dependency('rdoc')
-	#s.add_development_dependency('aruba')
-	#s.add_development_dependency('debugger')
-  #s.add_runtime_dependency('gli','2.5.0')
-	#s.add_runtime_dependency('termios')
-	#s.add_runtime_dependency('highline')
 	s.add_runtime_dependency('git')
-	#s.add_runtime_dependency('middleman')
-	s.add_runtime_dependency 'buzztools', '~>0.0.6'
-	#s.add_runtime_dependency('POpen4')
 	s.add_runtime_dependency('session')
 	# https://github.com/geemus/formatador
-	#s.add_runtime_dependency('bitbucket_rest_api')
-	#s.add_runtime_dependency('osx_keychain')
-	#s.add_runtime_dependency('json')
-	#s.add_runtime_dependency('net_dav')
-	#s.add_runtime_dependency('net-ssh')
-	#s.add_runtime_dependency('system_timer')
+
+  s.add_development_dependency 'rspec', '~>2.14.0'
+  s.add_development_dependency('rake')
 end

data/rigup.iml

@@ -14,9 +14,8 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" scope="PROVIDED" name="bundler (v1.5.3, RVM: ruby-2.0.0-p247) [gem]" level="application" />
-    <orderEntry type="library" scope="PROVIDED" name="buzztools (v0.0.6, RVM: ruby-2.0.0-p247) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="diff-lcs (v1.2.5, RVM: ruby-2.0.0-p247) [gem]" level="application" />
-    <orderEntry type="library" scope="PROVIDED" name="git (v1.2.6, RVM: ruby-2.0.0-p247) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="git (v1.2.8, RVM: ruby-2.0.0-p247) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rake (v10.2.0, RVM: ruby-2.0.0-p247) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rspec (v2.14.1, RVM: ruby-2.0.0-p247) [gem]" level="application" />
     <orderEntry type="library" scope="PROVIDED" name="rspec-core (v2.14.8, RVM: ruby-2.0.0-p247) [gem]" level="application" />

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rigup
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.10
 platform: ruby
 authors:
 - Gary McGhee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,27 +39,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.14.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.14.0
-- !ruby/object:Gem::Dependency
-  name: rake
+  name: git
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -67,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: git
+  name: session
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -81,27 +67,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: buzztools
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.6
-  type: :runtime
+        version: 2.14.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: 2.14.0
 - !ruby/object:Gem::Dependency
-  name: session
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -126,6 +112,9 @@ files:
 - lib/rigup/deploy_base.rb
 - lib/rigup/git_repo.rb
 - lib/rigup/svn.rb
+- lib/rigup/utils/config.rb
+- lib/rigup/utils/extend_stdlib.rb
+- lib/rigup/utils/file.rb
 - lib/rigup/utils/install.rb
 - lib/rigup/utils/run.rb
 - lib/rigup/version.rb