tduehr-libmatty 0.9.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.9.0 / 2009-05-10
+
+* initial github commit

data/README.txt

@@ -0,0 +1,28 @@
+libmatty
+    by Matasano Security, LLC
+    http://matasano.com/log
+
+== DESCRIPTION:
+
+Standard Matasano ruby extensions library
+
+== FEATURES/PROBLEMS:
+
+* Every time we ask "Why isn't this in the standard library?" we add it to this.
+
+== SYNOPSIS:
+
+  require 'libmatty' # load everything
+  require 'libmatty/string'
+
+== REQUIREMENTS:
+
+* most of the extensions have no requirements
+
+* exceptions:
+  *
+
+== INSTALL:
+
+* sudo gem install libmatty
+

data/Rakefile

@@ -0,0 +1,35 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'libmatty'
+
+task :default => 'spec:run'
+
+PROJ.name = 'libmatty'
+PROJ.ignore_file = '.gitignore'
+PROJ.authors = 'Matasano Security, LLC'
+PROJ.email = 'td@matasano.com'
+PROJ.description = 'Stanard Matasano extensions library for ruby'
+PROJ.url = 'http://github.com/tduehr/libmatty/tree/master'
+PROJ.version = Libmatty::VERSION
+# PROJ.rubyforge.name = 'libmatty'
+
+PROJ.spec.opts << '--color'
+
+PROJ.rdoc.opts << '--inline-source'
+PROJ.rdoc.opts << '--line-numbers'
+
+# EOF

data/bin/libmatty

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib libmatty]))
+
+# Put your code here
+
+# EOF

data/lib/libmatty.rb

@@ -0,0 +1,49 @@
+
+module Libmatty
+
+  # :stopdoc:
+  VERSION = '0.9.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module Libmatty
+
+Libmatty.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/libmatty/array.rb

@@ -0,0 +1,42 @@
+class Array
+    module ArrayExtensions
+        # Assume an array of key, value tuples, and convert to Hash
+        def to_hash
+            r = {}
+            each {|it| r[it[0]] = it[1]}
+            return r
+        end
+
+        def kind_of_these? y
+            inject(false) {|acc, klass| acc || y.kind_of?(klass)}
+        end
+
+        # return first hash-like element with key k
+        def kassoc(k)
+            each { |h| return h if h.try(:has_key?, k) }
+            return nil
+        end
+
+        # return first hash-like element with value v
+        def vassoc(v)
+            each { |h| return h if h.try(:has_value?, v) }
+            return nil
+        end
+
+        def extract_options!
+            last.is_a?(::Hash) ? pop : {}
+        end
+
+        def strip(*args)
+            list=[]
+
+            self.each_with_index do | e, i |
+                if(not args.member?(i))
+                    list << e
+                end
+            end
+            return list
+        end
+    end
+    include ArrayExtensions
+end

data/lib/libmatty/class.rb

@@ -0,0 +1,167 @@
+class Class
+    module ClassExtensions
+        # Also crazy that this isn't in the library
+        def inherits_from?(klass)
+            return true if self == klass
+            return true if self.superclass == klass
+            return false if self.superclass == Object
+
+            rec = lambda do |x|
+                if x == Object
+                    false
+                elsif x == klass
+                    true
+                else
+                    rec.call(x.superclass)
+                end
+            end
+
+            rec.call(self)
+        end
+
+        def alias_cmethod(to, from)
+            (class << self;self;end).class_eval {
+                define_method to do |*args|
+                    send(from, *args)
+                end
+            }
+        end
+
+
+        # Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+        # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+        # to, for example, an array without those additions being shared with either their parent, siblings, or
+        # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+        def class_inheritable_reader(*syms)
+            syms.each do |sym|
+                next if sym.is_a?(Hash)
+                class_eval <<-EOS
+def self.#{sym}
+    read_inheritable_attribute(:#{sym})
+end
+
+def #{sym}
+    self.class.#{sym}
+end
+EOS
+             end
+       end
+
+        def class_inheritable_writer(*syms)
+            options = syms.extract_options!
+            syms.each do |sym|
+                class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+       EOS
+          end
+       end
+
+       def class_inheritable_array_writer(*syms)
+           options = syms.extract_options!
+           syms.each do |sym|
+               class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+          end
+      end
+
+        def class_inheritable_hash_writer(*syms)
+            options = syms.extract_options!
+            syms.each do |sym|
+                class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+            end
+        end
+
+        def class_inheritable_accessor(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_writer(*syms)
+        end
+
+        def class_inheritable_array(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_array_writer(*syms)
+        end
+
+        def class_inheritable_hash(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_hash_writer(*syms)
+        end
+
+        def inheritable_attributes
+            @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+        end
+
+        def write_inheritable_attribute(key, value)
+            if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+                @inheritable_attributes = {}
+            end
+            inheritable_attributes[key] = value
+        end
+
+        def write_inheritable_array(key, elements)
+            write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+            write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+        end
+
+        def write_inheritable_hash(key, hash)
+            write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+            write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+        end
+
+        def read_inheritable_attribute(key)
+            inheritable_attributes[key]
+        end
+
+        def reset_inheritable_attributes
+            @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+        end
+private
+
+        # Prevent this constant from being created multiple times
+        EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+        def inherited_with_inheritable_attributes(child)
+            inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+            if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+                new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+            else
+                new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+                    memo.update(key => value.duplicable? ? value.dup : value)
+                end
+            end
+
+            child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+        end
+    end
+
+    include ClassExtensions
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/libmatty/dir.rb

@@ -0,0 +1,23 @@
+class Dir
+  module DirExtensions
+    module ClassMethods
+      # as with shell pushd/popd
+      ##
+      def with_dir(d)
+        begin
+          o = Dir.getwd
+          Dir.chdir(d)
+          yield
+        rescue
+          raise
+        ensure
+          Dir.chdir(o)
+        end
+      end
+    end
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+  include DirExtensions
+end

data/lib/libmatty/duplicable.rb

@@ -0,0 +1,39 @@
+class Object
+    # Can you safely .dup this object?
+    # False for nil, false, true, symbols, and numbers; true otherwise.
+    # TODO: Should be done the other way around not all that will ever
+    # inherit from Object can be dupped
+    def duplicable?
+        true
+    end
+end
+
+class NilClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class FalseClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class TrueClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class Symbol #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class Numeric #:nodoc:
+    def duplicable?
+        false
+    end
+end

data/lib/libmatty/enumerable.rb

@@ -0,0 +1,16 @@
+module Enumerable
+  module EnumerableExtensions
+    def each_recursive(&block)
+      self.each do |n|
+        block.call(n)
+        n.each_recursive(&block) if n.kind_of? Array or n.kind_of? Hash
+      end
+    end
+    
+    # return a random selection from any list of anything XXX
+    def choice
+      rand
+    end
+  end
+  include EnumerableExtensions
+end

data/lib/libmatty/file.rb

@@ -0,0 +1,32 @@
+class File
+    module FileExtensions
+        module ClassMethods
+            def mkfifo(name, mode="666", open_mode="r")
+                if File.exists? name and File.pipe? name # Leftover from before
+                    File.delete name
+                end
+
+                # apalling, but ruby/dl has x-p problems
+                if ! File.exists? name
+                    `mkfifo -m #{ mode } #{ name }`
+                end
+
+                return File.open(name, open_mode)
+            end
+            
+            # returns the contents of a file
+            def slurp(fn)
+                ret = nil
+                File.open(fn, "r") do |f|
+                    ret = f.read()
+                end
+                return ret
+            end
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+    end
+    include FileExtensions
+end