setfu 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b90873f3986a2bdf496d15f1f7aaa65802e51e3
+  data.tar.gz: 098b84b480360abe537007d4e84a4ba32f7b7933
+SHA512:
+  metadata.gz: 1e0dc3f17d1649ca8694a112128b3f609b7f81970eb1d1c8a3688f5e76e7b36082938dc23461644475faceef05470a2fd4605b08827f61e2010942fadd11b68d
+  data.tar.gz: afe4241c4c9f2c7bd266b4761860a76ddf3c09129e903d5e8c284fb11999e027731bc3e5989f6c7fe6e9a13418e7f0cc9098b4cf3ae330bb7aaf4a24d9f17c85

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in setfu.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Bryan Colvin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,154 @@
+# Setfu
+
+Purpose:  A general purpose object implementing sets.
+
+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
+   
+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
+
+Add this line to your application's Gemfile:
+
+    gem 'setfu'
+
+And then execute:
+
+    $ bundle
+
+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

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+Dir.glob('tasks/**/*.rake').each(&method(:import))

data/lib/setfu/version.rb

@@ -0,0 +1,3 @@
+module Setfu
+  VERSION = "1.0.0"
+end

data/lib/setfu.rb

@@ -0,0 +1,494 @@
+require "setfu/version"
+
+class Set
+  attr_reader :entropy
+  
+  def entropy=(ent)  # entropy only gets bigger, just like the universe!
+    @entropy = ent unless @entropy > ent
+  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
+
+  def add_parse_chars!
+    add [0..47, 58..64, 91..96, 123..126]
+    self
+  end
+
+  # this only works on integer ... String, Array, Range does not implement: &, |, ^
+  def coerce(other)
+    #puts "TESTING ... coerce called!"
+    return [self, other]   # does not seem to get called ...
+  end
+  
+  def dup
+    rtn = Set.new
+    rtn.set_bits!(@bits)
+    rtn
+  end
+  
+  def ^(item)
+    rtn = self.dup
+    if(item.class==Set)
+      rtn.set_bits!(rtn.to_i ^ item.to_i)
+    else
+      rtn = Set.new(item)
+      rtn.set_bits!(@bits ^ rtn.to_i)
+    end
+    rtn
+  end
+
+  def |(item)
+    rtn = self.dup
+    if(item.class==Set)
+      rtn.set_bits!(rtn.to_i | item.to_i)
+      self.entropy=item.entropy
+    else
+      rtn = Set.new(item)
+      rtn.set_bits!(@bits | rtn.to_i)
+    end
+    rtn
+  end
+
+  def &(item)
+    rtn = self.dup
+    if(item.class==Set)
+      rtn.set_bits!(rtn.to_i & item.to_i)
+    else
+      rtn = Set.new(item)
+      rtn.set_bits!(@bits & rtn.to_i)
+    end
+    rtn
+  end
+
+  def -(item)
+    rtn = Set.new
+    rtn.entropy = self.entropy
+    a = self.to_i
+    if(item.class==Set)
+      b = item.to_i
+      rtn.entropy = item.entropy
+    else
+      b = Set.new(item)
+      rtn.entropy = b.entropy
+      b = b.to_i
+    end
+    c = a & b
+    d = c ^ a
+    rtn.set_bits!(d)
+    rtn
+  end
+  
+  def **(item)  # intersection test
+    set_item = Set.new(item)
+    return false if (self & set_item).empty?
+    return true
+  end
+
+  # comparison operators:
+  def ==(item)
+    if(item.class==Set)
+      rtn = item.to_i == self.to_i
+    else
+      rtn = Set.new(item).to_i == self.to_i
+    end
+    rtn
+  end
+
+  def !=(item)
+    if(item.class==Set)
+      rtn = item.to_i != self.to_i
+    else
+      rtn = Set.new(item).to_i != self.to_i
+    end
+    rtn
+  end
+  
+  def set_case(mode=:mode_equal)
+    @mode = mode
+    self
+  end
+  
+  def ===(item)
+    # self ... when clause  ... 
+    # item ... case clause  ... case(item)
+    # Note: coerce does not work in this context ...
+    
+    md = item.to_set.mode || @mode
+    
+    case md
+      when :mode_intersection
+        return item ** self
+      when :mode_sub
+        return item <= self
+      when :mode_proper
+        return item < self
+      when :mode_super
+        return self <= item
+      when :mode_superproper
+        return self < item
+      else
+        return self == item  
+    end
+  end
+  
+  def <=(item)
+    si = Set.new item
+    return si.include?(self)
+  end
+  
+  def <(item)
+    si = Set.new item
+    return false if (si == self)  # not a 'proper' subset
+    return si.include?(self)
+  end
+
+  def add!(items)
+    if(items.class==Set)
+      @bits |= items.to_i
+      entropy = items.entropy
+    elsif(items.class==Range)
+      f=items.first.ord
+      l=items.last.ord
+      f,l = l,f if f>l
+      t = (l-f)+1
+      t = (1 << t)-1
+      @bits |= t << f
+      self.entropy = l+1
+    elsif(items.respond_to? :each_char)
+      items.each_char do |item|
+        @bits |= 1 << item.ord
+        self.entropy = item.ord+1
+      end
+    elsif(items.respond_to? :each)
+      items.each do |item|
+        add! item
+      end
+    else #assume number
+      raise "negative numbers are not allowed" if items < 0
+      pos = 1 << items
+      @bits |= pos
+      self.entropy = items+1
+    end
+    self
+  end
+  
+  def empty?
+    @bits == 0
+  end
+
+  def include?(items)
+    if(items.class==Set)
+      return (@bits & items.to_i) == items.to_i
+    elsif(items.class==Range)
+      f=items.first.ord
+      l=items.last.ord
+      f,l = l,f if f>l
+      t = (l-f)+1
+      t = (1 << t)-1
+      t = t << f
+      return (@bits & t) == t
+    elsif(items.respond_to? :each_char)
+      items.each_char do |item|
+        t = 1 << item.ord
+        return false if 0 == (t & @bits)
+      end
+    elsif(items.respond_to? :each)
+      items.each do |item|
+        return false if false==include?(item)
+      end
+    else #assume number
+      t = 1 << items.abs
+      return false if 0 == (t & @bits)
+    end
+    return true
+  end
+
+  def each_member
+    bits = @bits
+    pos = 0
+    while bits > 0
+      yield pos if ((bits & 1) == 1)
+      pos += 1
+      bits >>= 1
+    end  
+    self
+  end
+  
+  def to_i
+    return @bits
+  end
+  
+  def count
+    cnt = 0
+    each_member do |toss|
+      cnt += 1
+    end 
+    cnt    
+  end
+  
+  def to_s
+    rtn = ""
+    each_member do |ch|
+      rtn += ch.chr
+    end
+    rtn
+  end
+
+  def to_a
+    rtn = []
+    each_member do |num|
+      rtn.push num
+    end
+    rtn
+  end
+  
+  def set_bits!(bits)
+    raise "negative numbers are not allowed" if bits.to_i < 0
+    @bits = bits.to_i
+  end
+
+  def ~@()
+    rtn = dup
+    mask = (1 << @entropy) - 1
+    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
+    end
+    return state
+  end
+
+  def min
+    return nil if empty?
+    range = (self.entropy)..(0)
+    while((range.first - range.last) >= 2) do
+      mid = ((range.first - range.last) >> 1) + range.last
+      top = (range.first)..(mid)
+      bot = (mid)..(range.last)
+      range = self ** bot ? bot : top
+    end
+    #byebug
+    return range.last if (self[range.last])
+    range.first
+  end
+  
+  def max  #look from left
+    #byebug
+    return nil if empty?
+    range = (self.entropy)..(0)
+    while((range.first - range.last) >= 2) do
+      mid = ((range.first - range.last) >> 1) + range.last
+      top = (range.first)..(mid)
+      bot = (mid)..(range.last)
+      range = self ** top ? top : bot
+    end
+    #byebug
+    return range.first if (self[range.first])
+    range.last
+  end
+end  # end Set
+
+module SetFuMixinBinaryAndOperator
+  def &(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a & b
+  end
+end
+
+module SetFuMixinBinaryOrOperator
+  def |(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a | b
+  end
+end
+
+module SetFuMixinBinaryXorOperator
+  def ^(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a ^ b
+  end
+end
+
+module SetFuMixinBinaryIntersectionOperator
+  def **(item)  # intersection test
+    a = Set.new(self)
+    b = Set.new(item)
+    return a ** b
+  end
+end
+
+module SetFuMixinToSetMethod
+  def to_set
+    rtn = Set.new(self)
+    # byebug
+    return rtn
+  end
+end
+
+module SetFuMixinTrippleEqualsOperator
+  alias_method :old_triple_equal4Set, :===
+  def ===(item)
+    return old_triple_equal4Set(item) unless (item.class==Set)
+    return self.to_set === item
+  end
+end
+
+module SetFuMixinBinarySubtractOperator
+  def -(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a - b
+  end
+end
+
+module SetFuMixinBinarySubsetOperator
+  def <=(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a <= b
+  end
+end
+
+module SetFuMixinBinaryProperOperator
+  def <(item)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a < b
+  end
+end
+
+class String
+  alias_method :old_string_lt4set, :<
+  alias_method :old_string_lte4set, :<=
+  
+  include SetFuMixinBinaryAndOperator
+  include SetFuMixinBinaryOrOperator
+  include SetFuMixinBinaryXorOperator
+  include SetFuMixinBinaryIntersectionOperator
+  include SetFuMixinToSetMethod
+  include SetFuMixinTrippleEqualsOperator
+  include SetFuMixinBinarySubtractOperator
+
+  def <=(item)
+    return old_string_lte4set(item) if (item.class==String)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a <= b
+  end
+  def <(item)
+    return old_string_lt4set(item) if (item.class==String)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a < b
+  end 
+end
+
+class Array
+  alias_method :old_subtract_method4set, :-
+  alias_method :old_and_method4set, :&
+  alias_method :old_or_method4set, :|
+
+  include SetFuMixinBinaryXorOperator
+  include SetFuMixinBinaryIntersectionOperator
+  include SetFuMixinToSetMethod
+  include SetFuMixinTrippleEqualsOperator
+  include SetFuMixinBinarySubsetOperator
+  include SetFuMixinBinaryProperOperator
+
+  def -(item)
+    return old_subtract_method4set(item) if (item.class==Array)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a - b 
+  end
+  def &(item)
+    return old_and_method4set(item) if (item.class==Array)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a & b 
+  end
+  def |(item)
+    return old_or_method4set(item) if (item.class==Array)
+    a = Set.new(self)
+    b = Set.new(item)
+    return a | b 
+  end
+end
+
+class Range
+  include SetFuMixinBinaryAndOperator
+  include SetFuMixinBinaryOrOperator
+  include SetFuMixinBinaryXorOperator
+  include SetFuMixinBinaryIntersectionOperator
+  include SetFuMixinToSetMethod
+  include SetFuMixinTrippleEqualsOperator
+  include SetFuMixinBinarySubtractOperator
+  include SetFuMixinBinarySubsetOperator
+  include SetFuMixinBinaryProperOperator
+end

data/setfu.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'setfu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "setfu"
+  spec.version       = Setfu::VERSION
+  spec.authors       = ["Bryan Colvin"]
+  spec.email         = ["bryan@bdlsys.com"]
+  spec.description   = %q{
+Creates a Set class with methods that allow you to construct and opperate on
+set instances. A 'Bignum' instance is used internally to store each element
+of the set. This allows very fast operations when comparing two set instances.
+Member elements can be represented as positive small integers, or characters.
+Sets can be constructed with integers, strings, characters, ranges, and arrays.
+When characters are used, the ordinate value sets the element bit of the internal Bignum.}
+  spec.summary       = %q{Set class}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'byebug'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: setfu
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bryan Colvin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2-
+
+  Creates a Set class with methods that allow you to construct and opperate on
+  set instances. A 'Bignum' instance is used internally to store each element
+  of the set. This allows very fast operations when comparing two set instances.
+  Member elements can be represented as positive small integers, or characters.
+  Sets can be constructed with integers, strings, characters, ranges, and arrays.
+  When characters are used, the ordinate value sets the element bit of the internal Bignum.
+email:
+- bryan@bdlsys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/setfu.rb
+- lib/setfu/version.rb
+- setfu.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Set class
+test_files: []