bis 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0cb3f0e41a0b024e7f77b584cb61a1f441696cfa
-  data.tar.gz: 9fc69081e8ec4c9aace4b91ad6fe00ceeaa90b7b
+  metadata.gz: 61336b18bc5e7fd8daa89f0cee4a5d47b5c66859
+  data.tar.gz: 22444418a3a00b1a78caf0d370f429643e0b09e8
 SHA512:
-  metadata.gz: 627846ec74bb17d7086473f6070a5ab7520bfca5a142f3d8062c8e704f71add31d316c401ec830ca28c68c58c0096b7c56a4c88133422aed2e5464cb0b63a390
-  data.tar.gz: 3d736a96ac55b4d46645e033140cebfea8223b5e0df407fa11328ff99ae12f8686ca189f112d27dae9e04dc19e2b26871b8be7dbaf8a2e976db11faf88608835
+  metadata.gz: 26a5973b6e2376bad37eb55462442123eec989701cf0ce69bf63301938c1d5062747eb9898b96b01a167c564d971f2623e29ba189d591c314d2ad5a4835d322c
+  data.tar.gz: a5d6122cc1cde1e84952266449693a7e3c386db2f4a79b4c92746d634f3f6810a1308f36c09b09ab81f150ec9c286a8f4845e328a41096f09ae17ede598fd680

data/README.md

@@ -1,5 +1,12 @@
 # Bis
 
