Module: AttrBitwise::ClassMethods

Defined in:
lib/attr_bitwise.rb

Overview

ClassMethods

Instance Method Summary collapse

Instance Method Details

#attr_bitwise(name, column_name: nil, mapping:) ⇒ Object

Usage :

attr_bitwise :payment_types, mapping: [:slots, :credits],
  column_name: 'payment_types_value'



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/attr_bitwise.rb', line 48

def attr_bitwise(name, column_name: nil, mapping:)
  column_name = "#{name}_value" unless column_name.present?

  # mask attribute_accessor (internals)
  define_method('value') { send(column_name) }
  define_method('value=') { |value| send("#{column_name}=", value) }

  # build mapping
  bitwise_mapping = build_mapping(mapping, name)

  # mask to symbols helper
  define_method("#{name}") { send(:value_getter, bitwise_mapping) }

  define_method("#{name}=") do |values_or_symbols_array|
    unless values_or_symbols_array.is_a?(Array)
      values_or_symbols_array = [values_or_symbols_array]
    end
    send(:value_setter, values_or_symbols_array, bitwise_mapping)
  end

  # masks symbol presence
  define_method("#{name.to_s.singularize}?") do |value_or_symbol|
    send(:value?, force_to_bitwise_value(value_or_symbol, bitwise_mapping))
  end

  # add value to mask
  define_method("add_#{name.to_s.singularize}") do |value_or_symbol|
    send(:add_value, force_to_bitwise_value(value_or_symbol, bitwise_mapping))
  end

  # remove value from mask
  define_method("remove_#{name.to_s.singularize}") do |value_or_symbol|
    send(:remove_value, force_to_bitwise_value(value_or_symbol, bitwise_mapping))
  end

  # compute values union against mask
  define_method("#{name}_union") do |*mixed_array|
    self.class.bitwise_union(*mixed_array, name)
  end

  # compute values intersection against mask
  define_method("#{name}_intersection") do |*mixed_array|
    self.class.bitwise_intersection(*mixed_array, name)
  end
end

#bitwise_intersection(*mixed_array, name) ⇒ Object

given a values_arr ay array, return a possible matches

for a intersection

with PAYMENT_TYPES_MAPPING = { credits: 0b001, slots: 0b010, paypal: 0b100 } see www.calleerlandsson.com/2015/02/16/flags-bitmasks-and-unix-file-system-permissions-in-ruby/

bitwise_intersection(:slots, :credits, ‘payment_types’) => [0b101, 0b100, 0b011, 0b111]



122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/attr_bitwise.rb', line 122

def bitwise_intersection(*mixed_array, name)
  values_array = mixed_array.map { |v| to_bitwise_values(v, name) }
  mapping = mapping_from_name(name)
  mask = []
  val = values_array.reduce(&:|)

  mapping.values.each do |pv|
    mask << (pv | val)
  end

  mask.uniq
end

#bitwise_union(*mixed_array, name) ⇒ Object

given a payment_values array, return a possible matches

for a union

with PAYMENT_TYPES_MAPPING = { credits: 0b001, slots: 0b010, paypal: 0b100 } see www.calleerlandsson.com/2015/02/16/flags-bitmasks-and-unix-file-system-permissions-in-ruby/

bitwise_union(:slots, :credits, ‘payment_types’) => [0b011, 0b111]



101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/attr_bitwise.rb', line 101

def bitwise_union(*mixed_array, name)
  values_array = mixed_array.map { |v| to_bitwise_values(v, name) }
  mapping = mapping_from_name(name)
  mask = []

  values_array.each do |pv|
    mapping.values.each do |pvv|
      mask << (pv | pvv)
    end
  end

  mask.uniq
end

#force_to_bitwise_value(value_or_symbol, mapping) ⇒ Object

Given a raw value (int) or a symbol, return proper raw value (int)



148
149
150
151
152
153
154
 
# File 'lib/attr_bitwise.rb', line 148

def force_to_bitwise_value(value_or_symbol, mapping)
  if value_or_symbol.is_a?(Symbol)
    mapping[value_or_symbol]
  else
    value_or_symbol.to_i
  end
end

#to_bitwise_values(object, name) ⇒ Object

given an Object, return proper Fixnum value, depending of mapping



136
137
138
139
140
141
142
143
144
145
 
# File 'lib/attr_bitwise.rb', line 136

def to_bitwise_values(object, name)
  mapping = mapping_from_name(name)
  if object.is_a?(Array)
    object.map { |v| force_to_bitwise_value(v, mapping) }
  elsif object.is_a?(Hash)
    object.values.map { |v| force_to_bitwise_value(v, mapping) }
  else
    force_to_bitwise_value(object, mapping)
  end
end