betterobject 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/betterobject.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'betterobject/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "betterobject"
+  spec.version       = Betterobject::VERSION
+  spec.authors       = ["Bryan Colvin"]
+  spec.email         = ["bryan@bdlsys.com"]
+
+  spec.summary       = %q{Object method generator system}
+  spec.description   = %q{This gem installs several class methods to Object which in turn generates both class and instance methods but only when you are ready.
+In order to prevent name pollution, you have the ability to manage the generators to pick alternate names if you prefer.
+After scouring the RubyGems site, some of the better Class upgrades are included here as well as some of my own.
+The gem creates the backbone upon which future upgrades should be forthcoming.
+As a teaser, some of the generators presently include: obj.local_methods, obj.inherited_methods, obj.in?, COBJ.comes_from?, COBJ.derives_from?, COBJ.define_presence_of, obj.find_def. This first release installs 14 generators.
+Calling `Object.better_install_all` will install all of the generators.
+You can also generate a subset by calling `Object.better_install :generator_name` or `Object.better_install array_of_gen_names`.
+The generator names are also the method names which can be renamed by calling `Object.better_rename(old_name, new_name)`;
+this must be done before you generate the method.}
+
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files.push "lib/generators.rb"
+  
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'byebug', ">= 5.0.0"    
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "betterobject"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/betterobject/version.rb

@@ -0,0 +1,3 @@
+module Betterobject
+  VERSION = "0.1.0"
+end

data/lib/betterobject.rb

@@ -0,0 +1,246 @@
+require "betterobject/version"
+
+unless require "generators.rb"
+  require_relative "generators.rb"
+end
+
+class Object
+  ###
+  ###  The following are standard class methods
+  ###
+  
+  def self.better_be_object
+    raise "must call from Object" unless self==Object
+  end
+  
+  def self.better_be_defined(sym)
+    raise "unknown generator #{sym.inspect}" unless  @@better_object_valid_methods.include? sym
+  end
+  
+  def better_list(include_skip=false)
+    better_be_object
+    rtn = []
+    # @@better_object_valid_methods.keys.sort
+    @@better_object_valid_methods.each_pair do |key,rec|
+      rtn.push key unless rec[:skip]
+    end
+    return rtn.sort
+  end
+
+  def self.better_skip(*sym)
+    if sym.first.class == Array
+      sym = sym.first
+      sym.each { |m| better_skip m }
+      return true
+    else
+      if sym.count==1
+        sym = sym.first
+      else
+        sym.each { |m| better_skip m }
+        return true
+      end
+    end
+    better_be_object    
+    raise "unknown generator #{sym.inspect}" unless  @@better_object_valid_methods.include? sym
+    @@better_object_valid_methods[sym][:skip]=true
+  end
+  
+  def self.better_unskip(*sym)
+    if sym.first.class == Array
+      sym = sym.first
+      sym.each { |m| better_unskip m }
+      return true
+    else
+      sym = sym.first  
+    end
+    better_be_object
+    better_be_defined(sym)
+    @@better_object_valid_methods[sym][:skip]=false
+  end
+  
+  def self.better_skipped()
+    better_be_object
+    rtn = []
+    @@better_object_valid_methods.each_pair do |key,val|
+      if val[:skip]
+        rtn.push key
+      end
+    end
+    return rtn.sort
+  end
+  
+  def self.better_source_code(sym, return_string=false, inner_only = false, kind = :code)
+    better_be_object
+    better_be_defined(sym)
+    raise "expecting (:code, :rm) 4th parameter and got #{kind.inspect}" unless (kind==:code || kind==:rm)
+    return nil unless @@better_object_valid_methods[sym][kind]
+    str = "\n"
+    str += "class Object\n" unless inner_only
+    str += @@better_object_valid_methods[sym][kind]
+    str += "\n" unless str[-1]=="\n"
+    str += "end\n" unless inner_only
+    str = str.gsub(/BO_METH_NAME/,sym.to_s)
+    return str if return_string
+    puts str
+    sym
+  end
+   
+  def self.better_explain(sym=nil, pts=true)
+    better_be_object
+    if @@better_object_valid_methods.include? sym
+      str = @@better_object_valid_methods[sym][:explain]
+    else
+      if sym.nil?
+        str = "valid parameters to the method are:\n:"
+        meths = better_list.join ", :"
+        str += meths.to_s
+        str += "\n\nUsage:\n\nObject.better_explain(:one_of_the_above)\n"
+      else
+        str = "Undefined parameter #{sym.inspect}"
+      end
+    end
+    return str unless pts
+    puts str
+    sym
+  end
+
+  def self.better_installed
+    better_be_object
+    @@better_installed_methods.keys.sort
+  end
+
+    
+  def self.better_installed_class_methods
+    better_be_object
+    rtn = []
+    @@better_installed_methods.keys.each do |key|
+      rtn.push key if @@better_object_valid_methods[key][:type]==:class
+      rtn.push key if @@better_object_valid_methods[key][:type]==:both
+    end
+    return rtn.sort
+  end
+  
+  def self.better_installed_instance_methods
+    better_be_object
+    rtn = []
+    @@better_installed_methods.keys.each do |key|
+      rtn.push key if @@better_object_valid_methods[key][:type]==:instance
+      rtn.push key if @@better_object_valid_methods[key][:type]==:both
+    end
+    return rtn.sort
+  end
+  
+  def self.better_uninstall_all
+     @@better_installed_methods.keys.each {|m| better_uninstall m}
+  end
+  
+  def self.better_uninstall(*sym)
+    if sym.first.class == Array
+      sym = sym.first
+      sym.each { |m| better_uninstall m }
+      return true
+    else
+      if sym.count==1
+        sym = sym.first
+      else
+        sym.each { |m| better_uninstall m }
+        return true
+      end 
+    end
+    better_be_object
+    better_be_defined(sym)
+    return false unless @@better_installed_methods.include? sym
+    return false if @@better_object_valid_methods[sym][:skip]
+    obj = @@better_object_valid_methods[sym]
+    if obj[:rm]
+      code = obj[:rm].gsub(/BO_METH_NAME/,sym.to_s)    
+      class_eval code
+      @@better_installed_methods.delete sym
+      return true
+    end
+    cmd = "undef #{sym}" 
+    tp = obj[:type]  
+    if tp==:instance || tp==:both
+      eval cmd rescue :never_mind  # don't care if already undefined
+    end
+    if tp==:class || tp==:both
+      # This loses the local variable `cmd`
+      # class << self
+      #   eval cmd
+      # end
+      # this sould do the trick ...
+      singleton_class.class_eval do
+        eval cmd rescue :never_mind  # don't care if already undefined
+      end
+    end
+    @@better_installed_methods.delete sym
+    true
+  end
+  
+  def self.better_define(meth_name, code, type, doc="*Undocumented*", rm=nil)
+    better_be_object
+    hash = {}
+    hash[:code] = code
+    hash[:explain] = doc
+    hash[:type] = type
+    hash[:rm] = rm unless rm.nil?
+    @@better_object_valid_methods[meth_name] = hash
+  end
+  
+  def self.better_install_all
+     @@better_object_valid_methods.keys.each {|m| better_install m}
+  end
+  
+  def self.better_get_definition(sym)  # redo this with hash= way
+    better_be_object
+    better_be_defined(sym)
+    rec = @@better_object_valid_methods[sym]
+    puts " {  :type => :" + rec[:type].to_s + ","
+    puts "    :explain => " + '"' + rec[:explain] + '",'
+    puts "    :code =>"
+    puts "<<'CODE'"
+    term = rec[:rm].nil? ? "" :  ","
+    puts rec[:code]
+    puts "CODE" + term
+    unless rec[:rm].nil?
+      puts "    :rm =>"
+      puts "<<'CODE'"
+      puts rec[:rm]
+      puts "CODE"
+    end
+    puts "}"
+  end
+  
+  def self.better_install(*sym)
+    if sym.first.class == Array
+      sym = sym.first
+      sym.each { |m| better_install m }
+      return true
+    else
+      if sym.count==1
+        sym = sym.first
+      else
+        sym.each { |m| better_install m }
+        return true  # todo ... they may all be false ...
+      end 
+    end
+    better_be_object
+    better_be_defined(sym)    
+    return false if @@better_installed_methods.include? sym
+    return false if @@better_object_valid_methods[sym][:skip]
+    @@better_installed_methods[sym]=true    
+    code = @@better_object_valid_methods[sym][:code].gsub(/BO_METH_NAME/,sym.to_s)    
+    class_eval code
+    true
+  end
+  
+  def self.better_rename(old_sym, new_sym)
+    better_be_object
+    better_be_defined(old_sym)
+    raise "cannot rename installed generator" if @@better_installed_methods.keys.include? old_sym
+    rec = @@better_object_valid_methods[old_sym]
+    @@better_object_valid_methods[new_sym] = rec
+    @@better_object_valid_methods.delete old_sym    
+  end
+    
+end  

data/lib/generators.rb

@@ -0,0 +1,325 @@
+#
+# These are the rather ugly looking generators separated from the main code for clarity
+#
+
+
+# ::TODO::  
+# String.find_method(:new)  [:new, Class]  or [] if none found
+# "".find_method(:to_s)  # finds instance methods or signleton [:to_s, Comparable]  [:wow, Singleton]
+#
+#  String.local_methods  might also be cool!
+#  String.inherited_methods as well
+#
+#
+#
+
+class Object
+  @@better_installed_methods={}
+  @@better_object_valid_methods={}
+  
+  
+# 
+#  Generator :find_def
+#  
+hash = {}
+hash[:type] = :both
+hash[:explain] = "CLASS_NAME.find_def # locates owner (class name) of defined instance method"
+hash[:code] = "
+  def self.BO_METH_NAME(sym)
+    return method(sym).owner rescue nil
+  end 
+  def BO_METH_NAME(sym)
+    return method(sym).owner rescue nil
+  end 
+"  # does not seem to like the <<'CODE' thing ... not sure why ... works everywhere else
+   # so use the "" thing instead 
+@@better_object_valid_methods[:find_def] = hash  
+
+
+#
+#  Generator  :replaced_methods
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "obj.replaced_methods() # similar to methods but only lists methods replaced by inheritance or overridden by singletons"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME
+    locals = []
+    sc = self.class
+    methods.each do |item|
+      locals.push item if method(item).owner == sc
+    end
+    outs = []
+    singles = singleton_methods
+    chain = self.class.ancestors[1..-1]
+    chain.each do |item|
+      outs += item.instance_methods
+    end
+    outs_and_locals     = outs & locals
+    locals_and_singles  = locals & singles
+    singles_and_outs    = outs & singles
+    return (outs_and_locals | locals_and_singles | singles_and_outs).sort
+  end
+CODE
+@@better_object_valid_methods[:replaced_methods] = hash
+
+
+#
+#  Generator  :local_methods
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "obj.inherited_methods() # similar to methods but excludes locally defined methods"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME(include_singles=true)
+    rtn = []
+    sc = self.class
+    methods.each do |item|
+      rtn.push item if method(item).owner == sc
+    end
+    rtn += singleton_methods if include_singles
+    return rtn.sort
+  end
+CODE
+@@better_object_valid_methods[:local_methods] = hash
+
+
+#
+#  Generator  :inherited_methods
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "obj.inherited_methods() # similar to methods but excludes locally defined methods"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME
+    rtn = []
+    sc = self.class
+    methods.each do |item|
+      rtn.push item unless method(item).owner == sc
+    end
+    rtn -= singleton_methods
+    return rtn.sort
+  end
+CODE
+@@better_object_valid_methods[:inherited_methods] = hash
+
+
+#
+#  Generator  :comes_from?
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "CLASS_NAME.comes_from?(Other) # true if CLASS_NAME is or derives from Other"
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME(const)
+    ary = ancestors
+    rtn = ary.include? const
+    return rtn
+  end    
+CODE
+@@better_object_valid_methods[:comes_from? ] =  hash
+
+
+#
+#  Generator  :derives_from?
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "CLASS_NAME.derives_from?(Other) # true if CLASS_NAME derives from Other"
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME(const)
+    ary = ancestors - [self]
+    rtn = ary.include? const
+    return rtn
+  end    
+CODE
+@@better_object_valid_methods[:derives_from? ] = hash
+
+
+#
+#  Generator  :in?
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "obj.in?(enum) # ex:  3.in? [3,4,5] == true"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME(enum)
+    enum.include? self
+  end    
+CODE
+@@better_object_valid_methods[:in? ] = hash
+
+
+#
+#  Generator  :define_presence_of
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "CLASS_NAME.define_presence_of(:meth_name, val=true)\n  # ex:  String.define_presence_of :is_string?\n  ''.is_string?  # true"
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME(method_name, value=true)
+    Object.class_eval do
+      define_method(method_name) do
+        return !value
+      end  
+    end
+    class_eval do
+      define_method(method_name) do
+        return value
+      end  
+    end
+  end # def
+CODE
+@@better_object_valid_methods[:define_presence_of] = hash 
+
+
+#
+#  Generator  :sort!
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "hash_instance.sort! # forces Hash keys to be sorted in ascending order"
+hash[:code] = <<'CODE'
+  Hash.class_eval do
+    def BO_METH_NAME              
+      hash = {}
+      sort.each do |pair|
+        hash[pair.first]=pair.last
+      end
+      replace hash
+    end
+  end
+CODE
+hash[:rm] = <<'CODE'
+  Hash.class_eval do
+    undef BO_METH_NAME rescue :never_mind
+  end
+CODE
+@@better_object_valid_methods[:sort!] = hash 
+
+
+#
+#  Generator  :to_literal
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "obj.to_literal # alias for #inspect"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME
+    if respond_to? :inspect
+      inspect
+    else
+      to_s
+    end
+  end
+CODE
+@@better_object_valid_methods[:to_literal] = hash 
+
+
+#
+#  Generator  :pluralize
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "adds plural versions of include, respond_to?, start_with, etc"
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME(prm, alt=nil)
+    unless self==Object
+      raise "unknown method #{prm.to_sym}" unless instance_methods.include?(prm)
+    end  
+    if alt.nil?
+      sprm = prm.to_s
+      if (sprm.include? '_')
+        ary = sprm.split('_')
+        ary[0] += 's'
+        ps = ary.join "_"
+      else
+        if sprm[-1]=='?'
+          ps = sprm[0..(-2)] + 's?'
+        elsif sprm[-1]=='!'
+          ps = sprm[0..(-2)] + 's!'  
+        else
+          ps = sprm + 's'
+        end
+      end
+    else
+      ps = alt
+    end
+    cmd = "def #{ps}(*prms)\n#{sprm}(*prms)\nend"
+    class_eval cmd
+    ps
+  end
+CODE
+@@better_object_valid_methods[:pluralize] = hash 
+
+
+#
+#  Generator  :parent
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "finds the parent class not including modules"
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME
+    return Object if self==Object
+    ary = ancestors
+    ary[1..(-1)].each do |name|
+      next if name.class == Module
+      return Object if name==Object
+      return name
+    end  
+  end  
+CODE
+@@better_object_valid_methods[:parent] = hash
+
+
+#
+#  Generator  :tag
+#    
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "creates :tag, :tag=, :tag?, untag ..."
+hash[:code] = <<'CODE'
+  def BO_METH_NAME
+    nil || @bo_BO_METH_NAME
+  end
+  def BO_METH_NAME!
+    @bo_BO_METH_NAME = true
+  end  
+  def unBO_METH_NAME
+    @bo_BO_METH_NAME = false
+  end
+  def BO_METH_NAME?
+    return nil != (@bo_BO_METH_NAME || nil)
+  end
+  def BO_METH_NAME=(prm)
+    @bo_BO_METH_NAME=prm
+  end    
+CODE
+hash[:rm] = <<'CODE'
+  undef BO_METH_NAME rescue :never_mind
+  undef unBO_METH_NAME rescue :never_mind
+  undef BO_METH_NAME? rescue :never_mind
+  undef BO_METH_NAME! rescue :never_mind
+  undef BO_METH_NAME= rescue :never_mind
+CODE
+@@better_object_valid_methods[:tag] = hash
+
+
+#
+#  Generator  :functionize
+#    
+hash = {}
+hash[:type] = :class
+hash[:explain] = "creates MyClass() on Kernel level as an alternate constructor or some other method"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME(meth=:new)
+    raise "can't redefine #{self}" if Kernel.methods.include? self.to_s.to_sym
+    raise "can't redefine #{self}" if self.respond_to? self.to_s.to_sym
+    cmd = "def #{self}(*prms,&block); return #{self}.#{meth.to_s}(*prms,&block);end"
+    Kernel.class_eval cmd
+  end  
+CODE
+@@better_object_valid_methods[:functionize] = hash
+
+end