enums 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb53c7f0aba659b47bf538728d3c984e10f227c6
-  data.tar.gz: 35d975e75d3325e1ae884ed310b11bf73baed647
+  metadata.gz: c0e37d71cacfb8ee57b2b037caa082f6994912f6
+  data.tar.gz: faf257d577a56cb4a0b1d0df423cef87dbda37ed
 SHA512:
-  metadata.gz: d232ae4c94f1a115b71cd9fa172e2b5f6ba607a08a79e13624f4c0d1b69bcc1528e10824d19dc4ac37b78a98b158ca1017fdadbf493fa8ed6fd2a79279701c0d
-  data.tar.gz: 0663413b82dff6ebc503219df199f3b1755d74df81515660877d7cf58766fdd0f36b7fc466d61e6e62edba1815b978ba41342d128144066e2a443b7e0250a44c
+  metadata.gz: 1f2faa8be748c71b7e2fe9c3dc93f0a31ce14ec4cc85211815bf4e6a27ef228525d649fc0d21bb340f725ab99eac317e2f2a2de9c85573707fc78ace22ac591f
+  data.tar.gz: 54805411531355f799da430f9a6c243062f6676c9df2b0c92296e2a278f47511fb1b62f615b382db59f541cc286f6875ea3ba26989bf21006d4bdec04559e9e2

data/Manifest.txt

@@ -4,6 +4,11 @@ Manifest.txt
 README.md
 Rakefile
 lib/enums.rb
+lib/enums/enum.rb
+lib/enums/enum_builder.rb
+lib/enums/flags.rb
+lib/enums/flags_builder.rb
 lib/enums/version.rb
 test/helper.rb
 test/test_enum.rb
+test/test_flags.rb

data/README.md

@@ -76,12 +76,16 @@ class Color < Enum
   def self.keys()    [:red, :blue, :green]; end
   def self.members() [RED, BLUE, GREEN]; end
 
-  def self.value( index ) members[index]; end
-  def self.zero() value(0); end
+  def self.zero() members[0]; end
+
+  def self.value( value )
+    @hash_by_value ||= Hash[ values.zip( members ) ]
+    @hash_by_value[ value ]
+  end
 
   def self.key( key )
-    @hash ||= Hash[ keys.zip( members ) ]
-    @hash[ key ]
+    @hash_by_key ||= Hash[ keys.zip( members ) ]
+    @hash_by_key[ key ]
   end
   def self.[]( key ) self.key( key ); end
 
@@ -90,12 +94,15 @@ class Color < Enum
   def green?() self == GREEN; end
 end
 
-def Color( arg )
-  Color.value( arg )
+
+def Color( index )
+  Color.members[ index ]
 end
 ```
 
 
+
+
 Use like:
 
 ``` ruby

data/lib/enums.rb

@@ -7,193 +7,44 @@ require 'pp'
 ## our own code
 require 'enums/version'    # note: let version always go first
 
-##################################
-## auto-create/builds enum class.
-##
-## Example:
-##   Enum.new( :State, :fundraising, :expired_refund, :successful)
-##     auto-creates/builds:
-##
-##  class Enum
-##    def initialize( key, value )
-##      @key   = key
-##      @value = value
-##    end
-##  end
-##
-##  class State < Enum
-##
-##    FUNDRAISING    = new(:fundraising,    0)
-##    EXPIRED_REFUND = new(:expired_refund, 1)
-##    SUCCESSFUL     = new(:successful,     2)
-##
-##    def self.fundraising()    FUNDRAISING; end
-##    def self.expired_refund() EXPIRED_REFUND; end
-##    def self.successful()     SUCCESSFUL; end
-##
-##    def fundraising?()     self == FUNDRAISING; end
-##    def expired_refund?()  self == EXPIRED_REFUND; end
-##    def successful?()      self == SUCCESSFUL; end
-##  end
-##
-##  pp state = State.fundraising     #=> #<State @key=:fundraising, @value=0>
-##  pp state.fundraising?            #=> true
-##  pp state.expired_refund?         #=> false
-##  pp state.successful?             #=> false
-##  pp state = State.expired_refund  #=> #<State @key=:expired_refund, @value=1>
-##  pp state.fundraising?            #=> false
-##  pp state.expired_refund?         #=> true
-##  pp state.successful?             #=> false
-
-
 
+## forward declarations
 module Safe
-
-## note: use ClassMethods pattern for auto-including class methods
-##   note ClassMethods module is called SafeHelper
-def self.included( klass )
-  klass.extend( SafeHelper )
-end
-
-module SafeHelper; end
-## note: also extends (include a helper methods to Safe itself)
-##  lets you use:
-##  module Safe
-##    enum :Color, :red, :green, :blue
-##  end
-extend SafeHelper
-
-
-## base class for enum
-class Enum
-  ## return a new Enum read-only class
-  attr_reader :key
-  attr_reader :value
-
-  def initialize( key, value )
-    @key   = key
-    @value = value
-    self.freeze   ## make "immutable"
-    self
-  end
-
-
-
-  def self.value( index )
-    ## todo/fix: check for out-of-bound / unknown enum
-    ## puts "#{name}.value(#{index})"
-    ## pp keys
-    ## pp values
-    members[ index ]
-  end
-
-  def zero?() self == self.class.zero; end
-
-  def self.zero
-    members[0]
-  end
-
-  def self.key( key )
-    @hash ||= Hash[ keys.zip( members ) ].freeze
-    @hash[key]
-  end
-
-  def self.[]( key )   ## convenience alias for key
-    self.key( key )
-  end
-
-  def self.values
-    @values ||= (0...keys.size).to_a.freeze
-    @values
-  end
-
-  def self.size() keys.size; end
-  def self.length() size; end   ## alias (as is the ruby tradition)
-
-
-  def self.convert( arg )
-    ## todo/check: support keys too - why? why not?
-    ## e.g. Color(0), Color(1)
-    ##      Color(:red), Color(:blue) - why? why not?
-    value( arg )
+  ## note: use ClassMethods pattern for auto-including class methods
+  ##   note ClassMethods module is called SafeHelper
+  def self.included( klass )
+    klass.extend( SafeHelper )
   end
 
+  module SafeHelper; end
+  ## note: also extends (include a helper methods to Safe itself)
+  ##  lets you use:
+  ##  module Safe
+  ##    enum :Color, :red, :green, :blue
+  ##  end
+  extend SafeHelper
+end # module Safe
 
 
-  ###################
-  ##  meta-programming "macro" - build class (on the fly)
-  def self.build_class( class_name, *keys )
-
-    ## todo/fix:
-    ##  check class name MUST start with uppercase letter
-
-    ## check if all keys are symbols and follow the ruby id(entifier) naming rules
-    keys.each do |key|
-      if key.is_a?( Symbol ) && key =~ /\A[a-z][a-zA-Z0-9_]*\z/
-      else
-        raise ArgumentError.new( "[Enum] arguments to Enum.new must be all symbols following the ruby id naming rules; >#{key}< failed" )
-      end
-    end
-
-    klass = Class.new( Enum )
-
-    ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
-    klass.define_singleton_method( :new ) do |*args|
-      old_new( *args )
-    end
-
-    keys.each_with_index do |key,index|
-      klass.class_eval( <<RUBY )
-        #{key.upcase} = new( :#{key}, #{index} )
 
-        def #{key}?
-          self == #{key.upcase}
-        end
+require 'enums/enum'
+require 'enums/enum_builder'
+require 'enums/flags'
+require 'enums/flags_builder'
 
-        def self.#{key}
-          #{key.upcase}
-        end
-RUBY
-    end
 
-    klass.class_eval( <<RUBY )
-      def self.keys
-        @keys   ||= #{keys}.freeze
-      end
-
-      def self.members
-        @members ||= [#{keys.map {|key|key.upcase}.join(',')}].freeze
-      end
-RUBY
-
-    ## note: use Kernel for "namespacing"
-    ##   make all enums Kernel convenience converters (always) global
-    ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
-
-    ## add global convenience converter function
-    ##  e.g. State(0) is same as State.convert(0)
-    ##       Color(0) is same as Color.convert(0)
-    Kernel.class_eval( <<RUBY )
-      def #{class_name}( arg )
-         #{class_name}.convert( arg )
-      end
-RUBY
-
-    ## note: use Safe (module) and NO Object for namespacing
-    ##   use include Safe to make all enums constants and machinery global
-    Safe.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
-  end
 
 
-  class << self
-    alias_method :old_new, :new       # note: store "old" orginal version of new
-    alias_method :new,     :build_class    # replace original version with create
-  end
-end  # class Enum
+module Safe
+module SafeHelper
+  def enum( class_name, *args, flags: false, options: {} )
 
+    ## note: allow "standalone" option flags or
+    ## option hash
+    defaults = { flags: flags }
+    options = defaults.merge( options )
+    pp options
 
-module SafeHelper
-  def enum( class_name, *args )
     ########################################
     # note: lets you use:
     #   enum :Color, :red, :green, :blue
@@ -205,7 +56,11 @@ module SafeHelper
       keys = args
     end
 
-    Enum.new( class_name, *keys )
+    if options[:flags]
+      Flags.new( class_name, *keys )
+    else
+      Enum.new( class_name, *keys )
+    end
   end
 end # module SafeHelper
 end # module Safe

data/lib/enums/enum.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+###############################
+## base class for enum
+
+module Safe
+class Enum
+  ## return a new Enum read-only class
+  attr_reader :key
+  attr_reader :value
+
+  def initialize( key, value )
+    @key   = key
+    @value = value
+    self.freeze   ## make "immutable"
+    self
+  end
+
+
+  def self.keys
+    @keys ||= members.map {|member| member.key}.freeze
+    @keys
+  end
+
+  def self.key( key )
+    ## note: returns nil now for unknown keys
+    ##   use/raise IndexError or something - why? why not?
+    @hash_by_key ||= Hash[ keys.zip( members ) ].freeze
+    @hash_by_key[key]
+  end
+
+  def self.[]( key )   ## convenience alias for key
+    self.key( key )
+  end
+
+
+  def self.values
+    @values ||= members.map {|member| member.value}.freeze
+    @values
+  end
+
+  def self.value( value )
+    ## note: returns nil now for unknown values
+    ##   use/raise IndexError or something - why? why not?
+    @hash_by_value ||= Hash[ values.zip( members ) ].freeze
+    @hash_by_value[value]
+  end
+
+
+  def self.size() keys.size; end
+  def self.length() size; end   ## alias (as is the ruby tradition)
+
+
+  def self.convert( arg )
+    ## todo/check: support keys too - why? why not?
+    ## e.g. Color(0), Color(1)
+    ##      Color(:red), Color(:blue) - why? why not?
+    ## note: will ALWAYS look-up by (member) index and NOT by value (integer number value might be different!!)
+    members[ arg ]
+  end
+
+  def self.zero() members[0]; end
+  def zero?() self == self.class.zero; end
+end  # class Enum
+end  # module Safe

data/lib/enums/enum_builder.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+
+module Safe
+class Enum
+
+
+###################
+##  meta-programming "macro" - build class (on the fly)
+def self.build_class( class_name, *keys )
+
+  ## todo/fix:
+  ##  check class name MUST start with uppercase letter
+
+  ## check if all keys are symbols and follow the ruby id(entifier) naming rules
+  keys.each do |key|
+    if key.is_a?( Symbol ) && key =~ /\A[a-z][a-zA-Z0-9_]*\z/
+    else
+      raise ArgumentError.new( "[Enum] arguments to Enum.new must be all symbols following the ruby id naming rules; >#{key}< failed" )
+    end
+  end
+
+  klass = Class.new( Enum )
+
+  ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+  klass.define_singleton_method( :new ) do |*args|
+    old_new( *args )
+  end
+
+  keys.each_with_index do |key,index|
+    klass.class_eval( <<RUBY )
+      #{key.upcase} = new( :#{key}, #{index} )
+
+      def #{key}?
+        self == #{key.upcase}
+      end
+
+      def self.#{key}
+        #{key.upcase}
+      end
+RUBY
+  end
+
+  klass.class_eval( <<RUBY )
+    def self.members
+      @members ||= [#{keys.map {|key|key.upcase}.join(',')}].freeze
+    end
+RUBY
+
+  ## note: use Kernel for "namespacing"
+  ##   make all enums Kernel convenience converters (always) global
+  ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
+
+  ## add global convenience converter function
+  ##  e.g. State(0) is same as State.convert(0)
+  ##       Color(0) is same as Color.convert(0)
+  Kernel.class_eval( <<RUBY )
+    def #{class_name}( arg )
+       #{class_name}.convert( arg )
+    end
+RUBY
+
+  ## note: use Safe (module) and NO Object for namespacing
+  ##   use include Safe to make all enums constants and machinery global
+  Safe.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
+end
+
+
+class << self
+  alias_method :old_new, :new           # note: store "old" orginal version of new
+  alias_method :new,     :build_class   #   replace original version with build_class
+end
+
+end  # class Enum
+end  # module Safe

data/lib/enums/flags.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+
+###############################
+## base class for flag/flags
+
+
+
+module Safe
+class Flag
+
+  attr_reader :key
+  attr_reader :value
+
+  def initialize( key, value )
+    @key   = key
+    @value = value
+    self.freeze   ## make "immutable"
+    self
+  end
+
+
+  def self._typecheck!( o )
+    if self == o.class
+      o
+    else
+      raise TypeError.new( "[Flag] flag >#{name}< type expected; got >#{o.class.inspect}<" )
+    end
+  end
+
+  def self._value!( o )
+    if o.is_a? Integer
+      o
+    else
+      _typecheck!( o )
+      o.value
+    end
+  end
+
+  def bitwise_or( other )   ## bitwise-or
+    ## note: returns "plain" integer
+    @value | self.class._value!( other )
+  end
+  alias_method :|, :bitwise_or
+
+  def bitwise_inverse()  ## bitwise-inverse
+    ## note: returns "plain" integer
+     ~@value
+  end
+  alias_method :~, :bitwise_inverse
+
+
+  def coerce( other )
+    puts "[Flag] coerce( self= >#{self.inspect}<, other= >#{other.inspect}< #{other.class.name} )"
+    if other.is_a?( Integer )
+      [other, @value]
+    else
+      raise TypeError.new( "[Flag] coerce - wrong type >#{other.inspect}< #{other.class.name} - Integer number expected" )
+    end
+  end
+end  # class Flag
+
+
+
+class Flags
+  attr_reader :value
+
+  def initialize( *args )
+    if args.size == 0
+      @value = 0   ## same as new(0)
+    elsif args.size == 1 && args[0].is_a?(Integer)
+      @value = args[0]
+    else
+      ## assume flag object or symbols
+      @value = 0
+      args.each do |arg|
+        flag = _typecast_flag!( arg )
+        @value |= flag.value
+      end
+    end
+    self.freeze  ## make "immutable" - should be a value object like an integer number!!!
+    self # return self for chaining
+  end
+
+
+  def _value_for_flag!( o )
+    self.class::Flag._value!( o )
+  end
+
+  def _typecheck_flag!( o )
+    self.class::Flag._typecheck!( o )
+  end
+
+  def _typecast_flag!( o )
+    if o.is_a? Symbol   ## auto-convert symbol to flag
+      o = self.class.key( o )  ## lookup symbol in "parent" flags class
+    end
+    _typecheck_flag!( o )
+  end
+
+
+  def member?( other ) _member?(_typecast_flag!( other )); end
+  def _member?( other ) @value & other.value  != 0; end
+
+
+  def bitwise_or( other )
+    _unsafe_bitwise_or( _value_for_flag!( other ) )
+  end
+  alias_method :|, :bitwise_or
+
+  def _unsafe_bitwise_or( other )   ## always assumes other is an integer
+    self.class.new( @value | other )
+  end
+
+  def set( other )  ## typesafe version of bitwise-or (|=) (no "plain" Integer allowed)
+    _unsafe_bitwise_or( _typecast_flag!( other ).value )
+  end
+  alias_method :flag, :set
+
+
+  def bitwise_and( other )
+    _unsafe_bitwise_and( _value_for_flag!( other ) )
+  end
+  alias_method :&, :bitwise_and
+
+  def _unsafe_bitwise_and( other )
+    self.class.new( @value & other )
+  end
+
+
+  def unset( other )  ## typesafe version of bitwise-and/bitwise-inverse (&=~) (no "plain" Integer allowed)
+    _unsafe_bitwise_and( ~_typecast_flag!( other ).value )
+  end
+  alias_method :unflag, :unset
+
+
+  def bitwise_xor( other )
+    _unsafe_bitwise_xor( _value_for_flag!( other ))
+  end
+  alias_method :^, :bitwise_xor
+
+  def _unsafe_bitwise_xor( other )
+    self.class.new( @value ^ other )
+  end
+
+  def toggle( other ) ## typesafe version of bitwise-xor (^=) (no "plain" Integer allowed)
+    _unsafe_bitwise_xor( _typecast_flag!( other ).value )
+  end
+
+
+
+  def self.keys()
+    # note: does NOT include none - why? why not?
+    @keys ||= members.map { |member| member.key }.freeze
+  end
+
+  def self.key( key )
+    @hash_by_key ||= Hash[ keys.zip( members ) ].freeze
+    @hash_by_key[key]
+  end
+
+  def self.[]( key )  ## convenience alias for key
+    self.key( key )
+  end
+
+
+  def self.values()
+    # note: does NOT include none - why? why not?
+    @values ||= members.map { |member| member.value }.freeze
+  end
+
+
+  def self.convert( *args )
+    new( *args )
+  end
+
+  def self.zero() @zero ||= new(0); end
+  def zero?() @value == 0; end
+
+  ### todo/fix:
+  ##  add ==/eql?
+  ##   for self AND flag AND integer
+  ##     always compare integer value
+
+
+  ## add size|length too why? why not?
+  ## add value() lookup?
+  ##   not for now - why? combined values are undefined!! what to return??
+
+  ## add to_i, to_int - why? why not?
+  ## def to_i()   @value; end
+  ## def to_int() @value; end
+end  # class Flags
+end # module Safe

data/lib/enums/flags_builder.rb

@@ -0,0 +1,77 @@
+module Safe
+class Flags
+
+
+###################
+##  meta-programming "macro" - build class (on the fly)
+def self.build_class( class_name, *keys )
+
+  ## todo/fix:
+  ##  check class name MUST start with uppercase letter
+
+  ## check if all keys are symbols and follow the ruby id(entifier) naming rules
+  keys.each do |key|
+    if key.is_a?( Symbol ) && key =~ /\A[a-z][a-zA-Z0-9_]*\z/
+    else
+      raise ArgumentError.new( "[Flags] arguments to Flags.new must be all symbols following the ruby id naming rules; >#{key}< failed" )
+    end
+  end
+
+  klass = Class.new( Flags )
+  ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+  klass.define_singleton_method( :new ) do |*args|
+    old_new( *args )
+  end
+
+
+  ## add nested flag class for "typesafe" flags
+  klass.class_eval( <<RUBY )
+    class Flag < Safe::Flag; end
+RUBY
+
+  keys.each_with_index do |key,index|
+    klass.class_eval( <<RUBY )
+      #{key.upcase} = Flag.new( :#{key}, 1<<#{index} )
+
+      def self.#{key}
+        #{key.upcase}
+      end
+
+      def #{key}?
+        _member?( #{key.upcase} )
+      end
+RUBY
+  end
+
+  klass.class_eval( <<RUBY )
+    def self.members
+      @members ||= [#{keys.map {|key|key.upcase}.join(',')}].freeze
+    end
+RUBY
+
+  ## note: use Kernel for "namespacing"
+  ##   make all enums Kernel convenience converters (always) global
+  ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
+
+  ## add global convenience converter function
+  ##  e.g. State(0) is same as State.convert(0)
+  ##       Color(0) is same as Color.convert(0)
+  Kernel.class_eval( <<RUBY )
+    def #{class_name}( arg )
+       #{class_name}.convert( arg )
+    end
+RUBY
+
+  ## note: use Safe (module) and NO Object for namespacing
+  ##   use include Safe to make all enums constants and machinery global
+  Safe.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
+end
+
+
+class << self
+  alias_method :old_new, :new           # note: store "old" orginal version of new
+  alias_method :new,     :build_class   #   replace original version with build_class
+end
+
+end  # class Flags
+end  # module Safe

data/lib/enums/version.rb

@@ -5,8 +5,8 @@
 module Enums
 
   MAJOR = 1
-  MINOR = 1
-  PATCH = 1
+  MINOR = 2
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_enum.rb

@@ -9,7 +9,7 @@ require 'helper'
 
 
 module Safe
-  ## Enum.new( 'State', :fundraising, :expired_refund, :successful )
+  ## Enum.new( :State, :fundraising, :expired_refund, :successful )
   enum :State, :fundraising, :expired_refund, :successful
 
   pp State

data/test/test_flags.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+##
+#  to run use
+#     ruby -I ./lib -I ./test test/test_flags.rb
+
+
+require 'helper'
+
+
+module Safe
+  ## Flags.new( :FileAttribs, :readonly, :hidden, :system, :archive )
+  enum :FileAttribs, [:readonly, :hidden, :system, :archive], flags: true
+
+
+  pp FileAttribs
+  pp FileAttribs::Flag
+  pp FileAttribs(0)
+
+  puts "Safe.constants:"
+  pp Safe.constants  #=> [:SafeHelper, :Enum, :State, :Color]
+  puts "Flags.constants:"
+  pp Flags.constants  #=> []
+  puts "Flag.constants:"
+  pp Flag.constants  #=> []
+  puts "FileAttribs.constants:"
+  pp FileAttribs.constants  #=> []
+end
+
+
+class TestFlags < MiniTest::Test
+
+   include Safe   ## make all enums (and "convenience" converters) global
+
+
+def test_attribs
+
+  assert_equal [1<<0, 1<<1, 1<<2, 1<<3], FileAttribs.values
+  assert_equal [:readonly, :hidden, :system, :archive], FileAttribs.keys
+
+  assert_equal FileAttribs.readonly, FileAttribs::READONLY
+  assert_equal FileAttribs.hidden,   FileAttribs::HIDDEN
+  assert_equal FileAttribs.system,   FileAttribs::SYSTEM
+  assert_equal FileAttribs.archive,  FileAttribs::ARCHIVE
+
+  assert_equal FileAttribs.readonly, FileAttribs[:readonly]
+  assert_equal FileAttribs.hidden,   FileAttribs[:hidden]
+  assert_equal FileAttribs.system,   FileAttribs[:system]
+  assert_equal FileAttribs.archive,  FileAttribs[:archive]
+
+  assert_equal 1<<0,      FileAttribs.readonly.value
+  assert_equal :readonly, FileAttribs.readonly.key
+  assert_equal true,      FileAttribs.readonly.is_a?( Flag )
+  assert_equal true,      FileAttribs.readonly.is_a?( FileAttribs::Flag )
+
+  pp FileAttribs.members
+  assert_equal :readonly, FileAttribs.members[0].key
+  assert_equal 1<<0,      FileAttribs.members[0].value
+  assert_equal :hidden,   FileAttribs.members[1].key
+  assert_equal 1<<1,      FileAttribs.members[1].value
+
+  assert_equal 1<<0,      FileAttribs.readonly.value
+  assert_equal :readonly, FileAttribs.readonly.key
+  assert_equal 1<<0,      FileAttribs::READONLY.value
+  assert_equal :readonly, FileAttribs::READONLY.key
+end
+
+end # class TestFlags

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enums
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-22 00:00:00.000000000 Z
+date: 2019-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -55,9 +55,14 @@ files:
 - README.md
 - Rakefile
 - lib/enums.rb
+- lib/enums/enum.rb
+- lib/enums/enum_builder.rb
+- lib/enums/flags.rb
+- lib/enums/flags_builder.rb
 - lib/enums/version.rb
 - test/helper.rb
 - test/test_enum.rb
+- test/test_flags.rb
 homepage: https://github.com/s6ruby/enums
 licenses:
 - Public Domain