setfu 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98a90b0258e875fad04750814d8324d7a6a01d09
-  data.tar.gz: 871a1632723b4d212128bc1cba8e08c455ea464c
+  metadata.gz: 134e00fed065a113e94ad7aa53d038a3123ce7e2
+  data.tar.gz: c255f820ed6460f627da42276830fa2a03cf1bbc
 SHA512:
-  metadata.gz: b0ce98d4fdbfd73362b9a5d0b76b6fd5eecf623d47a9afd9e61e58ec81190c020210b21dc3547bb7c272f1295264b9c62c15af32d4a84a2e030a340da5822c4f
-  data.tar.gz: bab004705084529b0391eb2354c94077b0a73b36d630e1500062361a67244fa8f1cda39a3a09e8b9ec3794ad55b519a70ac031fcdc151cc5ef1f4ac956c760b7
+  metadata.gz: c6da933de018e78187a64b1000c8cfd0c1da26eaa00a88e74668193b171f803e83b25340c90a6607ea96dab1f4a16988d9e171f41762646351ef88ef2888e26c
+  data.tar.gz: 5da251f1351be7e684a20bdb490edccee46da8a06aab0d1c81748b6d200c746909a154ed564ef1efd8d32d579e40023957345b635877d83c2d702dfe6ca591b3

data/README.md

@@ -1,85 +1,10 @@
 # Setfu
 
-Purpose:  A general purpose object implementing sets.
+##Purpose:  A general purpose object implementing sets.
+
+##Documentation
+See: http://bdlsys.com/gems/setfu.html
 
-Construction:
-   Set.new                        >> creates an empty set
-   Set.new(p)                     >> creates a set initialized with elements p
-   Set.new.add!(p)                >> chained with #add method 
-       ::parameter p::
-           "abcxyz"        >> ordinate values of each character added to set
-           'a'..'z'        >> ordinate values of each range element added to set
-           [6,19,'g'..'k'] >> items in an array added to set (recursively)
-           375             >> element number `375` added to set
-           or set instance
-   [v0,v1,...].to_set                     >> converts array to set instance 
-       ::array values::
-           set instance
-           array literal, array instance  >> recursive values must comply to first-level rules
-           string literal, string instance
-           range literal, range instance
-           positive small integers including zero, integer instance
-   "a7P".to_set                  >> converts ordinate values of each char to set members
-   ('a'..'k').to_set             >> converts ordinate values of each char in range to set members
-                                    parenthesis needed for literal.  parenthesis not needed for instance variable                          
-     
-Operators:
-   a <  b      >>  true if `a` is a "proper" subset of `b`  ... a !=b and a in b            
-   a <= b      >>  true if `a` is a subset of `b`
-   a -  b      >>  set difference ... removes elements from a found in b
-   a &  b      >>  set intersection
-   a |  b      >>  set union
-   a ^  b      >>  exclusive union
-   s == a      >>  equality   ... both sets contain exactly the same elements
-   a === s     >>  case equality  ... where `s` applies to case variable, and `a` applies to when clause
-                   see: .set_case(sym) for additonal configuration
-   s != a      >>  inequality ... sets are different
-   ~a          >>  inversion
-   a ** b      >>  intersection test ... true if one or more elements are common to both sets
-   s[i]        >>  true if 'i' is an element of the set
-   s[i]=k      >>  if k==true, adds element `i` to set, otherwise removes element `i` from set
-   where a,b === instances of Set, String, Array, Range
-         s   === instance of Set
-         i   === member index ... positive integer (0,1,2,3...) or char ('a')
-                 character indexes use #ord to convert to integer
-         k   === boolean
-   
-Methods:
-   .count                >>  returns number of elements in set
-   .each_member {block}  >>  iterates on element ordinate of each element in set
-   .add!(p)              >>  includes additional members to current set
-   .include?(p)          >>  true if `p` is a subset of current set
-   .empty?               >>  true if there are no elements in set
-   .zap!                 >>  removes all elements of set and resets entropy to zero
-   .add_parse_chars!     >>  adds [0..47, 58..64, 91..96, 123..126] to set
-   .dup                  >>  creates a copy of the current set
-   .to_i                 >>  returns internal integer representing all bits of the set space
-   .to_s                 >>  returns a string representation of all elements
-   .to_a                 >>  returns an array of all elements (in integers)
-   .set_bits!(n)         >>  replaces set with each set bit of integer `n` ... negative numbers are not allowed!
-   .recalculate_entropy! >>  calculates new entropy value based on current elements on set.
-                             recommended to call this method after #set_bits! is called.
-                             not necessary to be called for normal operation.  Returns newly calculated entropy.
-   .min                  >>  returns element of smallest ordinate value, or nil if empty set
-   .max                  >>  returns element of highest ordinate value, or nil if empty set
-   .to_set               >>  returns self ... Also exported to String, Range, and Array which creates an instance of Set
-   .set_case(sym)        >>  sets case--when behavior as follows:
-                             :mode_equal (default)  case(s) -> when a ... validates on  a ==s
-                             :mode_intersection     case(s) -> when a ... validates on  a ** s
-                             :mode_sub              case(s) -> when a ... validates on  a <= s
-                             :mode_proper           case(s) -> when a ... validates on  a < s
-                             :mode_super            case(s) -> when a ... validates on  s <= a
-                             :mode_superproper      case(s) -> when a ... validates on  s < a
-   .add_opposing_case!   >>  for every letter character in set, the inverse case of that character is added to the set.
-                             ex:  y = "aBc".to_set.add_opposing_case!  ...  y == "abcABC"
-   .add_lowercase_chars! >>  same as  .add!('a'..'z')  
-   .add_uppercase_chars! >>  same as  .add!('A'..'Z') 
-   .add_digit_chars!     >>  same as  .add!('0'..'9') 
-   .add_parse_chars!     >>  adds white space and typical non-alphanumeric chars found on typical keyboard
-   
-Properties:
-   .entropy             >>  Total number of possible states. Like the universe, can only get bigger.
-                            Can be set to a higher number.  Property may be read. 
 
 ## Installation
 
@@ -95,66 +20,6 @@ Or install it yourself as:
 
     $ gem install setfu
 
-## Usage
-
-The Set class defines a group of
-positive integers including zero. Unlike the array, there is no implied order
-to each element of the set other than their chronological order implied by their ordinate value.
-Each set instance may not duplicate elements.  The upper bounds of an element is only limited 
-to the size of (1 << element) that a Bignum may hold.  Performance degrades with elements
-larger than 65536.  This is due to the amount of processing required to operate on large integers.
-One bit of storage is required to hold all possible values a set may hold. Internally, a Bignum
-instance is used to hold all the bits up to the highest ordinate value.
-
-Sets can simplify many programming paradigms. Instead of writing code like this:
-
-def valid_password_chars(str)
-  str.each_char do |ch|
-    return false unless (ch>='a' && ch <='z') || (ch>='A' && ch <='Z') || (ch>='0' && ch <='9') || (ch=='#') || (ch=='_') || (ch=='!')
-  end
-  return true
-end
-
-valid_password_chars "Not a valid password at all!"  # false
-valid_password_chars "Secret#15_!"                   # true
-
-You can instead do this:
-
-valid_char_set = Set.new ['a'..'z','A'..'Z','0'..'9','#','_','!']
-
-"Not a valid password at all!" <= valid_char_set     # false
-"Secret#15_!" <= valid_char_set                      # true
-
-Depending on the operator, the string expression above is converted in to a set instance.
-Fast bitwise math is then performed internally.
-
-Sets can often offer improved performance over regular expressions and arrays.
-This is possible thanks to very fast bit-wise operations on its internal Bignum representation.
-Each bit represents a placeholder for a possible element.
-
-Sets can be used within case statements. The entire case statement can be configured to use
-one of six different comparison modes. The case variable defines the modes of operation for the entire case statement.
-An alternate configuration is to set the same comparison modes on each when clause.
-Note that the case variable takes precedence over each and every when clause.
-The case variable must be of type `Set`.  The left side of the comparison is always the case variable.
-An example is as follows:
-
-case [2,4,6..13].to_set.set_case(:mode_sub)
-  when [1..31]
-    puts "subset detected!"
-end
-
-In ruby, case statements use the `===` operator when evaluating the when clause.
-The `case` variable sits on the left, and the `when` clause sits on the right.
-The Set class overloads the `===` operator and decides what operations are performed on
-the left and right side of the operator. The `#set_case` method takes one of six symbol
-arguments to perform one of 6 comparison modes.
-Comparison modes can be set on either the left or the right, but the right takes precedence.
-
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Not on github yet ... stay tuned!

data/lib/setfu.rb

@@ -7,92 +7,98 @@ class Set
     @entropy = ent unless @entropy > ent
   end
   
-  def to_set
-    return self
+  def self.uppercase_chars
+    set = Set.new
+    set.set_bits!(2475880041677272402379145216)
+    set.entropy=91
+    return set
   end
   
-  def mode
-    return @mode
+  def self.lowercase_chars
+    set = Set.new
+    set.set_bits!(10633823807823001954701781295154855936)
+    set.entropy=123
+    return set
   end
   
-  def initialize(data=nil)
-    @bits = 0
-    @entropy = 0
-    add!(data) unless data.nil?
-    self
+  def self.letter_chars
+    set = Set.new
+    set.set_bits!(10633823810298881996379053697534001152)
+    set.entropy=123
+    return set
   end
-
-  def zap!
-    @bits = 0
-    @entropy = 0
-    self
+  
+  def self.digit_chars
+    set = Set.new
+    set.set_bits!(287948901175001088)
+    set.entropy=58
+    return set
   end
   
-  def recalculate_entropy!
-    @entropy = 0
-    bits = @bits
-    num = 1 << 8192
-    while(bits > num)
-      @entropy += 8192
-      bits >>= 8192
-    end
-    num = 1 << 256
-    while(bits > num)
-      @entropy += 256
-      bits >>= 256
-    end
-    num = 1 << 16
-    while(bits > num)
-      @entropy += 16
-      bits >>= 16
-    end
-    while(bits > 0)
-      @entropy += 1
-      bits >>= 1
-    end
-    #@entropy += 1
-    @entropy
+  def self.parse_chars
+    set = Set.new
+    set.set_bits!(159507359650170349735020301117175103487)
+    set.entropy=127
+    return set
   end
-
+  
+  def replace(ent)
+    ent = ent.to_set
+    @mode = ent.mode
+    @entropy = ent.entropy
+    @bits = ent.to_i
+    self  
+  end
+  
   def add_parse_chars!
-    add! [0..47, 58..64, 91..96, 123..126]
+    # add! [0..47, 58..64, 91..96, 123..126]
+    add! Set.parse_chars
     self
   end
   
   def add_parse_chars
-    dup.add_parse_chars!
+    return Set.parse_chars | self
   end
   
   def add_digit_chars!
-    add! [48..57]
+    add! Set.digit_chars
     self
   end
   
   def add_digit_chars
-    dup.add_digit_chars!
+    return Set.digit_chars | self
   end
   
   def add_uppercase_chars!
-    add! [65..90]
+    add! Set.uppercase_chars
     self
   end
 
   def add_uppercase_chars
-    dup.add_uppercase_chars!
+    return Set.uppercase_chars | self
   end
   
   def add_lowercase_chars!
-    add! [97..122]
+    add! Set.lowercase_chars
     self
   end
 
   def add_lowercase_chars
-    dup.add_lowercase_chars!
+    return Set.lowercase_chars | self
+  end
+  
+  def add_letter_chars
+    return Set.letter_chars | self
+  end
+
+  def add_letter_chars!
+    add! Set.letter_chars
+    self
   end
   
   def add_opposing_case!
-    aa = Set.new.add_lowercase_chars!
-    bb = Set.new.add_uppercase_chars!
+    aa = Set.lowercase_chars
+    bb = Set.uppercase_chars
     ka = aa & self  # subset lower case
     kb = bb & self  # subset upper case
     @bits |= ka.to_i >> 32
@@ -104,6 +110,53 @@ class Set
   def add_opposing_case
     dup.add_opposing_case!
   end
+  
+  def to_set
+    return self
+  end
+  
+  def mode
+    return @mode
+  end
+  
+  def initialize(data=nil)
+    @bits = 0
+    @entropy = 0
+    add!(data) unless data.nil?
+    self
+  end
+
+  def zap!
+    @bits = 0
+    @entropy = 0
+    self
+  end
+  
+  def recalculate_entropy!
+    @entropy = 0
+    bits = @bits
+    num = 1 << 8192
+    while(bits > num)
+      @entropy += 8192
+      bits >>= 8192
+    end
+    num = 1 << 256
+    while(bits > num)
+      @entropy += 256
+      bits >>= 256
+    end
+    num = 1 << 16
+    while(bits > num)
+      @entropy += 16
+      bits >>= 16
+    end
+    while(bits > 0)
+      @entropy += 1
+      bits >>= 1
+    end
+    #@entropy += 1
+    @entropy
+  end
 
   # this only works on integer ... String, Array, Range does not implement: &, |, ^
   def coerce(other)
@@ -113,9 +166,8 @@ class Set
   
   def dup
     rtn = Set.new
-    rtn.set_bits!(@bits)
-    rtn.entropy = entropy
-    rtn
+    rtn.replace(self)
+    return rtn
   end
   
   def ^(item)
@@ -386,32 +438,40 @@ class Set
     rtn.set_bits!(mask ^ @bits)
     rtn
   end
-  
-  def [](pos)
-    idx = pos.ord if pos.class==String
-    idx = pos.to_i 
-    raise "Negative indexes are illegal for Set" if idx < 0
-    self.entropy = idx+1
-    y = @bits & (1<<idx)
-    return true if y > 0
-    false    
-  end
 
-  def []=(pos,value)
-    idx = pos.ord if pos.class==String
-    idx = pos.to_i 
-    raise "Negative indexes are illegal for Set" if idx < 0
-    state = value ? true : false
-    self.entropy = idx+1
-    if state # set bit
-      @bits |= 1 << idx
-    else     # clear bit
-      mask = 1 << idx
-      @bits |= mask
-      @bits ^= mask
+ # new behavior ... single element returns true/false
+ # multi element ... returns subset
+  def [](*pset)
+    idx = nil
+    if pset.count==1  # check for single instance  inst[5], inst['t']
+      if pset.first.kind_of? Integer
+        idx = pset.first
+      elsif pset.first.kind_of? String
+        if pset.first.length == 1
+          idx = pset.first.ord
+        end
+      end
+    end
+    unless idx.nil?
+      raise "Negative indexes are illegal for Set" if idx < 0
+      self.entropy = idx+1
+      y = @bits & (1<<idx)
+      return true if y > 0
+      return false    
     end
-    return state
+    return pset.to_set & self
   end
+  
+  def []=(*pset,value)  # pset goes in the box, value after '='
+    pset = pset.to_set
+    state = value ? true : false
+    if state
+      replace pset | self  # add elements to set
+    else
+      replace self - pset  # remove elements from set
+    end
+    return state # this gets ignored, but to be safe, do what the previous version did   
+  end  
 
   def min
     return nil if empty?
@@ -441,6 +501,33 @@ class Set
     return range.first if (self[range.first])
     range.last
   end
+    
+  # :array  :array_chars  :string  :set   
+  def rand(elm_count, format = :set)
+    raise "rand minimum count too low" if elm_count < 1
+    ary = self.to_a
+    ary.shuffle!
+    ary = ary[0..(elm_count-1)]
+    case format
+      when :array
+        return ary
+      when :array_chars
+        rtn = []
+        ary.each do |elm|
+          rtn.push elm.chr
+        end
+        return rtn
+      when :string
+        rtn = []
+        ary.each do |elm|
+          rtn.push elm.chr
+        end
+        return rtn.join ""
+      else # :set
+        return ary.to_set
+    end
+  end  
+  
 end  # end Set
 
 module SetFuMixinBinaryAndOperator

data/lib/setfu/version.rb

@@ -1,3 +1,3 @@
 module Setfu
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/setfu.gemspec

@@ -23,9 +23,10 @@ When characters are used, the ordinate value sets the element bit of the interna
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 1.9.1'
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency "rake", ">= 10.1.0"
+  spec.add_development_dependency 'rspec', ">= 3.3.0"
+  spec.add_development_dependency 'byebug', ">= 5.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: setfu
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-25 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,42 +30,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.0
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.0.0
 description: |2-
 
   Creates a Set class with methods that allow you to construct and opperate on
@@ -100,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="