orders 0.0.4 → 0.0.5

data/HISTORY

@@ -17,3 +17,7 @@
 == 0.0.4 / 2011-03-21
 
 * Item#to_s added
+
+== 0.0.5 / 2011-03-21
+
+* Iteration-safety added

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/orders/indexed_list.rb

@@ -3,22 +3,43 @@ module Orders
   # ������� ����� "������������� ������"
   class IndexedList < Hash
 
+    def initialize
+      @iteration_mutex = Mutex.new
+      super
+    end
+
     # Returns default list index for items
     def index item
       item.object_id
     end
 
-    # Adds new item to the list (replaces item with the same index)
+    # Determines if item is worthy to be included in the list
+    def check item
+      true
+    end
+
+    # Adds new item to the list if it passes check
+    # (replaces item with the same index)
+    def add? item
+      @iteration_mutex.synchronize { self[index item] = item } if check item
+    end
+
+    # Adds new item to the list, returning self for easy chaining
     def add item
-      self[index item] = item
+      add? item
       self
     end
 
     alias << add
 
+    # Removes item from the list, returns nil if nothing removed
+    def remove? item
+      @iteration_mutex.synchronize { delete index item }
+    end
+
     # Removes item from the list
     def remove item
-      delete index item
+      remove? item
       self
     end
 
@@ -30,20 +51,20 @@ module Orders
     # Removes either all items, or items for which given block returns trueish value
     def clear
       if block_given?
-        each {|item| remove item if yield item}
+        each { |item| remove item if yield item }
       else
-        each_value { |item| remove item }
+        each { |item| remove item }
       end
     end
 
-    # Yields list items in order of their index
+    # Yields list items (but NOT keys!) in order of their index
     def each
+      keys_dup = []
+      @iteration_mutex.synchronize { keys_dup = keys.dup }
       if block_given?
-        keys.sort.each { |key| yield self[key] }
+        keys_dup.sort.each { |key| yield self[key] }
       else
-        ary = []
-        keys.sort.each { |key| ary << self[key] }
-        ary
+        keys_dup.sort.map { |key| self[key] }
       end
     end
 

data/lib/orders/order_book.rb

@@ -3,7 +3,9 @@ module Orders
   # ������ ������� �� ����
   class OrderBook < IndexedList
 
-    attr_accessor :isin_id, :changed
+    attr_accessor :changed
+    attr_reader :isin_id
+    alias isin isin_id
 
     def initialize isin_id
       @isin_id = isin_id
@@ -15,21 +17,24 @@ module Orders
       item.price
     end
 
-    def add item
-      if item.price > 0
+    def check item
+      item.price > 0
+    end
+
+    def add? item
+      if super
         @changed = true # Marking DOM as changed
         item.order_book = self
-        super
-      else
-        self
+        item
       end
     end
 
-    # Does not call super!
-    def remove item
-      @changed = true if delete index item # Marking DOM as changed
-      item.order_book = nil
-      self
+    def remove? item
+      if super
+        @changed = true # Marking DOM as changed
+        item.order_book = nil
+        item
+      end
     end
   end
 end

data/lib/orders/order_book_item.rb

@@ -11,9 +11,16 @@ module Orders
   #        order_book      : tOrderBook;
   class OrderBookItem
     attr_accessor :isin_id, :id, :rev, :price, :volume, :buysell, :order_book
+    alias isin isin_id
+    alias isin= isin_id=
 
     def initialize opts = {}
-      opts.each {|key, value| send "#{key}=", value}
+      opts.each { |key, value| send "#{key}=", value }
+    end
+
+    def price= val
+      val = val.to_f
+      @price = val.round == val ? val.to_i : val
     end
 
     def inspect

data/lib/orders/order_list.rb

@@ -7,7 +7,10 @@ module Orders
     attr_accessor :order_books
 
     def initialize
-      @order_books = {}
+      @order_books = Hash.new do |hash, key|
+        hash[key] = Orders::OrderBook.new(key)
+        hash[key]
+      end
       super
     end
 
@@ -15,18 +18,21 @@ module Orders
       item.id
     end
 
-    def add item
-      order_book = @order_books[item.isin_id] ||= Orders::OrderBook.new(item.isin_id)
+    def add? item
       old_item = self[index item]
       remove old_item if old_item # Remove old item with the same index(id)
