has_blob_bit_field 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49981851b7b6ee4e6f47c6dd40d972da94f2214c
-  data.tar.gz: 42fd5835bb8f988c99e3ec6e79c9d08e9112bccc
+  metadata.gz: 84cb16ec03d0b3289a08923dbe26b84f80539290
+  data.tar.gz: bb148f70fc3bf032ef79f3b531abf22c32092ab0
 SHA512:
-  metadata.gz: 55d8342bd3714c23dcd756a1f075f5eb77ae464e78f4d674b3d02181e1c1cd9712c676a6eb680570cb33967c6647e2bb32518de8a672dae5e24dd0ef4bf90b3d
-  data.tar.gz: dcb70d44e7418e9f96f289c80a13437fc0c96e75ef4437b6355294b0ec2c698ce617d448502504bb9a87a14c0ac3ecf03e650d97a2746955cb80c82215867c99
+  metadata.gz: 7eb4a11088a4a8f9332a169c3c2fafabdd83b7911fbd903edafb1248daaa5b984f93eafa562e2a47ca3b3700bc22d47f88cc6e12f9c72dfb2f5ce50691da9b14
+  data.tar.gz: 1906c4b3239b81ead3899813c2eb707d5347342a2c8ca407399ce0635517230f8e568715ecf1d325ddec1fa1d0d9681f48883f5551d267c6db1f803caedce93e

data/README.md

@@ -2,22 +2,6 @@
 
 A Rails extension to treat a binary column (blob) as a sequence of `true`/`false` flags (bits)
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'has_blob_bit_field'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install has_blob_bit_field
-
 ## Example Usage
 
 ```
@@ -27,33 +11,50 @@ def change
 end
 
 # Model:
-
 class YourModel < ActiveRecord::Base
 	has_blob_field :many_flags
 end
 
 # Usage:
-
 o = YourModel.new
 o.many_flags.size # => 0
 o.many_flags.size = 666 # Can be as big as 8 times the binary limit of your column
 o.many_flags[42] # => false
 o.many_flags[42] = true
 o.many_flags[700] # => IndexError
+o.many_flags.count{|f| f} # => 1
+o.many_flags = [false, true, true, false, false, false, false, true]
+o.many_flags.map! {|f| !f}
+o.many_flags == [true, false, false, true, true, true, true, false] # => true
+o.many_flags_blob_changed? # => true
 ```
 
 ## Notes:
 
 * The convention is that your column has the same name as your accessing method with a `'_blob'` suffix, but you can specify the column to use when calling `has_blob_field`.
 
-* The first flag is stored using the highest bit of the first byte.
+* The blob is viewed as an array of bits where the first flag is stored using the highest bit of the first byte.
 
 * The size is always rounded up to a multiple of 8.
 
-* Accessing out of bounds indices raises an `IndexError`, but code could be adapted easily to return `nil` instead.
-
 * Targets: Ruby 2.0+, Rails 3.0+
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'has_blob_bit_field'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install has_blob_bit_field
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/has_blob_bit_field/accessor.rb

@@ -1,5 +1,7 @@
 module HasBlobBitField
   class Accessor
+    include Enumerable
+    include Comparable
     attr_reader :record, :column
 
     def initialize record, column
@@ -7,18 +9,21 @@ module HasBlobBitField
       @column = column
     end
 
-    def [](index)
-      val = byte(index)
-      val & flag(index) != 0
+    def [](bit_index)
+      bit_index = check_index(bit_index)
+      val = byte(bit_index)
+      val & flag(bit_index) != 0
     end
 
-    def []=(index, set)
-      set = !!set # force to true/false
-      val = byte(index)
-      mask = flag(index)
-      if (val & mask != 0) != set
+    def []=(bit_index, set)
+      bit_index = check_index(bit_index)
+      set = coerce_to_bool(set)
+      val = byte(bit_index)
+      mask = flag(bit_index)
+      was_set = val & mask != 0
+      if was_set != set
         notify_of_mutation
-        raw_value.setbyte(index >> 3, val ^ mask)
+        raw_value.setbyte(bit_index >> 3, val ^ mask)
       end
       set
     end
@@ -37,7 +42,7 @@ module HasBlobBitField
         if s.size > size_in_bytes
           s[size_in_bytes..s.size] = ''
         else
-          s << Array.new(size_in_bytes - s.size, 0).pack('C*')
+          s << "\0".b * (size_in_bytes - s.size)
         end
       end
       size_in_bits
@@ -48,28 +53,78 @@ module HasBlobBitField
 
     def raw_value(init_nil: false)
       @record.public_send(@column) ||
-        (init_nil && notify_of_mutation && @record.public_send(:"#{@column}=", ''.b)) ||
+        (init_nil && replace_raw_value(''.b)) ||
         ''.b
     end
 
+    def replace(values)
+      new_raw_value = if values.class == self.class
+        values.raw_value
+      else
+        masks = (0..7).map {|i| flag(i) }
+        self.size = values.size
+        values.each_slice(8).map do |flags|
+          flags.each_with_index.inject(0) do |sum, (flag, bit_number)|
+            sum | (flag ? masks[bit_number] : 0)
+          end
+        end.pack('C*')
+      end
+      replace_raw_value new_raw_value
+      self
+    end
+
+    def each
+      return to_enum unless block_given?
+      masks = (0..7).map {|i| flag(i) }
+      raw_value.each_byte do |byte|
+        masks.each do |mask|
+          yield mask & byte != 0
+        end
+      end
+      self
+    end
+
+    def map!
+      return to_enum unless block_given?
+      replace(map {|b| yield b })
+    end
+
+    def <=>(other)
+      value_method = other.class == self.class ? :raw_value : :to_a
+      public_send(value_method) <=> other.public_send(value_method)
+    end
 
-  private
+  protected
     def notify_of_mutation
       @record.public_send :"#{@column}_will_change!"
       self
     end
 
-    def flag(index)
-      0b1000_0000 >> (index & 0b111)
+    def replace_raw_value(raw)
+      notify_of_mutation
+      @record.public_send(:"#{@column}=", raw)
+    end
+
+    def flag(bit_index)
+      0b1000_0000 >> (bit_index & 0b111)
+    end
+
+    def byte(bit_index)
+      raw_value.getbyte(bit_index >> 3) || out_of_bound(bit_index)
+    end
+
+    def coerce_to_bool(value)
+      raise TypeError unless value == true || value == false
+      value
     end
 
-    def byte(index)
-      out_of_bound(index) unless index >= 0
-      raw_value.getbyte(index >> 3) || out_of_bound(index)
+    def check_index(bit_index)
+      out_of_bound(bit_index) if bit_index < 0
+      bit_index
     end
 
-    def out_of_bound(index)
-      raise IndexError, "#{index} is our of range for #{@column} which has size #{size}. Record: #{@record.inspect}}"
+    def out_of_bound(bit_index)
+      raise IndexError, "#{bit_index} is our of range for #{@column} which has size #{size}. Record: #{@record.inspect}}"
     end
   end
 end

data/lib/has_blob_bit_field/extension.rb

@@ -8,11 +8,11 @@ module HasBlobBitField
       def has_blob_bit_field field, column: :"#{field}_blob"
         class_eval <<-EVAL, __FILE__, __LINE__
           def #{field}
-            Accessor.new self, :#{column}
+            @_#{field}_accessor ||= Accessor.new self, :#{column}
           end
 
-          def #{field}=
-            raise "Don't set the pseudo field #{field} directly, use []= on it"
+          def #{field}=(values)
+            #{field}.replace(values)
           end
         EVAL
       end

data/lib/has_blob_bit_field/version.rb

@@ -1,3 +1,3 @@
 module HasBlobBitField
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_blob_bit_field
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Marc-Andre Lafortune
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-20 00:00:00.000000000 Z
+date: 2016-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Acces a binary column as a sequence of true/false flags