ckuru-tools 0.0.7 → 0.0.9

data/lib/ckuru-tools.rb

@@ -44,6 +44,72 @@ EOF
 
   module CkuruTools
 
+    def self.parameters(h,*args)
+      raise ArgumentError.new("argument to #{self.class}##{current_method} must be of class Hash; you may get this error if you don't call a function with a hash; check the initial call") unless h.is_a? Hash
+      ret = []
+      args.each do |a|
+        name,options = a
+        options = options || {}
+        unless h[:no_recurse]
+          vals = only_these_parameters(
+                                       options.merge!(:no_recurse => true),
+                                       [:instance_that_inherits_from, {:instance_of => Class}],
+                                       [:instance_of, {:instance_of => Class}],
+                                       [:klass_that_inherits_from, {:instance_of => Class}],
+                                       [:klass_of, {:instance_of => Class}],
+                                       [:no_recurse, {:instance_of => TrueClass}],
+                                       [:required, {:instance_of => TrueClass}],
+                                       [:default, {:instance_of => TrueClass}]
+                                       )
+          instance_that_inherits_from, instance_of, klass_that_inherits_from, klass_of, no_recurse, required, default = vals
+        end
+
+        if val = h[name]
+          if instance_that_inherits_from 
+            unless val.class.inherits_from? instance_that_inherits_from
+              raise ArgumentError.new(
+                                      "argument :#{name} to #{self.class}##{calling_method} must be an instance that inherits from #{instance_that_inherits_from}, #{val.class} does not") 
+            end
+          elsif instance_of
+            unless val.class == instance_of
+              raise ArgumentError.new(
+                                      "argument :#{name} to #{self.class}##{calling_method} must be an instance of class #{instance_of}, not #{val.class}")
+            end
+          elsif klass_that_inherits_from
+            unless val.inherits_from? klass_that_inherits_from
+              raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must inherits from class #{klass_that_inherits_from}, #{val} does not") 
+            end
+          elsif klass_of
+            unless val == klass_to
+              raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must be of class #{klass_of}, not #{val}") 
+            end
+          end
+        else
+          if options[:default]
+            val = options[:default]
+          elsif options[:required]
+            raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} is required")
+          end
+        end
+        ret.push val
+      end
+      ret
+    end
+
+
+    def self.only_these_parameters(h,*args)
+      ret = parameters(h,*args)
+      keys = h.keys
+      args.each do |a|
+        name,options = a
+        keys.delete name
+      end
+      if keys.length > 0
+        raise ArgumentError.new("unknown parameters #{keys.inspect} passed to #{self.class}##{calling_method}")
+      end
+      ret
+    end
+
     def self.validate_hash_arguments(h,*args)
       raise ArgumentError.new("argument to #{current_method} must be of class Hash") unless h.is_a? Hash
       ret = []
@@ -80,7 +146,7 @@ EOF
               raise ArgumentError.new("argument :#{name} to #{calling_method} must inherits from class #{klass_that_inherits_from}, #{val} does not") 
             end
           elsif klass_of
-            unless val == klass              
+            unless val == klass_of
               raise ArgumentError.new("argument :#{name} to #{calling_method} must be of class #{klass_of}, not #{val}") 
             end
           end
@@ -175,69 +241,12 @@ EOF
       #       view = parameters(h,[:view,{:klass => View,:required => true}])
 
       def parameters(h,*args)
