poolparty 0.2.84 → 1.2.2

data/lib/poolparty/core/array.rb

@@ -6,25 +6,43 @@ class Array
   def to_os
     map {|a| a.to_os }
   end
+  
   def collect_with_index &block
     self.enum_for(:each_with_index).collect &block
   end
+  
   def runnable(quiet=true)
     self.join(" \n ").runnable(quiet)
   end
+  
   def nice_runnable(quiet=true)
     self.flatten.reject{|e| (e.nil? || e.empty?) }.join(" \n ").chomp.nice_runnable(quiet)
   end
+  
   def to_string(pre="")
     map {|a| a.to_string(pre)}.join("\n")
   end
+  
   def get_named(str="")
     map {|a| a.name == str ? a : nil }.reject {|a| a.nil? }
   end
-  def to_option_string(ns=[])
-    "[ #{map {|e| e.to_option_string }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
-  end
+  
   def respec_string(ns=[])
     "'#{map {|e| e.to_option_string }.join("', '")}'"
   end
+  # Example  nodes.select_with_hash(:status=>'running')
+  def select_with_hash(conditions={})
+    return self if conditions.empty?
+    select do |node|
+      conditions.any? do |k,v| 
+        ( node.has_key?(k) && node[k]==v ) or ( node.respond_to?(k) && node.send(k)==v )
+      end
+    end
+  end
+  
+  def wrapping_next(id)
+    raise "Element #{id} not in array" unless index(id)
+    index(id) >= size-1 ? at(0) : at(index(id)+1)
+  end
+    
 end

data/lib/poolparty/core/hash.rb

@@ -2,16 +2,35 @@
   Hash extentions
 =end
 class Hash
-  alias :old_select :select
+  def choose(&block)
+    Hash[*self.select(&block).inject([]){|res,(k,v)| res << k << v}]
+  end
 
-  def select(&block)
-    Hash[*self.old_select(&block).inject([]){|res,(k,v)| res << k << v}]    
+  def to_instance_variables(inst=nil)
+    each do |k,v|
+      inst.instance_variable_set "@#{k}", v
+      inst.class.send :attr_reader, k if inst
+    end
   end
-  def extract!(&block)
-    o = select(&block)
-    o.keys.each {|k| self.delete(k) }
-    o
+  
+  # extracted from activesupport
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  def values_at(*indices)
+    indices.collect {|key| self[key]}
   end
+  
+  #TODO: deprecate
+  # def extract!(&block)
+  #   o = Hash[*select(&block).flatten]
+  #   o.keys.each {|k| self.delete(k) }
+  #   o
+  # end
+  
   def append(other_hash)
     returning Hash.new do |h|
       h.merge!(self)
@@ -20,24 +39,40 @@ class Hash
       end
     end
   end
+  
   def append!(other_hash)
     other_hash.each do |k,v|
       self[k] = has_key?(k) ? [self[k], v].flatten.uniq : v
     end
     self
   end
+  
   def safe_merge(other_hash)
     merge(other_hash.delete_if {|k,v| has_key?(k) })
   end
+  
   def safe_merge!(other_hash)
     merge!(other_hash.delete_if {|k,v| has_key?(k) && !v.nil? })
   end
-  def flush_out(pre="", post="")
-    map {|k,v| "#{pre}#{k} => #{v.to_option_string}#{post}"}
-  end
+  
   def to_os
     m={}
     each {|k,v| m[k] = v.to_os }
     MyOpenStruct.new(m)
   end
+  
+  def next_sorted_key(from)
+    idx = (size - keys.sort.index(from))
+    keys.sort[idx - 1]
+  end
+  
+  def method_missing(sym, *args, &block)
+    if has_key?(sym)
+      fetch(sym)
+    elsif has_key?(sym.to_s)
+      fetch(sym.to_s)
+    else
+      super
+    end
+  end
 end

data/lib/poolparty/core/kernel.rb

@@ -1,7 +1,25 @@
 =begin rdoc
   Kernel overloads
 =end
+
 module Kernel
+  def get_latest_caller
+    returning Array.new do |arr|
+      callstack.size.times {|i| arr << callstack[i][0] unless callstack[i][0] =~ /lib\/poolparty/ }
+    end.first
+  end
+  def callstack( level = 1 )
+    call_str_array = caller(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
   # Nice wait instead of sleep
   def wait(time=5)
     sleep time.is_a?(String) ? eval(time) : time
@@ -9,14 +27,6 @@ module Kernel
   def as(klass_or_obj, &block)
     block.in_context(klass_or_obj).call
   end
-  def load_p(dir)
-    Dir["#{dir}/*.rb"].sort.each do |file|
-      require "#{file}" if ::FileTest.file?(file)
-    end
-    Dir["#{dir}/*"].sort.each do |dir|
-      load_p(dir) if ::FileTest.directory?(dir)
-    end
-  end
   def with_warnings_suppressed
     saved_verbosity = $-v
     $-v = nil
@@ -24,6 +34,18 @@ module Kernel
   ensure
     $-v = saved_verbosity
   end
+  
+  def capture_stdout(&block)
+     old_stdout = $stdout
+     out = StringIO.new
+     $stdout = out
+     begin
+        block.call if block
+     ensure
+        $stdout = old_stdout
+     end
+     out.string
+  end
 
   #redirect stdout and stderr to /dev/null and reopen after block
   def hide_output

data/lib/poolparty/core/nil.rb

@@ -0,0 +1,8 @@
+# Class: NilClas
+#
+#
+class NilClass
+  def empty?
+    true
+  end
+end

data/lib/poolparty/core/object.rb

@@ -6,6 +6,9 @@ class Object
   def my_methods
     self.methods.sort - (self.class.methods + self.class.superclass.methods)
   end
+  def this
+    self
+  end
   def to_os
     self
   end  
@@ -13,8 +16,8 @@ class Object
     original = self.method(original_id).to_proc
     define_method(new_id){|*args| original.call(*args)}
   end
-  def with_options(opts={}, parent=self, &block)
-    @p = parent.clone
+  def with_options(opts={}, par=nil, &block)
+    @p = par.clone
     @p.options.merge!(opts)
     @p.instance_eval &block if block
   end  
@@ -27,21 +30,11 @@ class Object
     self
   end
   def send_if_method(v, *args)
-    if (v.nil? || v.to_s.empty? || v.is_a?(Array) || v.is_a?(Integer))
+    if (v.nil? || v.to_s.empty? || v.is_a?(Array) || v.is_a?(Integer))# && !v.is_a?(Symbol))#)v.is_a?(String)
       v
     else
       vs = v.to_s.to_sym
-      respond_to?(vs) ? self.send(vs, *args) : v rescue v
-    end
-  end
-  def to_option_string
-    case self.class
-    when String
-      self.to_option_string
-    when Array
-      self.each {|a| a.to_option_string }.join(" ")
-    else
-      "#{self}"
+      respond_to?(vs) ? self.send(vs, *args) : v rescue v  #NOTE MF: maybe we should not rescue all errors?
     end
   end
   def respec_string
@@ -72,22 +65,38 @@ class Object
   def meta_undef name
     meta_eval { remove_method name }
   end
-  def run_in_context(context=self, &block)
-    name="temp_#{self.class}_#{respond_to?(:parent) ? parent.to_s : Time.now.to_i}".to_sym
-    meta_def name, &block
-    self.send name, context
-    # self.instance_eval &block if block
-    meta_undef name rescue ""
-  end
+  # def run_in_context(context=self, &block)
+  #   name="temp_#{self.class}_#{respond_to?(:parent) ? parent.to_s : Time.now.to_i}".to_sym
+  #   meta_def name, &block
+  #   self.send name, context
+  #   meta_undef name rescue ""
+  # end
   def vputs(m="", o=self)
-    puts m if o.verbose
+    # puts m if o.verbose rescue ""
+    puts "[INFO] -- #{m}" if verbose?
+  end
+  def vprint(m="", o=self)
+    print m if o.verbose rescue ""
   end
   def dputs(m="", o=self)
-    vputs(">#{::File.basename(__FILE__)} (#{__LINE__}) #{m}", o)
+    puts "[DEBUG] -- #{m.inspect}" if debugging?(o) rescue ""
   end
-  def vprint(m="", o=self)
-    print m if o.verbose
+  def dprint(m="", o=self)
+    print "#{m}" if debugging?(o) || verbose?(o) rescue ""
+  end
+  def verbose?(o=self)
+    o.respond_to?(:verbose) ? o.verbose : ($TESTING ||= false)
+  end
+  def debugging?(o=self)
+    o.respond_to?(:debug) ? o.debug : ($DEBUGGING ||= false)
+  end
+  def debugging(bool=nil)
+    bool.nil? ? $DEBUGGING : $DEBUGGING = bool
+  end
+  def testing(bool=$TESTING)
+    bool.nil? ? $TESTING : $TESTING = bool
   end
+  alias :debug :debugging
   def unix_hide_string
     "2>&1 > /dev/null"
   end

data/lib/poolparty/core/ordered_hash.rb

@@ -0,0 +1,99 @@
+# Credit to Brian Candler on a ruby-forum post for this
+# http://www.ruby-forum.com/topic/166075
+require 'rubygems'
+require 'json'
+
+class OrderedHash
+	include Enumerable
+	def initialize
+		@h = {}
+		@a = []
+	end
+	def [](k)
+		@h[k]
+	end
+	def []=(k,v)
+		@a << k unless @h.has_key?(k)
+		@h[k] = v
+	end
+	def merge(o={})
+		na = dup
+		o.each {|k,v| na[k] = v }
+		na
+	end
+	def keys
+		map {|k,v| k }
+	end
+	def has_key?(k)
+	 
+	end
+	def values
+		map {|k,v| v }
+	end
+	def size
+		@h.size
+	end
+	def merge!(o={})
+		o.each {|k,v| self[k] = v }
+	end
+	def each
+		@a.each { |k| yield k,@h[k] }
+	end
+	
+	#TODO: Need specs below here
+	def each_value
+		@a.each {|k| yield(@h[k])}
+	end
+	def each_key
+		@a.each {|k| yield k}
+	end
+	def clear
+		@a.clear
+		@h.clear
+	end
+	def delete(k, &block)
+		@a.delete k
+		@h.delete(k, &block)
+	end
+	def reject!
+		del = []
+		each_pair {|k,v| del << k if yield k,v}
+		del.each {|k| delete k}
+		del.empty? ? nil : self
+	end
+	def delete_if(&block)
+		reject!(&block)
+		self
+	end
+	def method_missing(*args)
+	  @h.send(*args)
+	end
+	def to_hash
+		self
+	end
+	def to_h
+		self
+	end
+	def to_json
+	  
+	  "{#{collect{|k, v| "\"#{k.to_s}\":#{v.to_json}"}.join(',')}}"
+	end
+end
+
+# {}.to_json
+# oh2= OrderedHash.new
+# oh2[:thing] = 'majobber'
+# oh2['stuff'] = 'bb'
+# 
+# oh = OrderedHash.new
+# oh[nil] = nil
+# oh[:var1]=3
+# oh['time']=Time.now
+# oh[3]=[1,2,3]
+# oh['false'] = false
+# oh['ordered_hash'] = oh2
+# oh["var4"]={:keyme=>'valueme'}
+# oh.each { |k,v| puts "#{k}=>#{v}" }
+# p oh.to_json
+
+

data/lib/poolparty/core/string.rb

@@ -14,6 +14,9 @@ class String
   def ^(h={})
     self.gsub(/:([\w]+)/) {h[$1.to_sym] if h.include?($1.to_sym)}
   end
+  def grab_filename_from_caller_trace
+    self.gsub(/\.rb(.*)/, '.rb')
+  end
   def arrayable
     self.strip.split(/\n/)
   end
@@ -40,28 +43,18 @@ class String
     self.downcase.gsub(/[ ]/, '_')
   end
   def safe_quote
-    self.gsub(/[']/, '\\\\\'')
+    self.gsub(/['"]/, '\\\"')
+    # self.gsub(/["']/, "\\\"")
   end
   def nice_runnable(quite=true)
     self.split(/ && /).join("\n")
   end
-  # This is the method we use to turn the options into a string to build the main 
-  # manifests
-  def to_option_string(ns=[])
-    a_template = (self =~ /template/) == 0
-    a_service = self =~ /^[A-Z][a-zA-Z]*\[[a-zA-Z0-9\-\.\"\'_\$\{\}\/]*\]/
-    a_function = self =~/(.)*\((.)*\)(.)*/
-    if is_a?(PoolParty::Resources::Resource)
-      self.to_s
-    else
-      (a_service || a_template || a_function) ? self : "'#{self}'"
-    end    
-  end
+
   # Refactor this guy to get the class if the class is defined, and not always create a new one
   # although, it doesn't really matter as ruby will just reopen the class
   def class_constant(superclass=nil, opts={}, &block)
-    symc = ((opts && opts[:preserve]) ? ("#{self.camelcase}Classs") : "PoolParty#{self.camelcase}Classs").classify
-    
+    symc = ((opts && opts[:preserve]) ? ("#{self.camelcase}Class") : "PoolParty#{self.camelcase}Class").classify
+
     kla=<<-EOE
       class #{symc} #{"< #{superclass}" if superclass}
       end
@@ -74,6 +67,73 @@ class String
     klass
   end
   
+  def new_resource_class(superclass=nil, opts={}, &block)
+    symc = "::PoolParty::Resources::#{self.camelcase}"
+    kla=<<-EOE
+      class #{symc} < ::PoolParty::Resources::Resource
+      end
+    EOE
+    
+    Kernel.module_eval kla
+    klass = symc.constantize
+    klass.module_eval &block if block
+
+    klass
+  end
+  
+  def camelcase
+    gsub(/(^|_|-)(.)/) { $2.upcase }
+  end
+  def camelize
+    camelcase
+  end
+  
+  # "FooBar".snake_case #=> "foo_bar"
+   def snake_case
+     gsub(/\B[A-Z]+/, '_\&').downcase
+   end
+   def underscore
+     snake_case
+   end
+   
+    # "FooBar".dasherize #=> "foo-bar"
+    def dasherize
+      gsub(/\B[A-Z]+/, '-\&').downcase
+    end
+    
+    def classify
+      self.sub(/.*\./, '').camelcase
+    end
+    
+    #TODO: implement here to drop activesupport
+    # # Form can be either :utc (default) or :local.
+    # def to_time(form = :utc)
+    #   ::Time.send("#{form}_time", *::Date._parse(self, false)(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
+    # end
+    
+    
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize(mod=Object)
+    camelcased_word = camelcase
+    begin
+      mod.module_eval(camelcased_word, __FILE__, __LINE__)
+    rescue NameError
+      puts "#{camelcased_word} is not defined."
+      nil
+    end
+  end
+  
+  def preserved_class_constant(append="")
+    klass = "#{self}#{append}".classify
+    Object.const_defined?(klass.to_sym) ? klass.to_s.constantize : nil
+  end
+  
   def module_constant(append="", &block)
     symc = "#{self}_Module#{append}".camelcase
     mod = Object.const_defined?(symc) ? Object.const_get(symc.to_sym) : Module.new(&block)
@@ -91,4 +151,41 @@ class String
       arr << self.split(/\n/).collect_with_index(&block)
     end.flatten
   end
+  
+  # Read a new-line separated string and turn 
+  # the string from the form 
+  #   a = "b"
+  #   b = "c"
+  # into a hash
+  #  {:a => "b", :b => "c"}
+  def to_hash
+    split("\n").inject({}) do |sum,line| 
+      if line.include?("=")
+        l = line.split("=").map {|a| a.strip }
+        key = l[0].to_sym
+        value = l[1].gsub(/\"/, '')
+        sum.merge(key => value)
+      else
+        sum
+      end
+    end
+  end
+  
+  # Take a mac address and split it to map to the arp -a response
+  # Just rip off the first 0 if the first char is 0
+  def macify
+    split(":").map {|a| a[0].chr == "0" ? a[1].chr : a}.join(":")
+  end
+
+  ##
+  # @param o<String> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   "merb"/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self, o.to_s)
+  end
+  
 end

data/lib/poolparty/core/symbol.rb

@@ -14,4 +14,14 @@ class Symbol
   def <=>(b)
     "#{self}" <=> "#{b}"
   end
+  ##
+  # @param o<String, Symbol> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   :merb/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self.to_s, o.to_s)
+  end
 end

data/lib/poolparty/dependencies.rb

@@ -0,0 +1,49 @@
+module PoolParty
+  class Dependencies
+    
+    def self.dependencies
+      @dependencies ||= ["#{::File.dirname(__FILE__)}/../../vendor/dependencies/cache"]
+    end
+    
+    def self.package(file)
+      ::Tar.open(file, File::CREAT | File::WRONLY, 0644, Tar::GNU) do |tar|
+        dependencies.each do |dep|
+          if ::File.file? dep
+            tar.append_file(dep)
+          elsif ::File.directory? dep
+            Dir["#{dep}/*"].each do |file|
+              tar.append_file(file) if ::File.file? file
+            end
+          end
+        end
+      end      
+    end
+    
+    def self.gems(gem_list, gem_location)
+      require 'rubygems/dependency_installer'
+      
+      cache_dir = "#{gem_location}/cache"
+      ::FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir
+
+      gem_list.each do |g|
+        di = Gem::DependencyInstaller.new
+        spec, url = di.find_spec_by_name_and_version(g).first
+        begin
+          vputs "Downloading #{g} from github (#{spec.version} - #{spec.full_name})"
+          Gem::RemoteFetcher.fetcher.download spec, "http://gems.github.com", gem_location
+        rescue Exception => e
+          vputs "Downloading #{g} from rubyforge because #{e}"
+          Gem::RemoteFetcher.fetcher.download spec, url, gem_location
+        end        
+      end
+    end
+    
+    def self.packages(package_list, package_location)
+      package_list.each do |package|
+        puts "downloading #{package} to #{package_location}/#{package.split('/').last}"
+        `curl -L #{package} > #{package_location}/#{package.split('/').last}`        
+      end
+    end
+    
+  end
+end