GFunk911-rubytypeassert 0.0.1 → 0.0.2

data/aspect.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+require 'ostruct'
+
+class MethodRuns
+  attr_accessor :method_name, :method_class
+  def initialize(c,n)
+    @method_name = n.to_s
+    @method_class = c.to_s
+  end 
+  #:return: => Object
+  def runs
+    @runs ||= []
+  end 
+  def log_run!(r)
+    raise 'wrong' unless method_name == r.method_name.to_s and method_class = r.method_class.to_s
+    runs << r
+  end 
+  #:return: => Object
+  def arg_classes
+    runs.map { |r| r.args.map { |x| x.class } }.uniq
+  end 
+  def return_classes
+    runs.map { |r| r.return.class }.uniq
+  end 
+  #:return: => Object
+  def to_s
+    "#{method_class} / #{method_name}"
+  end 
+  #:return: => Object
+  def summary
+    "#{method_class}##{method_name}, returns: #{return_classes.inspect}, args: #{arg_classes.inspect}"
+  end 
+  #:return: => Object
+  def self.run_hash
+    @run_hash ||= Hash.new { |h,k| h[k] = new(*k) }
+  end 
+  #:return: => Object
+  def self.runs
+    run_hash.values
+  end 
+  #:return: => Object
+  def self.log_run!(r)
+    run_hash[[r.method_class.to_s,r.method_name.to_s]].log_run!(r)
+  end 
+  #:return: => Object
+  def self.get(c,n)
+    run_hash[[c.to_s,n.to_s]]
+  end 
+end
+  
+def add_advice!(*advised_classes)
+  require 'aquarium'
+  advised_classes.flatten.each do |cls|
+    Aquarium::Aspects::Aspect.new :around, :calls_to => cls.uniq_instance_methods, :on_types => cls do |jp, object, *args|
+      #p "Entering: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
+      result = jp.proceed
+      #p "Leaving: #{join_point.target_type.name}##{join_point.method_name} for object #{object}"
+      MethodRuns.log_run! OpenStruct.new(:method_class => jp.target_type.name, :method_name => jp.method_name, :args => args, :return => result)
+      result  # block needs to return the result of the "proceed"!
+    end
+  end
+end
+
+at_exit do 
+  File.create("method_runs.txt",MethodRuns.runs.map { |x| x.summary }.join("\n"))
+end
+  

data/core_ext.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+require 'facets/file/write'
+require 'facets/enumerable/collect'
+class Object
+  def common_methods
+    7.methods + "".methods + 7.class.methods + "".class.methods + ActiveRecord::Base.instance_methods
+  end
+  def uniq_methods
+    (methods - common_methods).sort
+  end
+  def uniq_instance_methods(include_ar=true)
+    (instance_methods - common_methods - superclass.instance_methods - uniq_modules.map { |x| x.instance_methods }.flatten + (include_ar ? ar_methods : [])).sort
+  end
+  def uniq_modules
+    included_modules - superclass.included_modules
+  end
+  def ar_methods
+    return [] unless inherits_from?(ActiveRecord::Base)
+    columns.map { |x| x.name }.map { |x| [x,"#{x}="] }.flatten
+  end
+  def inherits_from?(x)
+    return true if superclass == x
+    return false unless superclass
+    superclass.inherits_from?(x)
+  end
+end
+
+
+class Object
+  def tap
+    yield(self)
+    self
+  end
+end
+class Hash
+  def summary
+    keys.sort_by { |x| x.to_s }.map { |k| "#{k}: #{self[k]}" }.join("\n")
+  end
+end
+
+
+class Class
+  def cond_accessor(*names)
+    names.flatten.each do |name|
+      define_method(name) do |*args|
+        instance_variable_set("@#{name}",args.first) unless args.empty?
+        instance_variable_get("@#{name}")
+      end
+    end
+  end
+end      
+
+class Object
+  def klass
+    self.class
+  end
+end
+
+def eat_exceptions
+  yield
+rescue
+  return nil
+end
+
+class Object
+  def from_hash(ops)
+    ops.each { |k,v| send("#{k}=",v) unless (v == :UNSET_FIELD) }
+    self
+  end
+end
+
+class Class
+  def from_hash(ops)
+    new.from_hash(ops)
+  end
+end
+
+class Object
+  def lazy_method(sym,&b)
+    send(:define_method,sym) do
+      instance_variable_set("@#{sym}",instance_eval(&b)) if instance_variable_get("@#{sym}").nil?
+      instance_variable_get("@#{sym}")
+    end
+  end
+end
+
+class Object
+  #attr_accessor :system
+end
+
+def log(x)
+  puts x
+  File.append(File.dirname(__FILE__) + "/output.log",x.to_s+"\n")
+end
+
+def debug(x)
+end
+
+class WIN32OLE
+  include Enumerable
+  def first
+    each { |x| return x }
+  end
+  def size
+    self.Count
+  end
+  def pruned_methods
+    ole_methods.map { |x| x.to_s.gsub(/\d/,"") }.uniq.sort
+  end
+end
+
+module ForwardableExtension
+  def delegate_to(object, new_method, *args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    args.each do |element|
+      def_delegator object, element, new_method.to_sym
+      if options[:writer]
+        def_delegator object, :"#{element}=", :"#{new_method}="
+      end
+    end
+  end
+  
+  protected
+  def name_with_prefix(element, options)
+    "#{options[:prefix] + "_" unless options[:prefix].nil? }#{element}"
+  end
+end
+
+require 'forwardable'
+Forwardable.send :include, ForwardableExtension
+
+module Enumerable
+  def propagate_to!(target)
+    each { |x| x.propagate_to!(target) }
+  end
+end
+
+def tm(str,num=1)
+  t = Time.now
+  res = nil
+  num.times { res = yield }
+  sec = Time.now - t
+  puts "#{str} took #{sec} seconds (#{res})"
+end
+
+class Object
+  def to_is
+    self ? to_i.to_s : nil
+  end
+end
+
+class Object
+  def nvl(x)
+    self || x
+  end
+end

data/intel.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+class Object
+  def lazy_method(sym,&b)
+    send(:define_method,sym) do
+      instance_variable_set("@#{sym}",instance_eval(&b)) if instance_variable_get("@#{sym}").nil?
+      instance_variable_get("@#{sym}")
+    end
+  end
+end
+
+class OS
+  def each(&b)
+    ObjectSpace.each_object(&b)
+  end
+  include Enumerable
+  def self.method_missing(sym,*args,&b)
+    new.send(sym,*args,&b)
+  end
+end
+
+def current_classes
+  OS.select { |x| x.is_a?(Class) }.uniq
+end
+
+def local_class_names
+  $local_class_names ||= Dir["**/*.rb"].map do |filename|
+    File.new(filename).read.scan(/^\s*class (\S+)(?: |$)/).flatten
+  end.flatten.map { |x| x.split(":")[-1] }.sort
+end
+
+def init_classes
+  $init_classes ||= current_classes
+end
+
+def generate_local_class_defs!(req_file)
+  init_classes
+  load req_file
+  str = local_class_defs.map { |x| x.class_str }.join("\n")
+  File.create("local_class_defs.rb",str)
+end 
+
+def local_class_defs
+  $local_class_defs ||= (current_classes - init_classes).select { |x| local_class_names.include?(x.to_s.split(":")[-1]) }.map { |x| ClassDef.new(x) }
+end 
+
+class String
+  def prefix_each_line(pre)
+    pre + self[0..-2].gsub(/\n/,"\n#{pre}") + self[-1..-1]
+  end
+end
+
+module DefModule
+  def modules
+    cls.to_s.split(":")[0..-2].select { |x| x != '' }
+  end
+  def class_spaces
+    " "*2*modules.size  
+  end
+end
+
+class ClassDef
+  include DefModule
+  attr_accessor :cls
+  def initialize(c)
+    @cls = c
+  end
+  def bare_cls
+    cls.to_s.split(':')[-1]
+  end
+  def class_str
+    str = ''
+    modules.each_with_index { |x,i| str << " "*i*2 + "module #{x}\n" }
+    str << class_spaces + "class #{bare_cls}"
+    str << " < #{cls.superclass}" unless [Object,nil].include?(cls.superclass)
+    str << "\n"
+    cls.uniq_modules.each { |x| str << "#{class_spaces}  include #{x}\n" }
+    str << methods_str
+    str << class_spaces + "end\n"
+    modules.each_with_index { |x,i| str << " "*i*2 + "end\n" }
+    str
+  end
+  lazy_method(:methods) do
+    cls.uniq_instance_methods.map { |x| MethodDef.new(cls,x) }
+  end
+  def methods_str
+    methods.map { |x| x.method_str }.join("")
+  end
+end
+
+class MethodDef
+  include DefModule
+  attr_accessor :cls, :name
+  def initialize(c,n)
+    @cls = c
+    @name = n.to_s.downcase
+  end
+  def method_obj
+    eat_exceptions { cls.instance_method(m) }
+  end
+  def arity
+    method_obj ? method_obj.arity : 0
+  end
+  def arg_str
+    (0...arity).map { |x| ("a"[0]+x).chr }.join(",")
+  end
+  def manual_method_str
+    str =  "#{class_spaces}  # manual meth def\n"
+    str << "#{class_spaces}  def #{name}(#{arg_str})\n"
+    str << "#{class_spaces}  end\n"
+    str
+  end
+  def runs
+    MethodRuns.get(cls,name)
+  end
+  def return_type
+    runs.return_classes.flatten.first || Object
+  end
+  def type_comments
+    "#{class_spaces}  #:return: => #{return_type}\n"
+  end
+  lazy_method(:method_body) do
+    eat_exceptions { RubyToRuby.translate(cls,name).prefix_each_line(class_spaces+"  ") + "\n" } || manual_method_str
+  end
+  def arg_names 
+    return [] if method_body.strip =~ /^attr_/
+    arg_str = method_body.scan(/def.*#{name}(.*)$/).flatten.first
+    raise "no arg_str for #{cls} #{name} /def.*#{name}(.*)$/" unless arg_str
+    return [] if arg_str.strip == '' or arg_str.strip == '()'
+    arg_str[1..-2].split(",")
+  end
+  def arg_type(i)
+    (runs.arg_classes[i]||[]).first || Object
+  end
+  def arg_comments
+    arg_names.map_with_index do |arg,i| 
+      "#{class_spaces}  #:arg: #{arg} => #{arg_type(i)}\n" 
+    end.join("")
+  end
+  def method_str
+    type_comments + arg_comments + method_body
+  end
+end
+
+def rta_run!(req_file)
+  require 'ruby2ruby'
+  generate_local_class_defs!(req_file)
+  add_advice!(ActiveRecord::Base)
+  generate_local_class_defs!(req_file)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: GFunk911-rubytypeassert
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Mike Harris
@@ -22,7 +22,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- "*.rb"
+- aspect.rb
+- core_ext.rb
+- intel.rb
 has_rdoc: false
 homepage: http://github.com/GFunk911/RubyTypeAssert
 post_install_message: