bitmask_enum 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b142602ee1da79ca17074c2fe1edcabeb98d5a053c2486f98ef95410a6f0b15
-  data.tar.gz: fa1d5994dd353bd811ed560f1fbbb204d7d8fe2ff824280c8b4dc689592fb72e
+  metadata.gz: ca2abf599d5126367ff0a605da44b150e39d475a2e715fb7a1c424edc54a31ea
+  data.tar.gz: f67516fe2b686f8d92044ad745be0189c6cb71af86ef2689c9b3785b16a7e99a
 SHA512:
-  metadata.gz: 0bf71ad17b882b72b65f90902c54c8ecf2e2c6589acb4fd90b8b4f586d02b5caa20d2500a0a0b880ea10045048dae6062d5346801a6b0d89c6048dca3908f9e4
-  data.tar.gz: 4fc29a681c368a0808d4554fd74e448a28cf24486a81d0488d765add4124e38ce1e40ffeddcf38bedad81579813103bf58fc52e3d3feb38dc63c25aacb8c812b
+  metadata.gz: a2261aa059b461ce5ed1083a66fd8e9173c3f4fd58241e9beb116a1ac0848077f347370e8468d8012bf1555153a1f2fbaa293edd7944f392ed6391e03a19b7dd
+  data.tar.gz: 7ab5c0cd95db21e8e36aa744d46e61efc943ad465e6912898843fbf91e641d265b7bce6ecd857e8575b93b7678379d00813923b14f8ddff97c1ebd27c9d7d8b1

data/.rubocop.yml

@@ -6,6 +6,8 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 2.4
 
+Metrics/ClassLength: 
+  Max: 120
 Metrics/MethodLength: 
   Max: 20
 RSpec/ExampleLength:

data/CHANGELOG.md

@@ -37,3 +37,9 @@ Add YARD docs.
 Standardize output to symbols.
 Add validation of the attribute - less_than: 1 << flags.size
 Add max ActiveRecord version to protect against future breaking releases
+
+# 1.1.0 : 2022-08-30
+
+Add dynamic scopes for any of provided flags enabled or disabled.
+Add dynamic scopes for all of provided flags enabled or disabled.
+Correct and update some documentation.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitmask_enum (1.0.0)
+    bitmask_enum (1.1.0)
       activerecord (>= 4.2, <= 7.0)
 
 GEM

data/README.md

@@ -10,6 +10,8 @@ Supporting Ruby 2.4+ and Rails 4.2+.
 
 Credit is due to Joel Moss' gem [bitmask_attributes](https://github.com/joelmoss/bitmask_attributes). I came across it while considering if I should write a gem for this. It's great work and some elements of it inspired this gem, I just had my own thoughts about how I'd like the gem to operate, and wanted some more end-to-end experience on gem production so I decided to create this rather than pick up the torch on that repo.
 
+This gem attempts to improve performance by precomputing the integer values for the enum rather than using bitwise operations in the SQL.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -28,6 +30,8 @@ Or install it yourself as:
 
 ## Usage
 