-      order_book.add item         # Add item to appropriate order book
-      super
+      if super
+        @order_books[item.isin_id].add item # Add item to appropriate order book
+        item
+      end
     end
 
-    def remove item
-      # Removing item from appropriate order book when it's deleted from order list
-      @order_books[item.isin_id].remove item if delete index item
-      self
+    def remove? item
+      if super
+        # Removing item from appropriate order book when it's deleted from order list
+        @order_books[item.isin_id].remove item
+        item
+      end
     end
   end
 end

data/spec/orders/indexed_list_spec.rb

@@ -12,5 +12,9 @@ describe Orders::IndexedList do
   end
 
   it_behaves_like 'index_list'
+
+  it 'checks all items as worthy, by default' do
+    subject.check(@item).should == true
+  end
 end
 

data/spec/orders/order_book_item_spec.rb

@@ -5,6 +5,7 @@ describe Orders::OrderBookItem do
     subject { Orders::OrderBookItem.new }
 
     its (:isin_id) {should == nil}
+    its (:isin) {should == nil}
     its (:id) {should == nil}
     its (:rev) {should == nil}
     its (:price) {should == nil}
@@ -14,7 +15,7 @@ describe Orders::OrderBookItem do
   end
 
   describe '#new with opts' do
-    subject { Orders::OrderBookItem.new :isin_id => 1234567,
+    subject { Orders::OrderBookItem.new :isin => 1234567,
                                            :id => 12,
                                            :rev => 123,
                                            :price => 1234,
@@ -24,6 +25,7 @@ describe Orders::OrderBookItem do
     }
 
     its (:isin_id) {should == 1234567}
+    its (:isin) {should == 1234567}
     its (:id) {should == 12}
     its (:rev) {should == 123}
     its (:price) {should == 1234}
@@ -37,6 +39,14 @@ describe Orders::OrderBookItem do
        subject.inspect.should == "12:1234>12345+"
      end
    end
+
+   describe '#price=' do
+     it 'converts given price to Integer if it is integer' do
+       subject.price = 1313.0
+       subject.price.should == 1313
+       subject.price.should be_an Integer
+     end
+   end
   end
 end
 

data/spec/orders/order_book_spec.rb

@@ -15,8 +15,29 @@ describe Orders::OrderBook do
   it_behaves_like 'index_list'
 
   its (:isin_id) {should == 123456}
+  its (:isin) {should == 123456}
   its (:changed) {should == true}
 
+  it 'is possible to set its #changed attribute' do
+    subject.changed = false
+    subject.changed.should == false
+  end
+
+  it 'but #isin(_id) attribute is not settable' do
+    expect { subject.isin_id = 1313 }.to raise_error NoMethodError
+    expect { subject.isin = 1313 }.to raise_error NoMethodError
+  end
+
+  describe '#check' do
+    it 'fails if item.price <= 0' do
+      subject.check(@zero_price_item).should == false
+    end
+
+    it 'returns true otherwise' do
+      subject.check(@item).should == true
+    end
+  end
+
   describe 'adding item' do
     before(:each) do
       subject.add(@item).size.should == 1

data/spec/orders/order_list_spec.rb

@@ -63,6 +63,13 @@ describe Orders::OrderList do
 
   specify { subject.order_books.should be_empty }
 
+  it 'returns order_book for any isin_id, even if it was not initialized' do
+    order_book = subject.order_books[1313]
+    order_book.should_not be_nil
+    order_book.should be_an Orders::OrderBook
+    order_book.should be_empty
+  end
+
   describe 'adding item' do
     let(:expected_number_of_books) { 1 }
 
@@ -129,6 +136,7 @@ describe Orders::OrderList do
           subject.add new_item
           order_book = subject.order_books[@item.isin_id]
           order_book.should_not have_key @item.price
+          order_book.size.should == 0
         end
       end
     end

data/spec/orders/shared_examples.rb

@@ -1,5 +1,102 @@
+shared_examples_for 'removing items' do
+  context 'removing existing item' do
+    it 'returns to indicate success' do
+      remove_operation(@item).should == returns_if_remove_success #@item
+    end
+
+    it 'removes item from indexed list' do
+      remove_operation(@item)
+      subject.values.should_not include @item
+      subject.should_not have_key item_index
+      subject[item_index].should == nil
+    end
+
+    it 'does not remove other items' do
+      remove_operation(@item)
+      subject.values.should include @item1
+      subject.size.should == 1
+    end
+
+    it 'is synchronized to allow other threads iterations' do
+      expect_sync 3
+      remove_operation @item
+      remove_operation @item1
+      remove_operation @item2
+    end
+  end
+
+  context 'deleting non-included items' do
+    it 'returns to indicate failure' do
+      remove_operation(@item2).should == returns_if_remove_failed #nil
+    end
+
+    it 'removes nothing from the list' do
+      remove_operation(@item2)
+      subject.values.should include @item, @item1
+      subject.size.should == 2
+    end
+  end
+end
+
+shared_examples_for 'adding items' do
+  it 'runs check on item' do
+    subject.should_receive(:check).with(@item)
+    add_operation(@item)
+  end
+
+  it 'adds item only if it passes check' do
+    subject.should_receive(:check).with(@item).and_return(false)
+    add_operation(@item).should == returns_if_add_failed
+    subject.values.should_not include @item
+    subject.should_not have_key item_index
+    subject.size.should == 0
+  end
+
+  it 'returns either self or item in case of success' do
+    add_operation(@item).should == returns_if_add_success
+  end
+
+  it 'adds items to indexed list' do
+    add_operation(@item)
+    subject.values.should include @item
+    subject.should have_key item_index
+    subject[item_index].should == @item
+    subject.size.should == 1
+  end
+
+  it 'does not add same items twice' do
+    subject.add(@item)
+    add_operation(@item)
+    subject.values.should include @item
+    subject.should have_key item_index
+    subject[item_index].should == @item
+    subject.size.should == 1
+  end
+
+  it 'even adds item using << as alias to #add' do
+    subject << @item
+    subject.values.should include @item
+    subject.should have_key item_index
+    subject[item_index].should == @item
+    subject.size.should == 1
+  end
+
+  it 'is synchronized to allow other threads iterations' do
+    expect_sync 3
+    add_operation @item
+    add_operation @item1
+    subject << @item2
+  end
+end
+
 shared_examples_for 'index_list' do
 
+  def expect_sync times = 1
+    mutex = subject.instance_variable_get(:@iteration_mutex)
+    mutex.should be_a Mutex
+    mutex.should_receive(:synchronize).exactly(times).times
+  end
+
   describe 'items get/set' do
     it 'returns item from list by their index' do
       subject.add(@item)[item_index].should == @item
@@ -20,119 +117,91 @@ shared_examples_for 'index_list' do
     end
   end
 
-  describe '#add' do
-    it 'returns self for easy method chaining' do
-      subject.add(@item).should == subject
-    end
-
-    it 'adds items to indexed list' do
-      subject.add(@item)
-      subject.values.should include @item
-      subject[item_index].should == @item
-      subject.size.should == 1
+  describe '#add?' do
+    def add_operation item
+      subject.add? item
     end
 
-    it 'adds items to using alias <<' do
-      subject << @item
-      subject.values.should include @item
-      subject[item_index].should == @item
-      subject.size.should == 1
-    end
+    let(:returns_if_add_success) { @item }
+    let(:returns_if_add_failed) { nil }
+    it_behaves_like 'adding items'
   end
 
-  describe '#remove' do
-    before(:each) { subject.add(@item).add(@item1).size.should == 2 }
-
-    context 'removing existing item' do
-      it 'returns self for easy method chaining' do
-        subject.remove(@item).should == subject
-      end
-
-      it 'removes item from indexed list' do
-        subject.remove(@item)
-        subject.values.should_not include @item
-        subject[item_index].should == nil
-      end
-
-      it 'does not remove other items' do
-        subject.remove(@item)
-        subject.values.should include @item1
-        subject.size.should == 1
-      end
+  describe '#add' do
+    def add_operation item
+      subject.add item
     end
 
-    context 'deleting non-existing items by index' do
-      it 'still returns self' do
-        subject.remove(@item2).should == subject
-      end
-
-      it 'removes nothing from the list' do
-        subject.remove(@item2)
-        subject.values.should include @item, @item1
-        subject.size.should == 2
-      end
-    end
+    let(:returns_if_add_success) { subject }
+    let(:returns_if_add_failed) { subject }
+    it_behaves_like 'adding items'
   end
 
-  describe '#delete_by_index' do
-    before(:each) { subject.add(@item).add(@item1) }
-    context 'deleting existing item by index' do
-
-      it 'returns self' do
-        subject.delete_by_index(item_index).should == subject
-      end
-
-      it 'deletes item with given index from the list' do
-        subject.delete_by_index(item_index)
-        subject.values.should_not include @item
-        subject[item_index].should == nil
-      end
+  context 'with couple of items in the list' do
+    before(:each) { subject.add(@item).add(@item1).size.should == 2 }
 
-      it 'calls #remove on this item to properly remove it' do
-        subject.should_receive(:remove).with(@item)
-        subject.delete_by_index(item_index)
+    describe '#remove?' do
+      def remove_operation item
+        subject.remove? item
       end
 
-      it 'does not remove other items' do
-        subject.delete_by_index(item_index)
-        subject.values.should include @item1
-        subject.size.should == 1
-      end
+      let(:returns_if_remove_success) { @item }
+      let(:returns_if_remove_failed) { nil }
+      it_behaves_like 'removing items'
     end
 
-    context 'deleting non-existing items by index' do
-      it 'returns nil' do
-        subject.delete_by_index(subject.index @item2).should == nil
+    describe '#remove' do
+      def remove_operation item
+        subject.remove item
       end
 
-      it 'removes nothing from the list' do
-        subject.delete_by_index(subject.index @item2)
-        subject.values.should include @item, @item1
-        subject.size.should == 2
-      end
+      let(:returns_if_remove_success) { subject }
+      let(:returns_if_remove_failed) { subject }
+      it_behaves_like 'removing items'
     end
-  end
 
-  describe '#clear' do
-    before(:each) { subject.add(@item).add(@item1) }
+    describe '#clear' do
+      context 'without block' do
+        it 'removes all items from list' do
+          subject.clear
+          subject.should be_empty
+        end
 
-    context 'without block' do
-      it 'removes all items from list' do
-        subject.clear
-        subject.should be_empty
+        it 'ensures that #remove method is called once for each item in list' do
+          subject.should_receive(:remove).twice
+          subject.clear
+        end
       end
 
-      it 'ensures that #remove method is called once for each item in list' do
-        subject.should_receive(:remove).twice
-        subject.clear
+      context 'with block given' do
+        it 'yields items from list in index order' do
+          @count = 0
+          @items = []
+          subject.clear do |item|
+            @count += 1
+            @items << item
+          end
+          @count.should == 2
+          if subject.index(@item) < subject.index(@item1)
+            @items.should == [@item, @item1]
+          else
+            @items.should == [@item1, @item]
+          end
+        end
+
+        it 'only removes items for which given block returns true' do
+          subject.should_receive(:remove).once
+          subject.clear { |item| true if item == @item1 }
+          subject.should have_key item_index
+        end
       end
     end
 
-    context 'with block given' do
+    describe '#each' do
       it 'yields items from list in index order' do
         @count = 0
         @items = []
-        subject.clear do |item|
+        subject.each do |item|
           @count += 1
           @items << item
         end
@@ -144,37 +213,18 @@ shared_examples_for 'index_list' do
         end
       end
 
-      it 'only removes items for which given block returns true' do
-        subject.should_receive(:remove).once
-        subject.clear { |item| true if item == @item1 }
-        subject.should have_key item_index
-      end
-    end
-  end
-
-  describe '#each' do
-    before(:each) { subject.add(@item).add(@item1) }
-
-    it 'yields items from list in index order' do
-      @count = 0
-      @items = []
-      subject.each do |item|
-        @count += 1
-        @items << item
-      end
-      @count.should == 2
-      if subject.index(@item) < subject.index(@item1)
-        @items.should == [@item, @item1]
-      else
-        @items.should == [@item1, @item]
+      it 'returns list item in array, sorted by their index, if no block given' do
+        if subject.index(@item) < subject.index(@item1)
+          subject.each.should == [@item, @item1]
+        else
+          subject.each.should == [@item1, @item]
+        end
       end
-    end
 
-    it 'returns list item in array, sorted by their index, if no block given' do
-      if subject.index(@item) < subject.index(@item1)
-        subject.each.should == [@item, @item1]
-      else
-        subject.each.should == [@item1, @item]
+      it 'is synchronized to allow other threads add items while we`re iterating' do
+        expect_sync 2
+        subject.each { |item|}
+        subject.each
       end
     end
   end

metadata

@@ -2,7 +2,7 @@
 name: orders
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - arvicco