ruby_extensions 1.0.0

data/lib/m_array.rb

@@ -0,0 +1,101 @@
+class Array
+  
+  # This method is useful when you have a method that looks like this:
+  # def foo(*args)
+  #   do something
+  # end
+  # The problem is when you use the * like that everything that comes in is
+  # an array. Here are a few problems with this:
+  # foo([1,2,3])
+  # When you pass an array into this type of method you get the following nested array:
+  # [[1,2,3]]
+  # The from_args method, if called, would do this:
+  # args.from_args # => [1,2,3]
+  # Now say you called this method like such:
+  # foo(1)
+  # args would be [1]
+  # args.from_args # => 1
+  # Finally
+  # foo
+  # args.from_args # => nil
+  def from_args
+    unless self.empty?
+      args = self#.flatten
+      case args.size
+      when 1
+        return args.first # if there was only one arg passed, return just that, without the array
+      when 0
+        return nil # if no args were passed return nil
+      else
+        return args # else return the array back, cause chances are that's what they passed you!
+      end
+    end
+  end
+  
+  # This allows you to delete an array of values from another array.
+  # [1,2,3,4,5].delete_from_array([2,3,5]) # => [1,4]
+  def delete_from_array(args)
+    self.collect{ |x| x unless args.include?(x)}.compact
+  end
+  
+  # This calls the delete_from_array method, but will permantly replace the existing array.
+  def delete_from_array!(args)
+    self.replace(delete_from_array(args))
+  end
+  
+  # This will return a new instance of the array sorted randomly.
+  def randomize(&block)
+    if block_given?
+      self.sort {|x,y| yield x, y}
+    else
+      self.sort_by { rand }
+    end
+  end
+  
+  # This calls the randomize method, but will permantly replace the existing array.
+  def randomize!(&block)
+    if block_given?
+      self.replace(self.randomize(&block))
+    else
+      self.replace(self.randomize)
+    end
+  end
+  
+  # This will pick a random value from the array
+  def pick_random
+    self[rand(self.length)]
+  end
+  
+  # This allows you to easily recurse of the array randomly.
+  def random_each
+    self.randomize.each {|x| yield x}
+  end
+  
+  def subset?(other)
+    self.each do |x|
+      return false if !(other.include? x)
+    end
+    true
+  end
+  
+  def superset?(other)
+    other.subset?(self)
+  end
+  
+  # This will give you a count, as a Hash, of all the values in the Array.
+  # %w{spam spam eggs ham eggs spam}.count # => {"eggs"=>2, "ham"=>1, "spam"=>3}
+  def count
+    k = Hash.new(0)
+    self.each{|x| k[x] += 1}
+    k
+  end
+  
+  # This will invert the index and the values and return a Hash of the results.
+  # %w{red yellow orange}.invert # => {"red"=>0, "orange"=>2, "yellow"=>1}
+  def invert
+    h = {}
+    self.each_with_index{|x,i| h[x] = i}
+    h
+  end
+  
+end

data/lib/m_class.rb

@@ -0,0 +1,10 @@
+class Class
+  
+  def self.new_instance_of(klass_name)
+    mod = Module
+    mod = mod.const_get(klass_name)
+    mod.new
+  end      
+  
+end
+  

data/lib/m_dir.rb

@@ -0,0 +1,25 @@
+class Dir
+  
+  
+  #creates multiple directories
+  def self.make_dirs(path)
+    dir_names = path.split('/')
+    new_path=""
+    dir_names.each do |x|
+       new_path = new_path  << x << '/'
+       if !File.directory?(new_path)
+         Dir.mkdir(new_path)
+       end
+    end
+   end
+   
+   
+   #if a directory exists, it deletes everything in it, otherwise it creates the directory
+   def self.prep_dir(path)
+     if File.directory?(path)
+       Dir.foreach(path) {|x| File.delete(path + x) unless File.directory?(path + x)}
+     else
+       Dir.make_dirs(path)
+     end
+   end
+end

data/lib/m_float.rb

@@ -0,0 +1,5 @@
+class Float
+  def prec(x)
+    sprintf("%01.#{x}f", self).to_f
+  end
+end

data/lib/m_kernel.rb

@@ -0,0 +1,12 @@
+require 'pp'
+require 'stringio'
+
+module Kernel
+  
+  def self.pp_to_s(object)
+    pp_out = StringIO.new
+    PP.pp(object,pp_out)
+    return pp_out.string
+  end
+  
+end

data/lib/m_logger.rb

@@ -0,0 +1,38 @@
+class Logger
+   
+  %W[error debug fatal info warn].each do |level|
+    class_eval %{
+      alias_method :old_#{level}, :#{level}
+      
+      def #{level}(progname = nil, &block)
+        old_#{level}(format_progname(progname), &block)
+      end
+    }
+  end
+   
+  def format_message(severity, timestamp, progname, msg)
+    # Check for characters at the start of the message string indicating special formatting
+    # Make the typical case as efficient as possible
+    if not msg[0..1] == '$@'
+      return "[#{severity}]\t#{timestamp}\t#{msg}\n" 
+    end
+    format = msg[2..2]
+    msg = msg[3..-1]
+    # Original format
+    if format == 'O'
+      return "#{timestamp}\t[#{severity}]\t#{msg}\n" 
+    elsif format == 'S'
+      return "#{msg}\n" 
+    end 
+    
+  end
+
+  private
+  def format_progname(progname)
+    unless progname.nil?
+      progname = "#{progname.to_s}\n#{progname.backtrace.join("\n\t")}\n" if progname.is_a? Exception
+    end
+    progname
+  end
+   
+end

