betterobject 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f0fe8e69cf1f96c5d5150fca67a2b1ac82ebc54
-  data.tar.gz: dbed0f676c842b23bbcc562410a4931090ba82d9
+  metadata.gz: 8c0a48f6ca647b2e04d0da3ae2684874d64053e1
+  data.tar.gz: 8f47dec33142fc3c804e5f2577744668d2e68b63
 SHA512:
-  metadata.gz: 3e7baa787819509439a2fec0c2cf44f7a1c78aed1aed3b26717454a05ca484f4a01c5494c7bc795ca4f05f19335421f06a5b301acaaf9f7098bf15471a71d613
-  data.tar.gz: 82c0a7b11eb65ce5f5423e4eb5e5310d10d186c0748aa63937a5b1f9e6944bf92e22a21cfdeca35229901d0c4edf6a91d7be02171524a1e95765c61c6791bcae
+  metadata.gz: 6d572278169c31ae29c5ffc5e2f270ed7c74cbd6a8b3c404dd913bf5b75a5a4c3d77dd1ae484eca241a9cda56b8906d12b6a5d28455a56f8a1ec33b29c54fdec
+  data.tar.gz: b6be73de85b765e1b7d1ecc6e3cdb9b5b0d9fe8fa35270313810240616b4c33996e057489327c6b4ce6bbef782499fbe6ba148578a8da2ba1ad584ded42372e1

data/README.md

@@ -4,11 +4,8 @@ This gem installs several class methods to Object which in turn generates both c
 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.
+Generators are code in waiting. Only when installed do they become methods (either instance or class methods depending on the generator).
+The generator names are also the method names which can be renamed in the event that you get a name conflict.
 
 ## Installation
 
@@ -85,6 +82,7 @@ You can control which methods names get generated. Now let's dive into the other
 * `Object.better_source_code`
 * `Object.better_list`
 * `Object.better_install`
+* `Object.better_install_as!`
 * `Object.better_install_all`
 * `Object.better_uninstall`
 * `Object.better_uninstall_all`
@@ -92,6 +90,7 @@ You can control which methods names get generated. Now let's dive into the other
 * `Object.better_unskip`
 * `Object.better_skipped`
 * `Object.better_rename`
+* `Object.include_many?`
 
 
 Note that there are no instance methods created by this gem until you install a generator.
@@ -156,6 +155,25 @@ Object.better_install :methods_by_me
 "a string".methods_by_me # [list of local methods]
 ```
 
+### Object.better_install_as!(:generator_library_name, :permanent_clone_name)
+
+This forces permanent installation of a generator to an alternate target name.
+Note that once done, this alternate generator is permanently installed and cannot be removed.
+If you are creating a `gem` that requires `betterobject`, this type of installation will prevent someone else's code from deleting what you require.
+Alternately, you can capture the source code, and physically place the code in Object.
+This call leaves no trace once it is called other than the methods appearing from the generator.
+If you are using `betterobject` as part of a library `gem` project or a component then you should only install with this method and only install the minimum of what you need.
+A good naming convention could be prefixing the generator name with your gem name.
+As an example, this was used in the `setfu` gem as follows:
+
+```ruby
+class Object
+  better_install_as!(:push_unique, :setfu_push_unique)
+  better_install_as!(:tag, :setfu_tag)
+  better_install_as!(:tag, :setfu_count)
+end
+```
+
 ### Object.better_list(include_skip=false)
 
 This returns an array of generators that can be installed. Skipped generators can also be listed if you call this method with the value `true`.
@@ -296,13 +314,21 @@ you must provide code to remove your methods.
 * `:comes_from?`
 * `:define_presence_of`
 * `:in?`
+* `:include_many?`
 * `:to_literal`
 * `:pluralize`
 * `:parent`
-* `:sort!`
 * `:find_def`
 * `:tag`
+* `:create_tag`
 * `:functionize`
+* `:push_unique`
+* `:sort!`
+* `:many_at`
+* `:delete_many_at`
+* `:tripleize`
+
+
 
 
 ### Generator :local_methods(include_singleton_methods=true)
@@ -452,8 +478,8 @@ This class method can be called from Object, String, or any class you wish.
 The pluralization is pretty smart, but if it does not quite work, you can provide the altername name in the second parameter. The new method name is returned. See the example below  
 
 ```ruby
-
 Object.better_install :pluralize  # installs the first-level generator
+
 Object.pluralize :include?        # returns :includes?
 [1,2,3].includes? 2               # true
 
@@ -468,7 +494,18 @@ Object.pluralize :respond_to?     # :responds_to?
 
 This generator finds the first non-module ancestor of a class.
 The class Object's parent is always Object.
-This is a class method installed on Object.
+This is a class method installed on Object. See the example below:
+
+```ruby
+Object.better_install :parent
+
+6.class.ancestors  # [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
+6.class                      # Fixnum
+6.class.parent               # Integer
+6.class.parent.parent        # Numeric
+6.class.parent.parent.parent # Object  ... Note: Comparable is a Module
+6.class.parent.parent.parent.parent.parent.parent.parent.parent.parent  # Object
+```
 
 ### Generators :to_literal
 
@@ -529,7 +566,7 @@ See the example below:
  str = "Tag me!"
  str.tag1!
  str.tag2 = "forget me not"
- str.ta3  = 17
+ str.tag3  = 17
  str.tag1?  # true
  str.tag2?  # true
  str.flag?  # false
@@ -617,11 +654,94 @@ ary.push_unique "your boat"
 ary.join " "  # "row row row your boat" 
 ```
 
+### Generators :many_at(*list)
+
+This targets the Array class with an improved access method. You can pass an array of items, or a comma delimited list of items;
+items include integer indexes, ranges, and flat arrays of integers. See the example below:
+
+```ruby
+Object.better_install :many_at
+
+ary = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight"]
+stuff = ary.many_at 1, 3..5, 8     # stuff == ["one", "three", "four", "five", "eight"]
+stuff = ary.many_at [1, 3..5, 8]   # same as above
+stuff = ary.many_at 1, [3,4,5], 8  # same as above
+```
+
+### Generators :delete_many_at(*list)
+This targets the Array class with an improved `#delete_at` method. You can pass an array of items, or a comma delimited list of items;
+items include integer indexes, ranges, and flat arrays of integers. The method returns the deleted items as an array of elements
+in the reverse order in which they were deleted. Note that deletion indexes are internally sorted in reverse order in order to preserve the index integrity.
+If the list of deletion indexes is ascending, then we should see the same data as if we called `#many_at`.  See the example below:
+
+```ruby
+Object.better_install :delete_many_at
+
+ary = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight"]
+stuff = ary.delete_many_at 1, 3..5, 8     # stuff == ["one", "three", "four", "five", "eight"]
+                                          # ary   == ["zero", "two", "six", "seven"]
+# random delete order:                                          
+ary = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight"]
+stuff = ary.delete_many_at 8, 3..5, 1     # stuff == ["one", "three", "four", "five", "eight"]
+                                          # ary   == ["zero", "two", "six", "seven"]
+```
+
+### Generators :tripleize
+This installs a generator that defines the `===` operator on a particular existing class such as Array or Hash.
+Note that the `===` is used in conjunction with the `case`-`when` statement.
+The installed generator can be called with or without a block.
+The default behavior is to mimic what a Range does with the `===` operator.
+This is best explained by example: 
+```ruby
+(1..9) === 5               # true  ... Range defines  === as:  self.include? (right_expr)
+[1,2,3,4,5,6,7,8,9] === 5  # false ... Kernel defines === as:  self == (right_expr)
+
+Object.better_install :tripleize
+
+Array.tripleize  # install default behavior
+[1,2,3,4,5,6,7,8,9] === 5  # true
+
+Array.tripleize { |me , other| me.first == other }
+[1,2,3,4,5,6,7,8,9] === 5  # false
+[1,2,3,4,5,6,7,8,9] === 1  # true
+```
+
+### Generators :include_many?
+This is an instance generator on Object that creates a generalized instance method called `#include_many?` or some other name
+you think is better. If an Object implements `#include`, then `#include_many?` should work fine.
+Note that the `#include` method only looks at a single item, where `#include_many?` requires that all items are included.
+You can pass a list of items, or pass an `Array` of items. See the example below:
+
+```ruby
+Object.better_install :include_many?
+
+[1,2,3,4,5,6,7,8].include?      [3,4,7]  # false
+[1,2,3,4,5,6,7,8].include_many? [3,4,7]  # true
+[1,2,3,4,5,6,7,8].include_many? 3,4,7    # true
+[1,2,3,4,5,6,7,8].include_many? 3        # true
+[1,2,3,4,5,6,7,8].include_many? 1,9      # false
+[1,2,3,[4,5],[6,7],8].include_many? [[4,5],[6,7],1]    # true  ... not:  [4,5],[6,7],1 see note below:
+[1,2,3,[4,5],[6,7],8].include_many? [4,5],[6,7],1      # false ... same as:  .include_many? 4,5 ... see note below:
+[1,2,3,[4,5],[6,7],8].include_many? 1,[4,5],[6,7]      # true  ... see note below:
+"This is a test string".include_many? "test", "string" # true
+``` 
+
+Note that it is best to encapsulate the list inside an array, particularly if your elements are arrays.
+If the first item in the list is an array, then its contents will be the only thing tested.
+
+
 ## Change Log
 
