fairchild-poolparty 1.1.3

data/lib/poolparty/core/module.rb

@@ -0,0 +1,40 @@
+# Module overloads
+class Module
+  # Gives us alias_method_chain from rails
+  def alias_method_chain(target, feature)
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end
+  def attr_accessor_with_default( *syms, &block )
+    raise 'Default value in block required' unless block
+    syms.each do | sym |
+      module_eval do
+        attr_writer( sym )
+        define_method( sym ) do | |
+          class << self; self; end.class_eval do
+            attr_reader( sym )
+          end
+          instance_variables.include?("@#{sym}") ? instance_variable_get( "@#{sym}" ) : instance_variable_set( "@#{sym}", block.call )
+        end
+      end
+    end
+    nil
+  end
+  def instance_variables_from_hash(h={})
+    h.each {|k,v| instance_eval "@#{k} = #{v}"}
+  end
+end

data/lib/poolparty/core/my_open_struct.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+  Create an extended open struct
+=end
+require "ostruct"
+class MyOpenStruct < OpenStruct
+  attr_accessor :keys
+  def initialize(h)
+    @keys = h.keys
+    super
+  end
+  def to_hash
+    m = {}
+    @keys.map do |key|
+      m.update( {key => self.send(key)} )
+    end
+    m
+  end
+end

data/lib/poolparty/core/object.rb

@@ -0,0 +1,93 @@
+=begin rdoc
+  Basic, add an alias_method to the object class
+  Add returning to the object
+=end
+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  
+  def alias_method(new_id, original_id)
+    original = self.method(original_id).to_proc
+    define_method(new_id){|*args| original.call(*args)}
+  end
+  def with_options(opts={}, par=nil, &block)
+    @p = par.clone
+    @p.options.merge!(opts)
+    @p.instance_eval &block if block
+  end  
+  def returning(receiver)
+    yield receiver
+    receiver
+  end
+  def extended(&block)
+    block.in_context(self).call
+    self
+  end
+  def send_if_method(v, *args)
+    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  #NOTE MF: maybe we should not rescue all errors?
+    end
+  end
+  def respec_string
+    case self.class
+    when String
+      self.to_option_string
+    when Array
+      self.map {|a| "#{a.respec_string}" }.join(" ")
+    else
+      "'#{self}'"
+    end
+  end
+  def block_instance_eval(*args, &block)
+    return instance_eval(*args,&block) unless block && !block.arity.zero?
+    old_method = (self.class.instance_method(:__) rescue nil)
+    self.class.send(:define_method, :__, &block)
+    block_method = self.class.instance_method(:__)
+    if old_method
+      self.class.send(:define_method, :__, old_method)
+    else
+      self.class.send(:remove_method, :__)
+    end
+    block_method.bind(self).call(*args)
+  end
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+  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
+  #   meta_undef name rescue ""
+  # end
+  def vputs(m="", o=self)
+    puts m if o.verbose rescue ""
+  end
+  def vprint(m="", o=self)
+    print m if o.verbose rescue ""
+  end
+  def dputs(m="", o=self)
+    puts "-- #{m}" if $DEBUGGING rescue ""
+  end
+  def debugging(bool=false)
+    $DEBUGGING = bool
+  end
+  def testing(bool=$TESTING)
+    bool.nil? ? false : bool
+  end
+  alias :debug :debugging
+  def unix_hide_string
+    "2>&1 > /dev/null"
+  end
+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/proc.rb

@@ -0,0 +1,7 @@
+require 'ruby2ruby' 
+
+class Proc
+  def to_ruby(opts={})
+    Ruby2Ruby.new.process(self.to_sexp).gsub(/proc \{/, "do \n#{opts.map {|k,v| "#{k} \"#{v}\""}.join("\n")}\n").sub(/\}/, "\nend")
+  end
+end

data/lib/poolparty/core/string.rb

@@ -0,0 +1,140 @@
+class String
+  def hasherize(format=[])
+    hash = {}
+    i = 0
+    self.split(%r{[\n|\t|\s| ]+}).map {|a| a.strip}.each do |f|
+      next unless format[i]
+      unless f == "" || f.nil?
+        hash[format[i].to_sym] = f
+        i+=1
+      end      
+    end
+    hash
+  end
+  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
+  def runnable(quite=true)
+    # map {|l| l << "#{" >/dev/null 2>/dev/null" if quite}" }.
+    self.strip.split(/\n/).join(" && ")
+  end
+  def top_level_class
+    self.split("::")[-1].underscore.downcase rescue self.class.to_s
+  end
+  def sanitize
+    self.gsub(/[ \.\/\-]*/, '')
+  end
+  def keyerize
+    signed_short = 0x7FFFFFFF
+    len = self.sanitize.length
+    hash = 0 
+    len.times{ |i| 
+      hash = self[i] + ( hash << 6 ) + ( hash << 16 ) - hash 
+    } 
+    hash & signed_short
+  end
+  def dir_safe
+    self.downcase.gsub(/[ ]/, '_')
+  end
+  def safe_quote
+    self.gsub(/['"]/, '\\\"')
+    # self.gsub(/["']/, "\\\"")
+  end
+  def nice_runnable(quite=true)
+    self.split(/ && /).join("\n")
+  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}Class") : "PoolParty#{self.camelcase}Class").classify
+
+    kla=<<-EOE
+      class #{symc} #{"< #{superclass}" if superclass}
+      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
+    camelcased_word = camelcase
+    begin
+      Object.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)
+    Object.const_set(symc, mod) unless Object.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def preserved_module_constant(ext="", from="PoolParty::", &block)
+    symc = "#{self}#{ext}".camelcase
+    mod = Kernel.const_defined?(symc) ? Kernel.const_get(symc.to_sym) : Module.new(&block)
+    Kernel.const_set(symc, mod) unless Kernel.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def collect_each_line_with_index(&block)
+    returning [] do |arr|
+      arr << self.split(/\n/).collect_with_index(&block)
+    end.flatten
+  end
+end

data/lib/poolparty/core/symbol.rb

@@ -0,0 +1,17 @@
+class Symbol
+  # def >(num);"#{self} > #{num}";end
+  # def <(num);"#{self} < #{num}";end
+  # def >=(num);"#{self} >= #{num}";end
+  # def <=(num);"#{self} <= #{num}";end
+  # def ==(num);"#{self} > #{num}";end
+  
+  def to_string(pre="")
+    "#{pre}#{self.to_s}"
+  end
+  def sanitize
+    self.to_s.sanitize
+  end
+  def <=>(b)
+    "#{self}" <=> "#{b}"
+  end
+end

data/lib/poolparty/core/time.rb

@@ -0,0 +1,56 @@
+=begin rdoc
+  Based off the rails Numeric class.
+  Gives us the ability to use nice phrases such as
+  30.seconds, 5.days, etc.
+=end
+class Numeric
+  def ago(time = Time.now)
+    time - self
+  end
+  alias :until :ago
+
+  def since(time = Time.now)
+    time + self
+  end
+  alias :from_now :since
+  
+  def seconds
+    self
+  end
+  alias :second :seconds
+
+  def minutes
+    self * 60
+  end
+  alias :minute :minutes  
+
+  def hours
+    self * 60.minutes
+  end
+  alias :hour :hours
+
+  def days
+    self * 24.hours
+  end
+  alias :day :days
+
+  def weeks
+    self * 7.days
+  end
+  alias :week :weeks
+  
+  def months
+    self * 31.days
+  end
+  alias :month :months
+  
+  def time_ago
+    out = %w(year month week day hour minute).detect {|unit| self > 1.send(unit) }
+    units_ago(out, self) rescue "Less than a minute ago"
+  end
+
+  def units_ago(unit,seconds)
+    in_units = (seconds / 1.send(unit))
+    "#{in_units.to_i} #{in_units != 1 ? unit.to_s.pluralize : unit} ago" 
+  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