enums 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0e37d71cacfb8ee57b2b037caa082f6994912f6
-  data.tar.gz: faf257d577a56cb4a0b1d0df423cef87dbda37ed
+  metadata.gz: 21d675f9ace380c191b6ee58c484ab192dbdb440
+  data.tar.gz: 42c0d89f1a150c48a432b3c2d1b1fbbe00ac1aa0
 SHA512:
-  metadata.gz: 1f2faa8be748c71b7e2fe9c3dc93f0a31ce14ec4cc85211815bf4e6a27ef228525d649fc0d21bb340f725ab99eac317e2f2a2de9c85573707fc78ace22ac591f
-  data.tar.gz: 54805411531355f799da430f9a6c243062f6676c9df2b0c92296e2a278f47511fb1b62f615b382db59f541cc286f6875ea3ba26989bf21006d4bdec04559e9e2
+  metadata.gz: f990e4ab5fcc741b1226a3f4eb0d8f9e53f8b2b446d1c8175a4f8bd3464d6fcde42a59cc966735bd2216abc4ec397fd3f043c89254815209c7c61fd0464459ba
+  data.tar.gz: 22ff3b44aea19efd814a45f3ad46184bfaf9df24bbb3e23bb306b91b9f068ff68381de7404293ecb47d5e8b8e6e8d669d92f184d2adcd36ff372740b2c35ce57

data/Manifest.txt

@@ -6,9 +6,9 @@ Rakefile
 lib/enums.rb
 lib/enums/enum.rb
 lib/enums/enum_builder.rb
-lib/enums/flags.rb
-lib/enums/flags_builder.rb
+lib/enums/flag.rb
+lib/enums/flag_builder.rb
 lib/enums/version.rb
 test/helper.rb
 test/test_enum.rb
-test/test_flags.rb
+test/test_flag.rb

data/README.md

@@ -49,6 +49,11 @@ Enum.new( :Color, :red, :green, :blue )
 enum :Color, :red, :green, :blue
 # or
 enum :Color, [:red, :green, :blue]
+# or
+enum :Color, { red:   0, 
+               green: 1,
+               blue:  2 }
+
 ```
 
 
@@ -143,6 +148,10 @@ Enum.new( :State, :fundraising, :expired_refund, :successful )
 enum :State, :fundraising, :expired_refund, :successful
 # or
 enum :State, [:fundraising, :expired_refund, :successful]
+# or
+enum :State, { fundraising:    0, 
+               expired_refund: 1, 
+               successful:     2 }
 
 
 State.values  #=> [0, 1, 2]
@@ -189,6 +198,187 @@ and so on.
 
 
 
+
+### What about enums with flags and bitwise-operators for set (`|`) / unset (`&~`) / toggle (`^`)?
+
+Use the `flags` option or the `Flag` class. Example:
+
+``` ruby
+Flag.new( :FileAttrib, :read_only, :hidden, :system, :archive )
+# -or -
+enum :FileAttrib, [:read_only, :hidden, :system, :archive], flags: true
+# -or -
+enum :FileAttrib, :read_only, :hidden, :system, :archive, flags: true
+# -or -
+enum :FileAttrib, { read_only: 1<<0,    # 2^0 = 1  = 0b00000001
+                    hidden:    1<<1,    # 2^1 = 2  = 0b00000010
+                    system:    1<<2,    # 2^2 = 4  = 0b00000100
+                    archive:   1<<5,    # 2^5 = 32 = 0b00100000
+                  },
+                  flags: true
+```
+
+(Auto-)builds a class and code like:
+
+``` ruby
+class Flag
+  def initialize( key, value )
+    @key   = key
+    @value = value
+  end
+end
+
+
+class FileAttrib < Flag
+
+  READ_ONLY = new( :read_only, 1<<0 )
+  HIDDEN    = new( :hidden,    1<<1 )
+  SYSTEM    = new( :system,    1<<2 )
+  ARCHIVE   = new( :archive,   1<<3 )
+
+  def self.read_only() READ_ONLY; end
+  def self.hidden()    HIDDEN; end
+  def self.system()    SYSTEM; end
+  def self.archive()   ARCHIVE; end
+
+  def self.values()  [1<<0,1<<1,1<<2,1<<3]; end
+  def self.keys()    [:read_only, :hidden, :system, :archive]; end
+  def self.members() [READ_ONLY, HIDDEN, SYSTEM, ARCHIVE]; end
+
+  def self.zero() @zero ||= new(0); end
+
+  def self.key( key )
+    @hash_by_key ||= Hash[ keys.zip( members ) ]
+    @hash_by_key[ key ]
+  end
+  def self.[]( key ) self.key( key ); end
+
+  def read_only?()  member?( READ_ONLY ); end
+  def hidden?()     member?( HIDDEN ); end
+  def system?()     member?( SYSTEM ); end
+  def archive?()    member?( ARCHIVE ); end
+
+  def member?( other ) @value & other.value == other.value; end
+
+  def bitwise_or( other )
+    self.class.new( @value | other.value )
+  end
+  alias_method :|,    :bitwise_or
+  alias_method :set,  :bitwise_or
+  alias_method :flag, :bitwise_or
+
+  def bitwise_and( other )
+    self.class.new( @value & other.value )
+  end
+  alias_method :&, :bitwise_and
+
+  def unset( other )
+    self.class.new( @value & ~other.value )
+  end
+  alias_method :unflag, :unset
+
+  def bitwise_xor( other )
+    self.class.new( @value ^ other.value )
+  end
+  alias_method :^,      :bitwise_xor
+  alias_method :toggle, :bitwise_xor
+
+  # ...
+
+  def initialize( *args )
+    # ...
+  end
+end
+
+
+def FileAttrib( *args )
+  FileAttrib.new( *args )
+end
+```
+
+Use like:
+
+``` ruby
+FileAttrib.values  #=> [1, 2, 4, 8]
+FileAttrib.keys    #=> [:read_only, :hidden, :system, :archive]
+
+FileAttrib.read_only                      #=> <FileAttrib @key=:read_only, @value=1>
+FileAttrib::READ_ONLY                     #=> <FileAttrib @key=:read_only, @value=1>
+FileAttribs[:read_only]                    #=> <FileAttrib @key=:read_only, @value=1>
+
+FileAttrib(0)                             #=> <FileAttrib @key=:0000, @value=0>
+FileAttrib.read_only | FileAttrib.hidden  #=> <FileAttrib @key=:0011, @value=3>
+# -or-
+FileAttrib.new( FileAttrib.read_only | FileAttrib.hidden )
+FileAttrib.new( FileAttrib::READ_ONLY | FileAttrib::HIDDEN )
+FileAttrib.new( :read_only, :hidden )
+# -or-
+FileAttrib( FileAttrib.read_only | FileAttrib.hidden )
+FileAttrib( FileAttrib::READ_ONLY | FileAttrib::HIDDEN )
+FileAttrib( :read_only, :hidden )
+#=> <FileAttrib @key=:0011, @value=3>
+
+attrib  = FileAttrib.new        #=> <FileAttrib @key=:0000, @value=0>
+attrib |= FileAttrib.read_only  #=> <FileAttrib @key=:0001, @value=1>
+attrib.read_only?               #=> true
+# -or-
+attrib.member?( FileAttrib.read_only )                #=> true
+attrib.member?( FileAttrib.READ_ONLY )                #=> true
+attrib.member?( :read_only )                          #=> true
+attrib & FileAttrib.read_only == FileAttrib.read_only #=> true
+
+attrib ^= FileAttrib.read_only  #=> <FileAttrib @key=:0000, @value=0>
+attrib.read_only?               #=> false
+attrib ^= FileAttrib.read_only  #=> <FileAttrib @key=:0001, @value=1>
+attrib.read_only?               #=> true
+
+attrib &= ~FileAttrib.read_only #=> <FileAttrib @key=:0000, @value=0>
+attrib.read_only?               #=> false
+
+attrib.is_a? Flag               #=> true
+attrib.is_a? FileAttrib         #=> true
+# ...
+```
+
+and so on.
+
+
+### What about enums for (algebraic) union data types with variants?
+
+Yes, yes, yes. Use the `Union` class or the `data` helper from the safedata library.
+Note, now you can go "wild" and use strings, arrays or really anything or nothing (that is, unit types) for your values. Example:
+
+``` ruby
+data :Color, :Red, [1],
+             :Green, [2],
+             :Blue, [3]
+
+# -or-
+
+data :Color, :Red, ['red'],
+             :Green, ['green'],
+             :Blue, ['blue']
+
+# -or-
+
+data :Color, :Red, [1,'red'],
+             :Green, [2, 'green'],
+             :Blue, [3, 'blue']
+
+# -or-
+
+data :Color, :Red, [255, 0, 0],
+             :Green, [0, 255, 0],
+             :Blue, [0, 0, 255],
+             :Other, [:r, :g, :b]
+```
+
+and so on and so forth.
+See the [safedata library documentation for more »](https://github.com/s6ruby/safedata)
+
+
+
+
 ## More "Real World" Enum Samples
 
 - [The "Red Paper" about sruby](https://github.com/s6ruby/redpaper) - Small, Smart, Secure, Safe, Solid & Sound (S6) Ruby - The Ruby Programming Language for Contract / Transaction Scripts on the Blockchain World Computer - Yes, It's Just Ruby

data/lib/enums.rb

@@ -29,15 +29,20 @@ end # module Safe
 
 require 'enums/enum'
 require 'enums/enum_builder'
-require 'enums/flags'
-require 'enums/flags_builder'
+require 'enums/flag'
+require 'enums/flag_builder'
 
 
 
 
 module Safe
+
+  ## note make Flags an alias of Flag
+  Flags = Flag
+
+
 module SafeHelper
-  def enum( class_name, *args, flags: false, options: {} )
+  def enum( class_name, *args, flags: false, options: {}, **kwargs )
 
     ## note: allow "standalone" option flags or
     ## option hash
@@ -50,16 +55,14 @@ module SafeHelper
     #   enum :Color, :red, :green, :blue
     #    -or-
     #   enum :Color, [:red, :green, :blue]
-    if args[0].is_a?( Array )
-      keys = args[0]
-    else
-      keys = args
+    if args.size > 0 && args[0].is_a?( Array )
+      args = args[0]
     end
 
     if options[:flags]
-      Flags.new( class_name, *keys )
+      Flag.new( class_name, *args, **kwargs )
     else
-      Enum.new( class_name, *keys )
+      Enum.new( class_name, *args, **kwargs )
     end
   end
 end # module SafeHelper

data/lib/enums/enum.rb

@@ -47,6 +47,10 @@ class Enum
   end
 
 
+  def self.zero() members[0]; end
+  def zero?() self == self.class.zero; end
+
+
   def self.size() keys.size; end
   def self.length() size; end   ## alias (as is the ruby tradition)
 
@@ -58,8 +62,5 @@ class Enum
     ## 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

@@ -7,13 +7,23 @@ class Enum
 
 ###################
 ##  meta-programming "macro" - build class (on the fly)
-def self.build_class( class_name, *keys )
+def self.build_class( class_name, *args, **kwargs )
+
+  if args.size > 0
+    keys   = args
+    values = (0...keys.size).to_a   # note: use ... (exclusive) range
+    e = Hash[ keys.zip( values ) ]
+  else
+    ## assume kwargs
+    e = kwargs
+  end
+
 
   ## 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|
+  e.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" )
@@ -23,13 +33,13 @@ def self.build_class( class_name, *keys )
   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 )
+  klass.define_singleton_method( :new ) do |*new_args|
+    old_new( *new_args )
   end
 
-  keys.each_with_index do |key,index|
+  e.each do |key,value|
     klass.class_eval( <<RUBY )
-      #{key.upcase} = new( :#{key}, #{index} )
+      #{key.upcase} = new( :#{key}, #{value} )
 
       def #{key}?
         self == #{key.upcase}
@@ -43,7 +53,7 @@ RUBY
 
   klass.class_eval( <<RUBY )
     def self.members
-      @members ||= [#{keys.map {|key|key.upcase}.join(',')}].freeze
+      @members ||= [#{e.keys.map {|key|key.upcase}.join(',')}].freeze
     end
 RUBY
 

data/lib/enums/flag.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+###############################
+## base class for flag/flags
+
+
+
+module Safe
+class Flag
+  attr_reader :key
+  attr_reader :value
+
+  def initialize( *args )
+    fmt = "%08b"
+
+    if args.size == 0
+      @value = 0   ## same as new(0)
+      @key   = :"#{fmt % @value}"   ## use :none for 0 key - why? why not?
+    elsif args.size == 1 && args[0].is_a?(Integer)
+      @value = args[0]
+      @key   = :"#{fmt % @value}"   ## todo: lookup if value is a known flag (with key) - why? why not?
+    elsif args.size == 2 && args[0].is_a?(Symbol) && args[1].is_a?(Integer)
+      @key   = args[0]
+      @value = args[1]
+    else
+      ## assume flag object or symbols
+      @value = 0
+      args.each do |arg|
+        flag = _typecast_flag!( arg )
+        @value |= flag.value
+      end
+      @key = :"#{fmt % @value}"    ## todo: lookup if value is a known flag (with key) - why? why not?
+    end
+    self.freeze  ## make "immutable" - should be a value object like an integer number!!!
+    self # return self for chaining
+  end
+
+
+  def _typecheck_flag!( o )
+    if self.class == o.class
+      o
+    else
+      raise TypeError.new( "[Flag] flag >#{self.class.name}< type expected; got >#{o.class.inspect}<" )
+    end
+  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 ==( other )
+    if self.class == other.class
+      @value == other.value
+    elsif other.is_a?( Integer )  ## note: also allow compare by "plain" integer
+      @value == other
+    else
+      false
+    end
+  end
+  alias_method :eql?, :==
+
+
+  def member?( other ) _member?(_typecast_flag!( other )); end
+  def _member?( other ) @value & other.value == other.value; end
+
+
+  def bitwise_or( other )
+    self.class.new( @value | _typecheck_flag!( other ).value )
+  end
+  alias_method :|,    :bitwise_or
+
+  def bitwise_and( other )
+    self.class.new( @value & _typecheck_flag!( other ).value )
+  end
+  alias_method :&, :bitwise_and
+
+  def bitwise_xor( other )
+    self.class.new( @value ^ _typecheck_flag!( other ).value )
+  end
+  alias_method :^,      :bitwise_xor
+
+  def bitwise_inverse
+     self.class.new( ~@value )
+  end
+  alias_method :~, :bitwise_inverse
+
+
+  def set( other )  ## note: typecast also allows symbol e.g (:read_only, etc.)
+    self.class.new( @value | _typecast_flag!( other ).value )
+  end
+  alias_method :flag, :set
+
+  def unset( other )
+    self.class.new( @value & ~_typecast_flag!( other ).value )
+  end
+  alias_method :unflag, :unset
+
+  def toggle( other )
+    self.class.new( @value ^ _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 ||= Hash[ keys.zip( members ) ].freeze
+    @hash[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.zero() @zero ||= new(0); end
+  def zero?() @value == 0; end
+
+
+  def self.convert( *args )
+    new( *args )
+  end
+
+
+  ## 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 Flag
+end # module Safe

data/lib/enums/{flags_builder.rb → flag_builder.rb}

@@ -1,37 +1,43 @@
 module Safe
-class Flags
+class Flag
 
 
 ###################
 ##  meta-programming "macro" - build class (on the fly)
-def self.build_class( class_name, *keys )
+def self.build_class( class_name, *args, **kwargs )
+
+  if args.size > 0
+    keys   = args
+    values = (0...keys.size).to_a   # note: use ... (exclusive) range
+    values = values.map { |value| 1<<value }   ## use power of twos (e.g. 2^0, 2^1, etc.)
+    f = Hash[ keys.zip( values ) ]
+  else
+    ## assume kwargs
+    f = kwargs
+  end
+
 
   ## 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|
+  f.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" )
+      raise ArgumentError.new( "[Flag] arguments to Flag.new must be all symbols following the ruby id naming rules; >#{key}< failed" )
     end
   end
 
-  klass = Class.new( Flags )
+  klass = Class.new( Flag )
   ## 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 )
+  klass.define_singleton_method( :new ) do |*new_args|
+    old_new( *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|
+  f.each do |key,value|
     klass.class_eval( <<RUBY )
-      #{key.upcase} = Flag.new( :#{key}, 1<<#{index} )
+      #{key.upcase} = new( :#{key}, #{value} )
 
       def self.#{key}
         #{key.upcase}
@@ -45,7 +51,7 @@ RUBY
 
   klass.class_eval( <<RUBY )
     def self.members
-      @members ||= [#{keys.map {|key|key.upcase}.join(',')}].freeze
+      @members ||= [#{f.keys.map {|key|key.upcase}.join(',')}].freeze
     end
 RUBY
 
@@ -73,5 +79,5 @@ class << self
   alias_method :new,     :build_class   #   replace original version with build_class
 end
 
-end  # class Flags
+end  # class Flag
 end  # module Safe

data/lib/enums/version.rb

@@ -5,7 +5,7 @@
 module Enums
 
   MAJOR = 1
-  MINOR = 2
+  MINOR = 3
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/test_enum.rb

@@ -32,6 +32,10 @@ class TestEnum < MiniTest::Test
    pp Color
    pp Color(0)
 
+   enum :Roman, {i: 1, iv: 4, v: 5, ix: 9, x: 10 }
+   pp Roman
+   pp Roman(0)   ## first member by index
+
 
 def test_state
   assert_equal [:FUNDRAISING, :EXPIRED_REFUND, :SUCCESSFUL], State.constants

data/test/test_flag.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+##
+#  to run use
+#     ruby -I ./lib -I ./test test/test_flag.rb
+
+
+require 'helper'
+
+
+module Safe
+  ## Flags.new( :FileAttrib, :read_only, :hidden, :system, :archive )
+  enum :FileAttrib, [:read_only, :hidden, :system, :archive], flags: true
+
+
+  pp FileAttrib
+  pp FileAttrib(0)
+
+  puts "Safe.constants:"
+  pp Safe.constants  #=> [:SafeHelper, :Enum, :State, :Color]
+  puts "Flag.constants:"
+  pp Flag.constants  #=> []
+  puts "FileAttrib.constants:"
+  pp FileAttrib.constants  #=> []
+end
+
+
+class TestFlag < MiniTest::Test
+
+   include Safe   ## make all enums (and "convenience" converters) global
+
+
+def test_attrib
+
+  assert_equal [1<<0, 1<<1, 1<<2, 1<<3], FileAttrib.values
+  assert_equal [:read_only, :hidden, :system, :archive], FileAttrib.keys
+
+  assert_equal FileAttrib.read_only, FileAttrib::READ_ONLY
+  assert_equal FileAttrib.hidden,    FileAttrib::HIDDEN
+  assert_equal FileAttrib.system,    FileAttrib::SYSTEM
+  assert_equal FileAttrib.archive,   FileAttrib::ARCHIVE
+
+  assert_equal FileAttrib.read_only, FileAttrib[:read_only]
+  assert_equal FileAttrib.hidden,    FileAttrib[:hidden]
+  assert_equal FileAttrib.system,    FileAttrib[:system]
+  assert_equal FileAttrib.archive,   FileAttrib[:archive]
+
+  assert_equal 1<<0,      FileAttrib.read_only.value
+  assert_equal :read_only, FileAttrib.read_only.key
+  assert_equal true,      FileAttrib.read_only.is_a?( Flag )
+  assert_equal true,      FileAttrib.read_only.is_a?( FileAttrib )
+
+  pp FileAttrib.members
+  assert_equal :read_only, FileAttrib.members[0].key
+  assert_equal 1<<0,       FileAttrib.members[0].value
+  assert_equal :hidden,    FileAttrib.members[1].key
+  assert_equal 1<<1,       FileAttrib.members[1].value
+
+  assert_equal 1<<0,       FileAttrib.read_only.value
+  assert_equal :read_only, FileAttrib.read_only.key
+  assert_equal 1<<0,       FileAttrib::READ_ONLY.value
+  assert_equal :read_only, FileAttrib::READ_ONLY.key
+end
+
+def test_text_style
+   Flag.new( :TextStyle, :bold, :italic, :underline )
+
+   assert_equal [1<<0, 1<<1, 1<<2], TextStyle.values
+   assert_equal [:bold, :italic, :underline], TextStyle.keys
+
+   style = TextStyle(0)
+   assert_equal true, style == 0
+   style |= TextStyle.bold
+   assert_equal true, style.member?( :bold )
+   assert_equal true, style.member?( TextStyle.bold )
+   assert_equal true, style & TextStyle.bold == TextStyle.bold
+   assert_equal true, style & TextStyle.bold != 0
+
+   assert_equal false, style.member?( :italic )
+   assert_equal false, style.member?( TextStyle.italic )
+   style |= TextStyle.italic
+   assert_equal true, style.member?( :italic )
+   assert_equal true, style.member?( TextStyle.italic )
+   assert_equal true, style & TextStyle.italic == TextStyle.italic
+   assert_equal true, style & TextStyle.italic != 0
+end
+
+
+end # class TestFlag

metadata

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

data/lib/enums/flags.rb

@@ -1,193 +0,0 @@
-# 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/test/test_flags.rb

@@ -1,68 +0,0 @@
-# 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