betterobject 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17e2da8e7bbc0099c4d397ac0ecbc619ce9ba46c
-  data.tar.gz: 7b0350db719f6ba417e65e197032262a4507ce14
+  metadata.gz: 9f0fe8e69cf1f96c5d5150fca67a2b1ac82ebc54
+  data.tar.gz: dbed0f676c842b23bbcc562410a4931090ba82d9
 SHA512:
-  metadata.gz: aa69cb58b0152b7f729cb0a66f66eb737b2b701c5e6dd477f462fe313d18e157801ddd3024cf31582a1e1780005dae396c56539c56476611f28b90780c6453fe
-  data.tar.gz: 6fc1f62ef608d31bff14911771aa19d96f74d7bd741c732503a5f8c2d5c4d3414c29404a839cf9be9cb7443086a95de73dbc9a8e9145028caaff50d4888a4929
+  metadata.gz: 3e7baa787819509439a2fec0c2cf44f7a1c78aed1aed3b26717454a05ca484f4a01c5494c7bc795ca4f05f19335421f06a5b301acaaf9f7098bf15471a71d613
+  data.tar.gz: 82c0a7b11eb65ce5f5423e4eb5e5310d10d186c0748aa63937a5b1f9e6944bf92e22a21cfdeca35229901d0c4edf6a91d7be02171524a1e95765c61c6791bcae

data/README.md

@@ -77,7 +77,7 @@ Object.better_install [:in_the_thing_to_the_right?, :methods_by_me]  # or better
 
 You can control which methods names get generated. Now let's dive into the other class methods of `betterobject`.
 
-#### Object class methods created from the `betterobject` gem
+### Object class methods created from the `betterobject` gem
 * `Object.better_installed_instance_methods`
 * `Object.better_installed_class_methods`
 * `Object.better_installed`
@@ -97,28 +97,28 @@ You can control which methods names get generated. Now let's dive into the other
 Note that there are no instance methods created by this gem until you install a generator.
 Also, each and every method must be called from Object.
 
-#### Object.better_install_all
+### Object.better_install_all
 
 This will install every defined generator. In the event that a generator is renamed, the new name will be generated, while the old name
 will no longer exist. This is similar to renaming a file. Note that the generator essence never goes away, as it will exist under some new name.
 It is simply tucked away until needed. Also, generators marked as skipped will not be installed.
 
-#### Object.better_skip(gen or [gen1, gen2, ...] or gen1, gen2, ...)
+### Object.better_skip(gen or [gen1, gen2, ...] or gen1, gen2, ...)
 
 This is to prevent a generator from installing by adding a skip attribute.
 Additionally, skipped generators cannot be uninstalled until the skip flag is removed.
 If a generator is first installed then given this skip attribute, it cannot be uninstalled.
 This acts as a protection.
 
-#### Object.better_unskip(gen or [gen1, gen2, ...] or gen1, gen2, ...)
+### Object.better_unskip(gen or [gen1, gen2, ...] or gen1, gen2, ...)
 
 This removes the skip attribute enabling the generator to be installed or uninstalled.
 
-#### Object.better_skipped
+### Object.better_skipped
 
 This returns an array of skipped generators.
 
-#### Object.better_install(gen or [gen1, gen2, ...] or gen1, gen2, ...)
+### Object.better_install(gen or [gen1, gen2, ...] or gen1, gen2, ...)
 
 This will install a specific generator. 
 If you rename a generator, the old name no longer exists, so you must use the new name. See below:
@@ -133,13 +133,13 @@ str = "The cat in the hat is back"
 'cat'.is_in? str  # true
 ```
 
-#### Object.better_uninstall_all
+### Object.better_uninstall_all
 
 This will remove all the generators from Object. Note that some generators spawn additional generators such as `:define_presence_of`.
 If this generator is ever run, `Object.better_uninstall_all` will not remove these second generation methods.
 Note that generators marked with the skip flag will not be uninstalled.
 
-#### Object.better_uninstall(gen or [gen1, gen2, ...] or gen1, gen2, ...)
+### Object.better_uninstall(gen or [gen1, gen2, ...] or gen1, gen2, ...)
 
 This will uninstall a specific generator or a set of generators.
 This method returns false if the generator is skipped, or already uninstalled; otherwise true is returned.
@@ -156,23 +156,23 @@ Object.better_install :methods_by_me
 "a string".methods_by_me # [list of local methods]
 ```
 
-#### Object.better_list(include_skip=false)
+### 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`.
 
-#### Object.better_installed
+### Object.better_installed
 
 This returns a list of installed generators. This does not list what the generators generate.
 
-#### Object.better_installed_instance_methods
+### Object.better_installed_instance_methods
 
 This gives us a list of generators that created instance methods. This does not list what the generators generate.
 
-#### Object.better_installed_class_methods
+### Object.better_installed_class_methods
 
 This give us a list of generators that created class methods. This does not list what the generators generate.
 
-#### Object.better_rename(old_name, new_name)
+### Object.better_rename(old_name, new_name)
 
 This allows us to rename a generator which in turn (most likely) renames what gets generated.
 This is an important feature as placing methods at the Object level has the danger of bumping into potential name conflicts.
@@ -191,7 +191,7 @@ sorted_hash.bjc_tag?  # true
 :zoo.bjc_in? hash  # true
 ```
 
-#### Object.better_explain(:generator_name, pts=true)
+### Object.better_explain(:generator_name, pts=true)
 
 Calling this method without a generator name gives us a general list of the generators.
 Further details are revealed when a generator name is provided. The last default parameter puts the string to STOUT when true; otherwise,
@@ -202,7 +202,7 @@ See example below:
 Object.better_explain(:in?)  #  obj.in?(enum) # ex:  3.in? [3,4,5] == true
 ```
 
-#### Object.better_source_code(:generator_name, return_string = false, inner_only = false, type=:code)
+### Object.better_source_code(:generator_name, return_string = false, inner_only = false, type=:code)
 
 This will revel the source code for the generator. You can then copy and paste this in `irb` and experiment with it. See below:
 
@@ -220,7 +220,7 @@ The parameter `return_string` will return a string instance when set true.
 The parameter `inner_only` when set true will remove the `class Object` and enclosing `end` statements.
 The final parameter is set to either `:code` or `:rm` depending on if you need the creation code or the deletion code.
 
-#### Object.better_define(meth_name, code, type, doc="*Undocumented*", rm_code=nil)
+### Object.better_define(meth_name, code, type, doc="*Undocumented*", rm_code=nil)
 
 This installs a user-defined generator. As an example we will create a `whotheheckami` generator as follows.
 ```ruby
@@ -288,7 +288,7 @@ This method was used as a tool to create some of the generators.
 Note that if you decouple the method name from the generator name, or target a foreign object,
 you must provide code to remove your methods.
 
-#### Generator list
+### Generator list
 * `:local_methods`
 * `:inherited_methods`
 * `:replaced_methods`
@@ -305,7 +305,7 @@ you must provide code to remove your methods.
 * `:functionize`
 
 
-#### Generator :local_methods(include_singleton_methods=true)
+### Generator :local_methods(include_singleton_methods=true)
 
 This is an instance generator on Object. It is used on all objects that derive from Object (which is pretty much everything).
 The purpose is to view methods generated by the class of the instance and not the methods inherited by that class.
@@ -329,7 +329,7 @@ fred.local_methods(false)  #[:a, :b]
 fred.methods        # [:a, :b, :dup, :clone, etc ...]  
 ```
 
-#### Generator :inherited_methods
+### Generator :inherited_methods
 
 This is an instance generator on Object. It is similar to `#methods`, except all locally defined methods are excluded.
 The combination of `#local_methods` and `#inherited_methods` is the same as `#methods`. See below:
@@ -348,7 +348,7 @@ fred = Fred.new
 fred.methods.sort == [fred.local_methods + fred.inherited_methods].sort  # true
 ``` 
 
-#### Generator :replaced_methods
+### Generator :replaced_methods
 
 This is an instance generator on Object. This lets us discover which methods have been replaced during inheritance, or replaced due to a singleton method using the same name as an instance method. See the example below:
 
@@ -367,7 +367,7 @@ end
 fred.replaced_methods  # [:length, :to_s]
 ``` 
 
-#### Generators :derives_from? and :comes_from?
+### Generators :derives_from? and :comes_from?
 
 These methods are both class methods on Object. The purpose is to test hierarchy of derived objects.
 The two class methods once generated are identical except `comes_from?` is more inclusive.
@@ -391,7 +391,7 @@ Fred.comes_from? String   # true
 Fred.comes_from? Object   # true
 ``` 
 
-#### Generators :define_presence_of(:target_method_name, target_default_value = true)
+### Generators :define_presence_of(:target_method_name, target_default_value = true)
 
 This generator generates a generator!
 When installed, a class method is created on Object called `#define_presence_of`.
@@ -426,7 +426,7 @@ The generated generator defines an instance method on Object as well as the desc
 Each method returns an opposite result.
 There are several base class gems (not mine) that force a certain naming convention; this one let's you pick the name!
 
-#### Generators :in?
+### Generators :in?
 
 This generator allows us to swap the order of the standard `#include?` method with an improved comprehensive ordering.
 I saw this in another gem called ("object-in" by Tim Rogers), so I give him credit for the idea. It is included here because
@@ -443,7 +443,7 @@ Object.better_install :in?
 'i'.in? "team"  # false
 ``` 
 
-#### Generators :pluralize(meth_name, alt=nil)
+### Generators :pluralize(meth_name, alt=nil)
 
 This generator installs a generator that mimics another method using a pluralized name.
 One of my pet peves is poorly named methods that are grammatically incorrect.
@@ -464,17 +464,17 @@ Object.pluralize :respond_to?     # :responds_to?
 17.responds_to? :to_s             # true
 ```
 
-#### Generators :parent
+### Generators :parent
 
 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.
 
-#### Generators :to_literal
+### Generators :to_literal
 
 This is an alias for `#inspect`. In the event inspect fails, `#to_s` is then called.
 
-#### Generators :tag
+### Generators :tag
 
 This generator creates a family of instance methods. If unrenamed, you will get: `#tag`, `#tag!`, `#untag`, `#tag?` and `#tag=`.
 If you rename this generator to :fred, you will get these: `#fred`, `#fred!`, `#unfred`, `#fred?`, `#fred=`.
@@ -511,7 +511,36 @@ See the example below:
  var1.tag   # false
 ```
 
-#### Generators :sort!
+### Generators :create_tag
+This generator is a class method on Object that installs a named tag generating system.
+Once a tag is generated, it will work just like tag in the previous section.
+This allows an `Object` derived instance to have one or more tags attached.
+If you only need one tag, then the `:tag` generator is a better choice as it can be uninstalled.
+Tags created by #create_tag are 2nd level generators and cannot be uninstalled.
+These two generators are independent so long as you avoid using `:tag` as a source name.
+See the example below:
+
+```ruby
+ Object.better_install :create_tag
+ Object.create_tag :tag1
+ Object.create_tag :tag2
+ Object.create_tag :tag3
+ Object.create_tag :flag
+ str = "Tag me!"
+ str.tag1!
+ str.tag2 = "forget me not"
+ str.ta3  = 17
+ str.tag1?  # true
+ str.tag2?  # true
+ str.flag?  # false
+ str.tag2   # "forget me not"
+ str.flag   # nil
+ str.unflag
+ str.flag   # false
+ end
+```
+
+### Generators :sort!
 
 This method targets only the Hash class and creates the `#sort!` method.
 Hash has a method `#sort` that returns a sorted array of key value pairs.
@@ -527,7 +556,7 @@ hash.sort!
 Hash.keys                         # [:better, :fruit, :zoo]
 ```
 
-#### Generators :find_def
+### Generators :find_def
 
 This method locates the owner of either an instance method or a class method.
 The method expects a symbol representation of the method.
@@ -545,7 +574,7 @@ tst = Fixnum.find_def :new  # tst = nil
 tst = "nope".find_def :foo  # tst = nil
 ```
 
