primitive_wrapper 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9201093aa1a6b289a8daec63a5bb81db853ac54f
-  data.tar.gz: eb6ebb33dd2c259832b1678d24f22892b776e13d
+  metadata.gz: 8e2d245c1ee0f7d46c0df391fcd4165fe22095f9
+  data.tar.gz: b7e8d55707e1b244619154de8373a473e364278c
 SHA512:
-  metadata.gz: 31a190053179c69be065b30386ef83e4d300b39494a04f1cbce428df7f2b2083f21105a2d682ef04ec2a98ec311517f5c9e7130875ab7d431a63f339e52d562c
-  data.tar.gz: cd5a4c4a12b8a2bbc53d5050431cb1b6bafd55afc8febb0c914556466f0aeaf091237f4aadb1880e25124305badf3cf2f49a78abc06787ec9cd756ea52f24243
+  metadata.gz: 6d8791c319f2209cd5bc85dbca416b5471a751a316ad814370cc967e9f5e9f94dd9b2a4d7143a3a92d06ba8f973fbf97e7ef5d35943bbcdba5436b3f9a98d896
+  data.tar.gz: 079ed7917773ad0f916afca375fbddf0285328abda5691cd44cfcaa5b0eedcc786f2158a61bf876a6e6b6b5f5fff4e0818a7c0425ae8bb5f77cda5f62b14da80

data/README.md

@@ -65,21 +65,31 @@ five.kind_of? Integer  # false
 five.kind_of? Value    # true 
 
 5.kind_of? Integer  # true
-5.kind_of? Value    # false 
+5.kind_of? Value    # false
+
+five.type_of? Integer # true
+5.type_of? Integer # true
 ```
 
 As we can see from the above code, the Int class does not derive from Integer or anything that would appear numeric.
 Our `Int` class is simply a container which happens to have the methods of `Integer` but does not derive itself from `Integer`.
 All of these container objects derive from the Value class.
+Also note the new method `#type_of` which allows us test the inner-most entity.
 
 #### Object methods added
 
-There are two new instance methods added to the base Object class necessary to implement this system.
+There are five new instance methods added to the base Object class necessary to implement this system.
 The most important method is the `#to_wrapper` method.
 When an instance variable calls this method, one of the wrapper containers will generate a new instance.
 The one that gets picked is the one best suited for usability.
-The other method named `#prim_value` will return the inner container value or simply return `self` if it is not a container derived from the `Value` class.
-This is mostly used internally by the container objects. Below shows which objects get mapped to which containers:
+We also have a test method called `#wrapped?` to see if we are dealing with the original entity or its thinly wrapped sibling.
+Another method named `#prim_value` will return the inner container value or simply return `self` if it is not a container derived from the `Value` class.
+This is mostly used internally by the container objects. Now that we have wrapped versions of the base elemental objects,
+we need a type checking method that can work on both wrapped and unwrapped primitives: called `#type_of?`.
+Also needed is a method that can duplicated a primitive or its wrapped version; this is called `#pw_copy` which works like dup.
+Note that you can't call `#dup` on an Integer without raising an exception.
+
+Below shows which objects get mapped to which containers:
 
 ```
 nil          =>   Bit
@@ -91,20 +101,24 @@ Rational     =>   Number
 Symbol       =>   SymbolW
 Hash         =>   Property
 String       =>   Datum
+Array        =>   XArray
+Range        =>   XRange
 ```
 
 Some examples are as follows:
 
 ```ruby
-n = nil.to_wrapper     # n.class    == Bit
-b = true.to_wrapper    # b.class    == Bool
-y = 13.to_wrapper      # y.class    == Int
-t = 3e-9.to_wrapper    # t.class    == FloatW
-z = (1+6i).to_wrapper  # z.class    == Number
-str = "yo!".to_wrapper # str.class  == Datum
-me = :me.to_wrapper    # me.class   == SymbolW
-prop = {}.to_wrapper   # prop.class == Property
-aw =[1,2,3].to_wrapper # aw.class   == Value  ... everything else goes inside the Value container
+n = nil.to_wrapper      # n.class    == Bit
+b = true.to_wrapper     # b.class    == Bool
+y = 13.to_wrapper       # y.class    == Int
+t = 3e-9.to_wrapper     # t.class    == FloatW
+z = (1+6i).to_wrapper   # z.class    == Number
+str = "yo!".to_wrapper  # str.class  == Datum
+me = :me.to_wrapper     # me.class   == SymbolW
+prop = {}.to_wrapper    # prop.class == Property
+ary = [1,2].to_wrapper  # ary.class  == XArray  ... X for extended functionality
+ran = (3..0).to_wrapper # ran.class  == XRange
+aw = /[az]/.to_wrapper  # aw.class   == Value  ... everything else goes inside the Value container
 ```
 
 The next sections will detail which objects are allowed to be contained within each container objects.
@@ -112,12 +126,11 @@ The next sections will detail which objects are allowed to be contained within e
 #### Value class container
 
 This is the base class for all the containers created by this gem. Any object or primitive type can be held in this container.
-To access the contents, simply call `#val`, `#prim_val`, or `#unwrap`.
+To access the contents, simply call `#val`, `#prim_val`, `#unwrap`, or for non-numeric types use the tilde `~` prefix operator.
 Note that only `Value` derived objects can call `#val` while every object can call `#prim_val`.
 You can also replace the contents with the `#replace` method or the `#val=` method.
 The `Value` container has no restrictions on what it can hold. Other wrappers will raise an exception if the wrong type is added.
 The comparison binary operators `==`, and `!=` are used to compare equality and inequality; this is done on the inner contained element.
-Note that arrays are already containers, so there is little utility in placing it in another container.
 The value container can only contain a single object; it is like an Array object that is only allowed to hold one item.
 See the example code below: 
 
@@ -153,7 +166,11 @@ The Value class has the following instance methods:
 :==                            #   Compares equality of the inner elements
 :!=                            #   Compares inequality of the inner elements
 :inspect                       #   "(Value)==>data"  where Value is the class name of the Value derived object, and data is #val.inspect
-:to_s                          #   returns #to_s on contained entity                     
+:to_s                          #   returns #to_s on contained entity
+:to_wrapper                    #   returns self ... prevents wrapping a wrapped entity
+:wrapped?                      #   also on object, tests for wrapped behavior 
+:type_of?                      #   also added to object, tests innermost entity or self if primitive
+:inspect                       #   string representing wrapped primitive                 
 ```
 
 #### Bool class container
@@ -227,6 +244,8 @@ The `#to_int` method on `Int` returns self, while `#to_i` accesses the primitive
 Most of the time if `Integer` does not recognize something it calls coerce on the foreign object (which we grabbed from Integer).
 This means that most expressions should work in whatever order you wish: if not, you will have to convert the Int object into an Integer object.
 Pretty much all expressions with Int will create a primitive Integer.
+We also have new methods `#inc` and `#dec` which work like the `C/C++` post increment operators.
+Prefix version methods are `#pre_inc` and `#pre_dec`.
 See the example below:
 
 ```ruby
@@ -289,13 +308,13 @@ See below:
 
 ```ruby
 # non-mutating methods taken from Symbol:
-# :<, :<=, :>, :>=, :[], :between?, :capitalize, :downcase, :empty?, :length, :next, :size, :succ, :swapcase, :upcase
+# :<, :<=, :>, :>=, :[], :between?, :capitalize, :downcase, :empty?, :length, :next, :size, :succ, :pred, :swapcase, :upcase
 
 # non-mutating methods taken from String:
 # :append, :include?, :prepend   ... actually append renamed from :<<
 
 # mutating methods of SymbolW
-# :[]=, :append!, :capitalize!, :downcase!, :next!, :prepend!, :replace, :succ!, :swapcase!, :upcase!
+# :[]=, :append!, :capitalize!, :downcase!, :next!, :prepend!, :replace, :succ!, :pred!, :swapcase!, :upcase!
 
 # construction:
 wsym = :my_symbol.to_wrapper
@@ -379,6 +398,74 @@ abc.defined_properties!      # []  ... you just zapped the entire hash after abc
 # ::reserve_property_names! []  ...  adds additional reserved words    
 ```
 
+#### XRange class container for Range with extensions
+
+While inheritance could have accomplished similar goals, this gem is all about wrapped objects.
+Mutability would not be possible with an inherited version. Note that Range objects are not completely immutable;
+`range_instance.first.upcase!` will modify the range that is defined with strings.
+The `XRange` object redefines much of the behavior of `Range` with regard to ranges that descend rather than ascend.
+Note that descending Range objects will return false on methods such as `#include?` and `#cover?` and will not enumerate with `#each`.
+There is great utility in having a functional downward range that actually does what would naturally be expected.
+This gem includes the gem `pred` which makes reverse behavior possible.
+Integers and Strings use the method `#succ` within the classic `Range` to get the next sequence value.
+The method `#pred` is added to to Integers and Strings to get the inverse sequence value.
+The `XRange` container captures the methods of `Range` but redefines most of the methods to define reverse behavior.
+Below is a list of what has changed:
+
+```ruby
+# :reverse         Range, XRange  ... reverses first and last, creates a new object of same type as caller
+# :reverse!        XRange         ... self-modified version of :reverse
+# :reverse?        Range, XRange  ... true if descending
+# :simplify        Range, XRange  ... converts if possible excluded to non-excluded range with same behavior
+# :simplefy!       XRange         ... self-modified version of :simplify
+# :reorder         Range, XRange  ... creates ascending Range or XRange
+# :reorder!        XRange         ... self-modified version of :reorder  
+# :to_range        Range, XRange  ... accesses inner element or returns self if Range
+# :to_xr           Range, XRange  ... creates an XRange object or returns self if XRange
+# :size, :count    XRange         ... redefined from nil to actual size if descending were reversed
+# :include?        XRange         ... redefined from false to behave as if reversed
+# :cover?          XRange         ... redefined from false to behave as if reversed
+# :member?         XRange         ... redefined from false to behave as if reversed
+# :to_a            XRange         ... redefined from empty [] to list ordered sequence
+# :max, :min       XRange         ... redefined from nil to return maximum/minimum range values
+# :eql? :==        XRange         ... compares using contained entity
+# :step(n)         XRange         ... redefined to work with descending sequences
+# :reverse_step(n) XRange         ... reverses sequence before stepping
+# :each            XRange         ... redefined to work with descending sequences
+# :reverse_each    XRange         ... reverse version of :each
+# :re_range(ng)    XRange         ... creates new range converting negative start, end to positive given size==ng
+#                                 ... used by XArray access operators that use descending ranges.
+```
+
+#### XArray class container for Array with extensions
+
+This creates a wrapped `Array` with behavior that enhances the access operators of `Array`;
+additionally a few new methods were added to the wrapped version.
+The methods `#ssort`, `#ssort!` sort `XArray` elements using `#to_s` on each comparison.
+The methods `#isort`, `#isort!` sort `XArray` elements using `#inspect` on each comparison.
+The method `#to_xa` what added to `Array` as a more terse way of creating a wrapper on `Array`.
+The method `#empty!` was also added. These two aforementioned methods also get included in `XArray`.
+`XArray` mimics the behavior of `Array` but redefines `:[]` and `:[]=` to include lists wich comprise indexes, ranges, and arrays of indexes.
+There is also behavior that defines many-to-one, one-to-many, and many-to-many operations. Note that one-to-one behavior has not changed.
+An example best explains how this works:
+
+```ruby
+  ary = [2,3,5,7,11,13,17,19,23,29,31,37,41].to_xa
+  tst = ary[5..0,10,-1]  # tst == [13, 11, 7, 5, 3, 2, 31, 41]  ... note reverse range
+  
+  # many-to-many
+  ary[4,5,1] = "a", "b", "c", "d"  # ary == [2, "c", 5, 7, "a", "b", 17, 19, 23, 29, 31, 37, 41]
+  # note above, unused ignored
+  
+  # one-to-many
+  ary[8..-1] = :s  #  ary == [2, 3, 5, 7, 11, 13, 17, 19, :s, :s, :s, :s, :s]
+  # note: ary.prim_value[8..-1] = :s  returns this:  [2, 3, 5, 7, 11, 13, 17, 19, :s] ... which is useless
+
+  # many-to-one
+  ary[-1] = 1,2,3  # ary == [2, "c", 5, 7, "a", "b", 17, 19, :s, :s, :s, :s, [1, 2, 3]]
+  ary[-2] = [:a, :b] # ary == [2, "c", 5, 7, "a", "b", 17, 19, :s, :s, :s, [:a, :b], [1, 2, 3]]
+```
+
 #### Customization
 
 Things should work out of the box, until they don't. This section will detail what customization is possible with what container.
@@ -475,6 +562,14 @@ Now we are left with the head-scratcher on how to decide which is the best retur
 This can be mostly a matter of taste, but we can choose custom names that convey this information. Now if you have an extension library such as used by the `gstring` gem, you have an even larger list to choose from.
 So it is left to you to decide.
 
+## Revision History
+### Version 1.0.0
+* fixed wrapper inside wrapper causing stack overflow
+* Documentation updates
+* Added new wrappers for Range, Array as XRange and XArray
+* added primitive methods
+* added Value methods, and enhanced other derived wrappers
+
 ## 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/primitive_wrapper.rb

@@ -1,14 +1,24 @@
 require "primitive_wrapper/version"
 require "blockify"
-
+require "yieldhelper"  # am I using this really?
+require "pred"
 
 #
 #  Standard Object upgrades
 #
 class Object
+  def type_of?(cls)
+    kind_of? cls
+  end
+  def pw_copy
+    self.dup rescue self
+  end
   def prim_value
     self
   end
+  def wrapped?
+    false
+  end
   def to_wrapper
     return Bit.new(nil) if self.nil?
     return Bool.new(true) if self==true
@@ -19,6 +29,8 @@ class Object
     return Datum.new(self) if self.kind_of? String
     return SymbolW.new(self) if self.kind_of? Symbol
     return Property.new(self) if self.kind_of? Hash
+    return XArray.new(self) if self.kind_of? Array
+    return XRange.new(self) if self.kind_of? Range
     return Value.new(self)
   end
 end
@@ -47,6 +59,62 @@ class NilClass
   end
 end
 
+class Range
+  def ~
+    self
+  end
+end
+
+class Array
+  def ~
+    self
+  end
+end
+
+class Range       # if it makes sense, add methods here 
+  def reversed? 
+    first > last
+  end
+  def to_xr
+    XRange.new self
+  end
+  def reverse
+    if exclude_end?
+      (last...first)
+    else
+      (last..first)
+    end    
+  end
+  def reorder
+    if exclude_end?
+      last < first ? (last...first) : (first...last)
+    else
+      last < first ? (last..first) : (first..last)
+    end
+  end
+  def reversed?
+    last < first 
+  end
+  def simplify
+    if exclude_end?
+      return (first...last) if first==last
+      return (first..last.pred)
+    end
+    return (first..last)
+  end
+end
+
+class Array
+  def empty!
+    old = self.dup
+    replace []
+    return old
+  end
+  def to_xa
+    XArray.new(self)
+  end
+end
+
 #
 #  BASE CLASS == Value ... a wrapper for any ruby object
 #
@@ -68,6 +136,18 @@ class Value
     @value = obj
   end
   
+  def to_wrapper
+    self
+  end
+  def wrapped?
+    true
+  end
+  def type_of?(cls)
+    return true if @value.kind_of? cls
+    return true if self.kind_of? cls
+    false
+  end
+  
   def ensure_valid(obj, mess = "Incompatible type")
     unless valid_type(obj)
       raise mess
@@ -111,7 +191,7 @@ class Value
   end
   
   def replace(other)    
-    @value = other if valid_type(other)
+    @value = other.prim_value if valid_type(other)
   end
   
   def to_s
@@ -307,10 +387,10 @@ class SymbolW < Value
   end
   
   # create non-mutate SymbolW methods
-  bestow_symbol_methods( [:next, :succ, :[], :length, :size, :upcase, :downcase, :capitalize, :swapcase, :<, :>, :<=, :>=, :between?, :empty? ], false)
+  bestow_symbol_methods( [:next, :succ, :pred, :[], :length, :size, :upcase, :downcase, :capitalize, :swapcase, :<, :>, :<=, :>=, :between?, :empty? ], false)
   
   # create mutate SymbolW methods  ... these will auto-bang!
-  bestow_symbol_methods([:next, :succ, :upcase, :downcase, :capitalize, :swapcase, :succ], true)
+  bestow_symbol_methods([:next, :succ, :upcase, :downcase, :capitalize, :swapcase, :pred], true)
   
   # string non-mutate methods
   bestow_string_non_mutate_methods([:match, :include?], nil)
@@ -375,6 +455,14 @@ class Int < ValueAdd
   def ~
     ~@value
   end
+  
+  def pre_inc
+    @value+=1 
+  end
+
+  def pre_dec  
+    @value-=1 
+  end
 end
 
 class FloatW < ValueAdd
@@ -539,7 +627,7 @@ class Property < Value
     @hold_keys.each_pair do |key,val|
       bad[key] = @value[key]
     end
-    return [good,bad]
+    return [good, bad]
   end
   
   def [](idx)
@@ -604,7 +692,400 @@ class Property < Value
       @value[key]=dflt
     end
   end
+end
 
