bitsy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f9a51f778b9f04814432b25a2819b69cbef25e1
+  data.tar.gz: e024e744aab53793e2893440c732f7113ac0c8c3
+SHA512:
+  metadata.gz: e96f0fe2a70cd9a3435e245bb35c1f63c0fbb9dc413c3e8898eed4eb0c6deb18a48ca83b15a59ec173c5a085c8660e48e8a1d01de457413fadd9d9709a8656b7
+  data.tar.gz: 53a169d20b938c007ae658c8e128d60cdacd03f9748dc6e07418405cbd273482f467ea29cf0d00a6666653c86506af250647ae832dd9c8bd528b756001e07e4d

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bitsy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Oliver Nightingale
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# Bitsy
+
+A simple bitmask in ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bitsy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bitsy
+
+## Usage
+
+Create a bit mask class:
+
+    class UserRoles < Bitsy
+      flags :admin, :moderator, :author, :banned
+    end
+
+Then use this class to track which flags are set.
+
+    user_roles = UserRoles.new
+    user_roles.has_admin? # false
+    user_roles << :admin
+    user_roles.has_admin? # true
+
+### Checking for flags
+
+You can check for roles with the generated methods, e.g.
+
+    user_roles.has_admin_and_moderator_and_author
+    user_roles.has_admin_or_author
+
+You can also use the underlying methods `every` and `some`:
+
+    user_roles.every(:admin, :moderator, :author)
+    user_roles.some(:admin, :author)
+
+### Manipulating flags
+
+Flags can be set, unset and toggled:
+
+    user_roles.set(:admin)
+    user_roles.unset(:author)
+    user_roles.toggle(:moderator)
+
+    user_roles << :banned
+
+### Masks
+
+Masks are automatically created for the flags you specify:
+
+    UserRoles::ADMIN
+    UserRoles::MODERATOR
+    UserRoles::AUTHOR
+    UserRoles::BANNED
+
+Each of these is a `Bitsy::Mask`. These can be used to manipulate the flags directly, e.g. to set the `:banned` flag we can do:
+
+    user_roles |= UserRoles::BANNED
+
+Masks can be combined to form composite masks:
+
+    UserRoles::ADMIN_AND_AUTHOR = UserRoles::ADMIN | UserRoles::AUTHOR
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bitsy.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bitsy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bitsy"
+  spec.version       = Bitsy::VERSION
+  spec.authors       = ["Oliver Nightingale"]
+  spec.email         = ["oliver.nightingale1@gmail.com"]
+  spec.description   = %q{Simple Bitmask}
+  spec.summary       = %q{Simple Bitmask}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/bitsy.rb