+[![Gem Version](https://badge.fury.io/rb/bis.png)](http://badge.fury.io/rb/bis)
+[![Build Status](https://travis-ci.org/fuadsaud/bis.png?branch=master)]
+                (https://travis-ci.org/fuadsaud/bis)
+[![Code Climate](https://codeclimate.com/github/fuadsaud/bis.png)]
+                (https://codeclimate.com/github/fuadsaud/bis)
+
+
 A pure ruby bitset implementation.
 
 ## Installation

data/lib/bis/conversion.rb

@@ -1,12 +1,14 @@
 class Bis
   module Conversion
+    private
+
     def Bis(obj)
       if obj.kind_of? Bis
         obj
       elsif obj.kind_of? Enumerable
         Bis.from_enum(obj)
       elsif obj.respond_to? :to_i
-        Bis.new(Bis::WORD_SIZE, value: obj.to_i)
+        Bis.new(64, value: obj.to_i)
       else
         fail TypeError, "#{obj.class} can't be coerced to Bis"
       end
@@ -17,3 +19,7 @@ end
 module Kernel
   include Bis::Conversion
 end
+
+class Object
+  include Kernel
+end

data/lib/bis/version.rb

@@ -1,3 +1,3 @@
 class Bis
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/bis.rb

@@ -2,37 +2,35 @@ require 'bis/conversion'
 require 'bis/version'
 
 class Bis
-  WORD_SIZE = 0.size * 8
-
-  attr_reader :size
+  include Enumerable
 
   def self.from_enum(enum)
     Bis.new(enum.size, value: enum.join.to_i(2))
   end
 
-  def initialize(size, value: 0)
-    unless size.kind_of?(Integer) && size > 0
-      fail ArgumentError, 'size must be a positive integer'
-    end
+  attr_reader :size
+  alias_method :length, :size
+  alias_method :bitlength, :size # Ruby 2.1 Integer interoperability
 
-    @size = size
-    @store = Array.new(words_needed_for(size), 0)
+  def initialize(size, value: 0)
+    fail ArgumentError, 'size must be >= 0' if size < 0
 
-    self.value = value if value != 0
+    @size = size.to_i
+    @store = value & ((1 << size) - 1)
   end
 
   def set(index)
-    change_bit_at(index).(1)
+    new_with_same_size.(value: @store | 1 << index)
   end
 
   def clear(index)
-    change_bit_at(index).(0)
+    new_with_same_size.(value: @store & (~(1 << index)))
   end
 
   def [](index)
-    x, y = offset_for(index)
-
-    @store[x][y]
+    with_valid_index index do |index|
+      @store[index]
+    end
   end
 
   # Not sure if it's a good idead to implement this.
@@ -45,22 +43,15 @@ class Bis
     end
   end
 
-  def ==(other)
-    to_i == other
-  end
-
-  def <=>(other)
-    to_i <=> Bis(other).to_i
+  def concat(other)
+    size_and_value_for(other) do |other_size, other_value|
+      new.(size: size + other_size).(value: (to_i << other_size) | other_value)
+    end
   end
 
-  def +(value)
-    with_valid_bit value do |bit|
-      new_bis = new.(size: size + 1)
-
-      case bit
-      when 1 then new_bis.(value: to_i << 1 | bit)
-      when 0 then new_bis.(value: to_i << 1)
-      end
+  def +(other)
+    size_and_value_for(other + to_i) do |result_size, result|
+      new.(size: result_size).(value: result)
     end
   end
 
@@ -92,44 +83,65 @@ class Bis
     end
   end
 
+  def each_byte
+    return enum_for :each_byte unless block_given?
+
+    (size / 8).times.reverse_each do |offset|
+      yield Bis.new(8, value: (to_i >> offset * 8) & ((1 << 8) - 1))
+    end
+  end
+
+  def bytes
+    each_byte.to_a
+  end
+
   def to_a
     each.to_a
   end
 
   def to_i
-    each.reduce(0) { |a, e| (a << 1) | e }
+    @store
   end
 
   def to_s
     to_a.join
   end
 
-  def inspect
-    "<<#{ to_s }>> #{ to_i }"
+  def ==(other)
+    other == to_i
   end
 
-  protected
-  attr_writer :store
-
-  private
+  def ===(other)
+    to_i === other
+  end
 
-  def value=(value)
-    @store.each_with_index do |_, i|
-      @store[i] |= Integer(value >> (i * WORD_SIZE))
-    end
+  def <=>(other)
+    to_i <=> Bis(other).to_i
   end
 
-  def offset_for(index)
-    if index >= size
-      fail ArgumentError, "index #{index} out of boudaries for #{self}"
+  def coerce(other)
+    case other
+    when Integer
+      size_and_value_for(other) do |other_size, other_value|
+        [new.(size: other_size).(value: other_value), self]
+      end
+    else
+      fail TypeError, "#{ self.class } cannot be coerced into #{ other.class }"
     end
+  end
 
-    [index / WORD_SIZE, index % WORD_SIZE]
+  def inspect
+    "<<#{ to_s }>> #{ to_i }"
   end
 
+  protected
 
-  def words_needed_for(bits)
-    (bits - 1) / WORD_SIZE + 1
+  attr_writer :store
+
+  private
+
+  def size_and_value_for(bitset_or_integer)
+    yield bitlenght_for(bitset_or_integer), bitset_or_integer.to_i
   end
 
   def with_valid_bit(bit)
@@ -139,22 +151,11 @@ class Bis
     end
   end
 
-  def change_bit_at(index)
-    ->(bit) {
-      return self if self[index] == bit
-
-      x, y = offset_for(index)
-
-      new_with_same_size.().tap { |bis|
-        bis.store = @store.dup.tap { |s|
-          s[x] = s[x].send(change_operation_for(bit), 1 << y)
-        }
-      }
-    }
-  end
-
-  def change_operation_for(bit)
-    bit.zero? ? :^ : :|
+  def with_valid_index(index)
+    case index
+    when 0..@size then yield index
+    else fail ArgumentError, "index #{index} out of boudaries for #{self}"
+    end
   end
 
   def new_with_same_size
@@ -168,4 +169,16 @@ class Bis
       }
     }
   end
+
+  def bitlenght_for(bitset_or_integer)
+    case bitset_or_integer
+    when 0..1    then 1
+    when 2       then 2
+    when Integer then  Math.log2(bitset_or_integer).ceil
+    when Bis     then  bitset_or_integer.size
+    else fail ArgumentError, 'cannot resolve a bitlength'
+                             "#{ bitset_or_integer }. Must be either Integer"
+                             'or Bis'
+    end
+  end
 end

data/spec/bis_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Bis do
-  let(:size) { Bis::WORD_SIZE }
-
   it('has a version') { expect(Bis::VERSION).to be_a String }
 
   describe '.new' do
@@ -21,22 +19,40 @@ describe Bis do
     end
 
     context 'with size and value' do
-      let(:value) { 10 }
-
       subject { Bis.new(size, value: value) }
 
-      it 'is as big as the passed size' do
-        expect(subject.size).to eq size
+      context 'with a bitset big enough to fit given size' do
+        let(:size) { 16 }
+        let(:value) { 10 }
+
+        it 'is as big as the passed size' do
+          expect(subject.size).to eq size
+        end
+
+        it 'has the bits set to the given value' do
+          expect(subject).to eq value
+        end
       end
 
-      it 'has the bits set to the given value' do
-        expect(subject).to eq value
+      context 'with value overflowing the size' do
+        let(:size) { 3 }
+        let(:value) { 10 }
+        subject { Bis.new(size, value: value) }
+
+        it 'is as big as the passed size' do
+          expect(subject.size).to eq size
+        end
+
+        it 'truncates the given value to fit in the given biy length' do
+          expect(subject.to_i).to eq 2
+        end
       end
     end
   end
 
   describe '#==' do
     context 'with an integer' do
+      let(:size) { 16 }
       let(:value) { 16 }
 
       subject { Bis.new(size, value: value) }
@@ -63,6 +79,7 @@ describe Bis do
     end
 
     context 'small numbers' do
+      let(:size) { 16 }
       let(:value) { 10 }
 
       subject { Bis.new(size, value: value) }
@@ -75,16 +92,17 @@ describe Bis do
     context 'large numbers' do
       let(:size) { 65 }
 
-      subject { Bis.new(size).set(64) }
+      subject { Bis.new(size).set(16) }
 
       it 'returns the bit at the given position' do
-        expect(subject[64]).to eq 1
+        expect(subject[16]).to eq 1
       end
     end
   end
 
   describe '#[]=', pending: "Not sure if it's a good idea to implement this" do
     context 'invalid argument' do
+      let(:size) { 16 }
       subject { Bis.new(size) }
 
       it 'fails' do
@@ -93,6 +111,7 @@ describe Bis do
     end
 
     context 'valid argument' do
+      let(:size) { 16 }
       let(:value) { 7 }
 
       subject { Bis.new(size, value: 7)[index] = argument }
@@ -118,6 +137,7 @@ describe Bis do
   end
 
   describe '#set' do
+    let(:size) { 16 }
     let(:before) { 0b101 }
     let(:after) { 0b111 }
 
@@ -129,6 +149,7 @@ describe Bis do
   end
 
   describe '#clear' do
+    let(:size) { 16 }
     let(:before) { 0b111 }
     let(:after) { 0b101 }
 
@@ -170,58 +191,189 @@ describe Bis do
   end
 
   shared_examples 'pushing a bit' do
-    it 'increases the size' do
-      expect(subject.size).to eq size + 1
+  end
+
+  describe '#concat' do
+    subject { Bis.new(size, value: value).concat(argument) }
+
+    context '0' do
+      context 'zero' do
+        let(:size) { 8 }
+        let(:value) { 10 }
+        let(:argument) { 0 }
+        let(:argument_size) { 1 }
+        let(:new_value) { (value << argument_size) | argument }
+
+        it 'has the orginal size plus enough to fit the new integer value' do
+          expect(subject.size).to eq size + argument_size
+        end
+
+        it "concatenates the integer bits to the end it's end" do
+          expect(subject).to eq new_value
+        end
+      end
+
+      context '1' do
+        let(:size) { 8 }
+        let(:value) { 10 }
+        let(:argument) { 1 }
+        let(:argument_size) { 1 }
+        let(:new_value) { (value << argument_size) | argument }
+
+        it 'has the orginal size plus enough to fit the new integer value' do
+          expect(subject.size).to eq size + argument_size
+        end
+
+        it "concatenates the integer bits to the end it's end" do
+          expect(subject).to eq new_value
+        end
+      end
+
+      context '2' do
+        let(:size) { 8 }
+        let(:value) { 10 }
+        let(:argument) { 2 }
+        let(:argument_size) { 2 }
+        let(:new_value) { (value << argument_size) | argument }
+
+        it 'has the orginal size plus enough to fit the new integer value' do
+          expect(subject.size).to eq size + argument_size
+        end
+
+        it "concatenates the integer bits to the end it's end" do
+          expect(subject).to eq new_value
+        end
+      end
+
+      context '> 1' do
+        let(:size) { 8 }
+        let(:value) { 10 }
+        let(:argument) { 3 }
+        let(:argument_size) { 2 }
+        let(:new_value) { (value << argument_size) | argument }
+
+        it 'has the orginal size plus enough to fit the new integer value' do
+          expect(subject.size).to eq size + argument_size
+        end
+
+        it "concatenates the integer bits to the end it's end" do
+          expect(subject).to eq new_value
+        end
+      end
     end
 
-    it 'pushes the new bit to the end of the new bitset' do
-      expect(subject).to eq new_value
+    context 'with a bitset' do
+      let(:size) { 4 }
+      let(:value) { 3 }
+      let(:argument_size) { 10 }
+      let(:argument_value) { 10 }
+      let(:argument) { Bis.new(argument_size, value: argument_value) }
+      let(:new_value) { (value << argument_size) | argument_value }
+
+      it 'returns a new bitset with the size of both bitsets combined' do
+        expect(subject.size).to eq size + argument_size
+      end
+
+      it 'concatenates the two bitsets' do
+        expect(subject.to_i).to eq new_value
+      end
     end
   end
-  
+
   describe '#+' do
-    let(:size) { 8 }
-    let(:value) { 10 }
+    context 'with an integer' do
+    end
+  end
 
-    subject { Bis.new(size, value: value) + argument }
+  describe '#&' do
+    let(:size) { 16 }
 
-    context '1' do
-      let(:argument) { 1 }
-      let(:new_value) { (value << 1) | argument }
+    subject { Bis.new(size, value: value) & argument }
+
+    context 'with an integer' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument) { 5 }
+      let(:result) { value & argument }
 
-      it_behaves_like 'pushing a bit'
+      it 'evaluates to logic AND of the two bitsets' do
+        expect(subject).to eq result
+      end
     end
 
-    context '0' do
-      let(:argument) { 0 }
-      let(:new_value) { value << 1 }
+    context 'with another bitset' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument_value) { 5 }
+      let(:argument) { Bis.new(size, value: argument_value) }
+      let(:result) { value & argument_value }
 
-      it_behaves_like 'pushing a bit'
+      it 'evaluates to logic AND of the two bitsets' do
+        expect(subject).to eq result
+      end
     end
   end
 
-  describe '#&' do
-    it 'evaluates to logic AND of the two bitsets' do
-      expect(Bis.new(size, value: 0b1100) &
-             Bis.new(size, value: 0b0101)).to eq Bis.new(size, value: 0b0100)
+  describe '#|' do
+    let(:size) { 16 }
+
+    subject { Bis.new(size, value: value) | argument }
+
+    context 'with an integer' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument) { 5 }
+      let(:result) { value | argument }
+
+      it 'evaluates to logic AND of the two bitsets' do
+        expect(subject).to eq result
+      end
     end
-  end
 
-  describe '#|' do
-    it 'evaluates to logic OR of the two bitsets' do
-      expect(Bis.new(size, value: 0b1100) |
-             Bis.new(size, value: 0b0110)).to eq Bis.new(size, value: 0b1110)
+    context 'with another bitset' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument_value) { 5 }
+      let(:argument) { Bis.new(size, value: argument_value) }
+      let(:result) { value | argument_value }
+
+      it 'evaluates to logic OR of the two bitsets' do
+        expect(subject).to eq result
+      end
     end
   end
 
   describe '#^' do
-    it 'evaluates to logic XOR of the two bitsets' do
-      expect(Bis.new(size, value: 0b1100) ^
-             Bis.new(size, value: 0b0110)).to eq Bis.new(size, value: 0b1010)
+    let(:size) { 16 }
+
+    subject { Bis.new(size, value: value) ^ argument }
+
+    context 'with an integer' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument) { 5 }
+      let(:result) { value ^ argument }
+
+      it 'evaluates to logic AND of the two bitsets' do
+        expect(subject).to eq result
+      end
+    end
+
+    context 'with another bitset' do
+      let(:size) { 16 }
+      let(:value) { 12 }
+      let(:argument_value) { 5 }
+      let(:argument) { Bis.new(size, value: argument_value) }
+      let(:result) { value ^ argument_value }
+
+      it 'evaluates to logic XOR of the two bitsets' do
+        expect(subject).to eq result
+      end
     end
   end
 
   describe '#>>' do
+    let(:size) { 16 }
     let(:shift) { 1 }
 
     context 'zero value' do
@@ -244,6 +396,7 @@ describe Bis do
   end
 
   describe '#<<' do
+    let(:size) { 16 }
     let(:shift) { 1 }
 
     context 'zero value' do
@@ -264,4 +417,28 @@ describe Bis do
       end
     end
   end
+
+  describe '#each_byte' do
+    subject { ->(b) { Bis.new(size, value: value).each_byte(&b) } }
+
+    context 'bitset has less than 8 bits' do
+      let(:size) { 4 }
+      let(:value) { 0 }
+
+      it "doesn't yield" do
+        expect { |b| subject.(b) }.to_not yield_control
+      end
+    end
+
+    context 'bitset has at least pne byte' do
+      let(:size) { 16 }
+      let(:first_byte) { 38 }
+      let(:second_byte) { 213 }
+      let(:value) { (first_byte << 8) | second_byte }
+
+      it 'yields all the bytes' do
+        expect { |b| subject.(b) }.to yield_successive_args 38, 213
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,3 @@
 require 'rspec'
 
 require_relative File.join(__dir__, '../lib/bis')
-
-RSpec.configure do |config|
-  config.include Bis::Conversion
-end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: bis
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Fuad Saud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-11 00:00:00.000000000 Z
+date: 2013-09-24 00:00:00.000000000 Z
 dependencies:
 - !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'
 - !ruby/object:Gem::Dependency
   name: rubocop
   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: |2
@@ -78,12 +78,12 @@ 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: []