+### Version 1.1.0
+1. Update documentation
+2. Added generator `:delete_many_at`
+3. Added generator `:many_at`
+4. Added generator `:tripleize`
+5. Added generator `:include_many?`
+
 ### Version 1.0.0
-1. Added new generator :push_unique
-2. Added new generator :create_tag
+1. Added new generator `:push_unique`
+2. Added new generator `:create_tag`
 
 ## Development
 
@@ -631,7 +751,7 @@ To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-I need to control this for the time being.
+I need to control this for the time being. You you need a generator, shoot me an email and I will consider it on the next release.
 
 ## License
 

data/betterobject.gemspec

@@ -14,11 +14,11 @@ Gem::Specification.new do |spec|
 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.}
+As a teaser, some of the generators presently include: obj.local_methods, obj.inherited_methods, obj.replaced_methods, obj.in?, COBJ.comes_from?, COBJ.derives_from?, obj.find_def.
+There are currently 20 generators and counting.
+Calling Object.better_install_all will install all of the generators.
+You can also generate a subset by calling Object.better_install(:generator_name).
+The generator names are also the method names which can be renamed by calling Object.better_rename(old_name, new_name);}
 
   spec.license       = "MIT"
 

data/lib/betterobject.rb

@@ -1,8 +1,14 @@
 require "betterobject/version"
+require "generators.rb"
+
+### ::TODO::   :required ... prevent uninstall forever
+### :::  Array ... needs a delete_many_at(*prm)  ... 1,5,7,3  or an array  setfu need this!!!
+### :::            also, a delete_many(*prm)  ... deletes a bunch of stuff based on value
+### :::  Generator clone ???  another way to tag things .... or provide alternate names
+### :::  Generator drop ??? removes generator completely
+### :::  drop after permanent install? nah  ... not sure if I want drop either
+### :::  Object.better_install! :generator   ...  cannot be uninstalled  **** I like this!!! 
 
-unless require "generators.rb"
-  require_relative "generators.rb"
-end
 
 class Object
   ###
@@ -17,6 +23,11 @@ class Object
     raise "unknown generator #{sym.inspect}" unless  @@better_object_valid_methods.include? sym
   end
   
+  def self.better_be_different(old_sym, new_sym)
+    raise "unrecognize #{old_sym.inspect}" unless @@better_object_valid_methods.include? old_sym
+    raise "new name must be differenct that existing generator" if @@better_object_valid_methods.include? new_sym 
+  end
+  
   def self.better_list(include_skip=false)
     better_be_object
     rtn = []
@@ -234,9 +245,19 @@ class Object
     true
   end
   
+  def better_install_as!(old_sym, new_sym)  
+    better_be_object
+    better_be_defined(old_sym)
+    better_be_different(old_sym, new_sym)   
+    code = @@better_object_valid_methods[old_sym][:code].gsub(/BO_METH_NAME/,new_sym.to_s)    
+    class_eval code
+    true
+  end
+  
   def self.better_rename(old_sym, new_sym)
     better_be_object
     better_be_defined(old_sym)