-#### Generators :functionize(meth = :new)
+### Generators :functionize(meth = :new)
 
 This method makes your class look like a method that you simply call on the class constant.
 If you examine the `Rational` class, there is no `#new` constructor at all.
@@ -568,6 +597,32 @@ obj1 = Clown(:one, :two)         # fast way
 obj2 = Clown.new(:three, :four)  # slow way
 ```
 
+### Generators :push_unique(item)
+
+This method extends Array with a new method `#push_unique`. This works just like `#push`,
+but first checks to see if that item already exists; in that case no `#push` occurs.
+See the example below:
+
+```ruby
+Object.better_install :push_unique
+
+ary = []
+ary.push "row"
+ary.push "row"
+ary.push_unique "row"
+ary.push_unique "row"
+ary.push_unique "row"
+ary.push "row"
+ary.push_unique "your boat"
+ary.join " "  # "row row row your boat" 
+```
+
+## Change Log
+
+### Version 1.0.0
+1. Added new generator :push_unique
+2. Added new generator :create_tag
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/betterobject/version.rb

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

data/lib/betterobject.rb

@@ -17,7 +17,7 @@ class Object
     raise "unknown generator #{sym.inspect}" unless  @@better_object_valid_methods.include? sym
   end
   
-  def better_list(include_skip=false)
+  def self.better_list(include_skip=false)
     better_be_object
     rtn = []
     # @@better_object_valid_methods.keys.sort

data/lib/generators.rb

@@ -17,7 +17,6 @@ class Object
   @@better_installed_methods={}
   @@better_object_valid_methods={}
   
-  
 # 
 #  Generator :find_def
 #  
@@ -273,6 +272,23 @@ CODE
 @@better_object_valid_methods[:parent] = 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
+
+
 #
 #  Generator  :tag
 #    
@@ -307,19 +323,62 @@ CODE
 
 
 #
-#  Generator  :functionize
-#    
+#  Generator  :create_tag
+#
 hash = {}
 hash[:type] = :class
-hash[:explain] = "creates MyClass() on Kernel level as an alternate constructor or some other method"
+hash[:explain] = "creates multiple named tags similar to :tag"
 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  
+  def self.BO_METH_NAME(tag_name)
+    class_eval do
+      meth = tag_name.to_s
+      
+      define_method meth.to_sym do
+        @boh_BO_METH_NAME ||= {}
+        nil || @boh_BO_METH_NAME[tag_name]
+      end
+      define_method (meth+"!").to_sym do
+        @boh_BO_METH_NAME ||= {}
+        @boh_BO_METH_NAME[tag_name] = true
+      end
+      define_method ("un" + meth).to_sym do
+        @boh_BO_METH_NAME ||= {}
+        @boh_BO_METH_NAME[tag_name] = false
+      end
+      define_method (meth+"?").to_sym do
+        @boh_BO_METH_NAME ||= {}
+        return nil != (@boh_BO_METH_NAME[tag_name] || nil)
+      end
+      define_method (meth+"=").to_sym do |prm|
+        @boh_BO_METH_NAME ||= {}
+        @boh_BO_METH_NAME[tag_name]=prm
+      end      
+    end
+    tag_name
+  end
 CODE
-@@better_object_valid_methods[:functionize] = hash
+@@better_object_valid_methods[:create_tag] = hash
+
+
+#
+#  Generator  :push_unique
+#
+hash = {}
+hash[:type] = :instance
+hash[:explain] = "creates #push_unique method on Array"
+hash[:code] = <<'CODE'
+  Array.class_eval do
+    def BO_METH_NAME(item)
+      push item unless self.include? item
+      self
+    end
+ end   
+CODE
+hash[:rm] = <<'CODE'
+  Array.class_eval do
+    undef BO_METH_NAME
+  end
+CODE
+@@better_object_valid_methods[:push_unique] = hash
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: betterobject
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-30 00:00:00.000000000 Z
+date: 2018-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler