act_with_booleans 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cce67ecde91a5e0dd84ce1788a04b4520ea256165da7a03b3cc56187b91660bd
+  data.tar.gz: 26ed16a60a9992e662b9660da9809e6d29f035901d5292bceae74d8eec0a6792
+SHA512:
+  metadata.gz: c137960e5a9f0ff722c67102a0fb8dd9105c641e68bdf9c984eb2f852955264d406cd7a582b4c85d46fbc5cb8f6af1f7b6638ba30a347f5aa3a6e51523da0ad8
+  data.tar.gz: 895bdd627e055424d445152b0b462a83ed55f20d7551ef802ef5debf2d32da4fbe773891f8582d13f7040eec8213e70dca0dbbe942a55ef992ab4a29e94a93e9

data/.github/workflows/lint.yml

@@ -0,0 +1,16 @@
+name: Lint
+on: push
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - name: Run Standard
+        run: bundle exec standardrb
+#      - name: Run erb-lint
+#        run: bundle exec erblint --lint-all

data/.github/workflows/rake.yml

@@ -0,0 +1,27 @@
+# see also https://github.com/whitequark/parser/blob/master/.github/workflows/test.yml
+name: Rake
+
+on: push
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
+        ruby: [3.0.0, 3.1.2]
+        test_command: ["bundle exec rake test"]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Bundle install
+      run: |
+        bundle config path /home/runner/bundle
+        bundle install
+        bundle update
+    - run: ${{ matrix.test_command }}

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle/
+coverage/
+
+*.gem
+*.log
+*.lock

data/.ruby-gemset

@@ -0,0 +1 @@
+rails-7.0

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.1.2

data/.watchr