+    better_be_different(old_sym, new_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

data/lib/betterobject/version.rb

@@ -1,3 +1,3 @@
 module Betterobject
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/generators.rb

@@ -277,7 +277,7 @@ CODE
 #    
 hash = {}
 hash[:type] = :class
-hash[:explain] = "creates MyClass() on Kernel level as an alternate constructor or some other method"
+hash[:explain] = "creates MyClass() on Kernel level as an alternate constructor or class method"
 hash[:code] = <<'CODE'
   def BO_METH_NAME(meth=:new)
     raise "can't redefine #{self}" if Kernel.methods.include? self.to_s.to_sym
@@ -294,7 +294,7 @@ CODE
 #    
 hash = {}
 hash[:type] = :instance
-hash[:explain] = "creates :tag, :tag=, :tag?, untag ..."
+hash[:explain] = "creates :tag, :tag=, :tag?, untag, :tag!"
 hash[:code] = <<'CODE'
   def BO_METH_NAME
     nil || @bo_BO_METH_NAME
@@ -381,4 +381,117 @@ hash[:rm] = <<'CODE'
 CODE
 @@better_object_valid_methods[:push_unique] = hash
 
+
+#
+#  Generator  :delete_many_at
+#
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "creates #delete_many_at method on Array. Same as #delete_at, but also allows a list of arguments"
+hash[:code] = <<'CODE'
+  Array.class_eval do
+    def BO_METH_NAME(*list)
+      rtn = []
+      list = list.first if list.first.kind_of? Array   # must delete right-to_left
+      ran = []
+      ary = []
+      num = []
+      list.each do |elm|
+        if elm.kind_of? Range
+          ran.concat elm.to_a
+        elsif elm.kind_of? Array
+          ary.concat elm
+        else
+          num.push elm     
+        end
+      end
+      grp = (ran|ary|num).sort.reverse   
+      grp.each do |idx|
+        rtn.push(delete_at(idx))
+      end
+      return rtn.reverse
+    end
+ end   
+CODE
+hash[:rm] = <<'CODE'
+  Array.class_eval do
+    undef BO_METH_NAME
+  end
+CODE
+@@better_object_valid_methods[:delete_many_at] = hash
+
+
+#
+#  Generator  :many_at
+#
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "creates #many_at method on Array. Same as #at but allows a list of arguments"
+hash[:code] = <<'CODE'
+  Array.class_eval do
+    def BO_METH_NAME(*list)
+      rtn = []
+      list = list.first if list.first.kind_of? Array   # must delete right-to_left
+      list.each do |elm|
+        if elm.kind_of? Range
+          rtn.concat elm.to_a
+        elsif elm.kind_of? Array
+          rtn.concat elm
+        else
+          rtn.push elm     
+        end
+      end
+      return rtn
+    end
+ end   
+CODE
+hash[:rm] = <<'CODE'
+  Array.class_eval do
+    undef BO_METH_NAME
+  end
+CODE
+@@better_object_valid_methods[:many_at] = hash
+
+
+#
+#  Generator  tripleize
+#
+hash = {}
+hash[:type] = :class
+hash[:explain] = "defines === to mean: left.include? right or your block result" 
+hash[:code] = <<'CODE'
+  def self.BO_METH_NAME(&proc)
+    if proc.nil?
+      def === (elm)
+        self.include? elm
+      end  
+    else
+      @proc_tripleize = proc
+      def === (elm)
+        self.class.instance_variable_get(:@proc_tripleize).call(self,elm)
+      end
+    end
+  end
+CODE
+@@better_object_valid_methods[:tripleize] = hash
+
+
+#
+#  Generator  include_many?
+#
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "calls include? to check for multiple items"
+hash[:code] = <<'CODE'
+  def BO_METH_NAME(*items)
+    items = items.first if items.first.kind_of? Array
+    items.each do |item|
+      return false unless self.include? item
+    end
+    true
+  end
+CODE
+@@better_object_valid_methods[:include_many?] = hash
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: betterobject
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-01 00:00:00.000000000 Z
+date: 2018-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,11 +71,11 @@ description: |-
   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.
+  As a teaser, some of the generators presently include: obj.local_methods, obj.inherited_methods, obj.replaced_methods, obj.in?, COBJ.comes_from?, COBJ.derives_from?, obj.find_def.
+  There are currently 20 generators and counting.
+  Calling Object.better_install_all will install all of the generators.
+  You can also generate a subset by calling Object.better_install(:generator_name).
+  The generator names are also the method names which can be renamed by calling Object.better_rename(old_name, new_name);
 email:
 - bryan@bdlsys.com
 executables: []