+class XRange < ValueAdd
+  capture_base_methods(Range)
+  def valid_type(prm)
+    return true if prm.kind_of? Range
+    return true if prm.kind_of? XRange
+    false
+  end
+  def reverse!
+    @value = @value.reverse
+    self
+  end
+  def reverse
+    @value.reverse.to_xr
+  end
+  def simplify!
+    @value = @value.simplify
+    self
+  end
+  def reorder!
+    @value = @value.reorder
+    self
+  end
+  
+  def simplify
+    @value.simplify.to_xr
+  end  
+  def to_xr
+    self
+  end
+  def to_range  # add similar to other wrappers
+    @value
+  end
+  def re_range(ng) 
+    return self if ng.nil?
+    return self if ng <= 0
+    return self unless first.kind_of? Integer    
+    t_first = first
+    t_last = last
+    if first.negative?
+      t_first = ng+first
+    end
+    if last.negative?
+      t_last = ng+last
+    end
+    if exclude_end?
+      XRange.new (t_first...t_last)
+    else
+      XRange.new (t_first..t_last)
+    end
+  end
+  def re_range!(ng)
+    replace re_range(ng)
+  end  
+  def size   # getting the wrong count ... off by 1
+    dirty = false
+    sz = @value.size
+    if sz.nil?
+      dirty = true
+    elsif sz==0
+      dirty = true
+    end
+    unless dirty
+      return sz
+    end
+    if first.respond_to? :lcm  # Covers both Integer and Int
+      sz = reversed? ? @value.reverse.size : @value.size
+      return sz
+    end
+    range = @value.reorder
+    cnt = 0
+    # curr = range.first.dup rescue range.first
+    curr = range.first.pw_copy
+    stop = range.last
+    loop do
+      cnt += 1  # 5..5 is count of 1
+      break if curr==stop
+      curr.succ!
+    end
+    cnt -= 1 if exclude_end?
+    return cnt  
+  end
+  def count
+    size
+  end
+  def include?(val)  # account for reversed ordering
+    @value.reorder.include? val
+  end
+  def cover?(val)  # means val>=start and val<=end ... different than include
+    @value.reorder.include? val
+  end
+  def member?(val) # same as include?
+    @value.reorder.include? val
+  end
+  def to_a
+    dat = @value.reorder.to_a
+    return reversed? ? dat.reverse : dat    
+  end
+  def max(*n, &block)
+    @value.reorder.send(:max, *n, &block)  
+  end
+  def min(*n, &block)
+    @value.reorder.send(:min, *n, &block)  
+  end
+  def eql?
+    @value.eql? (~other)
+  end  
+  def ===(other)
+    @value.include? other
+  end
+  
+  def ==(other)
+    @value.eql? (~other)
+  end
+    
+  def step(n=1)
+    n = 1 if n<= 0
+    return Enumerator.enumerate_yields(self, :step, n) unless block_given?
+    curr = first.pw_copy
+    if exclude_end?
+      if reversed?
+        loop do
+          break if curr <= last
+          yield curr
+          n.times { |t| curr = curr.pred }
+        end
+      else
+        loop do
+          break if curr >= last
+          yield curr
+          n.times { |t| curr = curr.succ }
+        end
+      end
+    else
+      if reversed?
+        loop do
+          yield curr
+          break if curr <= last
+          n.times { |t| curr = curr.pred }
+        end
+      else
+        loop do
+          yield curr
+          break if curr >= last
+          n.times { |t| curr = curr.succ }
+        end
+      end
+    end    
+  end
+
+  def reverse_step(n=1)
+    n = 1 if n<= 0
+    return Enumerator.enumerate_yields(self, :reverse_step, n) unless block_given?
+    curr = last.pw_copy
+    if exclude_end?
+      if reversed?
+        loop do
+          break if curr >= first
+          yield curr
+          n.times { |t| curr = curr.succ }
+        end
+      else
+        loop do
+          break if curr <= first
+          yield curr
+          n.times { |t| curr = curr.pred }
+        end
+      end
+    else
+      if reversed?
+        loop do
+          yield curr
+          break if curr >= first
+          n.times { |t| curr = curr.succ }
+        end
+      else
+        loop do
+          yield curr
+          break if curr <= first
+          n.times { |t| curr = curr.pred }
+        end
+      end
+    end    
+  end
+
+  def each(&block)
+    self.send(:step, 1, &block)
+  end 
+  
+  def reverse_each(&block)
+    self.send(:reverse_step, 1, &block)
+  end 
+
+end
+
+module PrimitiveWrapper
+  def self.get_list(list, ng=nil)
+    rtn = []
+    if list.empty?
+      return []
+    elsif list.count == 1
+      item = list.first
+      if item.type_of? Range
+        rtn.push item.to_wrapper
+      else
+        rtn.push item
+      end
+      return rtn
+    end
+    list.each do |ii|
+      if(ii.type_of? Range)
+        ii = ii.to_wrapper
+        ii.re_range!(ng)
+      end
+      if ((ii.type_of? Range) || (ii.type_of? Array))
+        ii.each do |idx|
+          rtn.push idx
+        end
+      else 
+        rtn.push ii
+      end
+    end
+    return rtn
+  end
+  def self.copy(dest, source, indexes)
+    rtn = []
+    if indexes == :all
+      if source.type_of? Array
+        source.count.times do |idx|
+          rtn.push(dest[idx]=source[idx])
+        end
+      else
+        dest.count.times do |idx|
+          rtn.push(dest[idx]=source)
+        end
+      end
+    else
+      if source.type_of? Array
+        ii = 0
+        indexes.each do |idx|
+          rtn.push(dest[idx]=source[ii])
+          ii += 1
+        end      
+      else
+        indexes.each do |idx|
+          rtn.push(dest[idx]=source)
+        end            
+      end
+    end
+    rtn.count <= 1 ? rtn.first : rtn   
+  end  
 end
 
 
+### need to figure out how left and right things work ...
+####
+###   OK this is cool,  things on the right if more than one go in one array
+###   ... or a non-array if just one item
+
+class XArray < ValueAdd
+  LAM_ISORT = lambda {|a,b| a.inspect <=> b.inspect }
+  LAM_SSORT = lambda {|a,b| a.to_s <=> b.to_s }
+  capture_base_methods(Array)
+  
+  def initialize(obj=[])
+    obj = obj.prim_value
+    ensure_valid(obj)
+    @value = obj
+  end
+  
+  def valid_type(prm)
+    return true if prm.kind_of? Array
+    return true if prm.kind_of? XArray
+    false
+  end
+  def isort 
+    @value.sort &LAM_ISORT
+  end
+  def isort!
+    @value.sort! &LAM_ISORT
+  end
+  def ssort
+    @value.sort &LAM_SSORT
+  end
+  def ssort!
+    @value.sort! &LAM_SSORT
+  end
+  def [](*list)
+    list = PrimitiveWrapper::get_list(list,size)
+    if list.empty?
+      return nil
+    elsif list.count==1
+      if list.first == :all
+        return @value
+      elsif list.first.type_of? Range  # get_list may pick this appart
+        rtn = []
+        list.first.to_wrapper.re_range(size).each do |idx|
+          rtn.push @value[idx]
+        end
+        return rtn  
+      else
+        return @value[list.first]
+      end
+    end
+    rtn = []
+    # for now keep this here until you can justify that it is not needed
+    list.each do |ii|   # I don't need to do this do I ???  get_list should untangle things
+      if ii.type_of? Range
+        ii.to_wrapper.re_range(size).each do |idx|
+          rtn.push @value[idx]
+        end
+      elsif ii.type_of? Array
+        ii.each do |idx|
+          rtn.push @value[idx]
+        end
+      else
+        rtn.push @value[ii]
+      end
+    end
+    return rtn
+  end
+  def []=(*list)
+    data = list.pop
+    list = PrimitiveWrapper::get_list(list,size)
+    return nil if list.empty?
+    if list.count==1
+      if list.first.respond_to? :each
+        list = list.first
+        if list.type_of? Range
+          list = list.to_xr.re_range(size)
+        end
+      end
+    end
+    if list.count==1
+      if list.first == :all
+        PrimitiveWrapper.copy(@value, data, :all) 
+      end
+      idxs = list.first
+      if (idxs.respond_to? :each)
+        if idxs.type_of? Range
+          idxs = idxs.to_xr.re_range(size)
+        end        
+        idxs.each do |idx|
+          @value[idx] = data
+        end
+      else
+        @value[idxs] = data
+      end 
+    else
+      if data.type_of? Array
+        data = PrimitiveWrapper::get_list(data,size)
+      end
+      PrimitiveWrapper.copy(@value, data, list)
+    end
+  end
+  def delete_at(*index_list)
+    return nil if index_list.empty?
+    if (index_list.count==1)
+      if index_list.first==:all
+        self.empty!
+      end  
+    else
+      list = PrimitiveWrapper::get_list(index_list,size)
+      rtn = []
+      list.sort.reverse.each do |idx|
+        rtn.push = @value.delete_at(idx)
+      end
+      return rtn
+    end
+  end
+  def include?(*list)  # replace with list of stuff
+    if list.count==1
+      if list.first.respond_to? :each
+        list = list.first
+      end
+    end
+    list.each do |item|
+      return false unless @value.include? item
+    end
+    true
+  end
+  def include_any?(*list)  # replace with list of stuff
+    if list.count==1
+      if list.first.respond_to? :each
+        list = list.first
+      end
+    end
+    list.each do |item|
+      return true if @value.include? item
+    end
+    false
+  end
+end
+
+
+

data/lib/primitive_wrapper/version.rb

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

data/primitive_wrapper.gemspec

@@ -29,7 +29,11 @@ The `Property` object auto-methodizes the key names of the Hash.}
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   
-  spec.add_runtime_dependency 'blockify', '>= 0.1.0'
+  spec.required_ruby_version = '>= 2.2.0'
+  
+  spec.add_runtime_dependency 'blockify', '~> 0.2', '>= 0.2.0'
+  spec.add_runtime_dependency 'yieldhelper', '~> 0.1', '>= 0.1.0'
+  spec.add_runtime_dependency 'pred', '~> 0.1', '>= 0.1.2'
 
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,19 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: primitive_wrapper
 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-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blockify
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: yieldhelper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.0
@@ -21,9 +44,32 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: pred
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,7 +175,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="