data/lib/m_math.rb

@@ -0,0 +1,15 @@
+module Math
+
+  def self.log2(x)
+     self.log(x)/self.log(2.0)
+  end
+
+  def self.min(a, b)
+     a < b ? a : b
+  end
+
+  def self.max(a, b)
+     a > b ? a : b
+  end
+
+end

data/lib/m_object.rb

@@ -0,0 +1,78 @@
+class Object
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::DateHelper
+  
+  def running_time(message = "", logger = nil)
+    s_time = Time.now
+    s = "---Starting at #{s_time}---"
+    puts s
+    logger.info s unless logger.nil?
+    yield if block_given?
+    e_time = Time.now
+    e = "---Ending at #{e_time}---"
+    puts e
+    logger.info e unless logger.nil?
+    x = "Running time #{distance_of_time_in_words(s_time, e_time, true)} (#{e_time - s_time} seconds)."
+    x += " [MESSAGE]: #{message}" unless message.blank?
+    puts x
+    logger.info x unless logger.nil?
+  end
+  
+=begin
+  ivar_cache allows you to cache the results of the block into an instance variable in a class,
+  and then will serve up that instance variable the next time you call that method again.
+
+  old way:
+  def show_page_link
+    unless @show_page_link # check if instance variable exists
+      # if the instance variable doesn't exist let's do some work and assign it to the instance variable.
+      @show_page_link = link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+    @show_page_link # now return the instance variable
+  end
+
+  new way:
+  def show_page_link
+    ivar_cache do
+      link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+  end
+
+  this does everything the old way did, but it is much cleaner, and a lot less code!
+  in case you're wondering it caches the result, by default, to an instance variable named after the method,
+  so in our above example the instance variable would be name, @show_page_link. this can be overridden like such:
+
+  def show_page_link
+    ivar_cache("foo_var") do
+      link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+  end
+
+  now it will cache it to @foo_var
+=end  
+  def ivar_cache(var_name = nil,&block)
+    if var_name.nil?
+      call = caller[0]
+      var_name = call[(call.index('`')+1)...call.index("'")]
+    end
+    var = instance_variable_get("@#{var_name}")
+    unless var
+      return instance_variable_set("@#{var_name}", yield) if block_given?
+    end
+    instance_variable_get("@#{var_name}")
+  end
+  
+  def namespaces
+    ivar_cache("object_namespaces") do
+      nss = []
+      full_name = self.class.name.to_s
+      ns = full_name.split("::")
+      ns.each do |n|
+        nss << n
+      end
+      nss.pop
+      nss
+    end
+  end
+  
+end

data/lib/m_string.rb