+[RubyDocs for BitmaskEnum](https://www.rubydoc.info/github/lucygilbert/bitmask_enum/master)
+
 In the model, the bitmask enum is added in a similar way to enums. Given an integer attribute called `attribs`, flags of `flag` and `flag2`, adding the `flag_prefix` option with the value `type`, the following line would be used:
 
 ```ruby
@@ -129,7 +133,9 @@ The method returns an array of all enabled flags on the instance. The items will
 
 ### `{attribute}=` (_Override_)
 
-**No params**
+**Params**
+
+- value [Integer, Symbol, String, Array\<Symbol, String\>] - An integer, a defined flag or array of defined flags
 
 This method will be created once on the instance.
 
@@ -163,6 +169,54 @@ The method is a scope of all records for which the flag is disabled.
 
 **Return value:** `ActiveRecord::Relation` - a collection of all records for which the flag is disabled.
 
+### `any_{attribute}_enabled`
+
+**Params**
+
+- flags [Symbol, String, Array\<Symbol, String\>] - A defined flag or array of defined flags
+
+This method will be created once on the class.
+
+The method is a scope of all records for which any of the provided flags are enabled.
+
+**Return value:** `ActiveRecord::Relation` - a collection of all records for which the flag is enabled.
+
+### `any_{attribute}_disabled`
+
+**Params**
+
+- flags [Symbol, String, Array\<Symbol, String\>] - A defined flag or array of defined flags
+
+This method will be created once on the class.
+
+The method is a scope of all records for which any of the provided flags are disabled.
+
+**Return value:** `ActiveRecord::Relation` - a collection of all records for which the flag is disabled.
+
+### `all_{attribute}_enabled`
+
+**Params**
+
+- flags [Symbol, String, Array\<Symbol, String\>] - A defined flag or array of defined flags
+
+This method will be created once on the class.
+
+The method is a scope of all records for which all of the provided flags are enabled.
+
+**Return value:** `ActiveRecord::Relation` - a collection of all records for which the flag is enabled.
+
+### `all_{attribute}_disabled`
+
+**Params**
+
+- flags [Symbol, String, Array\<Symbol, String\>] - A defined flag or array of defined flags
+
+This method will be created once on the class.
+
+The method is a scope of all records for which all of the provided flags are disabled.
+
+**Return value:** `ActiveRecord::Relation` - a collection of all records for which the flag is disabled.
+
 ### `{attribute}`
 
 **No params**

data/lib/bitmask_enum/attribute.rb

@@ -30,6 +30,10 @@ module BitmaskEnum
       flag_getter_method
       flag_setter_method
 
+      dynamic_any_enabled_scope
+      dynamic_any_disabled_scope
+      dynamic_all_enabled_scope
+      dynamic_all_disabled_scope
       class_flag_values_method
     end
 
@@ -45,8 +49,8 @@ module BitmaskEnum
       flag_on_method(flag_label, flag_index)
       flag_off_method(flag_label, flag_index)
 
-      class_flag_enabled_scope(flag_label, flag_index)
-      class_flag_disabled_scope(flag_label, flag_index)
+      flag_enabled_scope(flag_label, flag_index)
+      flag_disabled_scope(flag_label, flag_index)
     end
 
     def flag_check_method(flag_label, flag_index)
@@ -80,25 +84,55 @@ module BitmaskEnum
       @model.class_eval EvalScripts.flag_method(method_name, method_code), __FILE__, __LINE__
     end
 
-    def class_flag_enabled_scope(flag_label, flag_index)
-      class_flag_scope("#{flag_label}_enabled", :on, flag_index)
+    def flag_enabled_scope(flag_label, flag_index)
+      flag_scope("#{flag_label}_enabled", :on, flag_index)
     end
 
-    def class_flag_disabled_scope(flag_label, flag_index)
-      class_flag_scope("#{flag_label}_disabled", :off, flag_index)
+    def flag_disabled_scope(flag_label, flag_index)
+      flag_scope("#{flag_label}_disabled", :off, flag_index)
     end
 
-    def class_flag_scope(scope_name, setting, flag_index)
-      comparator = setting == :on ? :> : :==
-      values_for_bitmask = (0...(1 << @flags.size)).select { |x| (x & (1 << flag_index)).send(comparator, 0) }
-
-      values_for_bitmask = @nil_handler.in_array(values_for_bitmask) if setting == :off
+    def flag_scope(scope_name, setting, flag_index)
+      values_for_bitmask = values_for_flag_bitmask(setting, flag_index)
 
       @conflict_checker.check_class_method!(scope_name)
 
       @model.class_eval EvalScripts.flag_scope(scope_name, @attribute, values_for_bitmask), __FILE__, __LINE__
     end
 
+    def dynamic_any_enabled_scope
+      dynamic_scope("any_#{@attribute}_enabled", :on, '|')
+    end
+
+    def dynamic_any_disabled_scope
+      dynamic_scope("any_#{@attribute}_disabled", :off, '|')
+    end
+
+    def dynamic_all_enabled_scope
+      dynamic_scope("all_#{@attribute}_enabled", :on, '&')
+    end
+
+    def dynamic_all_disabled_scope
+      dynamic_scope("all_#{@attribute}_disabled", :off, '&')
+    end
+
+    def dynamic_scope(scope_name, setting, bitwise_operator)
+      flags_and_values = @flags.each_with_index.map do |flag, flag_index|
+        [flag, values_for_flag_bitmask(setting, flag_index)]
+      end
+
+      @model.class_eval EvalScripts.dynamic_scope(
+        scope_name, @attribute, flags_and_values, bitwise_operator
+      ), __FILE__, __LINE__ - 2
+    end
+
+    def values_for_flag_bitmask(setting, flag_index)
+      comparator = setting == :on ? :> : :==
+      values_for_bitmask = (0...(1 << @flags.size)).select { |x| (x & (1 << flag_index)).send(comparator, 0) }
+      values_for_bitmask = @nil_handler.in_array(values_for_bitmask) if setting == :off
+      values_for_bitmask
+    end
+
     def flag_settings_hash_method
       method_name = "#{@attribute}_settings"
 

data/lib/bitmask_enum/eval_scripts.rb

@@ -33,7 +33,7 @@ module BitmaskEnum
       # Code for methods scoping by flag: `.flag_enabled`, `.flag_disabled`
       # @param scope_name [String] Name of the scope
       # @param attribute [String] Name of the attribute
-      # @param values_for_bitmask [Array] Array of integers for which the flag would be disabled
+      # @param values_for_bitmask [Array] Array of integers for which the flag would be enabled/disabled
       # @return [String] Code string to be evaled
       def flag_scope(scope_name, attribute, values_for_bitmask)
         %(
@@ -43,6 +43,33 @@ module BitmaskEnum
         )
       end
 
+      # Code for methods dynamically scoping by flags: `.attribs_enabled`, `.attribs_disabled`
+      # @param scope_name [String] Name of the scope
+      # @param attribute [String] Name of the attribute
+      # @param flags_and_values [Array] Array of arrays, first being the flag, second being the enum values for the flag
+      # @param bitwise_operator [String] Bitwise operator used to combine the enum value arrays
+      # @return [String] Code string to be evaled
+      def dynamic_scope(scope_name, attribute, flags_and_values, bitwise_operator)
+        %(
+scope :#{scope_name}, ->(flags) do                             # scope :attribs_disabled, ->(flags) do
+  enum_values = {                                              #   enum_values = {
+    #{flags_and_values.map { |f, v| "#{f}: #{v}" }.join(', ')} #     flag: [1,3], flag2: [2]
+  }                                                            #   }
+                                                               #
+  where('#{attribute}' => Array(flags).map do |flag|           #   where('attribs' => Array(flags).map do |flag|
+    flag_values = enum_values[flag.to_sym]                     #     flag_values = enum_values[flag.to_sym]
+    if flag_values.nil?                                        #     if flag_index.nil?
+      raise(                                                   #       raise(
+        ArgumentError,                                         #         ArgumentError,
+        "Invalid flag \#{flag} for #{attribute}"               #         "Invalid flag \#{flag} for attribs"
+      )                                                        #       )
+    end                                                        #     end
+    flag_values                                                #     flag_values
+  end.reduce(&:#{bitwise_operator}))                           #   end.map(&:|))
+end                                                            # end
+        )
+      end
+
       # Code for method returning hash of flags with their boolean setting: `#attribs_settings`
       # @param method_name [String] Name of the method
       # @param flag_hash_contents [String] Contents of the hash which provides the flag settings

data/lib/bitmask_enum/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BitmaskEnum
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitmask_enum
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Lucy Gilbert
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-29 00:00:00.000000000 Z
+date: 2022-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord