bijection 0.0.1 → 0.1.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/Rakefile

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

data/bijection.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "bijection/version"
+require "bijection"
 
 Gem::Specification.new do |s|
   s.name        = "bijection"
@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Ryan Berckmans"]
   s.email       = ["ryan.berckmans@gmail.com"]
   s.homepage    = "https://github.com/ryanberckmans/bijection"
-  s.summary     = "bijection container in ruby; pre-alpha wip"
-  s.description = s.summary
+  s.summary     = "bijection container in ruby"
+  s.description = s.summary + ". See example in Class Bijection."
 
   s.rubyforge_project = "bijection"
 

data/lib/bijection.rb

@@ -1,12 +1,143 @@
-require "bijection/version"
-require "bijection/base"
-
-# @example b = Bijection.new
-module Bijection
-  class << self
-    # @return [Base]
-    def new
-      Bijection::Base.new
-    end
+
+# Bijection is a container similar to a Hash with unique values.
+# {http://en.wikipedia.org/wiki/Bijection}
+#
+# Bijection associates each non-nil unique x in a set X, with a non-nil unique y in a set Y.
+#
+# Please send (welcome) feedback and bug reports to my {https://github.com/ryanberckmans github}.
+#
+# @example
+#  b = Bijection.new
+#  b.add 5, 7 # associates 5 in X with 7 in Y
+#  b.size
+#   => 1
+#  b.add 5, 2 # raises, 5 already in X
+#  b.add "foo", 7 # raises, 7 already in Y
+#  b.add "bar", 5 # OK; 5 was not yet in Y
+#  b.size
+#   => 2
+#  d = b.domain # d == [5, "bar"]
+#  r = b.range  # r == [7, 5] # i.e., not the "same" 5 in domain
+#  b.each_x { |x| puts x }
+#   => 5
+#   => "bar"
+#  b.each_y { |y| puts y }
+#   => 7
+#   => 5 # i.e., not the "same" 5 that's in X
+#  b.each_pair { |x,y| .. }
+#  x = b.get_x 7 # x == 5
+#  y = b.get_y 5 # y == 7
+#  is_nil = b.get_x "returns nil if not found" # is_nil == nil
+#  b.inverse! # X and Y are now swapped; all as above with x and y swapped
+class Bijection
+  VERSION = "0.1.0"
+
+  def initialize
+    @X = {} # @X[x] -> y
+    @Y = {} # @Y[y] -> x
+  end
+
+  # returns the number of pairs in the bijection
+  # @return [Fixnum]
+  def size
+    @X.size
+  end
+
+  # add (x,y) to the bijection set (X,Y)
+  # @param x the non-nil object associated with y
+  # @param y the non-nil object associated with x
+  # @note x must be unique in X; y must be unique in Y
+  # @return [self]
+  def add( x, y )
+    raise "Bijection: x may not be nil" if x == nil
+    raise "Bijection: y may not be nil" if y == nil
+    raise "Bijection: #{x.to_s} already present in domain set X" if @X.key? x
+    raise "Bijection: #{y.to_s} already present in range set Y" if @Y.key? y
+    @X[x] = y
+    @Y[y] = x
+    self
+  end
+
+  # get the domain set X as an Array
+  # @return [Array]
+  def domain
+    @X.keys
+  end
+
+  # get the range set Y as an Array
+  # @return [Array]
+  def range
+    @Y.keys
+  end
+
+  # swap domain X and range Y of this
+  # @return [nil]
+  def inverse!
+    temp = @X
+    @X = @Y
+    @Y = temp
+    nil
+  end
+
+  # get the x associated with y
+  # @param y in domain set Y
+  # @return the x associated with y, or nil if y not in range Y
+  def get_x( y )
+    @Y[y]
+  end
+
+  # get the y associated with x
+  # @param x in domain set X
+  # @return the y associated with x, or nil if x not in domain X
+  def get_y( x )
+    @X[x]
+  end
+
+  # @yield [x] each x in domain set X
+  # @return [nil]
+  def each_x
+    @X.each_key { |x| yield x } if block_given?
+    nil
+  end
+
+  # @yield [y] each y in range set Y
+  # @return [nil]
+  def each_y
+    @Y.each_key { |y| yield y } if block_given?
+    nil
+  end
+
+  # @yield [x,y] each (x,y) in sets X and Y
+  # @return [nil]
+  def each_pair
+    @X.each_pair { |x,y| yield x,y } if block_given?
+    nil
+  end
+
+  # given x, delete (x,y) and return y
+  # @param (see #get_x)
+  # @example
+  #  b = Bijection.new
+  #  x = 2 ; y = 3
+  #  b.add x, y
+  #  y = nil
+  #  while true do y = b.delete_by_x x ; b.add x, y end
+  # @return (see #get_x)
+  def delete_by_x( x )
+    y = @X[x]
+    @X.delete x
+    @Y.delete y
+    y
+  end
+
+  # given y, delete (x,y) and return x
+  # @param (see #get_y)
+  # @return (see #get_y)
+  # see example #delete_by_x
+  def delete_by_y( y )
+    x = @Y[y]
+    @Y.delete y
+    @X.delete x
+    x
   end
 end

data/spec/lib/bijection_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+describe Bijection do
+  before(:each) { @b = Bijection.new }
+
+  it "initializes with empty domain" do
+    @b.domain.should be_empty
+  end
+
+  it "initializes with empty range" do
+    @b.range.should be_empty
+  end
+
+  it "initializes with empty size" do
+    @b.size.should == 0
+  end
+
+  it "returns self when add is called" do
+    @b.add(5, 3).should == @b
+  end
+
+  it "returns nil when inverse! is called" do
+    @b.inverse!.should be_nil
+  end
+
+  it "add raises when x is nil" do
+    expect { @b.add nil, "fooz" }.to raise_error
+  end
+
+  it "add raises when y is nil" do
+    expect { @b.add 57, nil }.to raise_error
+  end
+
+  it "delete_by_x returns nil for x not in X" do
+    @b.delete_by_x(5).should be_nil
+  end
+
+  it "delete_by_y returns nil for y not in Y" do
+    @b.delete_by_y(5).should be_nil
+  end
+
+  it "each_x returns nil" do
+    @b.each_x.should be_nil
+  end
+
+  it "each_y returns nil" do
+    @b.each_y.should be_nil
+  end
+
+  it "each_pair returns nil" do
+    @b.each_pair.should be_nil
+  end
+
+  context "with one pair added" do
+    before :each do
+      @x = 3
+      @y = []
+      @b.add @x, @y
+    end
+
+    it "has domain with exactly x" do
+      @b.domain.should == [@x]
+    end
+
+    it "has range with exactly y" do
+      @b.range.should == [@y]
+    end
+
+    it "finds x in each_x" do
+      @b.each_x { |x| x.should == @x }
+    end
+
+    it "finds y in the each_y" do
+      @b.each_y { |y| y.should == @y }
+    end
+
+    it "finds x,y in each_pair" do
+      x1 = nil
+      y1 = nil
+      @b.each_pair do |x,y|
+        x1 = x
+        y1 = y
+      end
+      x1.should == @x
+      y1.should == @y
+    end
+
+    it "raises when x is re-added" do
+      expect { @b.add @x, "fooz" }.to raise_error
+    end
+
+    it "raises when y is re-added" do
+      expect { @b.add "sdfdsfs", @y }.to raise_error
+    end
+
+    it "returns x when given y" do
+      @b.get_x(@y).should == @x
+    end
+
+    it "returns y when given x" do
+      @b.get_y(@x).should == @y
+    end
+
+    it "returns nil when given x not in X" do
+      @b.get_y(7).should be_nil
+    end
+
+    it "returns nil when given y not in Y" do
+      @b.get_x("foo").should be_nil
+    end
+
+    it "returns x for delete_by_y y and then the bijection is empty" do
+      @b.delete_by_y(@y).should == @x
+      @b.size == 0
+    end
+
+    it "returns y for delete_by_x x and then the bijection is empty" do
+      @b.delete_by_x(@x).should == @y
+      @b.size == 0
+    end
+
+    context "after deleting (x,y)" do
+      before :each do
+        @b.delete_by_x @x
+      end
+
+      it "bijection is empty" do
+        @b.size.should == 0
+      end
+
+      it "allows re-adding of (x,y)" do
+        @b.add @x, @y
+      end
+
+      context "when re-adding (x,y)" do
+        before :each do
+          @b.add @x, @y
+        end
+
+        it "should have size 1" do
+          @b.size.should == 1
+        end
+      end
+    end
+
+    context "the inverse" do
+      before(:each) do
+        @b.inverse!
+      end
+
+      it "returns y for get_x" do
+        @b.get_x(@x).should == @y
+      end
+
+      it "returns x for get_y" do
+        @b.get_y(@y).should == @x
+      end
+    end # context inverse
+  end # context one pair added
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bijection
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-20 00:00:00.000000000Z
+date: 2011-06-21 00:00:00.000000000Z
 dependencies: []
-description: bijection container in ruby; pre-alpha wip
+description: bijection container in ruby. See example in Class Bijection.
 email:
 - ryan.berckmans@gmail.com
 executables: []
@@ -19,14 +19,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - .rvmrc
 - .yardopts
 - Gemfile
 - Rakefile
 - bijection.gemspec
 - lib/bijection.rb
-- lib/bijection/base.rb
-- lib/bijection/version.rb
+- spec/lib/bijection_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ryanberckmans/bijection
 licenses: []
@@ -51,5 +51,5 @@ rubyforge_project: bijection
 rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: bijection container in ruby; pre-alpha wip
+summary: bijection container in ruby
 test_files: []

data/lib/bijection/base.rb

@@ -1,68 +0,0 @@
-module Bijection
-
-  # @example
-  #   b = Bijection.new
-  #   => Bijection::Base
-  class Base
-    def initialize
-      @x = {}
-      @y = {}
-    end
-
-    # add (x,y) to the bijection set (X,Y)
-    # @param x the object associated with y
-    # @param y the object associated with x
-    # @note x must be unique in X; y must be unique in Y
-    # @return self
-    def map( x, y )
-      self
-    end
-
-    # @return [Enumerator] the domain set X
-    def domain
-      @x.each_key
-    end
-
-    # @return [Enumerator] the range set Y
-    def range
-      @y.each_key
-    end
-
-    # swap domain X and range Y of this
-    # @return nil
-    def inverse!
-    end
-
-    # @param y in domain set Y
-    # @return the x associated with y
-    def get_x( y )
-    end
-
-    # @param x in domain set X
-    # @return the y associated with x
-    def get_y( x )
-    end
-
-    # @return [Enumerator] an enumerator all (x,y)
-    def each_pair
-    end
-
-    # given x, delete (x,y) and return y
-    # @param (see #get_x)
-    # @example
-    #  b = Bijection.new
-    #  x = 2 ; y = 3
-    #  b.map x, y
-    #  y = nil
-    #  while 1 { y = b.delete_x x ; b.map x, y }
-    # @return the y associated with x
-    def delete_x( x )
-    end
-
-    # given y, delete (x,y) and return x
-    # @param (see #get_y)
-    # @return x associated with y
-    def delete_y( y )
-    end
-  end
-end

data/lib/bijection/version.rb

@@ -1,3 +0,0 @@
-module Bijection
-  VERSION = "0.0.1"
-end