-        raise ArgumentError.new("argument to #{self.class}##{current_method} must be of class Hash") unless h.is_a? Hash
-        ret = []
-        args.each do |a|
-          name,options = a
-          options = options || {}
-          unless h[:no_recurse]
-            vals = only_these_parameters(
-              options.merge!(:no_recurse => true),
-              [:instance_that_inherits_from, {:instance_of => Class}],
-              [:instance_of, {:instance_of => Class}],
-              [:klass_that_inherits_from, {:instance_of => Class}],
-              [:klass_of, {:instance_of => Class}],
-              [:no_recurse, {:instance_of => TrueClass}],
-              [:required, {:instance_of => TrueClass}],
-              [:default, {:instance_of => TrueClass}]
-              )
-            instance_that_inherits_from, instance_of, klass_that_inherits_from, klass_of, no_recurse, required, default = vals
-          end
-
-          if val = h[name]
-            if instance_that_inherits_from 
-              unless val.class.inherits_from? instance_that_inherits_from
-                raise ArgumentError.new(
-                  "argument :#{name} to #{self.class}##{calling_method} must be an instance that inherits from #{instance_that_inherits_from}, #{val.class} does not") 
-              end
-            elsif instance_of
-              unless val.class == instance_of
-                raise ArgumentError.new(
-                  "argument :#{name} to #{self.class}##{calling_method} must be an instance of class #{instance_of}, not #{val.class}")
-              end
-            elsif klass_that_inherits_from
-              unless val.inherits_from? klass
-                raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must inherits from class #{klass_that_inherits_from}, #{val} does not") 
-              end
-            elsif klass_of
-              unless val == klass              
-                raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must be of class #{klass_of}, not #{val}") 
-              end
-            end
-          else
-            if options[:default]
-              val = options[:default]
-            elsif options[:required]
-              raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} is required")
-            end
-          end
-          ret.push val
-        end
-        ret
+        CkuruTools.parameters(h,args)
       end
 
       # insure that only the defined parameters have been passed to a function
       def only_these_parameters(h,*args)
-        ret = parameters(h,*args)
-        keys = h.keys
-        args.each do |a|
-          name,options = a
-          keys.delete name
-        end
-        if keys.length > 0
-          raise ArgumentError.new("unknown parameters #{keys.inspect} passed to #{self.class}##{calling_method}")
-        end
-        ret
+        CkuruTools.only_these_parameters(h,args)
       end
 
 
@@ -399,6 +408,7 @@ EOF
             require 'ruby-debug'
           end
         end
+        raise "sorry ...exiting"
       end
     end
 

data/lib/ckuru-tools.rb~

@@ -0,0 +1,490 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? CkuruTools
+
+  class Module
+    def instance_of_class_accessor( klass, *symbols )
+
+      symbols.each do |symbol|
+        module_eval( "def #{symbol}() @#{symbol}; end" )
+        module_eval( "def #{symbol}=(val) raise ArgumentError.new('#{symbol} must be a #{klass}') unless val.class.inherits_from? #{klass} ; @#{symbol} = val; end" )
+      end
+    end
+    def class_accessor( klass, *symbols )
+      symbols.each do |symbol|
+        module_eval( "def #{symbol}() @#{symbol}; end" )
+        module_eval( "
+def #{symbol}=(val) 
+  raise ArgumentError.new('argument to #{symbol} must be a class') unless val.is_a? Class
+  raise ArgumentError.new('#{symbol} must be a #{klass}') unless val.inherits_from? #{klass} 
+  @#{symbol} = val
+end" )
+      end
+    end
+
+      # raise ArgumentError.new("assignment must be of class CkuruTools::TypedArray, not \#{arr.class}") unless arr.instance_inherits_from? CkuruTools::TypedArray 
+      # raise ArgumentError.new("TypedArray must require #{klass}") unless arr.required_type == #{klass}
+    def typed_array_accessor(klass,*symbols)
+      symbols.each do |symbol|
+        module_eval( "def #{symbol}() @#{symbol}; end" )
+        module_eval <<"EOF"
+    def #{symbol}=(arr)
+      @#{symbol} = CkuruTools::TypedArray.new(#{klass})
+      arr.each do |elem|
+        @#{symbol}.push elem
+      end
+      @#{symbol}
+    end
+EOF
+      end
+    end
+  end
+
+  module CkuruTools
+
+    def self.validate_hash_arguments(h,*args)
+      raise ArgumentError.new("argument to #{current_method} must be of class Hash") unless h.is_a? Hash
+      ret = []
+      args.each do |a|
+        name,options = a
+        options = options || {}
+        unless h[:no_recurse]
+          vals = only_these_parameters(
+            options.merge!(:no_recurse => true),
+            [:instance_that_inherits_from, {:instance_of => Class}],
+            [:instance_of, {:instance_of => Class}],
+            [:klass_that_inherits_from, {:instance_of => Class}],
+            [:klass_of, {:instance_of => Class}],
+            [:no_recurse, {:instance_of => TrueClass}],
+            [:required, {:instance_of => TrueClass}],
+            [:default, {:instance_of => TrueClass}]
+            )
+          instance_that_inherits_from, instance_of, klass_that_inherits_from, klass_of, no_recurse, required, default = vals
+        end
+
+        if val = h[name]
+          if instance_that_inherits_from 
+            unless val.class.inherits_from? instance_that_inherits_from
+              raise ArgumentError.new(
+                "argument :#{name} to #{calling_method} must be an instance that inherits from #{instance_that_inherits_from}, #{val.class} does not") 
+            end
+          elsif instance_of
+            unless val.class == instance_of
+              raise ArgumentError.new(
+                "argument :#{name} to #{calling_method} must be an instance of class #{instance_of}, not #{val.class}")
+            end
+          elsif klass_that_inherits_from
+            unless val.inherits_from? klass
+              raise ArgumentError.new("argument :#{name} to #{calling_method} must inherits from class #{klass_that_inherits_from}, #{val} does not") 
+            end
+          elsif klass_of
+            unless val == klass_of
+              raise ArgumentError.new("argument :#{name} to #{calling_method} must be of class #{klass_of}, not #{val}") 
+            end
+          end
+        else
+          if options[:default]
+            val = options[:default]
+          elsif options[:required]
+            raise ArgumentError.new("argument :#{name} to #{calling_method} is required")
+          end
+        end
+        ret.push val
+      end
+      ret
+    end
+
+
+    def self.class_space
+      ret = TypedArray.new(Class)
+      ObjectSpace.each_object {|x| ret.push(x) if x.is_a? Class}
+      ret.uniq
+    end
+
+    # :stopdoc:
+    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)
+    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)
+    end
+
+    # Utility method used to rquire 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
+
+    #
+    # extending HashInitalizerClass enables you to get Object.new(hash) functionality
+    # where each key will dispatch to an object setter method.
+    #
+    # Usage:
+    #
+    # class MyClass < HashInitalizerClass
+    # ..attr_accessor :foo
+    # end
+    #
+    # m = MyClass(:foo => "bar")
+    # m.foo
+    # => "bar"
+    #
+    #
+    
+    class HashInitializerClass
+      # check for required attributes
+      def required_attributes(*symbols)
+        symbols.each do |symbol|
+          raise ArgumentError.new("attribute :#{symbol} must be set in #{self.class}.initialize") if self.send(symbol).nil?
+        end
+      end
+      
+      # parse and return parameters from a hash
+      #
+      #       view = only_these_parameters(h,[:view,{:klass => View,:required => true}])
+      # or
+      #
+      #       view = parameters(h,[:view,{:klass => View,:required => true}])
+
+      def parameters(h,*args)
+        raise ArgumentError.new("argument to #{self.class}##{current_method} must be of class Hash; you may get this error if you don't call a function with a hash; check the initial call") unless h.is_a? Hash
+        ret = []
+        args.each do |a|
+          name,options = a
+          options = options || {}
+          unless h[:no_recurse]
+            vals = only_these_parameters(
+              options.merge!(:no_recurse => true),
+              [:instance_that_inherits_from, {:instance_of => Class}],
+              [:instance_of, {:instance_of => Class}],
+              [:klass_that_inherits_from, {:instance_of => Class}],
+              [:klass_of, {:instance_of => Class}],
+              [:no_recurse, {:instance_of => TrueClass}],
+              [:required, {:instance_of => TrueClass}],
+              [:default, {:instance_of => TrueClass}]
+              )
+            instance_that_inherits_from, instance_of, klass_that_inherits_from, klass_of, no_recurse, required, default = vals
+          end
+
+          if val = h[name]
+            if instance_that_inherits_from 
+              unless val.class.inherits_from? instance_that_inherits_from
+                raise ArgumentError.new(
+                  "argument :#{name} to #{self.class}##{calling_method} must be an instance that inherits from #{instance_that_inherits_from}, #{val.class} does not") 
+              end
+            elsif instance_of
+              unless val.class == instance_of
+                raise ArgumentError.new(
+                  "argument :#{name} to #{self.class}##{calling_method} must be an instance of class #{instance_of}, not #{val.class}")
+              end
+            elsif klass_that_inherits_from
+              unless val.inherits_from? klass_that_inherits_from
+                raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must inherits from class #{klass_that_inherits_from}, #{val} does not") 
+              end
+            elsif klass_of
+              unless val == klass_to
+                raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} must be of class #{klass_of}, not #{val}") 
+              end
+            end
+          else
+            if options[:default]
+              val = options[:default]
+            elsif options[:required]
+              raise ArgumentError.new("argument :#{name} to #{self.class}##{calling_method} is required")
+            end
+          end
+          ret.push val
+        end
+        ret
+      end
+
+      # insure that only the defined parameters have been passed to a function
+      def only_these_parameters(h,*args)
+        ret = parameters(h,*args)
+        keys = h.keys
+        args.each do |a|
+          name,options = a
+          keys.delete name
+        end
+        if keys.length > 0
+          raise ArgumentError.new("unknown parameters #{keys.inspect} passed to #{self.class}##{calling_method}")
+        end
+        ret
+      end
+
+
+      def initialize(h={})
+        raise ArgumentError.new("argument to #{self.class}##{current_method} must be of class Hash") unless h.is_a? Hash
+        h.keys.each do |k|
+          self.send("#{k}=",h[k])
+        end
+
+        yield self if block_given?
+      end
+    end
+
+  end  # module CkuruTools
+
+  CkuruTools.require_all_libs_relative_to __FILE__
+  CkuruTools.require_all_libs_relative_to CkuruTools.libpath
+
+  #
+  # class Foo < ActiveRecord::Base
+  # end
+  # 
+  # Foo.inherits_from? ActiveRecord::Base      
+  # => true
+  # 
+  class Class
+
+    # show's live decendants of this class
+    def decendants
+      CkuruTools.class_space.select {|x| x.inherits_from? self and x != self}
+    end
+      
+    def inherits_from?(klass)
+      raise ArgumentError.new("argument must be of type Class") unless klass.is_a? Class
+      if klass == self
+        true
+      elsif self.superclass.is_a? Class
+        self.superclass.inherits_from? klass
+      else
+        false
+      end
+    end
+  end
+
+  class Array
+    def to_comma_separated_string
+      ret = ''
+      self.each do |elem|
+        ret += ',' if ret.length > 0
+        ret += elem.to_s
+      end
+      ret
+    end
+  end
+
+  class Object
+    # this method allows a an 'initialize' method to define itself as a abstract class; yet still run some code. 
+    #
+    # To use effectively place at the last line of an initialize method like so:
+    #
+    #  class DataSource < ::CkuruTools::HashInitializerClass
+    #    def initialize(h={})
+    #      super h
+    #      this_is_an_abstract_constructor_for AuraVisualize::DataSource
+    #    end
+    #  end
+
+    def this_is_an_abstract_constructor_for(klass)
+      unless self.class.superclass.inherits_from? klass # abstract constructor
+        str = ''
+        self.class.decendants.each do |d|
+          str += "#{d}\n"
+        end
+        raise <<"EOF" 
+Do not call method of #{self.class}.#{calling_method} directly, you must instantiate a base class.
+
+Maybe you want one of these?:
+
+#{str}
+EOF
+      end
+    end
+      
+    # see if this object's class inherits from another class
+    def instance_inherits_from?(klass)
+      self.class.inherits_from?(klass)
+    end
+
+    def _require ; each {|r| require r } ; end
+
+    def docmd(cmd,dir=nil)
+      ret = docmdi(cmd,dir)
+      if ret.exitstatus != 0
+        raise "cmd #{cmd} exitstatus #{ret.exitstatus} : #{ret}"
+      end
+      ret
+    end
+
+    def docmdi(cmd,dir=nil)
+      if dir
+        unless Dir.chdir(dir) 
+          ckebug 0, "failed to cd to #{dir}"
+          return nil
+        end
+      end
+      ret = msg_exec "running #{cmd}" do
+        cmd.gsub!(/\\/,"\\\\\\\\\\\\\\\\")
+        cmd.gsub!(/\'/,"\\\\'")
+        cmd.gsub!(/\"/,"\\\\\\\\\\\"")
+        system("bash -c \"#{cmd}\"")
+        if $?.exitstatus != 0 
+          print " failed exit code #{$?.exitstatus} "
+        end
+      end
+      $?
+    end
+        
+    ################################################################################
+
+    def docmd_dir(h={})
+      ret = nil
+      if h[:dir]
+        unless Dir.chdir(h[:dir]) 
+          ckebug 0, "failed to cd to #{h[:dir]}"
+          return nil
+        end
+      end
+      if h[:commands]
+        h[:commands].each do |cmd|
+          ret = docmd(cmd)
+          if ret.exitstatus != 0
+            ckebug 0, "giving up"
+            return ret
+          end
+        end
+      end
+      ret
+    end
+
+    def emacs_trace
+      begin
+        yield
+      rescue Exception => e
+        puts e
+        puts "... exception thrown from ..."
+        e.backtrace.each do |trace|
+          a = trace.split(/:/)
+          if a[0].match(/^\//)
+            puts "#{a[0]}:#{a[1]}: #{a[2..a.length].join(':')}"
+          else
+            d = File.dirname(a[0])
+            f = File.basename(a[0])
+            dir = `cd #{d}; pwd`.chomp
+            goodpath = File.join(dir,f)
+
+            puts "#{goodpath}:#{a[1]}: #{a[2..a.length].join(':')}"              
+          end
+          if $emacs_trace_debugger
+            require 'ruby-debug'
+          end
+        end
+        raise "sorry ...exiting"
+      end
+    end
+
+    def ckebug(level,msg)      
+      CkuruTools::Debug.instance.debug(level,msg)
+    end
+
+    def current_method
+      caller[0].match(/`(.*?)'/)[1]
+    end
+
+    def calling_method
+      caller[1] ? caller[1].match(/`(.*?)'/)[1] : ""
+    end
+
+    def calling_method2
+      if caller[2]
+        if matchdata = caller[2].match(/`(.*?)'/)
+          matchdata[1]
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+    def calling_method3
+      if caller[3]
+        if matchdata = caller[3].match(/`(.*?)'/)
+          matchdata[2]
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+
+
+    def calling_method_sig
+      caller[1] ? caller[1] : ""
+    end
+
+      
+
+#     def calling_method
+#       if caller[2]
+#         caller[2].match(/`(.*?)'/)[1]
+#       else
+#         ""
+#       end
+      
+#     end
+
+  end
+end
+
+class Time
+  def ckuru_time_string
+    strftime("%m/%d/%Y %H:%M:%S")
+  end
+end
+
+def printmsg(msg,newline=true)
+  print "#{Time.new.ckuru_time_string}: #{msg}"
+  puts if newline
+end
+
+
+#module MlImportUtils
+def msg_exec(msg)
+  printmsg("#{msg} ... ",false)
+  t1 = Time.new
+  ret = yield
+  puts "done (#{Time.new - t1})"
+  ret
+end
+
+def chatty_exec(level,name)
+  ret = yield
+  ckebug level, "#{name} is #{ret}"
+  ret
+end
+
+
+# EOF

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ckuru-tools
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 13
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Bret Weinraub
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-27 00:00:00 Z
+date: 2011-05-05 00:00:00 Z
 dependencies: []
 
 description: The infamous ckuru-tools gem.  A miscellaneous grab bag of ruby class extensions, utility classes, etc.
@@ -32,6 +32,7 @@ files:
 - ./lib/debug.rb
 - ./lib/args.rb
 - ./lib/ckuru-tools.rb
+- ./lib/ckuru-tools.rb~
 - ./tasks/notes.rake
 - ./tasks/rdoc.rake
 - ./tasks/bones.rake