bitty 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 oleg dashevskii
+
+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.rdoc

@@ -0,0 +1,7 @@
+= bitty
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 oleg dashevskii. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bitty"
+    gem.summary = %Q{ActiveRecord plugin for rich bitfields}
+    gem.email = "olegdashevskii@gmail.com"
+    gem.homepage = "http://github.com/be9/bitty"
+    gem.authors = ["oleg dashevskii"]
+    gem.files.exclude '.gitignore', '.document'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bitty #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Jeweler::GemcutterTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bitty.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bitty}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["oleg dashevskii"]
+  s.date = %q{2009-12-08}
+  s.email = %q{olegdashevskii@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bitty.gemspec",
+     "lib/bitty.rb",
+     "lib/bitty/bit_proxy.rb",
+     "test/bitty_test.rb",
+     "test/proxy_test.rb",
+     "test/support/models.rb",
+     "test/support/schema.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/be9/bitty}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ActiveRecord plugin for rich bitfields}
+  s.test_files = [
+    "test/bitty_test.rb",
+     "test/support/schema.rb",
+     "test/support/models.rb",
+     "test/proxy_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/bitty/bit_proxy.rb

@@ -0,0 +1,152 @@
+module Bitty
+  # This class acts like a proxy. It presents you with all these
+  # bitfield methods, but it doesn't store the value itself.
+  def true?(val)
+    case val
+    when true, 1, /1|y|yes/i then true
+    else false
+    end
+  end
+
+  module_function :true?
+
+  class BitProxy
+    # this will be redefined in self.column=
+    def initialize(*args)
+    end
+
+    class <<self
+      def power2(name)
+        @power2[name.to_sym]
+      end
+
+      def bit_names=(names)
+        @power2 = {}
+        p = 1
+
+        names.each do |name|
+          n = name.to_sym
+
+          if @power2.include?(n)
+            raise ArgumentError, "Bit name #{n} repeated more that once!"
+          else
+            @power2[n] = p
+            p <<= 1
+          end
+        end
+
+        @power2.each do |name, bitmask|
+          inv = ~bitmask
+          class_eval <<-RUBY
+            def #{name}
+              (value & #{bitmask}) != 0
+            end
+
+            alias #{name}? #{name}
+
+            def #{name}=(val)
+              self.value = Bitty.true?(val) ? (value | #{bitmask}) : (value & #{inv})
+            end
+          RUBY
+        end
+      end
+
+      attr_reader :column
+
+      def column=(column)
+        @column = column
+
+        class_eval <<-RUBY
+          attr_accessor :model_object
+
+          def initialize(model_object)
+            self.model_object = model_object
+
+            super
+          end
+
+          def value
+            model_object[:#{column}]
+          end
+
+          def value=(newval)
+            model_object[:#{column}] = newval
+          end
+        RUBY
+      end
+
+      def named_scope(*args)
+        bits = args.extract_options!
+        args.each { |arg| bits[arg] = true }
+
+        masks = [0, 0]
+
+        bits.each do |name, val|
+          mask = power2(name)
+          raise ArgumentError, "invalid bit name #{name}" unless mask
+
+          masks[Bitty.true?(val) ? 1 : 0] |= mask
+        end
+
+        cond = [nil, nil]
+
+        if masks[0] != 0
+          cond[0] = "#{column} & #{masks[0]} = 0"
+        end
+
+        if masks[1] != 0
+          cond[1] = "#{column} & #{masks[1]} = #{masks[1]}"
+        end
+
+        { :conditions => cond.compact.map { |c| "(#{c})" } * ' AND ' }
+      end
+    end
+
+    def [](key)
+      bitmask = power2(key)
+
+      if bitmask
+        (value & bitmask) != 0
+      else
+        nil
+      end
+    end
+
+    def []=(key, val)
+      bitmask = power2(key)
+      raise ArgumentError, "unknown bitname: #{key}" unless bitmask
+
+      self.value = Bitty.true?(val) ? (value | bitmask) : (value & ~bitmask)
+    end
+
+    def set!(value)
+      case value
+      when Array
+        value.each { |key| self[key] = true }
+      when Hash
+        value.each { |key, val| self[key] = val }
+      when Fixnum
+        self.value = value
+      else
+        raise ArgumentError, "invalid value (must be Array/Hash/Fixnum)"
+      end
+    end
+
+    protected
+
+    # this will be redefined in self.column=
+    def value
+      raise
+    end
+
+    # this will be redefined in self.column=
+    def value=(newval)
+      raise
+    end
+
+    # power of 2, corresponding to key
+    def power2(key)
+      self.class.power2(key)
+    end
+  end
+end

data/lib/bitty.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), 'bitty', 'bit_proxy')
+
+module Bitty
+  module ActiveRecordExtensions
+    def bitty(field, *args)
+      field = field.to_sym
+
+      opts = args.extract_options!
+
+      proxy = Class.new(Bitty::BitProxy)
+      proxy.bit_names = args
+      proxy.column = opts[:column] || field
+
+      # TODO: opts[:default]
+      # TODO: opts[:named_scope]
+      # TODO: check if field has already been defined in superclass
+      write_inheritable_hash(:_bitty_fields, { field => proxy } )
+
+      class_eval <<-RUBY
+        def #{field}
+          @_bitty_#{field} ||=
+            self.class.read_inheritable_attribute(:_bitty_fields)[:#{field}].new(self)
+        end
+
+        def #{field}=(value)
+          #{field}.set!(value)
+        end
+      RUBY
+    end
+
+    def bitty_named_scope(name, bitty_field, *args)
+      proxy_class = read_inheritable_attribute(:_bitty_fields)[bitty_field]
+
+      if proxy_class
+        named_scope name, proxy_class.named_scope(*args)
+      else
+        raise ArgumentError, "There's no bitfield '#{bitty_field}' defined!"
+      end
+    end
+  end
+end
+
+if defined? ActiveRecord::Base
+  ActiveRecord::Base.send(:extend, Bitty::ActiveRecordExtensions)
+end

data/test/bitty_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+require 'support/models'
+load 'support/schema.rb'
+
+class Foo < ActiveRecord::Base
+  bitty :bitval, :uno, :dos, :tres, :quatro
+end
+
+class BittyTest < Test::Unit::TestCase
+  context "Foo" do
+    before { @foo = Foo.new }
+
+    it "should have :bitval attribute" do
+      @foo.should respond_to :bitval
+      @foo.should respond_to :bitval=
+    end
+
+    it "attribute method should return an instance of BitProxy" do
+      @foo.bitval.should be_kind_of(Bitty::BitProxy)
+    end
+
+    it "proxy value should correspond to model object column value" do
+      @foo2 = Foo.new
+      [0, 1, 200].each do |ival|
+        @foo[:bitval] = ival
+        @foo.bitval.send(:value).should == ival
+        @foo2.bitval.send(:value).should be_nil
+      end
+    end
+
+    it "proxy :value= should set model object's value" do
+      [0, 1, 200].each do |ival|
+        @foo.bitval.send(:value=, ival)
+        @foo[:bitval].should == ival
+      end
+    end
+
+    it "proxy :value= should not spoil other objects of the same type" do
+      @foo2 = Foo.new
+      @foo2.bitval.send(:value=, 333)
+      @foo.bitval.send(:value=, 1000)
+      @foo2.bitval.value.should == 333
+    end
+  end
+end
+
+class FooWithScope < Foo
+  bitty_named_scope :with_uno, :bitval, :uno
+  bitty_named_scope :without_4, :bitval, :quatro => 0
+  bitty_named_scope :with_110_, :bitval, :quatro => 1, :tres => 1, :dos => 0
+end
+
+class BittyNamedScopeTest < Test::Unit::TestCase
+  before :all do
+    @foos = (0..15).to_a.map do |v|
+      FooWithScope.create!(:bitval => v)
+    end
+  end
+
+  it ".with_uno should find values with :uno set" do
+    FooWithScope.with_uno.all.should == fs(1,3,5,7,9,11,13,15)
+  end
+
+  it ".with_4 should find values with :quatro unset" do
+    FooWithScope.without_4.all.should == fs(*(0..7).to_a)
+  end
+
+  it ".with_110_ should find by bit prefix 110" do
+    FooWithScope.with_110_.all.should == fs(12,13)
+  end
+
+  it "raises ArgumentError given invalid bitfield" do
+    lambda do
+      FooWithScope.class_eval do
+        bitty_named_scope :test_1, :nonexistent, :foo
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError given invalid bitname" do
+    lambda do
+      FooWithScope.class_eval do
+        bitty_named_scope :test_2, :bitval, :foo
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  def fs(*args)
+    args.map { |i| @foos[i] }
+  end
+end

data/test/proxy_test.rb

@@ -0,0 +1,196 @@
+require 'test_helper'
+
+class ValueTester < Hash
+  def value; self[:value] end
+  def value=(newval)
+    self[:value] = newval
+  end
+end
+
+class BittyProxyTest < Test::Unit::TestCase
+  before :all do
+    @proxy_class = Class.new(Bitty::BitProxy)
+    @proxy_class.bit_names = [:uno, :dos, :tres, :quatro]
+    @proxy_class.column = :value
+  end
+
+  before do
+    @mobject = ValueTester.new
+    @mobject.value = 0b1010
+    @foo = @proxy_class.new(@mobject)
+  end
+
+  [:to_sym, :to_s].each do |conv|
+    it "should allow to query values with [bitname.#{conv}]" do
+      @foo['uno'.send(conv)].should == false
+      @foo['dos'.send(conv)].should == true
+      @foo['tres'.send(conv)].should == false
+      @foo['quatro'.send(conv)].should == true
+    end
+
+    [true, '1', 1, 'yes', 'y', 'YES'].each do |yesval|
+      it "should set 1st bit with bitval['uno'.#{conv}] = #{yesval.inspect}" do
+        @foo['uno'.send(conv)] = yesval
+        @mobject.value.should == 0b1011
+      end
+
+      it "should set 2nd bit with bitval['dos'.#{conv}] = #{yesval.inspect}" do
+        @foo['dos'.send(conv)] = yesval
+        @mobject.value.should == 0b1010
+      end
+
+      it "should set 3rd bit with bitval['tres'.#{conv}] = #{yesval.inspect}" do
+        @foo['tres'.send(conv)] = yesval
+        @mobject.value.should == 0b1110
+      end
+    end
+
+    [false, '0', 0, 'no', 'n', 'NO'].each do |noval|
+      it "should reset 1st bit with bitval['uno'.#{conv}] = #{noval.inspect}" do
+        @foo['uno'.send(conv)] = noval
+        @mobject.value.should == 0b1010
+      end
+
+      it "should reset 2nd bit with bitval['dos'.#{conv}] = #{noval.inspect}" do
+        @foo['dos'.send(conv)] = noval
+        @mobject.value.should == 0b1000
+      end
+
+      it "should reset 4th bit with bitval['quatro'.#{conv}] = #{noval.inspect}" do
+        @foo['quatro'.send(conv)] = noval
+        @mobject.value.should == 0b0010
+      end
+    end
+  end
+
+  describe "#set!" do
+    it "should set value given integer" do
+      @foo.set! 0b1111
+      @mobject.value.should == 0b1111
+    end
+
+    it "should set value given a hash of values" do
+      @mobject.value = 0
+      @foo.set! :uno => 1, :quatro => 'yeah'
+      @mobject.value.should == 0b1001
+
+      @mobject.value = 0b1111
+      @foo.set! :dos => 0, :tres => 'N'
+      @mobject.value.should == 0b1001
+    end
+
+    it "should raise ArgumentError given hash with unknown bitname" do
+      @mobject.value = 0
+      lambda do
+        @foo.set! :uno => 1, :unknown => 'yeah'
+      end.should raise_error(ArgumentError)
+    end
+
+    it "should set value given an array of set bits" do
+      @mobject.value = 0
+      @foo.set! [:uno, :quatro]
+      @mobject.value.should == 0b1001
+
+      @mobject.value = 0
+      @foo.set! %w(dos tres)
+      @mobject.value.should == 0b0110
+    end
+
+    it "should raise ArgumentError given array with unknown bitnames" do
+      @mobject.value = 0
+      lambda do
+        @foo.set! [:uno, :unknown]
+      end.should raise_error(ArgumentError)
+    end
+
+    ["yeah", 123.321, nil, true, false, 1..10].each do |crap|
+      it "should raise ArgumentError given unsupported type (#{crap.inspect})" do
+        lambda do
+          @foo.set! crap
+        end.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "named access" do
+    it "should allow to query bits directly" do
+      @foo.uno.should == false
+      @foo.dos.should == true
+      @foo.tres.should == false
+      @foo.quatro.should == true
+    end
+
+    it "should allow to query bits with question mark methods" do
+      @foo.uno?.should == false
+      @foo.dos?.should == true
+      @foo.tres?.should == false
+      @foo.quatro?.should == true
+    end
+
+    it "should allow to set bits directly" do
+      @mobject.value = 0b1010
+      @foo.uno = true
+      @mobject.value.should == 0b1011
+
+      @mobject.value = 0b1010
+      @foo.dos = 1
+      @mobject.value.should == 0b1010
+
+      @mobject.value = 0b1010
+      @foo.tres = 'YES'
+      @mobject.value.should == 0b1110
+    end
+
+    it "should allow to reset bits directly" do
+      @mobject.value = 0b1010
+      @foo.uno = false
+      @mobject.value.should == 0b1010
+
+      @mobject.value = 0b1010
+      @foo.dos = 'N'
+      @mobject.value.should == 0b1000
+
+      @mobject.value = 0b1010
+      @foo.quatro = 0
+      @mobject.value.should == 0b0010
+    end
+  end
+
+  describe "#named_scope" do
+    it "should generate valid condition for 0 bits" do
+      ns(:uno => 0).should == cond("(value & 1 = 0)")
+      ns(:uno => 0, :quatro => 0).should == cond("(value & 9 = 0)")
+    end
+
+    it "should generate valid condition for 1 bits" do
+      ns(:uno => 1).should == cond("(value & 1 = 1)")
+      ns(:uno => 1, :quatro => 1).should == cond("(value & 9 = 9)")
+    end
+
+    it "should generate valid condition for 1 bits given as array" do
+      ns(:uno).should == cond("(value & 1 = 1)")
+      ns(:uno, :quatro).should == cond("(value & 9 = 9)")
+    end
+
+    it "should generate valid condition for mixed bit values" do
+      ns(:uno => 1, :dos => 0, :tres => 1, :quatro => 0).should == 
+        cond("(value & 10 = 0) AND (value & 5 = 5)")
+      ns(:uno, :tres, :dos => 0, :quatro => 0).should == 
+        cond("(value & 10 = 0) AND (value & 5 = 5)")
+    end
+
+    it "should raise ArgumentError given invalid bitnames" do
+      lambda { ns(:bzz) }.should raise_error(ArgumentError)
+      lambda { ns(:bzz => 0) }.should raise_error(ArgumentError)
+      lambda { ns(:foo, :bzz => 0) }.should raise_error(ArgumentError)
+    end
+
+    def ns(*args)
+      @proxy_class.named_scope(*args)
+    end
+
+    def cond(str)
+      { :conditions => str }
+    end
+  end
+end

data/test/support/models.rb

@@ -0,0 +1,3 @@
+class Bar < ActiveRecord::Base
+  bitty :bar, :uno, :dos, :tres, :quatro, :column => :bitval
+end

data/test/support/schema.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table "foos", :force => true do |t|
+    t.integer  "bitval"
+  end
+
+  create_table "bars", :force => true do |t|
+    t.integer  "bitval"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'test/unit'
+require 'context'
+require 'matchy'
+require 'active_support'
+require 'active_record'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bitty'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :dbfile => 'test.sqlite3')
+
+#class Test::Unit::TestCase
+#end
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: bitty
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- oleg dashevskii
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-08 00:00:00 +06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: olegdashevskii@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bitty.gemspec
+- lib/bitty.rb
+- lib/bitty/bit_proxy.rb
+- test/bitty_test.rb
+- test/proxy_test.rb
+- test/support/models.rb
+- test/support/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/be9/bitty
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ActiveRecord plugin for rich bitfields
+test_files: 
+- test/bitty_test.rb
+- test/support/schema.rb
+- test/support/models.rb
+- test/proxy_test.rb
+- test/test_helper.rb