act_with_flags 0.2.4 → 3.0.1

data/lib/act_with_flags/admin.rb

@@ -1,68 +1,25 @@
-# rubocop:disable all
 # frozen_string_literal: true
 
 class ActWithFlags::Admin
-
   attr_reader :model
-  attr_reader :origin
-  attr_reader :delete_mask
 
   def initialize(model)
+    @locations = {}
+    @clears = {}
     @model = model
-    @origin = :flags
-    @map = {}
-    @delete_mask = 0
-    @max_position = 512 - 1
     @boolean_hash = {}
-    [true,  'true',  1, '1'].each { |x| @boolean_hash[x] = true }
-    [false, 'false', 0, '0'].each { |x| @boolean_hash[x] = false }
+    [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 names
-    @map.keys.sort
-  end
-
   def to_boolean(value)
     res = @boolean_hash[value]
-    return res  unless res.nil?
+    return res unless res.nil?
 
     raise "invalid boolean <#{value}>"
   end
-
-  def origin=(name)
-    raise 'invalid update of origin'  unless @map.empty? || (origin == name)
-    @origin = name
-  end
-
-  def position(name)
-    pos = @map[name]
-    return pos  if pos
-
-    parent = self.model.superclass.act_with_flags
-    return parent.position(name)  if parent
-
-    raise "unknown flag '#{model}##{name}'"
-  end
-
-  def mask(*names)
-    names.inject(0) { |msk, name| msk | ( 1 << position(name) ) }
-  end
-
-  def add(name, pos)
-    values = @map.values
-    pos ||= (0..@max_position).detect { |i| !values.include?(i) }
-    raise "invalid position '#{name} @ #{pos}'"  unless pos
-    raise "name in use '#{name} @ #{pos}'"       if @map.key?(name)
-    raise "position in use '#{name} @ #{pos}'"   if @map.value?(pos)
-    @map[name] = pos
-  end
-
-  def add_to_delete_mask(name)
-    @delete_mask |= mask(name)
-  end
-
 end

data/lib/act_with_flags/clear.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class ActWithFlags::Admin
+  attr_reader :clears
+
+  def clear_at_save(*flags)
+    flags.each { |name| add_to_clear_mask(name) }
+    clears.each { |orig, mask|
+      before_save(orig, mask)
+    }
+    @clears = {}
+  end
+
+  private
+
+  def add_to_clear_mask(name)
+    _model, orig, _pos = location(name).values
+    mask = @clears[orig] || 0
+    mask |= 1 << position(name)
+    @clears[orig] = mask
+  end
+
+  def before_save(orig, mask)
+    model.class_eval %(
+      before_save do |row|
+        row.#{orig} &= ~#{mask}
+      end
+    ), __FILE__, __LINE__ - 4
+  end
+end

data/lib/act_with_flags/define.rb

@@ -1,16 +1,13 @@
-# rubocop:disable all
 # frozen_string_literal: true
 
 class ActWithFlags::Admin
-
-  def add_accessors(origin, accessor, mask)
-#p ["act_with_flags#add_accessors:", model, origin, accessor, mask]
+  def add_accessors(accessor, origin, mask)
     unless model.method_defined?(:act_with_flags)
       model.class_eval %(
         def act_with_flags
           #{model}.act_with_flags
         end
-      )
+      ), __FILE__, __LINE__ - 4
     end
 
     model.class_eval %(
@@ -19,7 +16,7 @@ class ActWithFlags::Admin
       end
 
       def #{accessor}?
-        raise "Uninitialized '#{model}.#{origin}'"  if #{origin}.nil?
+        raise "Uninitialized '#{model}.#{origin}'" if #{origin}.nil?
         if #{origin}.is_a?(String)
           flags = self.#{origin}.to_i
           !( flags & #{mask} ).zero?
@@ -29,9 +26,9 @@ class ActWithFlags::Admin
       end
 
       def #{accessor}=(value)
-        raise "Uninitialized '#{model}.#{origin}'"  if #{origin}.nil?
+        raise "Uninitialized '#{model}.#{origin}'" if #{origin}.nil?
         is_a_string = #{origin}.is_a?(String)
-        flags = is_a_string ? self.#{origin}.to_i : self.#{origin}
+        flags = self.#{origin}.to_i
         flags ||= 0
 
         result = self.act_with_flags.to_boolean(value)
@@ -44,36 +41,10 @@ class ActWithFlags::Admin
 
         result
       end
-    )
+    ), __FILE__, __LINE__ - 31
   end
 
   def remove_accessor(accessor)
     my_undef model, accessor, "#{accessor}?", "#{accessor}="
   end
