active_record_bitmask 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0836338456ad6155feff23e641e6f6b991ba9a670763b2c09c9ab2a3d243797
+  data.tar.gz: 0210e6445e4ac868fe4e41d3473b4f8fdb17ff0202e2058ad89845023e939c11
+SHA512:
+  metadata.gz: 040e8da0c1ef2cdc42687c5ae66eb7d379d25a29d7b13c29877a27dd8c834075542b4757a2950e57b8cb945ebe37fa2a5ad2ddc36653eb2434ada7e088837487
+  data.tar.gz: 8373e9a4903dfab97a8ec21052192e99f4813ff99257e362c025427f1de3b97228565f2b35df65edb35ef39f0c3ab28fe917ec43c49ceb877c4601ec1b3fc34d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--require spec_helper
+--color

data/.rubocop.yml

@@ -0,0 +1,88 @@
+AllCops:
+  Exclude:
+    - '.bundle/**/*'
+    - Gemfile
+  TargetRubyVersion: 2.6
+  DisplayCopNames: true
+
+Bundler:
+  Enabled: false
+
+Naming:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DocumentationMethod:
+  Enabled: true
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Layout/ParameterAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Lint/DisjunctiveAssignmentInConstructor:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/PerceivedComplexity:
+  Max: 10
+
+Lint/UselessAccessModifier:
+  ContextCreatingMethods:
+    - concerning

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.13.7

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'
+gem 'rubocop'
+
+group :test do
+  gem 'sqlite3'
+end

data/README.md

@@ -0,0 +1,76 @@
+# ActiveRecordBitmask
+
+Transparent manipulation of bitmask attributes for ActiveRecord
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_bitmask'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record_bitmask
+
+## Usage
+
+Simply declare an existing integer column as a bitmask.
+
+```ruby
+class Post < ApplicationRecord
+  bitmask(roles: [:administrator, :provider, :guest])
+end
+```
+
+You can then modify the column using the declared values.
+
+```ruby
+post = Post.create(roles: [:provider, :guest])
+post.roles #=> [:provider, :guest]
+post.roles += [:administrator]
+post.roles #=> [:administrator, :provider, :guest]
+```
+
+You can check bitmask
+
+```ruby
+post = Post.create(roles: [:provider, :guest])
+post.roles?(:provider) #=> false
+post.roles?(:guest, :provider) #=> true
+```
+
+You can get the definition of bitmask
+
+```ruby
+map = Post.bitmask_for(:rules)
+map.keys   #=> [:administrator, :provider, :guest]
+map.values #=> [1, 2, 4]
+```
+
+### Scopes
+
+#### `with_rules`
+
+#### `with_any_rules`
+
+#### `without_rules`
+
+#### `with_exact_rules`
+
+#### `no_rules`
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake` to run the tests. 
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/alpaca-tc/active_record_bitmask.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/active_record_bitmask.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record_bitmask/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active_record_bitmask'
+  spec.version       = ActiveRecordBitmask::VERSION
+  spec.authors       = ['alpaca-tc']
+  spec.email         = ['alpaca-tc@alpaca.tc']
+
+  spec.summary       = 'Simple bitmask attribute support for ActiveRecord'
+  spec.homepage      = 'https://github.com/pixiv/active_record_bitmask'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '>= 5.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/active_record_bitmask.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support/lazy_load_hooks'
+
+module ActiveRecordBitmask
+  require 'active_record_bitmask/version'
+  require 'active_record_bitmask/attribute_methods'
+  require 'active_record_bitmask/bitmask_type'
+  require 'active_record_bitmask/map'
+end
+
+ActiveSupport.on_load :active_record do
+  require 'active_record_bitmask/model'
+  include(ActiveRecordBitmask::Model)
+end

data/lib/active_record_bitmask/attribute_methods.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRecordBitmask
+  module AttributeMethods
+    require 'active_record_bitmask/attribute_methods/query'
+  end
+end

data/lib/active_record_bitmask/attribute_methods/query.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveRecordBitmask
+  module AttributeMethods
+    module Query
+      private
+
+      def bitmask_attribute?(attribute_name)
+        self.class.bitmasks.key?(attribute_name.to_sym)
+      end
+
+      def attribute?(attribute_name, *values)
+        if bitmask_attribute?(attribute_name) && values.present?
+          # assert bitmask values
+          map = self.class.bitmask_for(attribute_name)
+          map.attributes_to_bitmask(values)
+
+          current_value = attribute(attribute_name)
+          values.all? { |value| current_value.include?(value) }
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_record_bitmask/bitmask_type.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module ActiveRecordBitmask
+  class BitmaskType < ActiveModel::Type::Value
+    # @param name [String]
+    # @param map [ActiveRecordBitmask::Map]
+    # @param sub_type [ActiveModel::Type::Value]
+    def initialize(_name, map, sub_type)
+      @map = map
+      @sub_type = sub_type
+    end
+
+    # @return [Symbol]
+    def type
+      @sub_type.type
+    end
+
+    # @return [Array<Symbol>]
+    def cast(value)
+      return [] if value.blank?
+
+      bitmask = @map.bitmask_or_attributes_to_bitmask(value)
+      @map.bitmask_to_attributes(bitmask)
+    end
+
+    # @return [Integer]
+    def serialize(value)
+      @map.bitmask_or_attributes_to_bitmask(value) || 0
+    end
+
+    # @param raw_value [Integer, nil]
+    #
+    # @return [Array<Symbol>]
+    def deserialize(raw_value)
+      value = @sub_type.deserialize(raw_value)
+      return [] if value.nil?
+
+      @map.bitmask_to_attributes(value)
+    end
+
+    # @param raw_old_value [Integer]
+    # @param new_value [Array<Symbol>]
+    #
+    # @return [boolean]
+    def changed_in_place?(raw_old_value, new_value)
+      raw_old_value.nil? != new_value.nil? ||
+        cast(raw_old_value) != cast(new_value)
+    end
+  end
+end

data/lib/active_record_bitmask/map.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveRecordBitmask
+  class Map
+    attr_reader :mapping
+
+    # @param keys [Array<#to_sym>]
+    def initialize(keys)
+      @mapping = attributes_to_mapping(keys).freeze
+    end
+
+    # @param value [Integer, Symbol, Array<#to_sym>]
+    #
+    # @return [Integer]
+    def bitmask_or_attributes_to_bitmask(value)
+      value = bitmask_to_attributes(value) if value.is_a?(Integer)
+      attributes_to_bitmask(value)
+    end
+
+    # @param bitmask [Integer]
+    #
+    # @return [Array<Integer>]
+    def bitmask_combination(bitmask)
+      return [0] if bitmask.to_i.zero?
+
+      max_value = values.max
+      combination_pattern_size = (max_value << 1) - 1
+      0.upto(combination_pattern_size).select { |i| i & bitmask == bitmask }
+    end
+
+    # @return [Range<Integer>]
+    def all_combination
+      max_bit = values.size
+      max_value = (2 << (max_bit - 1)) - 1
+
+      1..max_value
+    end
+
+    # @param bitmask [Integer]
+    #
+    # @return [Array<Symbol>]
+    def bitmask_to_attributes(bitmask)
+      return [] if bitmask.to_i.zero?
+
+      mapping.each_with_object([]) do |(key, value), values|
+        values << key.to_sym if (value & bitmask).nonzero?
+      end
+    end
+
+    # @param attributes [Array<#to_sym>]
+    #
+    # @return [Integer]
+    def attributes_to_bitmask(attributes)
+      attributes = [attributes].compact unless attributes.respond_to?(:inject)
+
+      attributes.inject(0) do |bitmask, key|
+        key = key.to_sym if key.respond_to?(:to_sym)
+        bit = mapping.fetch(key) { raise(ArgumentError, "#{key.inspect} is not a valid value") }
+        bitmask | bit
+      end
+    end
+
+    # @return [Array<Symbol>]
+    def keys
+      mapping.keys
+    end
+
+    # @return [Array<Integer>]
+    def values
+      mapping.values
+    end
+
+    private
+
+    def attributes_to_mapping(keys)
+      keys.each_with_index.each_with_object({}) do |(value, index), hash|
+        hash[value.to_sym] = 0b1 << index
+      end
+    end
+  end
+end

data/lib/active_record_bitmask/model.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveRecordBitmask
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveRecordBitmask::AttributeMethods::Query
+      class_attribute(:bitmasks, instance_accessor: false, default: {})
+    end
+
+    class_methods do
+      # @param base [ActiveRecord::Base]
+      def inherited(base)
+        base.bitmasks = bitmasks.deep_dup
+        super
+      end
+
+      # @param definitions [Hash]
+      #
+      # @return [void]
+      def bitmask(definitions)
+        definitions.each do |attribute, values|
+          raise ArgumentError, 'must provide an Array option' if values.empty?
+
+          attribute = attribute.to_sym
+          map = ActiveRecordBitmask::Map.new(values)
+
+          bitmasks[attribute] = map
+
+          define_bitmask_attribute(attribute, map)
+          define_bitmask_scopes(attribute)
+        end
+      end
+
+      # @param attribute [#to_sym]
+      #
+      # @raise [KeyError]
+      #
+      # @return [ActiveRecordBitmask::Map]
+      def bitmask_for(attribute)
+        bitmasks.fetch(attribute.to_sym)
+      end
+
+      private
+
+      def define_bitmask_attribute(attribute, map)
+        decorate_attribute_type(attribute, :bitmask) do |subtype|
+          ActiveRecordBitmask::BitmaskType.new(attribute, map, subtype)
+        end
+      end
+
+      def define_bitmask_scopes(attribute)
+        blank = [0, nil].freeze
+
+        scope :"with_#{attribute}", ->(*values) {
+          map = bitmask_for(attribute)
+          bitmask = map.bitmask_or_attributes_to_bitmask(values)
+          combination = map.bitmask_combination(bitmask)
+
+          if bitmask.zero?
+            where(attribute => map.all_combination)
+          else
+            where(attribute => combination)
+          end
+        }
+
+        scope :"with_any_#{attribute}", ->(*values) {
+          map = bitmask_for(attribute)
+          bitmasks = values.map { |value| map.bitmask_or_attributes_to_bitmask(value) }
+          combination = bitmasks.flat_map { |bitmask| map.bitmask_combination(bitmask) }
+
+          if combination.empty?
+            where(attribute => map.all_combination)
+          else
+            where(attribute => combination)
+          end
+        }
+
+        scope :"without_#{attribute}", ->(*values) {
+          map = bitmask_for(attribute)
+          bitmasks = values.map { |value| map.bitmask_or_attributes_to_bitmask(value) }
+          combination = bitmasks.flat_map { |bitmask| map.bitmask_combination(bitmask) }
+
+          if values.empty?
+            public_send(:"no_#{attribute}")
+          else
+            excepted = (map.all_combination.to_a + blank) - combination
+            where(attribute => excepted)
+          end
+        }
+
+        scope :"with_exact_#{attribute}", ->(*values) {
+          map = bitmask_for(attribute)
+          bitmasks = values.map { |value| map.bitmask_or_attributes_to_bitmask(value) }
+          bitmask = bitmasks.inject(0, &:|)
+
+          if bitmask.zero?
+            public_send(:"no_#{attribute}")
+          else
+            where(attribute => bitmask)
+          end
+        }
+
+        scope :"no_#{attribute}", -> {
+          where(attribute => blank)
+        }
+      end
+    end
+  end
+end

data/lib/active_record_bitmask/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordBitmask
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: active_record_bitmask
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- alpaca-tc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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: rspec
+  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: 
+email:
+- alpaca-tc@alpaca.tc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- active_record_bitmask.gemspec
+- lib/active_record_bitmask.rb
+- lib/active_record_bitmask/attribute_methods.rb
+- lib/active_record_bitmask/attribute_methods/query.rb
+- lib/active_record_bitmask/bitmask_type.rb
+- lib/active_record_bitmask/map.rb
+- lib/active_record_bitmask/model.rb
+- lib/active_record_bitmask/version.rb
+homepage: https://github.com/pixiv/active_record_bitmask
+licenses: []
+metadata: {}
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Simple bitmask attribute support for ActiveRecord
+test_files: []