@@ -0,0 +1,61 @@
+TESTING = %w[test]
+HH = "#" * 22 unless defined?(HH)
+H = "#" * 5 unless defined?(H)
+
+def usage
+  puts <<-EOS
+  Ctrl-\\ or ctrl-4   Running all tests
+  Ctrl-C             Exit
+  EOS
+end
+
+def run(cmd)
+  puts "#{HH} #{Time.now} #{HH}"
+  puts "#{H} #{cmd}"
+  system "/usr/bin/time --format '#{HH} Elapsed time %E' #{cmd}"
+end
+
+def run_it(type, files)
+  files.split(" ").flatten.each do |file|
+    case type
+    when "test" then run %(bundle exec ruby -I test #{file})
+    #  when 'spec';  run %(rspec -X #{file})
+    else; puts "#{H} unknown type: #{type}, file: #{file}"
+    end
+  end
+end
+
+def run_all_tests
+  puts "\n#{HH} Running all tests #{HH}\n"
+  TESTING.each { |dir| run "bundle exec rake #{dir}" if File.exist?(dir) }
+end
+
+def run_matching_files(base)
+  base = base.split("_").first
+  TESTING.each { |type|
+    files = Dir["#{type}/**/*.rb"].select { |file| file =~ /#{base}_.*\.rb/ }
+    run_it type, files.join(" ") unless files.empty?
+  }
+end
+
+TESTING.each { |type|
+  watch("#{type}/#{type}_helper\.rb") { run_all_tests }
+  watch("lib/.*\.rb") { run_all_tests }
+  watch("#{type}/.*/*_#{type}\.rb") { |match| run_it type, match[0] }
+  watch("#{type}/data/(.*)\.rb") { |match|
+    m1 = match[1]
+    run_matching_files("#{type}/#{m1}/#{m1}_#{type}.rb")
+  }
+}
+
+%w[rb erb haml slim].each { |type|
+  watch("app/.*/(.*)\.#{type}") { |match|
+    run_matching_files(match[1])
+  }
+}
+
+# Ctrl-\ or ctrl-4
+Signal.trap("QUIT") { run_all_tests }
+# Ctrl-C
+Signal.trap("INT") { abort("Interrupted\n") }
+usage

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+gemspec
+
+group :test do
+  gem "observr"
+  gem "standard", require: false
+  gem "simplecov", require: false
+  gem "benchmark-ips"
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Dittmar Krall - www.matiq.com
+
+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,120 @@
+# ActWithFlags
+
+[![Gem Version](https://badge.fury.io/rb/act_with_booleans.png)](http://badge.fury.io/rb/act_with_booleans)
+
+A Ruby gem handling booleans placed in an integer.
+
+Defines setters and getters to access the booleans.
+
+
+## Installation
+
+As usual:
+```ruby
+# Gemfile
+gem "act_with_booleans"
+```
+
+## Examples
+
+### Simple Example
+
+```ruby
+#require "act_with_booleans"
+
+class Foo
+  include ActWithBooleans
+  attr_accessor :booleans
+
+  add_to_booleans :x, :y
+end
+
+foo = Foo.new
+foo.x    # --> false
+foo.x = true
+foo.x    # --> true
+foo.x?   # --> true
+Foo.booleans_mask(:x, :y) # 3 (0x03)
+```
+
+## Example Using Position
+
+```ruby
+class Foo
+  add_to_booleans z: 10
+end
+
+Foo.booleans_mask(:z) # 1024 (0x400 or 2 ** 10)
+```
+
+### Additional Functions
+
+```ruby
+foo.x = true
+foo.y = false
+foo.booleans_any?(:x, :y)  # true
+foo.booleans_all?(:x, :y)  # false
+foo.booleans_none?(:x, :y) # false
+```
+
+### Using a Non Default Origin
+
+```ruby
+#require "act_with_booleans"
+
+class Foo
+  include ActWithBooleans
+  attr_accessor :flags
+
+  add_to_booleans :x, :y, origin: :flags
+end
+
+foo = Foo.new
+foo.x    # --> false
+```
+### Internals
+
+```ruby
+Foo.act_with_booleans.size # 11
+Foo.act_with_booleans.position(:y) # 1
+Foo.act_with_booleans.to_s
+```
+
+## Rails
+
+ActWithBooleans is PORO,
+i.e. it can and, usually, will be used in Rails.
+
+The "origin" (default :booleans) is an integer containing the booleans.
+
+Ruby supports pretty large integers,
+but your database has limitations.
+Therefore, it is strongly recommended to validate accordingly
+the "origin" in the model.
+
+## Testing
+
+As "Best Practice" a test coverage of 100% has been achieved
+(and should be kept).
+
+GitHub workflow enable tests for several configurations.
+Please, feel free to inspect the corresponding file.
+
+## Links
+
+Further reading:
+
+- [gem bitmask_attributes](https://github.com/joelmoss/bitmask_attributes)
+- [gem bitfields](https://github.com/grosser/bitfields)
+- [gem active_flag](https://github.com/kenn/active_flag)
+- [gem has-bit-field](https://github.com/pjb3/has-bit-field)
+- [gem bitfield_attribute](https://github.com/gzigzigzeo/bitfield_attribute)
+- [gem bitwise](https://github.com/kenn/bitwise)
+
+
+## License MIT
+
+Copyright (c) 2022 [Dittmar Krall](matiq UG (haftungsbeschränkt))
+and is released under the MIT license:
+
+* https://opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1,11 @@
+require "rake/testtask"
+
+desc "Run the tests."
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/act_with_booleans.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "act_with_booleans/version"
+
+Gem::Specification.new do |s|
+  s.name = "act_with_booleans"
+  s.version = ActWithBooleans::VERSION
+  s.summary = %(Ruby gem act_with_booleans)
+  s.description = %(Handles booleans packed in an integer)
+  s.authors = ["Dittmar Krall"]
+  s.email = ["dittmar.krall@matiq.com"]
+  s.homepage = "http://matiq.com"
+
+  s.license = "MIT"
+  s.platform = Gem::Platform::RUBY
+  s.metadata["source_code_uri"] = "https://github.com/matique/act_with_booleans"
+
+  s.files = `git ls-files -z`.split("\x0")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+end

data/lib/act_with_booleans/admin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ActWithBooleans::Admin
+  attr_reader :model
+  attr_accessor :origin
+  attr_accessor :size
+
+  def initialize(model)
+    @locations = {}
+    @model = model
+    @size = 0
+    @boolean_hash = {}
+    [true, "true", 1, "1"].each { |x| @boolean_hash[x] = true }
+    [false, "false", 0, "0"].each { |x| @boolean_hash[x] = false }
+  end
+
+  def reset_model(model)
+    initialize model
+  end
+
+  def to_boolean(value)
+    res = @boolean_hash[value]
+    return res unless res.nil?
+
+    raise "invalid boolean <#{value}>"
+  end
+end

data/lib/act_with_booleans/booleans.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class ActWithBooleans::Admin
+  Location = Struct.new(:model, :origin, :position)
+
+  attr_reader :locations
+
+  def position(name)
+    @locations[name].position
+  end
+
+  private
+
+  def add_to_locations(flag, location)
+    who = "<#{flag}: #{location.origin}@#{location.position}>"
+    raise "name already used #{who}" if @locations.key?(flag)
+    bool = @locations.has_value?(location)
+    raise "position already used #{who}" if bool
+    @locations[flag] = location
+  end
+
+  def check_pos(pos)
+    pos ||= @size
+
+    raise "Position already in use" if pos < @size
+    @size = pos + 1
+    pos
+  end
+end

data/lib/act_with_booleans/define.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class ActWithBooleans::Admin
+  def add_accessors(accessor, origin, mask)
+    unless model.method_defined?(:act_with_booleans)
+      model.class_eval %(
+        def act_with_booleans
+          #{model}.act_with_booleans
+        end
+      ), __FILE__, __LINE__ - 4
+    end
+
+    model.class_eval %(
+      def #{accessor}
+        #{accessor}?
+      end
+
+      def #{accessor}?
+        !( self.#{origin}.to_i & #{mask} ).zero?
+      end
+
+      def #{accessor}=(value)
+        booleans = self.#{origin}.to_i
+
+        result = self.act_with_booleans.to_boolean(value)
+        if result
+          booleans |= #{mask}
+        else
+          booleans &= ~#{mask}
+        end
+        self.#{origin} = booleans
+
+        result
+      end
+    ), __FILE__, __LINE__ - 22
+  end
+
+  def remove_accessors(accessor)
+    my_undef model, accessor, "#{accessor}?", "#{accessor}="
+  end
+end

data/lib/act_with_booleans/print.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class ActWithBooleans::Admin
+  def to_s
+    res = []
+    res << title("Variables")
+    res << variables(:origin)
+    res << variables(:size)
+    res << variables(:boolean_hash)
+
+    res << blk("Booleans sorted alfabetically") { |key, loc|
+      "#{key} #{loc}"
+    }
+    res << blk("Booleans and mask; sorted alfabetically") { |key, loc|
+      "#{key}  #{hex(model.booleans_mask(key))}"
+    }
+    res << blk("BOOLEAN assignment; sorted alfabetically") { |key, loc|
+      "BOOLEAN_#{key.upcase} = #{hex(model.booleans_mask(key))}"
+    }
+
+    res << title("@locations")
+    res << @locations
+    res.flatten.join("\n")
+  end
+
+  private
+
+  def title(msg)
+    sep = "#" * 10
+    ["", "#{sep} #{msg} #{sep}"]
+  end
+
+  def blk(legend, &block)
+    res = [title(legend)]
+    sorted = @locations.sort
+    sorted.each { |key, loc| res << block.call(key, loc) }
+    res
+  end
+
+  def variables(*names)
+    names.collect { |name|
+      value = instance_variable_get(:"@#{name}")
+      "#{name} #{value}"
+    }
+  end
+
+  def hex(value)
+    sprintf("0x%08X", value)
+  end
+end

data/lib/act_with_booleans/utils.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class ActWithBooleans::Admin
+  def add_flag(name, pos)
+    accessor = name.to_sym
+    validate_accessor accessor, "#{accessor}?", "#{accessor}="
+
+    pos = check_pos(pos)
+    loc = Location.new(model, origin, pos)
+    add_to_locations accessor, loc
+
+    mask = model.booleans_mask(accessor)
+    add_accessors(accessor, origin, mask)
+  end
+
+  def add_mask_et_all(origin)
+    model.class_eval %(
+      def booleans_mask(*names)
+        #{model}.booleans_mask(*names)
+      end
+
+      def booleans_any?(*names)
+        mask = #{model}.booleans_mask(*names)
+        booleans = self.#{origin} || 0
+        !(booleans & mask).zero?
+      end
+
+      def booleans_all?(*names)
+        mask = #{model}.booleans_mask(*names)
+        booleans = self.#{origin} || 0
+        (booleans & mask) == mask
+      end
+
+      def booleans_none?(*names)
+        mask = #{model}.booleans_mask(*names)
+        booleans = self.#{origin} || 0
+        (booleans & mask).zero?
+      end
+    ), __FILE__, __LINE__ - 22
+  end
+
+  def reset
+    names = @locations.keys.sort
+    names.each { |name|
+      remove_accessors name
+    }
+    reset_model model
+  end
+
+  private
+
+  def validate_accessor(*names)
+    names.each { |acc|
+      raise "redefining #{acc} rejected" if model.method_defined?(acc)
+    }
+  end
+
+  def my_undef(*names)
+    names.each { |name|
+      model.class_eval %(
+        begin
+          undef #{name}
+        rescue
+        end
+      ), __FILE__, __LINE__ - 5
+    }
+  end
+end

data/lib/act_with_booleans/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActWithBooleans
+  VERSION = "0.0.1" # 2022-09-10
+  # VERSION = "3.1.0" # 2022-08-29
+end

data/lib/act_with_booleans.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Principles:
+#  POLA
+#  KISS
+#  YAGNI
+#  POLS
+#  DEI
+#  TDD is great
+#  TGCB
+#  TIOLI
+#  PORO
+
+module ActWithBooleans
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    attr_reader :act_with_booleans
+
+    def add_to_booleans(*booleans, origin: nil, **hash)
+      origin = origin&.to_sym
+      init(origin)
+
+      booleans.each { |name| act_with_booleans.add_flag(name, nil) }
+      hash.each { |name, pos| act_with_booleans.add_flag(name, pos) }
+    end
+
+    def booleans_mask(*booleans)
+      booleans.inject(0) { |memo, bool|
+        memo | 1 << act_with_booleans.position(bool)
+      }
+    end
+
+    private
+
+    def init(origin)
+      unless act_with_booleans
+        @act_with_booleans = ActWithBooleans::Admin.new self
+        origin ||= :booleans
+        act_with_booleans.origin = origin
+        act_with_booleans.add_mask_et_all origin
+        origin = nil
+      end
+      raise "ActWithBooleans: origin already defined" if origin
+    end
+  end
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
+require "act_with_booleans/version"
+require "act_with_booleans/utils"
+require "act_with_booleans/define"
+require "act_with_booleans/admin"
+require "act_with_booleans/booleans"
+require "act_with_booleans/print"

data/test/any_all_none_test.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+describe "any? all? and none?" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, c: 3, b: 7
+  end
+
+  it "checks any?" do
+    order.a = true
+    assert order.booleans_any?(:a, :b)
+    order.a = false
+    refute order.booleans_any?(:a, :b)
+  end
+
+  it "checks any? #2" do
+    order.b = true
+    assert order.booleans_any?(:a, :b)
+    order.b = false
+    refute order.booleans_any?(:a, :b)
+  end
+
+  it "checks all?" do
+    order.a = order.b = true
+    assert order.booleans_all?(:a, :b)
+    order.a = false
+    refute order.booleans_all?(:a, :b)
+  end
+
+  it "checks none? #2" do
+    order.a = order.b = true
+    refute order.booleans_none?(:a, :b)
+    order.a = false
+    refute order.booleans_none?(:a, :b)
+    order.b = false
+    assert order.booleans_none?(:a, :b)
+  end
+end

data/test/benchmark_test.rb

@@ -0,0 +1,73 @@
+# For development purposes; do not waste your tine reading it!
+# YAGNI
+
+require "test_helper"
+require "benchmark"
+require "benchmark/ips"
+# ENV["MORE"] = "true"
+
+describe "Internal timings boolean" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans :blocked
+  end
+
+  it "times ips" do
+    return unless ENV["MORE"]
+
+    Benchmark.ips do |x|
+      x.report("assign true : ") { order.blocked = true }
+      x.report("assign false: ") { order.blocked = false }
+      x.report("assign \"false\": ") { order.blocked = "false" }
+      x.report("x = order.blocked? ") { x = order.blocked? }
+      x.report("x = order.blocked ") { x = order.blocked }
+
+      x.compare!
+    end
+  end
+end
+
+describe "Internal timings mask" do
+  let(:order) { Order.new }
+  let(:admin) { Order.act_with_booleans }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, c: 3, b: 7
+    # Order.add_to_booleans a: 1, c: 3, b: 60
+    # Order.add_to_booleans a: 1, c: 3, b: 1000
+  end
+
+  it "times ips" do
+    return unless ENV["MORE"]
+
+    Benchmark.ips do |x|
+      x.report("mask(:a, :b):  ") { Order.booleans_mask(:a, :b) }
+      x.report("any?(:a, :b):  ") { order.booleans_any?(:a, :b) }
+      x.report("all?(:a, :b):  ") { order.booleans_all?(:a, :b) }
+      x.report("none?(:a, :b): ") { order.booleans_none?(:a, :b) }
+
+      x.compare!
+    end
+  end
+end
+
+class BenchFoo < Minitest::Benchmark
+  def bench_order_blocked
+    return unless ENV["MORE"]
+
+    n = 1_000_000
+    n = 100_000
+    n = 10_000
+    Order.add_to_booleans :blocked2
+    order = Order.new
+    assert_performance_constant do |input|
+      n.times do
+        order.blocked2 = true
+        order.blocked2 = !order.blocked2
+      end
+    end
+  end
+end

data/test/coding_check_add_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+describe "Internal check add boolean" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, b: 7
+  end
+
+  it "skips reserved position" do
+    Order.add_to_booleans :xx
+    order.xx = true
+    assert_equal 0x100, order.booleans
+
+    Order.add_to_booleans :yy
+    order.yy = true
+    assert_equal 0x300, order.booleans
+  end
+
+  it "rejects redefinition" do
+    Order.add_to_booleans :z
+    assert_raises { Order.add_to_booleans :z }
+  end
+
+  it "rejects reuse of position" do
+    assert_raises { Order.add_to_booleans qq: 1 }
+  end
+end

data/test/coding_coverage_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+describe "Coverage" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, b: 7
+  end
+
+  it "coverage to_s" do
+    res = order.act_with_booleans.to_s
+    # puts res
+    puts res if ENV["MORE"]
+  end
+
+  it "coverage position" do
+    assert_equal 1, order.act_with_booleans.position(:a)
+    assert_equal 7, Order.act_with_booleans.position(:b)
+    assert_equal 7, order.act_with_booleans.position(:b)
+    assert_raises { order.act_with_booleans.position(:unknown) }
+  end
+end

data/test/coding_null_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+describe "Internal Null" do
+  let(:admin) { Order.act_with_booleans }
+
+  def setup
+    reset_order
+    Order.add_to_booleans
+  end
+
+  it "respond to act_with_booleans" do
+    assert Order.respond_to?(:act_with_booleans)
+    refute_nil Order.act_with_booleans
+  end
+
+  it "tests to_boolean" do
+    assert admin.to_boolean(true)
+    assert admin.to_boolean("true")
+    assert admin.to_boolean(1)
+    assert admin.to_boolean("1")
+    refute admin.to_boolean(false)
+    refute admin.to_boolean("false")
+    refute admin.to_boolean(0)
+    refute admin.to_boolean("0")
+    assert_raises { admin.to_boolean(nil) }
+    assert_raises { admin.to_boolean(2) }
+    assert_raises { admin.to_boolean("unknown") }
+  end
+end

data/test/coding_one_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+describe "Internal One Flag" do
+  let(:bool) { :blocked }
+  let(:admin) { Order.act_with_booleans }
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans bool
+  end
+
+  it "test order.act_with_booleans" do
+    refute_nil admin
+    assert_equal admin, order.class.act_with_booleans
+    assert_equal admin, order.act_with_booleans
+    assert_equal admin, Order.act_with_booleans
+  end
+
+  it "checks definition of methods for bool" do
+    msg = "method '#{bool}' not defined"
+    assert order.respond_to?(bool.to_s), msg
+    assert order.respond_to?("#{bool}?"), msg
+    assert order.respond_to?("#{bool}="), msg
+  end
+end

data/test/coding_reset_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+describe "Testing reset" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans :a
+  end
+
+  it "reset hard" do
+    empty = {}
+    refute_equal empty, Order.act_with_booleans.locations
+
+    Order.act_with_booleans&.reset
+    assert_equal empty, Order.act_with_booleans.locations
+  end
+end

data/test/inheritance_test.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+
+class A < Order
+end
+
+class B < Order
+  include ActWithBooleans
+
+  add_to_booleans y: 2
+end
+
+describe "inheritance" do
+  let(:order) { Order.new }
+  let(:a) { A.new }
+  let(:b) { B.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans x: 1
+  end
+
+  it "tests Order" do
+    refute order.x?
+    order.x = true
+    assert order.x?
+  end
+
+  it "tests A" do
+    refute a.x?
+    a.x = true
+    assert a.x?
+  end
+
+  it "tests B" do
+    refute b.x?
+    b.x = true
+    assert b.x?
+
+    refute b.y?
+    b.y = true
+    assert b.y?
+
+    assert_raises { order.y? }
+  end
+
+  it "tests booleans_mask" do
+    assert_equal 0x02, Order.booleans_mask(:x)
+    assert_raises { Order.booleans_mask(:y) }
+    assert_raises { B.booleans_mask(:x) }
+    assert_equal 0x04, B.booleans_mask(:y)
+    assert_raises { B.booleans_mask(:x, :y) }
+  end
+end

data/test/legacy_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+describe "Legacy Flag" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, c: 3, b: 7
+  end
+
+  it "set true" do
+    test3 true, true, true
+  end
+
+  it "set false" do
+    test3 false, false, false
+  end
+
+  it "set mixture" do
+    test3 false, true, false
+  end
+
+  it "set mixture #2" do
+    test3 true, false, true
+  end
+
+  private
+
+  def test3(a, b, c)
+    order.a = a
+    order.b = b
+    order.c = c
+
+    assert_equal a, order.a
+    assert_equal b, order.b
+    assert_equal c, order.c
+  end
+end

data/test/mask_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+describe "mask" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans a: 1, c: 3, b: 7
+  end
+
+  it "mask empty" do
+    assert_equal 0x00, order.booleans_mask
+    assert_equal 0x00, Order.booleans_mask
+  end
+
+  it "mask of one boolean" do
+    assert_equal 0x80, order.booleans_mask(:b)
+    assert_equal 0x80, Order.booleans_mask(:b)
+  end
+
+  it "mask of several booleans" do
+    assert_equal 0x8a, order.booleans_mask(:a, :b, :c)
+    assert_equal 0x8a, Order.booleans_mask(:a, :b, :c)
+  end
+
+  it "order is not relevant" do
+    mask = order.booleans_mask(:a, :b, :c)
+    assert_equal mask, Order.booleans_mask(:c, :b, :a)
+  end
+end

data/test/null_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+describe "Order: just include ActWithBooleans and :booleans" do
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans
+  end
+
+  it "respond to ActWithBooleans API" do
+    assert Order.respond_to?(:add_to_booleans)
+    assert Order.respond_to?(:act_with_booleans)
+    assert Order.respond_to?(:booleans_mask)
+  end
+
+  it "checks mask et all; no parameters" do
+    assert_equal 0, order.booleans_mask
+    refute order.booleans_any?
+    assert order.booleans_all?
+    assert order.booleans_none?
+  end
+end

data/test/one_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+describe "One Flag" do
+  let(:bool) { :blocked }
+  let(:order) { Order.new }
+
+  def setup
+    reset_order
+    Order.add_to_booleans bool
+  end
+
+  it "checks bool default" do
+    refute_equal true, order.blocked
+    assert_equal false, order.blocked
+    assert_equal false, order.blocked?
+  end
+
+  it "set bool (:blocked)" do
+    order.blocked = true
+    assert_equal true, order.blocked
+    assert_equal true, order.blocked?
+
+    order.blocked = "false"
+    assert_equal false, order.blocked
+    assert_equal false, order.blocked?
+  end
+
+  it "rejects redefining" do
+    assert_raises { Order.add_to_booleans bool }
+  end
+
+  it "rejects redefining #2" do
+    Order.add_to_booleans :berta
+    assert_raises { Order.add_to_booleans :berta }
+  end
+end

data/test/origin_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+# class A used elsewhere => use AA
+class AA
+  include ActWithBooleans
+end
+
+# dito
+class BB
+  include ActWithBooleans
+end
+
+# dito
+class CC
+  include ActWithBooleans
+end
+
+describe "Testing origin" do
+  it "checks default origin :booleans" do
+    assert_raises { AA.act_with_booleans.origin }
+    AA.add_to_booleans
+    assert_equal :booleans, AA.act_with_booleans.origin
+  end
+
+  it "checks origin set to :origin" do
+    BB.add_to_booleans origin: :origin
+    assert_equal :origin, BB.act_with_booleans.origin
+    assert_raises { BB.act_with_booleans origin: :origin2 }
+  end
+
+  it "rejects a second origin" do
+    CC.add_to_booleans
+    assert_equal :booleans, CC.act_with_booleans.origin
+    assert_raises { CC.act_with_booleans origin: :origin2 }
+  end
+end

data/test/size_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+describe "size" do
+  let(:admin) { Order.act_with_booleans }
+
+  def setup
+    reset_order
+    Order.add_to_booleans
+  end
+
+  it "checks empty booleans" do
+    assert_equal 0, admin.size
+    order = Order.new
+    assert_equal 0, order.act_with_booleans.size
+  end
+
+  it "checks one boolean" do
+    Order.add_to_booleans :a
+    assert_equal 1, admin.size
+  end
+
+  it "checks size using postion" do
+    n = 123
+    Order.add_to_booleans a: n
+    assert_equal n + 1, admin.size
+  end
+
+  it "trying to overwrite" do
+    Order.add_to_booleans :a
+    assert_equal 1, admin.size
+    assert_raises { Order.add_to_booleans b: 0 }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+end
+
+require "minitest/autorun"
+require "minitest/benchmark"
+require "act_with_booleans"
+
+class Order
+  include ActWithBooleans
+
+  attr_accessor :booleans
+end
+
+def reset_order
+  Order.act_with_booleans&.reset
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: act_with_booleans
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dittmar Krall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: minitest
+  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: Handles booleans packed in an integer
+email:
+- dittmar.krall@matiq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/lint.yml"
+- ".github/workflows/rake.yml"
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".watchr"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- act_with_booleans.gemspec
+- lib/act_with_booleans.rb
+- lib/act_with_booleans/admin.rb
+- lib/act_with_booleans/booleans.rb
+- lib/act_with_booleans/define.rb
+- lib/act_with_booleans/print.rb
+- lib/act_with_booleans/utils.rb
+- lib/act_with_booleans/version.rb
+- test/any_all_none_test.rb
+- test/benchmark_test.rb
+- test/coding_check_add_test.rb
+- test/coding_coverage_test.rb
+- test/coding_null_test.rb
+- test/coding_one_test.rb
+- test/coding_reset_test.rb
+- test/inheritance_test.rb
+- test/legacy_test.rb
+- test/mask_test.rb
+- test/null_test.rb
+- test/one_test.rb
+- test/origin_test.rb
+- test/size_test.rb
+- test/test_helper.rb
+homepage: http://matiq.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/matique/act_with_booleans
+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: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Ruby gem act_with_booleans
+test_files: []