@@ -0,0 +1,125 @@
+require "bitsy/version"
+require "bitsy/mask"
+
+class Bitsy
+  class InvalidFlagError < StandardError ; end
+
+  def self.flags(*flags)
+    if flags.empty?
+      @flags
+    else
+      @flags = flags
+    end
+  end
+
+  def self.masks
+    @masks ||= flags.inject({}) do |memo, flag|
+      mask = Bitsy::Mask.with_index(flag, self.flags.index(flag))
+      self.const_set(flag.upcase, mask)
+      memo[flag] = mask
+      memo
+    end
+  end
+
+  def initialize(val = 0)
+    self.value = val
+  end
+
+  def to_i
+    value
+  end
+
+  def to_a
+    self.class.masks.each_with_object([]) do |(_, mask), memo|
+      memo << mask.flag unless (value & mask.value).zero?
+    end
+  end
+
+  def method_missing(name, *args, &block)
+    super unless name.match(/^has_/)
+
+    if name.match(/_or_/)
+      some(*name.to_s.gsub(/^has_/, '').split(/_or_/))
+    else
+      every(*name.to_s.gsub(/^has_/, '').split(/_and_/))
+    end
+  end
+
+  def every(*flags)
+    flags.inject(true) do |memo, flag|
+      mask = self.class.masks.fetch(flag.to_sym, nil)
+      raise InvalidFlagError.new(flag) unless mask
+      memo && !(value & mask.value).zero?
+    end
+  end
+
+  def some(*flags)
+    flags.inject(false) do |memo, flag|
+      mask = self.class.masks.fetch(flag.to_sym, nil)
+      raise InvalidFlagError.new(flag) unless mask
+      memo || !(value & mask.value).zero?
+    end
+  end
+
+  def set(*flags)
+    self.value = flags
+  end
+
+  alias_method :<<, :set
+
+  def unset(*flags)
+    masks_for_flags(flags) do |mask|
+      self.value = value & ~mask.value
+    end
+  end
+
+  def toggle(*flags)
+    masks_for_flags(flags) do |mask|
+      self.value = value ^ mask.value
+    end
+  end
+
+  def &(other)
+    self.class.new(value & other.to_i)
+  end
+
+  def |(other)
+    self.class.new(value | other.to_i)
+  end
+
+  def ^(other)
+    self.class.new(value ^ other.to_i)
+  end
+
+  private
+
+  attr_reader :value
+
+  def masks_for_flags(flags)
+    flags.each do |flag|
+      mask = self.class.masks.fetch(flag.to_sym, nil)
+      raise InvalidFlagError unless mask
+      yield mask
+    end
+  end
+
+  def value=(val)
+    if val.is_a? Integer
+      @value = val
+
+    elsif val.is_a? Array
+      @value = 0 if @value.nil?
+
+      val.each do |flag|
+        mask = self.class.masks.fetch(flag.to_sym, nil)
+        raise InvalidFlagError unless mask
+
+        @value |= mask.value
+      end
+
+    else
+      raise ArgumentError
+
+    end
+  end
+end

data/lib/bitsy/mask.rb

@@ -0,0 +1,45 @@
+class Bitsy
+  class Mask
+
+    attr_reader :flag, :value
+
+    def self.with_index(flag, idx)
+      self.new(flag, (1 << idx))
+    end
+
+    def initialize(flag, value)
+      @flag = flag
+      @value = value
+    end
+
+    def to_i
+      value
+    end
+
+    def &(other)
+      self.class.new(combine_flag(other, 'AND'), value & other.to_i)
+    end
+
+    def |(other)
+      self.class.new(combine_flag(other, 'OR'), value | other.to_i)
+    end
+
+    def ^(other)
+      self.class.new(combine_flag(other, 'XOR'), value ^ other.to_i)
+    end
+
+    def ~
+      self.class.new("NOT_#{flag}".to_sym, ~value)
+    end
+
+    private
+
+    def combine_flag(other, operation)
+      if other.respond_to?(:flag)
+        "#{flag}_#{operation}_#{other.flag}".to_sym
+      else
+        "#{flag}_#{operation}_#{other}".to_sym
+      end
+    end
+  end
+end

data/lib/bitsy/version.rb

@@ -0,0 +1,3 @@
+class Bitsy
+  VERSION = "0.0.1"
+end

data/spec/bitsy_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+class Prefs < Bitsy
+  flags :create, :update, :blocked, :donedone, :complete, :destroy
+end
+
+describe Bitsy do
+
+  describe "#initialize" do
+    context "no value" do
+      subject { Prefs.new }
+      its(:to_i) { should == 0 }
+      its(:to_a) { should be_empty }
+    end
+
+    context "integer value" do
+      subject { Prefs.new(2) }
+      its(:to_i) { should == 2 }
+      its(:to_a) { should == [:update] }
+    end
+
+    context "array value" do
+      context "empty array" do
+        subject { Prefs.new([]) }
+        its(:to_i) { should == 0 }
+        its(:to_a) { should be_empty }
+      end
+
+      context "non empty array" do
+        context "valid flags" do
+          let(:flags) { [:create, :update] }
+          subject { Prefs.new(flags) }
+          its(:to_i) { should == 3 }
+          its(:to_a) { should == flags }
+        end
+
+        context "invalid flags" do
+          let(:flags) { [:invalid] }
+
+          it "should raise a InvalidFlagError" do
+            expect {
+              Prefs.new(flags)
+            }.to raise_error(Bitsy::InvalidFlagError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "mask constants" do
+    it "should set a constant for each flag" do
+      Prefs.flags.each do |flag|
+        Prefs.const_defined?(flag.upcase, false).should be_true
+      end
+    end
+  end
+
+  describe ".masks" do
+    subject { Prefs.masks }
+    its(:size) { should == 6 }
+    its([:create]) { should be_a Bitsy::Mask }
+  end
+
+  describe "#has_*" do
+    subject { Prefs.new([:create, :update]) }
+
+    context "single flag" do
+      its(:has_create) { should be_true }
+      its(:has_donedone) { should be_false }
+    end
+
+    context "multiple and flag" do
+      its(:has_create_and_donedone) { should be_false }
+      its(:has_create_and_update) { should be_true }
+    end
+
+    context "multiple or flag" do
+      its(:has_create_or_donedone) { should be_true }
+      its(:has_create_or_update) { should be_true }
+      its(:has_blocked_or_donedone) { should be_false }
+    end
+  end
+
+  describe "#set" do
+    context "flag is unset" do
+      subject { Prefs.new }
+      before { subject.set(:create) }
+      its(:has_create) { should be_true }
+    end
+
+    context "flag is set" do
+      subject { Prefs.new([:create]) }
+      before { subject.set(:create) }
+      its(:has_create) { should be_true }
+    end
+
+    context "unrecognised flag" do
+      let(:prefs) { Prefs.new }
+
+      it "should raise InvalidFlagError" do
+        expect {
+          prefs.set(:invalid)
+        }.to raise_error(Bitsy::InvalidFlagError)
+      end
+    end
+  end
+
+  describe "#unset" do
+    context "flag is unset" do
+      subject { Prefs.new }
+      before { subject.unset(:create) }
+      its(:has_create) { should_not be_true }
+    end
+
+    context "flag is set" do
+      subject { Prefs.new([:create]) }
+      before { subject.unset(:create) }
+      its(:has_create) { should_not be_true }
+    end
+
+    context "unrecognised flag" do
+      let(:prefs) { Prefs.new }
+
+      it "should raise InvalidFlagError" do
+        expect {
+          prefs.unset(:invalid)
+        }.to raise_error(Bitsy::InvalidFlagError)
+      end
+    end
+  end
+
+  describe "#toggle" do
+    context "flag is unset" do
+      subject { Prefs.new }
+      before { subject.toggle(:create) }
+      its(:has_create) { should be_true }
+    end
+
+    context "flag is set" do
+      subject { Prefs.new([:create]) }
+      before { subject.toggle(:create) }
+      its(:has_create) { should_not be_true }
+    end
+
+    context "unrecognised flag" do
+      let(:prefs) { Prefs.new }
+
+      it "should raise InvalidFlagError" do
+        expect {
+          prefs.toggle(:invalid)
+        }.to raise_error(Bitsy::InvalidFlagError)
+      end
+    end
+  end
+
+  describe "#&" do
+    let(:prefs) { Prefs.new(1) }
+
+    context "with an integer" do
+      subject { prefs & 1 }
+      its(:to_i) { should == 1 }
+      it { should be_kind_of Prefs }
+    end
+
+    context "with a mask" do
+      let(:mask) { Bitsy::Mask.new(:flag, 1) }
+      subject { prefs & mask }
+      its(:to_i) { should == 1 }
+      it { should be_kind_of Prefs }
+    end
+  end
+
+  describe "#|" do
+    let(:prefs) { Prefs.new(1) }
+
+    context "with an integer" do
+      subject { prefs | 2 }
+      its(:to_i) { should == 3 }
+      it { should be_kind_of Prefs }
+    end
+
+    context "with a mask" do
+      let(:mask) { Bitsy::Mask.new(:flag, 2) }
+      subject { prefs | mask }
+      its(:to_i) { should == 3 }
+      it { should be_kind_of Prefs }
+    end
+  end
+
+  describe "#^" do
+    let(:prefs) { Prefs.new(2) }
+
+    context "with an integer" do
+      subject { prefs ^ 2 }
+      its(:to_i) { should == 0 }
+      it { should be_kind_of Prefs }
+    end
+
+    context "with a mask" do
+      let(:mask) { Bitsy::Mask.new(:flag, 2) }
+      subject { prefs ^ mask }
+      its(:to_i) { should == 0 }
+      it { should be_kind_of Prefs }
+    end
+  end
+end

data/spec/mask_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Bitsy::Mask do
+
+  describe ".with_index" do
+    subject { Bitsy::Mask.with_index(:foo, 4) }
+
+    its(:value) { should == 16 }
+    its(:flag) { should == :foo }
+    its(:to_i) { should == 16 }
+  end
+
+  describe "#&" do
+    let(:mask) { Bitsy::Mask.new(:foo, 1) }
+
+    context "with an integer" do
+      subject { mask & 1 }
+      its(:to_i) { should == 1 }
+      its(:flag) { should == :foo_AND_1 }
+      it { should be_kind_of Bitsy::Mask }
+    end
+
+    context "with a mask" do
+      let(:other_mask) { Bitsy::Mask.new(:flag, 1) }
+      subject { mask & other_mask }
+      its(:to_i) { should == 1 }
+      its(:flag) { should == :foo_AND_flag }
+      it { should be_kind_of Bitsy::Mask }
+    end
+  end
+
+  describe "#|" do
+    let(:mask) { Bitsy::Mask.new(:foo, 1) }
+
+    context "with an integer" do
+      subject { mask | 2 }
+      its(:to_i) { should == 3 }
+      its(:flag) { should == :foo_OR_2 }
+      it { should be_kind_of Bitsy::Mask }
+    end
+
+    context "with a mask" do
+      let(:other_mask) { Bitsy::Mask.new(:flag, 2) }
+      subject { mask | other_mask }
+      its(:to_i) { should == 3 }
+      its(:flag) { should == :foo_OR_flag }
+      it { should be_kind_of Bitsy::Mask }
+    end
+  end
+
+  describe "#^" do
+    let(:mask) { Bitsy::Mask.new(:foo, 2) }
+
+    context "with an integer" do
+      subject { mask ^ 2 }
+      its(:to_i) { should == 0 }
+      its(:flag) { should == :foo_XOR_2 }
+      it { should be_kind_of Bitsy::Mask }
+    end
+
+    context "with a mask" do
+      let(:other_mask) { Bitsy::Mask.new(:flag, 2) }
+      subject { mask ^ other_mask }
+      its(:to_i) { should == 0 }
+      its(:flag) { should == :foo_XOR_flag }
+      it { should be_kind_of Bitsy::Mask }
+    end
+  end
+
+  describe "#~" do
+    let(:mask) { Bitsy::Mask.new(:foo, 1) }
+    subject { ~mask }
+    its(:to_i) { should == -2 }
+    its(:flag) { should == :NOT_foo }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'bitsy'

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: bitsy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Oliver Nightingale
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: Simple Bitmask
+email:
+- oliver.nightingale1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bitsy.gemspec
+- lib/bitsy.rb
+- lib/bitsy/mask.rb
+- lib/bitsy/version.rb
+- spec/bitsy_spec.rb
+- spec/mask_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Simple Bitmask
+test_files:
+- spec/bitsy_spec.rb
+- spec/mask_spec.rb
+- spec/spec_helper.rb