cldwalker-core 0.0.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2008 Gabriel Horner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,80 @@
+Description
+===========
+
+My extensions to core and standard ruby 1.8 classes, similar to the facets and activesupport gems.
+Although my extensions are probably nothing new, they are unobtrusive (monkeypatching is up to you)
+and have basic checks for preventing method name collision.
+So if you're not feeling shy, monkeypatch away: 
+
+	irb>> require 'core'
+	true
+	irb>> Core.adds_to Array
+	Array
+	irb>> Core.ancestors
+	=> [Array, Core::Array, Enumerable, Object, PP::ObjectMixin, Kernel]
+	
+And if you're not feeling your monkey-fu:
+	
+	irb>> class Base; class Array < Array; end; end
+	=> nil
+	irb>> Core.add_to Base::Array, :with=>Core::Array
+	=>Base::Array
+	irb>> Base::Array.ancestors
+	=>[Base::Array,Array, Core::Array, Enumerable, Object, PP::ObjectMixin, Kernel]
+
+So what happens when it's four o'clock in the morning and you monkeypatch the wrong way?:
+
+	irb>> module Core::Array; def is_a?(*args); puts "dunno, i'm sleepy!"; end; end
+	nil
+	irb>> Core.adds_to Array
+	Couldn't include Core::Array into Array because the following methods conflict:
+	map
+
+Phew, that was a close one. But wait, I really do think I know what I'm doing:
+
+	irb>> Core.adds_to Array, :force=>true
+	Array
+	irb>> [1,2].is_a?(Array)
+	dunno, i'm sleepy!
+	=>nil
+	
+Hopefully you'll use the force option more wisely.	
+
+Your Core
+=========
+If you'd like to wrap your own core extensions in say the original namespace MyCore:
+	
+	MyCore.send :include, Core::Loader
+
+You'll then be able to extend classes as in the examples above, replacing Core with MyCore.
+To take advantage of the auto-requiring done by Core::Loader, place your extensions
+in a directory mycore/ and make sure your $LOAD\_PATH contains the directory mycore.
+In other words, `require 'mycore/array'` should be valid.
+
+To wrap up your methods for MyCore, see my extensions or use this template:
+
+	#in mycore/array.rb
+	module MyCore
+		#extensions for Array's
+		module Array
+			def blah
+			end
+			#....
+		end
+	end
+	
+
+Limitations
+===========
+
+Checks for method name collisions currently use *instance\_methods and *methods of a class.
+Patches for more thorough checks are welcome.
+
+Todo
+====
+
+* Support extending class methods of the extended class.
+* Import/Upgrade my old tests for my extension classes.
+* Would be nice to:
+** Provide aliasing for methods to avoid method name clashes.
+** Make it easier to share/install core extensions made by others.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "core"
+    s.description = "My extensions to core ruby classes, similar to the facets gem."
+    s.summary = s.description
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/core"
+    s.authors = ["Gabriel Horner"]
+    s.files = FileList["VERSION.yml", "Rakefile", "README.markdown", "LICENSE.txt", "{bin,lib}/**/*"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.markdown", "LICENSE.txt", "TODO.txt"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/core/array.rb

@@ -0,0 +1,105 @@
+module Core
+  module Array
+  # Allows you to specify ranges of elements and individual elements with one string, array starts at 1
+  # Example: choose first and fourth through eighth elements: '1,4-8'
+  def multislice(range,splitter=',',offset=nil)
+    #td: fix swallowing of empty lines
+    result = []
+    for r in range.split(splitter)
+    if r =~ /-/
+      min,max = r.split('-')
+      slice_min = min.to_i - 1
+      slice_min += offset if offset
+      result.push(*self.slice(slice_min, max.to_i - min.to_i + 1))
+    else
+      index = r.to_i - 1
+      index += offset if offset
+      result.push(self[index])
+    end
+    end
+    return result
+  end
+  
+  # Converts an even # of array elements ie [1,2,3,4]
+  # or an array of array pairs ie [[1,2],[3,4]] to a hash.
+  def to_hash
+    Hash[*self.flatten]
+  end
+
+  # Returns hash mapping elements to the number of times they are found in the array.
+  def count_hash
+    count = {}
+    each {|e|
+      count[e] ||= 0
+      count[e] += 1
+    }
+    count
+  end
+  
+  # Returns all possible paired permutations of elements disregarding order.
+  def permute
+    permutations = []
+    for i in (0 .. self.size - 1)
+      for j  in (i + 1 .. self.size - 1)
+        permutations.push([self[i],self[j]])
+      end
+    end
+    permutations
+  end
+  
+  # Assuming the array is an array of hashes, this returns a hash of the elements grouped by their
+  # values for the specified hash key. 
+  def group_aoh_by_key(key,parallel_array=nil)
+    group = {}
+    each_with_index {|h,i|
+      value = h[key]
+      group[value] = [] if ! group.has_key?(value)
+      group[value].push((parallel_array.nil?) ? h : parallel_array[i])
+    }
+    group
+  end
+
+  # Maps the result of calling each element with the given method name and optional arguments.
+  def mmap(methodname,*args)
+    map {|e| e.send(methodname,*args) }
+  end
+
+  # Maps the result of calling the given function name with each element as its argument.
+  def fmap(function)
+    (function =~ /\./) ?
+      map {|e| eval "#{function}(e)" } :  
+      map {|e| send(function,e) }
+  end
+
+  # Returns index of first element to match given regular expression.
+  def regindex(regex)
+    each_with_index {|e,i|
+      return i if e =~ /#{regex}/
+    }
+    nil
+  end
+
+  # Replaces element at index with values of given array.
+  def replace_index(i,array)
+    replace( (self[0, i] || []) +  array + self[i + 1 .. -1] )
+  end
+
+  # Returns true if the array includes any from the first array and excludes all from the second.
+  def include_and_exclude?(do_include,dont_include=[])
+    include_any?(do_include) && exclude_all?(dont_include)
+  end
+
+  # Returns true if it has any elements in common with the given array.
+  def include_any?(arr)
+    #good for large sets w/ few matches
+    #! Set.new(self).intersection(arr).empty?
+    arr.any? {|e| self.include?(e) }
+  end
+
+
+  # Returns true if it has no elements in common with the given array.
+  def exclude_all?(arr)
+    ! include_any?(arr)
+  end
+end
+end

data/lib/core/class.rb

@@ -0,0 +1,18 @@
+class Class
+  # Returns ancestors that aren't included modules and the class itself.
+  def real_ancestors
+    ancestors - included_modules - [self]
+  end
+
+  #Returns all objects of class.
+  def objects
+    object = []
+    ObjectSpace.each_object(self) {|e| object.push(e) }
+    object
+  end
+
+  #td: used to be :objects, change tb_* files to reflect change
+  def object_strings #:nodoc:
+    objects.map {|e| e.to_s}
+  end
+end

data/lib/core/dir.rb

@@ -0,0 +1,63 @@
+# All methods here take an optional directory argument, defaulting to the current directory.
+class Dir
+  # Returns current directory with a '/' appended.
+  def self.mpwd
+    Dir.pwd + "/"
+  end
+
+  # Returns entries from simple_entries() that are directories.
+  def self.dir_children(dirname=mpwd)
+    self.simple_entries(dirname).find_all {|e|
+      File.directory?(File.join(dirname, e))
+    }
+  end
+
+  # Returns entries from simple_entries() that are files.
+  def self.file_children(dirname=mpwd)
+    self.simple_entries(dirname).find_all {|e|
+      File.file?(File.join(dirname,e))
+    }
+  end
+
+  # Returns everything in a directory that entries() would except
+  # for '.', '..' and vim's backup files ie files ending with ~ or .sw*.
+  # You should override this method to take advantage of methods based on it.
+  def self.simple_entries(dirname=mpwd)
+    dir_files = Dir.entries(dirname)
+    files = dir_files - ['.','..'] - dir_files.grep(/~$/) - dir_files.grep(/\.sw[o-z]$/)
+  end
+
+  # Returns entries from simple_entries() that are not symlinks.
+  def self.nonlink_entries(dirname=mpwd)
+    self.simple_entries(dirname).select {|e|
+      ! File.symlink?(File.join(dirname,e))
+    }
+  end
+
+  #Returns the full paths of simple_entries().
+  def self.full_entries(dirname=mpwd)
+    self.simple_entries(dirname).map {|e| File.join(dirname,e) }
+  end
+
+  # Returns all simple_entries under a directory for the specified depth. If no depth specified
+  # it'll return all entries under the directory.
+  def self.levels_of_children(dirname=mpwd,max_level=1000)
+    @max_level = max_level
+    @level_children = []
+    self.get_level_children(dirname,0)
+    @level_children
+  end
+
+  #used recursively by levels_of_children
+  def self.get_level_children(dirname,level) #:nodoc:
+    dir_children = self.full_entries(dirname)
+    @level_children += dir_children
+    if level < @max_level
+      dir_children.each {|e|
+        if File.directory?(e)
+          self.get_level_children(e,level + 1)
+        end
+      }
+    end
+  end
+end

data/lib/core/file.rb

@@ -0,0 +1,11 @@
+class File
+  # Converts file to string.
+  def self.to_string(file)
+    IO.read(file)
+  end
+
+  # Writes string to file.
+  def self.string_to_file(string,file)
+    File.open(file,'w') {|f| f.write(string) }
+  end
+end

data/lib/core/hash.rb

@@ -0,0 +1,81 @@
+class Hash
+  # For a hash whose keys are strings of Class names, this will delete any pairs that have
+  # nonexistant class names.
+  def validate_value_klass(klass)
+    self.each {|sid,obj|
+      if obj.class != Object.const_get(klass)
+        warn "object of '#{sid}' not a #{klass}"
+        self.delete(sid)
+      end
+    }
+  end  
+
+  # Returns a hash which will set its values by calling each value with the given method and optional argument.
+  # If a block is passed, each value will be set the value returned by its block call.
+  def vmap(arg=nil,method='[]',&block)
+    new = {}
+    if block
+      self.each {|k,v|
+        v1 = yield(k,v)
+        new[k] = v1
+      }
+    else  
+      self.each {|k,v|
+        new[k] = arg.nil? ? v.send(method) : v.send(method,arg)
+      }
+    end
+    new
+  end
+  
+  # Same as vmap() but merges its results with the existing hash.
+  def vmap!(*args,&block)
+    self.update(vmap(*args,&block))
+  end
+
+  # For a hash whose values are arrays, this will return a hash with each value substituted by the
+  # size of the value.
+  def vsize
+    vmap(nil,'size')
+  end
+
+  # Same as pass_keys!() but replaces the hash with the resulting hash.
+  def only_keep(arr=[],opt={})
+    delete_keys!(self.keys - arr,opt)
+  end
+
+  def delete_keys!(arr=[],opt={}) #:nodoc:
+    deleted = {}
+    arr.each {|e| 
+      puts "deleting #{e}" if opt[:verbose]
+      deleted[e] = self.delete(e) if has_key?(e)
+    }
+    deleted
+  end
+  
+  # Returns a subset of the hash for the specified keys. These entries will be deleted from the
+  # original hash.
+  def pass_keys!(*keys)
+    delete_keys!(keys)
+  end
+
+  # For a hash whose values are arrays, this will set each unique element in a value array as a key
+  # and set its values to all the keys it occurred in.
+  # This is useful when modeling one to many relationships with keys
+  # and values.
+  def transform_many
+    b = {}
+    each {|k,arr| 
+      #raise "#{arr.inspect} not an Array" if arr.class != Array
+      arr = [arr] if arr.class != Array
+      arr.each {|e| 
+        b.has_key?(e) ? b[e].push(k) : b[e] = [k]
+      }
+    }
+    b
+  end
+
+  #Sorts hash by values, returning them as an array of array pairs.
+  def vsort
+    sort { |a,b| b[1]<=>a[1] }
+  end
+end

data/lib/core/io.rb

@@ -0,0 +1,21 @@
+class IO
+  #Returns array of lines up until the given string matches a line of the file.
+  def self.read_until(file,string)
+    f = self.readlines(file)
+    i = f.index(string) || 100000
+    f.slice(0,i)
+  end
+  
+  #from output_catcher gem
+  def self.capture_stdout(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+  
+end

data/lib/core/irb.rb

@@ -0,0 +1,29 @@
+#from http://errtheblog.com/posts/9-drop-to-irb
+# call with IRB.start_session(Kernel.binding) in script
+require 'irb'
+
+module IRB
+  def self.start_session(binding)
+    IRB.setup(nil)
+
+    workspace = WorkSpace.new(binding)
+
+    if @CONF[:SCRIPT]
+      irb = Irb.new(workspace, @CONF[:SCRIPT])
+    else
+      irb = Irb.new(workspace)
+    end
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+

data/lib/core/object.rb

@@ -0,0 +1,19 @@
+class Object
+  # A more versatile for of Object.const_get.
+  # Retrieves constant for given string, even if it's nested under classes.
+  def self.any_const_get(name)
+    begin
+    klass = Object
+    name.split('::').each {|e|
+      klass = klass.const_get(e)
+    }
+    klass
+    rescue; nil; end
+  end
+
+  #Reloads a file just as you would require it.
+  def reload(filename)
+    $".delete(filename + ".rb")
+    require(filename)
+  end
+end

data/lib/core/string.rb

@@ -0,0 +1,12 @@
+class String
+  # Counts # of times the given string is in the string. This is unlike String.count which
+  # only counts the given characters.
+  def count_any(str)
+    count = 0
+    self.gsub(str) {|s| 
+      count += 1
+      str
+    }
+    count
+  end
+end

data/lib/core.rb

@@ -0,0 +1,69 @@
+$:.unshift(File.dirname(__FILE__)) unless 
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+module Core
+  module Loader    
+    def self.included(base)
+      base.extend(self)
+    end
+    
+    def adds_to(klass, options = {})
+      unless (extension_klass = options[:with] || get_extension_class(klass))
+        puts "No #{self} extension class found"
+        return false
+      end
+      conflicts = check_for_conflicts(klass, extension_klass)
+      if conflicts.empty? || options[:force]
+        klass.send :include, extension_klass
+      else
+        puts "Couldn't include #{extension_klass} into #{klass} because the following methods conflict:"
+        puts conflicts.sort.join(", ")
+        false
+      end
+    end
+    alias_method :add_to, :adds_to
+    
+    def detect_extension_class(klass)
+      extension_klass = self.const_get(klass.to_s) rescue nil
+      extension_klass = nil if extension_klass == klass
+      extension_klass
+    end
+    
+    def get_extension_class(klass)
+      unless (extension_klass = detect_extension_class(klass))
+        #try again but first by requiring possible file
+        begin; require("#{self.to_s.gsub('::','/').downcase}/#{klass.to_s.downcase}"); rescue(LoadError); end
+        extension_klass = detect_extension_class(klass)
+      end
+      extension_klass
+    end
+  
+    def check_for_conflicts(klass, extension_klass)
+      if false #TODO: extension_klass.to_s =~ /ClassMethods/
+      else
+        all_instance_methods(klass) & all_instance_methods(extension_klass)
+      end
+    end
+  
+    def all_instance_methods(klass)
+      klass.public_instance_methods + klass.private_instance_methods + klass.protected_instance_methods
+    end
+  end
+end
+
+Core.send :include, Core::Loader
+
+__END__
+
+#extend Array with Core::Array's ClassMethods + InstanceMethods
+Core.adds_to Array
+
+#extend MyArray from file
+class My::Array
+  Core.adds_to self
+end
+
+#from console
+Core.adds_to My::Array
+
+#extend Array only with ClassMethods
+Core.adds_to Array, :from=>Core::Array::ClassMethods

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-core
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: My extensions to core ruby classes, similar to the facets gem.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE.txt
+- TODO.txt
+files: 
+- VERSION.yml
+- Rakefile
+- README.markdown
+- LICENSE.txt
+- lib/core
+- lib/core/array.rb
+- lib/core/class.rb
+- lib/core/dir.rb
+- lib/core/file.rb
+- lib/core/hash.rb
+- lib/core/io.rb
+- lib/core/irb.rb
+- lib/core/object.rb
+- lib/core/string.rb
+- lib/core.rb
+- TODO.txt
+has_rdoc: true
+homepage: http://github.com/cldwalker/core
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: My extensions to core ruby classes, similar to the facets gem.
+test_files: []
+