primitive_wrapper 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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "primitive_wrapper"
+
+# 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/primitive_wrapper.rb

@@ -0,0 +1,610 @@
+require "primitive_wrapper/version"
+require "blockify"
+
+
+#
+#  Standard Object upgrades
+#
+class Object
+  def prim_value
+    self
+  end
+  def to_wrapper
+    return Bit.new(nil) if self.nil?
+    return Bool.new(true) if self==true
+    return Bool.new(false) if self==false
+    return Int.new(self) if self.kind_of? Integer
+    return FloatW.new(self) if self.kind_of? Float
+    return Number.new(self) if self.kind_of? Numeric
+    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 Value.new(self)
+  end
+end
+
+class Symbol
+  def ~
+    self
+  end
+end
+
+class TrueClass
+  def ~
+    self
+  end
+end
+
+class FalseClass
+  def ~
+    self
+  end
+end
+
+class NilClass
+  def ~
+    self
+  end
+end
+
+#
+#  BASE CLASS == Value ... a wrapper for any ruby object
+#
+class Value
+  def self.raise_on_freeze
+   @freeze_raise = true
+  end
+  def self.ignore_on_freeze
+   @freeze_raise = false
+  end
+  def self.freeze_raise?
+    @freeze_raise
+  end
+  ignore_on_freeze
+  
+  def initialize(obj=nil)
+    obj = obj.prim_value
+    ensure_valid(obj)
+    @value = obj
+  end
+  
+  def ensure_valid(obj, mess = "Incompatible type")
+    unless valid_type(obj)
+      raise mess
+    end  
+  end 
+
+  def freeze  # never allow the wrapper to be frozen
+    raise "this object cannot be frozen" if self.class.freeze_raise?
+  end
+
+  def val
+    @value
+  end
+  
+  def ~
+    @value
+  end
+
+  def val=(dat)
+    replace(dat)
+  end
+
+  def prim_value
+    @value
+  end
+  
+  def unwrap
+    @value
+  end
+
+  def ==(other)
+    other.prim_value == @value
+  end
+
+  def !=(other)
+    other.prim_value != @value
+  end  
+
+  def valid_type(prm=nil)
+    true
+  end
+  
+  def replace(other)    
+    @value = other if valid_type(other)
+  end
+  
+  def to_s
+    @value.to_s
+  end  
+
+  def inspect
+    str = @value.nil? ? "nil" : @value.inspect
+    "(#{self.class}==>#{str})"
+  end  
+end
+
+class Bool < Value
+  def valid_type(prm)
+    return true if prm.kind_of? TrueClass
+    return true if prm.kind_of? FalseClass
+    return true if prm.kind_of? TrueW
+    return true if prm.kind_of? FalseW
+    return true if prm.kind_of? Bool
+    false
+  end
+  
+  def |(other)
+    Bool.new(@value | other.prim_value)
+  end
+  
+  def &(other)
+    Bool.new(@value & other.prim_value)
+  end
+  
+  def ^(other)
+    Bool.new(@value ^ other.prim_value)
+  end
+
+  def !
+    Bool.new(!@value)
+  end
+    
+  def to_i
+    @value ? 1:0
+  end
+  def to_int
+    Int.new(@value ? 1:0)
+  end
+end
+
+class Bit < Bool
+  def valid_type(prm)
+    return true if prm.kind_of? TrueClass
+    return true if prm.kind_of? FalseClass
+    return true if prm.kind_of? NilClass
+    return true if prm.kind_of? Bool
+    false
+  end 
+  def |(other)
+    @value | other.prim_value
+  end
+  
+  def &(other)
+    @value & other.prim_value
+  end
+  
+  def ^(other)
+    @value ^ other.prim_value
+  end
+
+  def !
+    !@value
+  end
+  def to_i
+    @value ? 1:0
+  end
+  def to_int
+    Int.new(@value ? 1:0)
+  end  
+end
+
+class FixedBit < Bit
+  def initialize
+    raise "FixedBit cannot create instance"
+  end    
+  def replace(other)
+    raise "can't assign primitive type"
+  end  
+end
+
+class FalseW < FixedBit
+  def initialize
+    @value = false
+  end    
+end
+
+class TrueW < FixedBit
+  def initialize
+    @value = true  
+  end
+end
+
+class Null < FixedBit
+  def initialize
+    @value = nil
+  end
+end
+
+class SymbolW < Value
+  def valid_type(prm)
+    return true if prm.kind_of? Symbol
+    return true if prm.kind_of? SymbolW
+    false
+  end
+  
+  FIX_ARGS = lambda do |elm|
+    rtn = elm
+    if elm.kind_of? Symbol
+      rtn = elm.to_s
+    elsif elm.kind_of? SymbolW
+      rtn = elm.to_s
+    end
+    rtn
+  end
+    
+  def self.bestow_string_mutate_method(meth_def_name, meth_call_name)
+    define_method meth_def_name do |*args, &block| 
+      prms = args.blockify_elements &FIX_ARGS
+      str = @value.to_s
+      str.send(meth_call_name, *prms, &block)
+      @value = str.to_sym
+    end  
+  end
+  
+  def self.bestow_string_non_mutate_method(meth_def_name, meth_call_name, return_type = SymbolW)
+    if return_type==Symbol
+      define_method meth_def_name do |*args, &block|
+        prms = args.blockify_elements &FIX_ARGS
+        @value.to_s.send(meth_call_name, *prms, &block).to_sym
+      end
+    elsif return_type==String
+      define_method meth_def_name do |*args, &block|
+        prms = args.blockify_elements &FIX_ARGS
+        @value.to_s.send(meth_call_name, *prms, &block).to_s
+      end
+    elsif return_type==SymbolW
+      define_method meth_def_name do |*args, &block|
+        prms = args.blockify_elements &FIX_ARGS
+        SymbolW.new @value.to_s.send(meth_call_name, *prms, &block).to_s.to_sym
+      end
+    else  # default type
+      define_method meth_def_name do |*args, &block|
+        prms = args.blockify_elements &FIX_ARGS
+        @value.to_s.send(meth_call_name, *prms, &block)
+      end
+    end    
+  end 
+  
+  def self.bestow_symbol_method(meth_def_name, meth_call_name, mutate_self=false)
+    if mutate_self      
+      define_method meth_def_name do |*args, &block| 
+        margs = args.blockify_elements { |t| t.prim_value }       
+        tval = @value.send(meth_call_name, *margs, &block)
+        ensure_valid(tval, "symbol mutate method not valid")
+        @value = tval
+        return self
+      end  
+    else
+      define_method meth_def_name do |*args, &block| 
+        margs = args.blockify_elements { |t| t.prim_value }
+        rtn = @value.send(meth_call_name, *margs, &block)
+        return rtn
+      end  
+    end
+  end 
+  
+  def self.bestow_string_mutate_methods(meths)
+    meths.each do |meth|
+      bestow_string_mutate_method(meth, meth)
+    end    
+  end
+  
+  def self.bestow_string_non_mutate_methods(meths, return_type = SymbolW)
+    meths.each do |meth|
+      bestow_string_non_mutate_method(meth, meth, return_type)
+    end    
+  end
+    
+  def self.bestow_symbol_methods(meths, mutate_self=false)
+    meths.each do |meth|
+      dmeth=meth 
+      if mutate_self
+        dmeth = (meth.to_s + '!').to_sym
+      end
+      bestow_symbol_method(dmeth, meth, mutate_self)
+    end    
+  end
+  
+  # create non-mutate SymbolW methods
+  bestow_symbol_methods( [:next, :succ, :[], :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)
+  
+  # string non-mutate methods
+  bestow_string_non_mutate_methods([:match, :include?], nil)
+  bestow_string_non_mutate_methods([:prepend], SymbolW)
+  bestow_string_non_mutate_method(:append, :<<, SymbolW)
+
+  # string mutate methods
+  bestow_string_mutate_method(:prepend!, :prepend)
+  bestow_string_mutate_method(:append!, :<<)
+  bestow_string_mutate_method(:[]=, :[]=)
+
+  # why did I redefine this? don't remember ... investigate later
+  def include? pat
+    self.to_s.include? pat.to_s
+  end
+  
+  # old-fashioned defines:
+  def to_sym
+    @value
+  end
+  def to_str
+    @value.to_s
+  end
+end
+
+class ValueAdd < Value
+  def valid_type(prm) # must override
+    false
+  end
+  def self.bestow_methods(*args)
+    args = args.first if args.first.kind_of? Array
+    args.each do |meth|
+      define_method meth do |*args, &block|
+        @value.send(meth, *args, &block)
+      end  
+    end    
+  end  
+  def self.capture_base_methods(type, except=Object)
+    add_me = type.instance_methods - except.instance_methods - Value.instance_methods - [:singleton_method_added]
+    bestow_methods add_me
+  end
+end
+
+class Int < ValueAdd
+  capture_base_methods(Fixnum)  # Bignum also works here  ... :to_f, :* etc
+  def valid_type(prm)
+    return true if prm.kind_of? Integer
+    return true if prm.kind_of? Int
+    false
+  end
+  def inc   # simulates post-increment
+    @value+= 1
+    return @value-1
+  end
+  def dec   # simulates post-deccrement
+    @value-= 1
+    return @value+1
+  end
+  def to_int
+    self
+  end
+  def ~
+    ~@value
+  end
+end
+
+class FloatW < ValueAdd
+  capture_base_methods(Float)
+  def valid_type(prm)
+    return true if prm.kind_of? Float
+    return true if prm.kind_of? FloatW
+    false
+  end
+  def to_int
+    Int.new @value.to_i
+  end
+end
+
+class Number < ValueAdd
+  capture_base_methods(Fixnum)
+  capture_base_methods(Float, self)
+  capture_base_methods(Complex, self)
+  capture_base_methods(Rational, self)  
+  def valid_type(prm)
+    return true if prm.kind_of? Numeric
+    return true if prm.kind_of? Number
+    false
+  end
+  def ~   # make sure capture did not muck things up
+    @value   # If you need ~ use Int instead of Number
+  end
+  def to_int
+    Int.new @value.to_i
+  end  
+end
+
+# string, number
+class Datum < ValueAdd
+  capture_base_methods(Number)
+  capture_base_methods(String, self)
+  def valid_type(prm)
+    return true if prm.kind_of? Numeric
+    return true if prm.kind_of? String
+    return true if prm.kind_of? Datum
+    false
+  end
+
+  # methods that broke ... fixed here  
+  def to_s
+    @value.to_s    
+  end
+  def ~   # make sure capture did not muck things up
+    @value   # If you need ~ use Int instead of Number
+  end 
+  def to_int
+    Int.new @value.to_i
+  end  
+end
+
+class Property < Value
+  GOOD_KEY_RGX = /\A[a-zA-Z_][a-zA-Z_0-9]*\z/
+
+  def initialize(hash={})
+    self.val=(hash)
+  end
+  
+  def self.bad_key?(idx)
+    @badkeys ||= {}
+    true==@badkeys[idx]
+  end
+
+  def self.good_candidate_name? name
+    name = name.prim_value
+    return false unless name.kind_of? Symbol
+    tst = GOOD_KEY_RGX.match name
+    return false if tst.nil?
+    true
+  end
+  
+  def self.good_key?(idx)  # syntax and not bad ... does not check to see if taken as only instansts can do that
+    idx = idx.prim_value
+    return false unless good_candidate_name? idx 
+    return false if bad_key?(idx)
+    true    
+  end
+  
+  def self.reserve_property_names!(*names)
+    @badkeys ||= {}
+    names = names.first if names.first.kind_of? Array
+    names.each do |key|
+      next if key[-1]=='!'
+      next if key[-1]=='?'
+      kw = key[-1]=='=' ? key[0..-2] : key[0..-1]
+      md = GOOD_KEY_RGX.match kw
+      next if md.nil?  # bad key 
+      @badkeys[key]=true
+    end
+  end
+  reserve_property_names!(self.instance_methods)
+  reserve_property_names!(Object.new.private_methods)
+  
+  # assign replacement hash
+  def val=(hash)
+    ensure_valid(hash)
+    hash = hash.prim_value
+    @value = hash    # keep this as prime as possible
+    rekey!
+  end
+  
+  def rekey!
+    @good_keys = {}  # these keys can be properties
+    @hold_keys  = {} # these keys can't
+    @value.each_pair do |pkey,val|
+      key = pkey.prim_value
+      if self.class.good_key? key
+        @good_keys[key.prim_value]=true
+      else
+        @hold_keys[key.prim_value]=true
+      end
+    end
+  end  
+  
+  def method_missing(method, *args, &block)
+    flag_good = @good_keys.include? method
+    unless flag_good
+      unless method[-1]=='='
+        if @value.include? method
+          rekey!
+          flag_good = @good_keys.include? method
+        end
+      end
+    end
+    raise "Illegal Block attachment" unless block.nil?
+    if flag_good
+      raise "*** ArgumentError Exception: wrong number of arguments (given #{args.count}, expected 0)" unless args.empty?
+      return @value[method]  
+    end
+    if method[-1]=='='  # assignment
+      key = method[0..-2].to_sym      
+      if args.count==1
+        if @good_keys.include? key
+          @value[key] = args[0]
+          return true
+        end
+        # creating a new key here ... good or bad?
+        if self.class.good_key? key
+          @good_keys[key]=true
+        else
+          @hold_keys[key]=true
+        end
+        return @value[key] = args[0] 
+      end
+      raise "*** ArgumentError Exception: wrong number of arguments (given #{args.count}, expected 1)"
+    else
+      # lookup failed ... punt
+      super
+    end
+  end
+    
+  def split!
+    good = {}
+    bad = {}
+    @good_keys.each_pair do |key,val|    
+      good[key] = @value[key]
+    end
+    @hold_keys.each_pair do |key,val|
+      bad[key] = @value[key]
+    end
+    return [good,bad]
+  end
+  
+  def [](idx)
+    @value[idx]
+  end
+  
+  def []=(idx,val)
+    idx = idx.prim_value # in case it is wrapped
+    rtn = @value[idx] = val
+    # now put key in one of two bins
+    if self.class.good_key? idx
+      @good_keys[idx]=true
+    else
+      @hold_keys[idx]=true
+    end
+    return rtn
+  end
+
+  def import_hash!(hash)
+    hash.each_pair do |key,val|
+      self[key]=val
+    end 
+  end
+  
+  def valid_type(prm)
+    return true if prm.kind_of? Hash
+    return true if prm.kind_of? Property
+    false
+  end
+  
+  def defined_properties!
+    rekey!
+    @good_keys.keys.sort
+  end
+  def deferred_properties!
+    rekey!
+    @hold_keys.keys  # can't sort bad keys without a ton of work
+  end
+  
+  def property?(tst)
+    rekey!
+    tst = tst.prim_value
+    return true if @good_keys.include? tst
+    false
+  end
+
+  def deferred?(tst)
+    rekey!
+    tst = tst.prim_value
+    return true if @hold_keys.include? tst
+    false
+  end
+  
+  def define_properties!(ary, dflt="")
+    ary.each do |item|
+      key = item.prim_value
+      raise "*** Property Error: must use Symbol type to define properties" unless key.kind_of? Symbol
+      raise "*** Property Error: property #{key.inspect} already defined" if @good_keys.include? key
+      raise "*** Property Error: property #{key.inspect} violates naming convention" unless self.class.good_candidate_name? key
+      raise "*** Property Error: property #{key.inspect} is reserved" if self.class.bad_key? key
+      @good_keys[key]=true
+      @value[key]=dflt
+    end
+  end
+
+end
+
+