-
-  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
-      )
-    }
-  end
-
-  def before_save
-    model.class_eval %(
-      before_save do |row|
-        row.#{origin} &= ~row.class.act_with_flags.delete_mask
-      end
-    )
-  end
-
 end

data/lib/act_with_flags/flags.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class ActWithFlags::Admin
+  Location = Struct.new(:model, :origin, :position)
+
+  attr_reader :locations
+
+  def mask(*flags)
+    return 0 if flags.empty?
+
+    res = mask2d(*flags)
+    raise "Mixing origins fails: #{flags}" unless res.length == 1
+
+    res.values.first
+  end
+
+  def mask2d(*flags)
+    res = {}
+    flags.each { |flag|
+      model, orig, pos = location(flag).values
+      idx = "#{model}##{orig}"
+      mask = res[idx] || 0
+      res[idx] = mask | (1 << pos)
+    }
+    res
+  end
+
+  def location(name)
+    location = @locations[name]
+    return location if location
+
+    parent = model.superclass.act_with_flags
+    return parent.location(name) if parent
+
+    raise "unknown flag '#{model}##{name}'"
+  end
+
+  private
+
+  def position(name)
+    location(name).position
+  end
+
+  def add_to_locations(flag, location)
+    location = check_position(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_position(location)
+    model, orig, pos = location.values
+    return location if pos
+
+    max_position = -1
+    @locations.each { |name, location|
+      model2, orig2, pos2 = location.values
+      next unless model == model2 && orig == orig2
+
+      max_position = pos2 if pos2 > max_position
+    }
+
+    Location.new(model, orig, max_position + 1)
+  end
+end

data/lib/act_with_flags/print.rb

@@ -1,44 +1,39 @@
-# rubocop:disable all
 # frozen_string_literal: true
 
 class ActWithFlags::Admin
-
   def to_s
     res = []
-    res << title('Variables')
-    res << variables(:origin, :boolean_hash)
+    res << title("Variables")
+    res << variables(:boolean_hash)
     res << variables(:delete_mask)
 
-    res << title('Flags sorted alfabetically')
-    @map.sort.each { |key, pos| res << "#{key}  #{position(key)}" }
-
-    res << title('Flags sorted by position')
-    @map.sort.sort_by(&:last).each { |key, pos|
-      res << "#{key}  #{position(key)}"
+    res << blk("Flags sorted alfabetically") { |key, loc|
+      "#{key} #{loc}"
     }
-
-    res << title('Flags and mask; sorted alfabetically')
-    @map.sort.each { |key, pos|
-      res << "#{key}  #{sprintf('0x%08X', mask(key))}"
-    }
-
-    res << title('FLAG assignment; sorted alfabetically')
-    @map.sort.each { |key, pos|
-      res << "FLAG_#{key.upcase} = #{sprintf('0x%08X', mask(key))}"
+    res << blk("Flags and mask; sorted alfabetically") { |key, loc|
+      "#{key}  #{sprintf("0x%08X", mask(key))}"
     }
-
-    res << title('FLAG assignment; sorted by position')
-    @map.sort.sort_by(&:last).each { |key, pos|
-      res << "FLAG_#{key.upcase} = #{sprintf('0x%08X', mask(key))}"
+    res << blk("FLAG assignment; sorted alfabetically") { |key, loc|
+      "FLAG_#{key.upcase} = #{sprintf("0x%08X", mask(key))}"
     }
 
+    res << title("@locations")
+    res << @locations
     res.flatten.join("\n")
   end
 
- private
+  private
+
   def title(msg)
-    sep = '#' * 10
-    ['', "#{sep} #{msg} #{sep}"]
+    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)
@@ -47,5 +42,4 @@ class ActWithFlags::Admin
       "#{name} #{value}"
     }
   end
-
 end

data/lib/act_with_flags/utils.rb

@@ -1,16 +1,14 @@
-# rubocop: disable all
+# frozen_string_literal: true
 
 class ActWithFlags::Admin
-
-  def add_accessor(name, pos)
-#p "** act_with_flags: add_accessor '#{name} @ #{pos}'"
+  def add_flag(name, origin, pos)
     accessor = name.to_sym
     validate_accessor accessor, "#{accessor}?", "#{accessor}="
 
-    add accessor, pos
+    loc = Location.new(model, origin, pos)
+    add_to_locations accessor, loc
     mask = mask(accessor)
-    origin = self.origin
-    add_accessors(origin, accessor, mask)
+    add_accessors(accessor, origin, mask)
   end
 
   def add_mask_et_all(origin)
@@ -33,19 +31,33 @@ class ActWithFlags::Admin
         mask = self.class.act_with_flags.mask(*names)
         ( self.#{origin} & mask ).zero?
       end
-    )
-  end
-
-  def delete_mask_et_all
-    my_undef :flags_mask, :flags_any?, :flags_all?, :flags_none?
+    ), __FILE__, __LINE__ - 19
   end
 
   def reset
-    delete_mask_et_all
+    names = @locations.keys.sort
     names.each { |name|
       remove_accessor 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_flags/version.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-# rubocop: disable all
 
 module ActWithFlags
-  VERSION = '0.2.4'     # 2021-06-21
-# VERSION = '0.2.3'     # 2020-07-14
-# VERSION = '0.2.2'     # 2020-04-27
-# VERSION = '0.2.1'     # 2020-03-01
-# VERSION = '0.2.0'     # 2019-10-04
-# VERSION = '0.1.0'     # 2019-04-07
+  VERSION = "3.0.1" # 2022-08-07
+  # VERSION = "3.0.0" # 2022-07-27
+  # VERSION = "0.2.4" # 2021-06-21
+  # VERSION = "0.2.3" # 2020-07-14
+  # VERSION = "0.2.2" # 2020-04-27
+  # VERSION = "0.2.1" # 2020-03-01
+  # VERSION = "0.2.0" # 2019-10-04
+  # VERSION = "0.1.0" # 2019-04-07
 end

data/lib/act_with_flags.rb

@@ -1,4 +1,3 @@
-# rubocop:disable all
 # frozen_string_literal: true
 
 # Principles:
@@ -8,47 +7,37 @@
 #  POLS
 #  DEI
 #  TDD considered harmful
+#  TGCB
 
 class << ActiveRecord::Base
-
-  attr_accessor :act_with_flags
+  attr_reader :act_with_flags
 
   def add_to_flags(*flags, origin: :flags, **hash)
-#p "act_with_flags: add_to_flags #{flags.inspect}"
-#p "act_with_flags: origin #{origin.inspect}"
-#p "act_with_flags: hash   #{hash.inspect}"
-
-    @act_with_flags ||= ActWithFlags::Admin.new self
-    if origin.is_a?(Integer)
-      hash[:origin] = origin
-    else
-      @act_with_flags.origin = origin
-      @act_with_flags.delete_mask_et_all
+    unless @act_with_flags
+      @act_with_flags ||= ActWithFlags::Admin.new self
       @act_with_flags.add_mask_et_all origin
     end
 
-    flags.each { |name|      @act_with_flags.add_accessor(name, nil) }
-    hash.each  { |name, pos| @act_with_flags.add_accessor(name, pos) }
+    flags.each { |name| @act_with_flags.add_flag(name, origin, nil) }
+    hash.each { |name, pos| @act_with_flags.add_flag(name, origin, pos) }
 
     @act_with_flags
   end
 
   def remove_from_flags(*flags)
-#p "remove_from_flags #{flags.inspect}"
     flags.each { |name| @act_with_flags.remove_accessor(name) }
   end
 
   def clear_flags_at_save(*flags)
-#p "clear_flags_at_save #{flags.inspect}"
-    flags.each { |name| @act_with_flags.add_to_delete_mask(name) }
-    @act_with_flags.before_save
+    @act_with_flags.clear_at_save(*flags)
   end
-
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
-require 'act_with_flags/version'
-require 'act_with_flags/utils'
-require 'act_with_flags/define'
-require 'act_with_flags/admin'
-require 'act_with_flags/print'
+require "act_with_flags/version"
+require "act_with_flags/utils"
+require "act_with_flags/define"
+require "act_with_flags/admin"
+require "act_with_flags/flags"
+require "act_with_flags/clear"
+require "act_with_flags/print"

data/test/any_all_none_test.rb

@@ -1,8 +1,6 @@
-# rubocop: disable all
+require "test_helper"
 
-require 'test_helper'
-
-describe 'any? all? and none?' do
+describe "any? all? and none?" do
   let(:order) { Order.create }
 
   def setup
@@ -10,28 +8,28 @@ describe 'any? all? and none?' do
     Order.add_to_flags a: 1, b: 7, c: 3
   end
 
-  it 'checks any?' do
+  it "checks any?" do
     order.a = true
     assert order.flags_any?(:a, :b)
     order.a = false
     refute order.flags_any?(:a, :b)
   end
 
-  it 'checks any? #2' do
+  it "checks any? #2" do
     order.b = true
     assert order.flags_any?(:a, :b)
     order.b = false
     refute order.flags_any?(:a, :b)
   end
 
-  it 'checks all?' do
+  it "checks all?" do
     order.a = order.b = true
     assert order.flags_all?(:a, :b)
     order.a = false
     refute order.flags_all?(:a, :b)
   end
 
-  it 'checks none? #2' do
+  it "checks none? #2" do
     order.a = order.b = true
     refute order.flags_none?(:a, :b)
     order.a = false
@@ -39,5 +37,4 @@ describe 'any? all? and none?' do
     order.b = false
     assert order.flags_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 flag" do
+  let(:order) { Order.create }
+
+  def setup
+    reset_order
+    Order.add_to_flags :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.create }
+  let(:admin) { Order.act_with_flags }
+
+  def setup
+    reset_order
+    Order.add_to_flags a: 1, b: 7, c: 3
+    # Order.add_to_flags a: 1, b: 60, c: 3
+    # Order.add_to_flags a: 1, b: 1000, c: 3
+  end
+
+  it "times ips" do
+    return unless ENV["MORE"]
+
+    Benchmark.ips do |x|
+      x.report("mask(:a, :b):  ") { admin.mask(:a, :b) }
+      x.report("any?(:a, :b):  ") { order.flags_any?(:a, :b) }
+      x.report("all?(:a, :b):  ") { order.flags_all?(:a, :b) }
+      x.report("none?(:a, :b): ") { order.flags_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_flags :blocked2
+    order = Order.create
+    assert_performance_constant do |input|
+      n.times do
+        order.blocked2 = true
+        order.blocked2 = !order.blocked2
+      end
+    end
+  end
+end

data/test/clear_test.rb

@@ -1,7 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
-describe 'Clear Flags at Save' do
-  let(:admin) { Order.act_with_flags }
+describe "Clear flags at save" do
   let(:order) { Order.create }
 
   def setup
@@ -10,21 +9,20 @@ describe 'Clear Flags at Save' do
     order.a = order.b = order.c = true
   end
 
-  it 'checks sanity' do
+  it "checks sanity" do
     assert_equal 0x8a, order.flags
     assert order.b
   end
 
-  it 'clear flags during save' do
+  it "clear flags during save" do
     Order.clear_flags_at_save :b
     order.save
     order.reload
     assert_equal 0x0a, order.flags
   end
 
-  it 'does not remove accessor' do
+  it "does not remove accessor" do
     Order.clear_flags_at_save :b
     Order.respond_to? :b
   end
-
 end

data/test/coding_check_add_test.rb

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

data/test/coding_coverage_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+describe "Coverage" do
+  let(:order) { Order.create }
+
+  def setup
+    reset_order
+    Order.add_to_flags a: 1, b: 7
+  end
+
+  it "coverage to_s" do
+    res = order.act_with_flags.to_s
+    puts res if ENV["MORE"]
+  end
+
+  it "coverage location raise" do
+    assert_raises { order.act_with_flags.location(:unknown) }
+  end
+end