@@ -0,0 +1,137 @@
+class String
+  
+  def starts_with?(x)
+    self.match(/^#{x}/) ? true : false
+  end
+  
+  def ends_with?(x)
+    self.match(/#{x}$/) ? true : false
+  end
+  
+  # Returns "is" or "are" based on the number, i.e. "i=6; There #{isare(i)} #{i} topics here."
+  def self.pluralize_word(num, vals = ["is", "are"])
+    return vals[0] if num.to_i==1
+    return vals[1]
+  end
+  
+  def remove(val)
+    gsub(val, '')
+  end
+  
+  def remove!(val)
+    gsub!(val, '')
+  end
+  
+  # makes long strings of unbroken characters wrap inside elements (hopefully! tested in Safari, Firefox, and IE for Windows)
+  # For documentation about this kind of workaround to this browser compatibility problem please see the following URL's:
+  # http://www.quirksmode.org/oddsandends/wbr.html
+  # http://krijnhoetmer.nl/stuff/css/word-wrap-break-word/
+  # note: if the txt has spaces, this will only try to break up runs of non-space characters longer than "every" characters
+  def breakify(every = 30)
+    every = 1 if every < 1
+    text = self
+    brokentxt = text.gsub(/\S{#{every},}/) { |longword| longword.scan(/.{1,#{every}}/).join("<wbr/>") }
+    #text = %Q[<span style='word-wrap:break-word;wbr:after{content:"\\00200B"}'>#{brokentxt}</span>]
+    #brokentxt.gsub("<wbr/>", "<br />")
+    brokentxt.gsub("<wbr/>", " ")
+  end
+  
+  def breakify!(every = 30)
+    self.replace(self.breakify(every))
+  end
+  
+  def to_h
+    self.underscore.split('_').join(' ').humanize
+  end
+  
+  
+  def hexdigest
+    Digest::SHA1.hexdigest(self.downcase)
+  end                                    
+  
+  def hexdigest!
+    self.replace(self.hexdigest)
+  end
+  
+  def equal_ignore_case(x)
+    self.downcase == x.downcase if !x.nil?
+  end
+
+  def h_url
+    x = ""
+    word_size = 5
+    while x.blank?
+      x = self.gsub(/([^ a-zA-Z0-9_-]+)/n, '').tr(' ', '-').gsub(/--/, '-').downcase#.truncate(100, "")
+      x = x.split('-').collect {|word| word if word.size >= word_size}.compact[0..3].join("-")
+      x = x.truncate(100, "")
+      word_size -= 1
+      return self if word_size == -1
+    end
+    x
+  end
+  
+  def h_url!
+    self.replace(self.h_url)
+  end
+  
+  def self.randomize(length = 10)
+    chars = ("A".."H").to_a + ("J".."N").to_a + ("P".."T").to_a + ("W".."Z").to_a + ("3".."9").to_a
+    newpass = ""
+    1.upto(length) { |i| newpass << chars[rand(chars.size-1)] }
+    return newpass.upcase
+  end 
+  
+  def truncate(length = 30, truncate_string = "...")
+    if self.nil? then return end
+    l = length - truncate_string.length
+    if $KCODE == "NONE"
+      self.length > length ? self[0...l] + truncate_string : self
+    else
+      chars = self.split(//)
+      chars.length > length ? chars[0...l].join + truncate_string : self
+    end
+  end
+  
+  def truncate!(length = 30, truncate_string = "...")
+    self.replace(self.truncate(length, truncate_string))
+  end
+  
+  def capitalize_all_words
+    self.gsub(/\b\w/) {|s| s.upcase}
+  end
+  
+  def capitalize_all_words!
+    self.replace(self.capitalize_all_words)
+  end
+  
+  # remove_bad_chars!:  any characters not in the allowed set will be removed
+  # squeeze: remove any repeated dash, underscore, period, comma characters
+  def remove_bad_chars
+    #ic = Iconv.new('UTF-8//IGNORE', 'UTF-8') # ignore bytes you can't convert
+    #str = ic.iconv(self + ' ')[0..-2]
+    if !self.nil?
+      x = self.gsub(/[^\s0-9\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\_\~\`\^\|\\ \{\}\[\]\’\“\” A-Za-z]/, '').to_s.gsub(/[\’]/, "'").to_s.gsub(/[\“]/, '"').to_s.gsub(/[\”]/, '"').squeeze(",").squeeze("-").squeeze("!").squeeze("*").squeeze("?")
+      
+      # now use the WhiteListHelper plugin to clean out html encodings
+      white_list(x)
+    end
+    
+  end
+  
+  def remove_bad_chars! 
+    self.replace(self.remove_bad_chars)
+  end
+  
+  # keep adding on to this whenever it becomes apparent that unsafe strings
+  # could get passed through into the database
+  def sql_safe_str
+    if !self.nil?
+      self.gsub(/[\']/, "\'\'")
+    end
+  end
+  
+  def sql_safe_str! 
+    self.replace(self.sql_safe_str)
+  end
+  
+end

data/lib/ruby_extensions.rb

@@ -0,0 +1,21 @@
+require 'find'
+path = File.join(RAILS_ROOT, "vendor", "plugins", "ruby_extensions", "lib")
+Find.find(path) do |f|
+  if FileTest.directory?(f) and f =~ /\.svn/
+    Find.prune
+  else
+    if FileTest.file?(f)
+      f.gsub!(path, "")
+      m = f.match(/\/[a-zA\-Z-_]*.rb/)
+      if m
+        model = m.to_s
+        x = model.gsub('/', '').gsub('.rb', '')
+        begin
+          require x
+        rescue => ex
+          puts ex
+        end
+      end
+    end
+  end
+end

data/lib/tasks/rubyforge_config.yml

@@ -0,0 +1,5 @@
+--- !ruby/object:RubyForgeConfig 
+gem_name: ruby_extensions
+package: ruby_extensions
+project: magrathea
+version: 1.0.0

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: ruby_extensions
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-20 00:00:00 -04:00
+summary: ruby_extensions
+require_paths: 
+- lib
+- lib
+- lib
+- lib/tasks
+email: 
+homepage: 
+rubyforge_project: magrathea
+description: "ruby_extensions was developed by: markbates"
+autorequire: 
+- ruby_extensions
+- m_string
+- m_object
+- m_math
+- m_logger
+- m_kernel
+- m_float
+- m_dir
+- m_class
+- m_array
+- m_string
+- m_object
+- m_math
+- m_logger
+- m_kernel
+- m_float
+- m_dir
+- m_class
+- m_array
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- markbates
+files: 
+- init.rb
+- lib/m_array.rb
+- lib/m_class.rb
+- lib/m_dir.rb
+- lib/m_float.rb
+- lib/m_kernel.rb
+- lib/m_logger.rb
+- lib/m_math.rb
+- lib/m_object.rb
+- lib/m_string.rb
+- lib/ruby_extensions.rb
+- lib/tasks/rubyforge_config.yml
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+