cldwalker-my_core 0.1.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2009 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.rdoc

@@ -0,0 +1,31 @@
+== Description
+
+My collection of extensions to Ruby's core and stdlib classes.
+
+== Install
+
+    gem install cldwalker-my_core -s http://github.com/cldwalker/my_core
+
+== Usage
+
+Since all these extensions are wrapped in modules you need to require
+the extension you want and then include/extend it into your desired class.
+I don't automatically monkeypatch your classes. You have the choice
+to monkeypatch or not.
+
+To use the instance methods of my Array extension.
+
+  require 'my_core/object'
+  Object.send :include, MyCore::Array
+
+To use the class methods of my File extension.
+
+  require 'my_core/file'
+  Object.send :extend, MyCore::File
+
+If you'd like a more convient way of loading multiple extensions in this library,
+see my core gem: http://github.com/cldwalker/core .
+
+== Todo
+
+Tests!

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 = "my_core"
+    s.description = "My extensions to core ruby classes, similar to activesupport and facets gems."
+    s.summary = s.description
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/my_core"
+    s.authors = ["Gabriel Horner"]
+    s.files = FileList["VERSION.yml", "Rakefile", "README.rdoc", "LICENSE.txt", "{bin,lib}/**/*"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.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/my_core.rb

@@ -0,0 +1,5 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module MyCore
+end

data/lib/my_core/array.rb

@@ -0,0 +1,116 @@
+module MyCore
+  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
+
+    # A real array def, not a set diff
+    # a1 = [1,1,2]
+    # a2 = [1,2]
+    # a1 - a2 #=> []
+    # a1.diff(a2) #=> [1]
+    def diff(other)
+      list = self.dup
+      other.each { |elem| list.delete_at( list.index(elem) ) }
+      list
+    end
+  end
+end

data/lib/my_core/class.rb

@@ -0,0 +1,33 @@
+module MyCore
+  module 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
+
+    def eigenclass
+      instance_eval("class << self; self; end")
+    end
+
+    # gaining temporary access to private methods
+    # http://blog.jayfields.com/2007/11/ruby-testing-private-methods.html
+    def publicize_methods
+      saved_private_instance_methods = self.private_instance_methods
+      self.class_eval { public *saved_private_instance_methods }
+      yield
+      self.class_eval { private *saved_private_instance_methods }
+    end
+  end
+end

data/lib/my_core/dir.rb

@@ -0,0 +1,67 @@
+# All methods here take an optional directory argument, defaulting to the current directory.
+module MyCore
+  module Dir
+    module ClassMethods
+      # Returns current directory with a '/' appended.
+      def mpwd
+        ::Dir.pwd + "/"
+      end
+
+      # Returns entries from simple_entries() that are directories.
+      def dir_children(dirname=mpwd)
+        simple_entries(dirname).find_all {|e|
+          File.directory?(File.join(dirname, e))
+        }
+      end
+
+      # Returns entries from simple_entries() that are files.
+      def file_children(dirname=mpwd)
+        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 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 nonlink_entries(dirname=mpwd)
+        simple_entries(dirname).select {|e|
+          ! File.symlink?(File.join(dirname,e))
+        }
+      end
+
+      #Returns the full paths of simple_entries().
+      def full_entries(dirname=mpwd)
+        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 levels_of_children(dirname=mpwd,max_level=1000)
+        @max_level = max_level
+        @level_children = []
+        get_level_children(dirname,0)
+        @level_children
+      end
+
+      #used recursively by levels_of_children
+      def get_level_children(dirname,level) #:nodoc:
+        dir_children = full_entries(dirname)
+        @level_children += dir_children
+        if level < @max_level
+          dir_children.each {|e|
+            if File.directory?(e)
+              get_level_children(e,level + 1)
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/my_core/file.rb

@@ -0,0 +1,25 @@
+module MyCore
+  module File
+    module ClassMethods
+      # Converts file to string.
+      def to_string(file)
+        IO.read(file)
+      end
+
+      # Writes string to file.
+      def string_to_file(string,file)
+        File.open(file,'w') {|f| f.write(string) }
+      end
+      
+      #mac only: http://stream.btucker.org/post/65635235/file-creation-date-in-ruby-on-macs
+      def creation_time(file)
+        require 'open3'
+        require 'time'
+         Time.parse( Open3.popen3("mdls", 
+          "-name","kMDItemContentCreationDate", 
+          "-raw", file)[1].read)
+      end
+      
+    end
+  end
+end

data/lib/my_core/hash.rb

@@ -0,0 +1,83 @@
+module MyCore
+  module 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
+end

data/lib/my_core/io.rb

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

data/lib/my_core/irb.rb

@@ -0,0 +1,31 @@
+#from http://errtheblog.com/posts/9-drop-to-irb
+# call with IRB.start_session(Kernel.binding) in script
+require 'irb'
+
+module IRB
+  module ClassMethods
+    def 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
+end
+

data/lib/my_core/object.rb

@@ -0,0 +1,33 @@
+module MyCore
+  module Object
+    
+    module ClassMethods
+      # A more versatile version of Object.const_get.
+      # Retrieves constant for given string, even if it's nested under classes.
+      def any_const_get(name)
+        begin
+          klass = Object
+          name.split('::').each {|e|
+            klass = klass.const_get(e)
+          }
+          klass
+        rescue; nil; end
+      end
+    end
+
+    #Reloads a file just as you would require it.
+    def reload(filename)
+      $".delete(filename + ".rb")
+      require(filename)
+    end
+
+    # list methods which aren't in superclass
+    def local_methods(obj = self)
+      (obj.methods - obj.class.superclass.instance_methods).sort
+    end
+
+    def backtick(cmd,*args)
+      IO.popen('-') {|f| f ? f.read : exec(cmd,*args)}
+    end
+  end
+end

data/lib/my_core/open_struct.rb

@@ -0,0 +1,22 @@
+require 'ostruct'
+
+# Explained http://tagaholic.blogspot.com/2009/01/simple-block-to-hash-conversion-for.html
+module MyCore
+  module OpenStruct
+    module ClassMethods
+      def block_to_hash(block=nil)
+        config = self.new
+        if block
+          block.call(config)
+          config.to_hash
+        else
+          {}
+        end
+      end
+    end
+
+    def to_hash
+      @table
+    end
+  end
+end

data/lib/my_core/regexp.rb

@@ -0,0 +1,17 @@
+module MyCore
+  module Regexp
+    # Convenience method on Regexp so you can do
+    # /an/.show_match("banana")
+    # stolen from the pickaxe
+    def show_regexp(a, re)
+       if a =~ re
+          "#{$`}<<#{$&}>>#{$'}"
+       else
+          "no match"
+       end
+    end
+    def show_match(a)
+      show_regexp(a, self)
+    end
+  end
+end

data/lib/my_core/string.rb

@@ -0,0 +1,14 @@
+module MyCore
+  module 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
+end

data/lib/my_core/symbol.rb

@@ -0,0 +1,8 @@
+module MyCore
+  module Symbol
+    # Enable items.map(&:name) a la Rails
+    def to_proc
+      lambda {|*args| args.shift.__send__(self, *args)}
+    end
+  end 
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-my_core
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-02 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: My extensions to core ruby classes, similar to activesupport and facets gems.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+files: 
+- VERSION.yml
+- Rakefile
+- README.rdoc
+- LICENSE.txt
+- lib/my_core
+- lib/my_core/array.rb
+- lib/my_core/class.rb
+- lib/my_core/dir.rb
+- lib/my_core/file.rb
+- lib/my_core/hash.rb
+- lib/my_core/io.rb
+- lib/my_core/irb.rb
+- lib/my_core/object.rb
+- lib/my_core/open_struct.rb
+- lib/my_core/regexp.rb
+- lib/my_core/string.rb
+- lib/my_core/symbol.rb
+- lib/my_core.rb
+has_rdoc: true
+homepage: http://github.com/cldwalker/my_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 activesupport and facets gems.
+test_files: []
+