buzzware-buzzcore 0.2.2 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/buzzcore.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{buzzcore}
-  s.version = "0.2.2"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["buzzware"]
@@ -28,12 +28,10 @@ Gem::Specification.new do |s|
      "buzzcore.vpw",
      "lib/buzzcore.rb",
      "lib/buzzcore.rb",
-     "lib/buzzcore/cap_utils.rb",
      "lib/buzzcore/config.rb",
      "lib/buzzcore/database_utils.rb",
      "lib/buzzcore/enum.rb",
      "lib/buzzcore/extend_base_classes.rb",
-     "lib/buzzcore/ftp_extra.rb",
      "lib/buzzcore/logging.rb",
      "lib/buzzcore/misc_utils.rb",
      "lib/buzzcore/require_paths.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: buzzware-buzzcore
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - buzzware
@@ -42,12 +42,10 @@ files:
 - buzzcore.vpj
 - buzzcore.vpw
 - lib/buzzcore.rb
-- lib/buzzcore/cap_utils.rb
 - lib/buzzcore/config.rb
 - lib/buzzcore/database_utils.rb
 - lib/buzzcore/enum.rb
 - lib/buzzcore/extend_base_classes.rb
-- lib/buzzcore/ftp_extra.rb
 - lib/buzzcore/logging.rb
 - lib/buzzcore/misc_utils.rb
 - lib/buzzcore/require_paths.rb

data/lib/buzzcore/cap_utils.rb

@@ -1,181 +0,0 @@
-# use "extend CapUtils" inside a task to use this
-require 'buzzcore/misc_utils'
-require 'buzzcore/string_utils'
-require 'buzzcore/xml_utils'
-require 'buzzcore/shell_extras'
-require 'net/ssh'
-require 'net/sftp'
-
-module CapUtils
-
-	# upload the given local file to the remote server and set the given mode.
-	# 0644 is the default mode
-	#
-	# Unix file modes :
-	# 4: read
-	# 2: write
-	# 1: execute
-	# 0[owner][group][other]
-	def upload_file(aLocalFilePath,aRemoteFilePath,aMode = 0644)
-		puts "* uploading #{aLocalFilePath} to #{aRemoteFilePath}"
-		s = nil
-		File.open(aLocalFilePath, "rb") { |f| s = f.read }
-		put(s,aRemoteFilePath,:mode => aMode)
-	end
-	
-	def render_template_file(aTemplateFile,aXmlConfig,aOutputFile,aMoreConfig=nil)
-		template = MiscUtils.string_from_file(aTemplateFile)
-		values = XmlUtils.read_config_values(aXmlConfig)
-		values = values ? values.merge(aMoreConfig || {}) : aMoreConfig
-		result = StringUtils.render_template(template, values)
-		MiscUtils.string_to_file(result, aOutputFile)
-  end
-
-	def get_ip
-		run "ifconfig eth0 |grep \"inet addr\"" do |channel,stream,data|
-			return data.scan(/inet addr:([0-9.]+)/).flatten.pop
-		end
-	end
-
-	# check if file exists. Relies on remote ruby
-	def remote_file_exists?(aPath)
-		remote_ruby("puts File.exists?('#{aPath}').to_s")=="true\n"
-	end
-
-	def remote_ruby(aRubyString)
-		run 'ruby -e "'+aRubyString+'"' do |channel,stream,data|
-			return data
-		end
-	end
-
-	def sudo_run(aString)
-# 		as = fetch(:runner, "app")
-# 		via = fetch(:run_method, :sudo)
-# 		invoke_command(aString, :via => via, :as => as)
-# 		if aUseSudo
-# 			run "sudo "+aString
-# 		else
-			run aString
-# 		end
-	end
-
-	def upload_file_anywhere(aSourceFile,aDestHost,aDestUser,aDestPassword,aDestFile,aDestPort=22)
-		Net::SSH.start(aDestHost, aDestUser, {:port => aDestPort, :password => aDestPassword, :verbose =>Logger::DEBUG}) do |ssh|
-			File.open(aSourceFile, "rb") { |f| ssh.sftp.upload!(f, aDestFile) }
-		end
-	end
-
-	def branch_name_from_svn_url(aURL)
-		prot_domain = (aURL.scan(/[^:]+:\/\/[^\/]+\//)).first
-		without_domain = aURL[prot_domain.length..-1]
-		return 'trunk' if without_domain =~ /^trunk\//
-		return (without_domain.scan(/branches\/(.+?)(\/|$)/)).flatten.first
-	end
-	
-	# give block with |aText,aStream,aState| that returns response or nil
-	def run_respond(aCommand)
-		run(aCommand) do |ch,stream,text|
-			ch[:state] ||= { :channel => ch }
-			output = yield(text,stream,ch[:state])
-			ch.send_data(output) if output
-		end
-	end
-
-	# pass prompt to user, and return their response
-	def run_prompt(aCommand)
-		run_respond aCommand do |text,stream,state|
-			Capistrano::CLI.password_prompt(text)+"\n"
-		end
-	end
-	
-	def ensure_link(aTo,aFrom,aDir=nil,aUserGroup=nil)
-		cmd = []
-		cmd << "cd #{aDir}" if aDir
-		cmd << "#{sudo} rm -f #{aFrom}"
-		cmd << "#{sudo} ln -sf #{aTo} #{aFrom}"
-		cmd << "#{sudo} chown -h #{aUserGroup} #{aFrom}" if aUserGroup
-		run cmd.join(' && ')
-	end
-	
-
-	def file_exists?(path)
-		begin
-			run "ls #{path}"
-			return true
-		rescue Exception => e
-			return false
-		end
-	end
-	
-	# Used in deployment to maintain folder contents between deployments.
-	# Normally the shared path exists and will be linked into the release.
-	# If it doesn't exist and the release path does, it will be moved into the shared path
-	# aFolder eg. "vendor/extensions/design"
-	# aSharedFolder eg. "design" 
-	def preserve_folder(aReleaseFolder,aSharedFolder)	
-		aReleaseFolder = File.join(release_path,aReleaseFolder)
-		aSharedFolder = File.join(shared_path,aSharedFolder)
-		release_exists = file_exists?(aReleaseFolder)
-		shared_exists = file_exists?(aSharedFolder)
-		if shared_exists
-			run "rm -rf #{aReleaseFolder}" if release_exists
-		else
-			run "mv #{aReleaseFolder} #{aSharedFolder}" if release_exists
-		end
-		ensure_link("#{aSharedFolder}","#{aReleaseFolder}",nil,"#{user}:#{apache_user}")
-	end
-
-	def select_target_file(aFile)
-		ext = MiscUtils.file_extension(aFile,false)
-		no_ext = MiscUtils.file_no_extension(aFile,false)
-		dir = File.dirname(aFile)
-		run "#{sudo} mv -f #{no_ext}.#{target}.#{ext} #{aFile}"
-		run "#{sudo} rm -f #{no_ext}.*.#{ext}"
-	end
-	
-	def shell(aCommandline,&aBlock)
-		result = block_given? ? POpen4::shell(aCommandline,nil,nil,&aBlock) : POpen4::shell(aCommandline)
-		return result[:stdout]
-	end
-
-	def run_local(aString)
-		`#{aString}`
-	end
-
-
-	def run_for_all(aCommand,aPath,aFilesOrDirs,aPattern=nil,aInvertPattern=false,aSudo=true)
-		#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 << "find #{aPath}"
-		cmd << "-wholename '#{aPattern}'" if aPattern
-		cmd << "-prune -o" if aInvertPattern
-		cmd << case aFilesOrDirs.to_s[0,1]
-			when 'f' then '-type f'
-			when 'd' then '-type d'
-			else ''
-		end
-		cmd << "-exec"		
-		cmd << aCommand
-		cmd << '{} \;'		
-		cmd = cmd.join(' ')
-		run cmd
-	end
-	
-	# if aGroup is given, that will be the users only group
-	def adduser(aNewUser,aPassword,aGroup=nil)
-		run "#{sudo} adduser --gecos '' #{aGroup ? '--ingroup '+aGroup : ''} #{aNewUser}" do |ch, stream, out|
-			ch.send_data aPassword+"\n" if out =~ /UNIX password:/
-		end
-	end
-	
-	def add_user_to_group(aUser,aGroup)
-		run "#{sudo} usermod -a -G #{aGroup} #{aUser}"
-	end
-
-end
-
-class CapUtilsClass
-	self.extend CapUtils
-end

data/lib/buzzcore/ftp_extra.rb

@@ -1,188 +0,0 @@
-require 'net/ftp'
-
-this_path = File.dirname(__FILE__)
-require this_path+'/misc_utils'
-
-String.class_eval do    
-  def bite!(aValue=$/,aString=self)
-    if aString[0,aValue.length] == aValue
-      aString[0,aValue.length] = ''
-      return aString
-    else
-      return aString
-    end
-  end
-
-  def bite(aValue=$/)
-    bite!(aValue,self.clone)
-  end  
-end
-
-
-module Net
-  class FTP
-		def FTP.with_connect(aHost,aUsername,aPassword,aDir=nil)
-			open(aHost,aUsername,aPassword) do |f|
-				f.passive = true
-				f.chdir(aDir) if aDir
-				yield f
-			end
-		end
-
-		def self.crack_file_line(aString)
-			values = aString.scan(/(.{10}).{28}(.{13})(.*)$/).flatten
-			{
-				:bits => values[0],
-				:date => values[1],
-				:name => values[2]
-			}
-		end
-
-		# BEGIN BUGFIXES
-
-    #
-    # Returns the size of the given (remote) filename.
-    #
-    def size(filename)
-      voidcmd("TYPE I")
-      resp = sendcmd("SIZE " + filename)
-			code = resp[0, 3]
-      if code != "213" && code != "220"
-	raise FTPReplyError, resp
-      end
-      return resp[3..-1].strip.to_i
-    end
-
-		# END BUGFIXES
-
-		def subdirs(aPath)
-			list.delete_if {|line| line[0,1]=='d'}
-			return list
-		end
-
-		def files(aPath)
-			list.delete_if {|line| line[0,1]!='d'}
-			return list
-		end
-
-		def expand_dir(aPath,aBase=nil)
-			return aPath if aPath=='/'
-			return MiscUtils::path_relative?(aPath) ? File.expand_path(aPath,aBase || pwd()) : File.expand_path(aPath)
-		end
-
-		def dir_exists?(aPath)
-			aPath = expand_dir(aPath)
-			return true if aPath=='/'
-			dirname = File.basename(aPath)
-			parent = MiscUtils.path_parent(aPath)
-			dirname!='' && nlst(parent).include?(dirname)
-		end
-
-		def file_exists?(aPath)
-			aPath = expand_dir(aPath)
-			filename = File.basename(aPath)
-			parent = File.dirname(aPath)
-			filename!='' && nlst(parent).include?(filename)
-		end
-
-		def filelist_recurse(aPath=nil,aResult=nil,&block)
-			#puts "filelist_recurse: #{aPath.to_s}  #{aResult.inspect}"
-			orig_dir = !aResult ? pwd : nil	# assigned if called at top with aResult=nil
-			aResult ||= []
-			aPath ||= ''
-			chdir(aPath)
-			list('*').each do |f| 
-				is_dir = f[0,1]=='d'
-				details = FTP::crack_file_line(f)
-				full = File.join(aPath,details[:name])
-				if !block_given? || yield(full)
-					if is_dir
-						filelist_recurse(full,aResult)
-					else
-						aResult << full
-					end
-				end
-			end
-			chdir(orig_dir) if orig_dir
-			return aResult
-		end
-
-		def get_files(aRemoteDir,aLocalDir,aFiles,aOptions=nil)
-			aOptions = {:overwrite => true}.merge(aOptions || {})
-			aFiles.each do |r|
-				relative = r.bite(MiscUtils::append_slash(aRemoteDir))
-				d = File.join(aLocalDir,relative)
-				puts "getting #{relative}"
-				getbinaryfile(r, d) unless !aOptions[:overwrite] && File.exists?(d)
-			end
-		end
-
-		def get_dir(aRemoteDir,aLocalDir,aOptions=nil,&block)
-			remote_files = block_given? ? filelist_recurse(aRemoteDir,nil,&block) : filelist_recurse(aRemoteDir)
-			get_files(aRemoteDir,aLocalDir,remote_files,aOptions)
-		end
-
-		def highest_existing(aPath)
-			sep = MiscUtils::sniff_seperator(aPath)
-			path = MiscUtils::path_parts(File.expand_path(aPath)) if aPath.is_a?(String)
-			# now assume path is an Array
-			depth = path.length-1
-			depth.downto(0) do |i|	# from full path up to root
-				curr = (path[0]=='' && i==0) ? '/' : path[0..i].join(sep)
-				return curr if dir_exists?(curr)
-			end
-			return sep	# root
-		end
-
-		def ensure_dir(aPath,aThorough=false)
-			if !aThorough
-				mkdir(aPath) unless dir_exists?(aPath)
-			else
-				return if dir_exists?(aPath)
-				path = expand_dir(aPath)
-				hi_existing = highest_existing(path)
-				# path to create under hi_existing
-				to_create = MiscUtils::path_debase(path,hi_existing)
-				parts = MiscUtils::path_parts(to_create)
-				curr_path = hi_existing
-				
-				parts.each do |part|
-					curr_path = File.join(curr_path,part)
-					mkdir(curr_path)
-				end
-			end
-		end
-
-		def put_files(aLocalDir,aRemoteDir,aFiles,aOptions=nil)
-			aOptions = {:overwrite => true}.merge(aOptions || {})
-
-			# convert all files to relative to aLocalDir
-			aFiles = aFiles.map { |f| f.bite(MiscUtils::append_slash(aLocalDir)) }.sort
-			
-			filelist = nil
-			this_dir = last_dir = nil
-			aFiles.each do |r|
-				d = File.expand_path(r,aRemoteDir)
-				this_dir = File.dirname(d)
-				if this_dir!=last_dir
-					ensure_dir(this_dir,true)
-					filelist = files(this_dir) - ['.','..','.svn']
-				end
-				if aOptions[:overwrite] || !filelist.member?(File.basename(r))
-					puts "Putting #{r}"
-					putbinaryfile(File.expand_path(r,aLocalDir), d)
-				else
-					puts "Skipping #{relative}"
-				end
-				last_dir = this_dir
-			end
-		end
-
-		def put_dir(aLocalDir,aRemoteDir,&block)
-			local_files = block_given? ? MiscUtils::recursive_file_list(aLocalDir,true,&block) : MiscUtils::recursive_file_list(aLocalDir) 
-			put_files(aLocalDir,aRemoteDir,local_files)
-		end
-
-	end
-end
-