array_scanner 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWQ4MTcwNjcxNTljZWZjYWFlOGU0OTQxODg0ZmIxMDA3NzhhYTcwYw==
+  data.tar.gz: !binary |-
+    ZjY5ODhkMzQzYTBhNzg5NTUwYjQ2MGNkY2IyODg3YWU1Yjc4ZWUwMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZTc0ZjRlNTYwNDIzMzJjYjZlOTI4MmJmMWE3ODliNmIzN2EwYzMzN2ZmNDE4
+    MTk3YjU4YjgyZDFhYzkwYjU4MmQ0ZGIyZjgwYzA4ZmZmMmFlMGZlMGE0ZmRi
+    ZDIwYTBlMDU2ZTg2ZGRmMzQwNGMyYjFkZjFlMTlmODlmZmE2YjE=
+  data.tar.gz: !binary |-
+    ZDlhMGY0YTg3ZDNhZjQ3Mjc2NzNjMTM3MmJjYzU2YTQ4NTdkMTIyOTYwOGNk
+    ODY1ZmY4MWViZTM3ZWQ0ZTMzYjkzYjEwMGUxM2U2MDRjZjE0NWJhZjcxZGM3
+    OWMzMTY1NWJjNTNjNDVlZmMxYWE4MTFkZGVjYWUzMWJlNjA0Yzk=

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LFDM
+
+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,78 @@
+# ArrayScanner
+
+Class for traversing an array, remembering the position of a pointer and
+recent scan operations, very much like Ruby's standard library
+StringScanner.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'array_scanner'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install array_scanner
+
+## Example Usage
+
+    ArrayScanner.new([:a,      :b,      :c,      :d,      :e,      :f,      :g])
+
+                 inspect => "Pointer at 0/6. Current element: :a"
+
+                 forward(2) => 2
+                       o-------2-------> *
+
+                 current_element => :c
+                                         *
+                 
+                 scan { |el| el == :c } => :c
+                                         o---1--> *
+
+                 position => 3
+                                                  *
+
+                 rest => [:d, :e, :f, :g]
+                                                  *
+
+                 rest_size => 4
+                                                  *
+
+                 scan_until { |el| el == :f } => [:d, :e]
+                                                  o-------2-------> *
+                 
+                 unscan => 3
+                                                  * <-------2-------o                  
+
+                 scan_until(true) { |el| el == :f } => [:d, :e, :f]
+                                                  o------------3-----------> *
+
+                 eoa? => true
+                                                                             *
+
+                 rewind_to { |el| el == :b } => :b
+                               * <--------------------5--------------------- *
+
+                 surroundings => [:a, :c]
+                               *
+
+                 last_positions => [6, 3, 5, 3, 2, 0]
+                               *
+
+                 last_results => [[:d, :e, :f], [:d, :e], :c]
+                               *
+                                        
+                 Check tests for more behaviour.
+
+
+## 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/array_scanner.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'array_scanner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "array_scanner"
+  spec.version       = ArrayScanner::VERSION
+  spec.authors       = ["LFDM"]
+  spec.email         = ["1986gh@gmail.com"]
+  spec.description   = %q{ArrayScanner that mimics ruby's std lib StringScanner}
+  spec.summary       = %q{Class for traversing an array, remembering the position of a pointer and recent scan operations.}
+  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/array_scanner/version.rb

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

data/lib/array_scanner.rb

@@ -0,0 +1,224 @@
+require "array_scanner/version"
+require_relative "hist"
+
+class ArrayScanner
+  attr_reader :position, :pos_hist, :res_hist
+  alias :pos     :position
+  alias :pointer :position
+
+  def initialize(arr, history_size = 10)
+    raise TypeError.new("Argument is not an Array.")      unless arr.is_a?(Array)
+    raise TypeError.new("History size is not a Fixnum.")  unless history_size.is_a?(Fixnum)
+
+    @arr = arr
+    @position = 0
+
+    @pos_hist = Hist.new(history_size)
+    @res_hist = Hist.new(history_size)
+  end
+
+  def size
+    @arr.size
+  end
+
+  alias :length :size
+
+  def eoa
+    size - 1
+  end
+
+  def eoa?
+    @position == eoa
+  end
+
+  def current_element
+    @arr[@position]
+  end
+
+  alias :points_at :current_element
+  alias :current   :current_element
+
+  def position=(new)
+    raise TypeError.new("New position not a Fixnum.") unless new.is_a? Fixnum
+    raise ArgumentError.new("New position #{new} outside of range 0..#{eoa}.") unless new.between?(0, eoa)
+
+    @pos_hist.push(@position)
+    @position = new
+  end
+
+  alias :pos=     :position=
+  alias :pointer= :position=
+
+  def surroundings
+    [scanned.last, rest[1]]
+  end
+
+  def last_position
+    @pos_hist.recent
+  end
+
+  def last_positions(n = nil)
+    n ? @pos_hist.recent(n) : @pos_hist.stack
+  end
+
+  def unscan(steps = 1)
+    return nil if last_positions.empty?
+    self.position = last_positions[steps - 1] || last_positions.last
+  end
+
+  def last_result(valid = false)
+    valid ? @res_hist.stack.find { |x| x } : @res_hist.recent
+  end
+
+  def last_results(n = nil)
+    n ? @res_hist.recent(n) : @res_hist.stack
+  end
+
+  def forward(fixnum)
+    new = @position + fixnum
+    self.position = (new > eoa ? eoa : new)
+  end
+
+  def forward_to
+    if block_given?
+      f = rest.find { |x| yield(x) }
+      f ? self.position = @arr.index(f) : nil
+    else
+      raise needs_block
+    end
+  end
+
+  def rewind(fixnum)
+    new = @position - fixnum
+    self.position = (new < 0 ? 0 : new)
+  end
+
+  def rewind_to
+    if block_given?
+      b = scanned.find { |x| yield(x) }
+      b ? self.position = @arr.index(b) : nil
+    else
+      raise needs_block
+    end
+  end
+
+  def reset
+    self.position = 0
+  end
+
+  def terminate
+    self.position = eoa
+  end
+
+  alias :clear :terminate
+
+  def scanned
+    @arr[0...@position]
+  end
+
+  def scanned_size
+    @position
+  end
+
+  def rest
+    @arr[@position..-1]
+  end
+
+  def rest_size
+    size - @position
+  end
+
+  def scan(forward = true)
+    res = @arr[@position]
+
+    if block_given? and not yield(res)
+      rr(false)
+    else
+      forward(1) if forward &! eoa?
+      rr(res)
+    end
+  end
+
+  def scan_until(include_true_element = false)
+    if block_given?
+      if e = rest.find { |el| yield(el) }
+        i  = @arr.index(e)
+        i += 1 if include_true_element
+
+        self.position = (i > eoa ? eoa : i)
+        rr(@arr[last_position...i])
+      else
+        rr(false)
+      end
+    else
+      raise needs_block
+    end
+  end
+
+  def peek(n = nil)
+    n ? rest.take(n) : rest.first
+  end
+
+  def peek_until
+    if block_given?
+      i = rest.index { |el| yield(el) }
+      i ? rest[0...i] : []
+    else
+      raise needs_block
+    end
+  end
+
+  def look_behind(n = nil)
+    n ? scanned.reverse.take(n) : scanned.last
+  end
+
+  def look_behind_until
+    if block_given?
+      rev = scanned.reverse
+      i = rev.index { |el| yield(el) }
+      i ? rev[0...i] : []
+    else
+      raise needs_block
+    end
+  end
+
+  def find
+    if block_given?
+      rest.find { |e| yield e }
+    else
+      raise needs_block
+    end
+  end
+
+  alias :next :find
+
+  def previous
+    if block_given?
+      scanned.reverse.find { |e| yield e }
+    else
+      raise needs_block
+    end
+  end
+
+  def rr(obj)
+    # means return result
+    @res_hist.push(obj)
+    obj
+  end
+
+  def needs_block
+    ArgumentError.new("Method needs block.")
+  end
+
+  def to_a
+    @arr
+  end
+
+  def to_s
+    @arr.to_s
+  end
+
+  def inspect
+    "Pointer at #{@position}/#{eoa}. Current element: #{":" if current.is_a?(Symbol)}#{current}"
+  end
+end

data/lib/hist.rb

@@ -0,0 +1,21 @@
+class Hist
+  attr_reader :stack, :max_size
+
+  def initialize(max_size = 10)
+    @stack = []
+    @max_size = max_size
+  end
+
+  def push(obj)
+    @stack.pop if @stack.size == @max_size
+    @stack.unshift(obj)
+  end
+
+  def recent(n = nil)
+    n ? @stack.take(n) : @stack.first
+  end
+
+  def [](i)
+    @stack[i]
+  end
+end

data/spec/lib/array_scanner_spec.rb

@@ -0,0 +1,481 @@
+require_relative "../../lib/array_scanner"
+
+describe ArrayScanner do
+  describe "#initialize" do
+    it "should raise type errors for wrong arguments" do
+      expect { ArrayScanner.new({}) }     .to raise_error(TypeError)
+      expect { ArrayScanner.new([], nil) }.to raise_error(TypeError)
+    end
+  end
+
+  before :each do
+    @a = ArrayScanner.new([1,2,3,4,5])
+  end
+
+  describe "#size" do
+    it "should return the arrays size" do
+      @a.size.should be 5
+    end
+  end
+
+  describe "#length" do
+    it "is an alias for #size" do
+      @a.length.should == @a.size
+    end
+  end
+
+  describe "#eoa" do
+    it "should return last valid position, i.d. end of array" do
+      @a.eoa.should be 4
+    end
+  end
+
+  describe "#eoa?" do
+    it "should return false if not at end of array" do
+      @a.eoa?.should be_false
+    end
+
+    it "should return true if at end of array" do
+      @a.position = 4
+      @a.eoa?.should be_true
+    end
+  end
+
+  describe "#current_element" do
+    it "should return element at the pointers position" do
+      @a.position = 2
+      @a.current_element.should be 3
+    end
+  end
+
+  describe "#current" do
+    it "is an alias for #current_element" do
+      @a.position = 2
+      @a.current.should be 3
+    end
+  end
+
+  describe "#points_at" do
+    it "is an alias for #current_element" do
+      @a.position = 2
+      @a.points_at.should be 3
+    end
+  end
+
+  describe "#position" do
+    it "should return current position" do
+      @a.position.should be 0
+    end
+  end
+
+  describe "#pos" do
+    it "is an alias for #position" do
+      @a.pos.should be 0
+    end
+  end
+
+  describe "#pointer" do
+    it "is an alias for #position" do
+      @a.pointer.should be 0
+    end
+  end
+
+  describe "#position=" do
+    it "should set new position" do
+      @a.position = 4
+      @a.position.should be 4
+    end
+
+    it "should raise error when new position is invalid type" do
+      expect { @a.position = "" }.to raise_error(TypeError)
+    end
+
+    it "should raise error when new position is outside of arrays range" do
+      expect { @a.position = 6 }.to raise_error(ArgumentError)
+      expect { @a.position = 5 }.to raise_error(ArgumentError)
+    end
+
+    it "should add to positions history stack" do
+      [1,2,3].each { |n| @a.position = n }
+      @a.pos_hist.stack.should == [2,1,0]
+    end
+  end
+
+  describe "#pos=" do
+    it "is an alias for #position=" do
+      @a.pos = 4
+      @a.position.should be 4
+    end
+  end
+
+  describe "#pointer=" do
+    it "is an alias for #position=" do
+      @a.pointer = 4
+      @a.position.should be 4
+    end
+  end
+
+  describe "#surroundings" do
+    it "should return element in front and element behind pointer" do
+      @a.pos = 2
+      @a.surroundings.should == [2,4]
+    end
+
+    it "should return nil elements for edge positions" do
+      @a.surroundings.should == [nil, 2]
+      @a.terminate
+      @a.surroundings.should == [4, nil]
+    end
+  end
+
+  describe "#last_position" do
+    it "should return last position after recent movement" do
+      @a.position = 1 and @a.position = 2
+      @a.last_position.should be 1
+    end
+  end
+
+  describe "#last_positions" do
+    it "should return array of all pointer movements when called without arg" do
+      @a.position = 3 and @a.position = 1 and @a.position = 4
+      @a.last_positions.should == [1,3,0]
+    end
+
+    it "should return array of all pointer movements according to argument number" do
+      @a.position = 3 and @a.position = 1 and @a.forward(1)
+      @a.last_positions(2).should == [1,3]
+    end
+  end
+
+  describe "#unscan" do
+    before :each do
+      [1,2,3,4].each { |n| @a.pos_hist.push(n) }
+    end
+
+    context "without argument" do
+      it "should reset pointer to last position and return new value" do
+        @a.unscan.should be 4
+        @a.position.should be 4
+      end
+    end
+
+    context "with argument" do
+      it "should reset pointer by n steps and return new value" do
+        @a.unscan(3).should be 2
+        @a.position.should be 2
+      end
+    end
+
+    it "should return nil when position history is empty" do
+      @a.pos_hist.stack.clear
+      @a.unscan.should be_nil
+    end
+
+  end
+
+  describe "#last_result" do
+    it "should return last result" do
+      @a.scan
+      @a.last_result.should == 1
+    end
+
+    it "should return last valid result with true argument" do
+      @a.scan and @a.scan { |x| x == 100 }
+      @a.last_result.should be_false
+      @a.last_result(true).should == 1
+    end
+  end
+
+  describe "#forward" do
+    it "should forward pointer by argument" do
+      @a.forward(2)
+      @a.position.should be 2
+    end
+
+    it "should foward pointer to eoa if new position is outside of range" do
+      @a.forward(10)
+      @a.position.should be 4
+    end
+  end
+
+  describe "#forward_to" do
+    it "should forward pointer and return new position if block is true" do
+      @a.forward_to { |el| el == 3 }.should be 2
+      @a.position.should be 2
+    end
+
+    it "should not forward pointer and return nil if block is false" do
+      @a.forward_to { |el| el == 7 }.should be_nil
+      @a.position.should be 0
+    end
+
+    it "raises ArgumentError without block" do
+      expect { @a.look_behind_until }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#rewind" do
+    it "should rewind pointer by argument" do
+      @a.position = 3
+      @a.rewind(2)
+      @a.position.should be 1
+    end
+
+    it "should rewind to zero if new position is outside of range" do
+      @a.position = 2
+      @a.rewind(4)
+      @a.position.should be 0
+    end
+  end
+
+  describe "#rewind_to" do
+    it "should rewind pointer to new position if block is true" do
+      @a.position = 4
+      @a.rewind_to { |el| el == 2 }.should be 1
+      @a.position.should be 1
+    end
+
+    it "should not rewind pointer and return nil if block is false" do
+      @a.position = 4
+      @a.rewind_to { |el| el == 5 }.should be_nil
+      @a.position.should be 4
+    end
+
+    it "raises ArgumentError without block" do
+      expect { @a.look_behind_until }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#reset" do
+    it "should reset pointer to 0" do
+      @a.position = 4
+      @a.reset
+      @a.position.should be 0
+    end
+  end
+
+  describe "#terminate" do
+    it "should set pointer to eoa position" do
+      @a.terminate
+      @a.position.should be 4
+    end
+  end
+
+  describe "#clear" do
+    it "is an alias for #terminate" do
+      @a.clear.should be @a.terminate
+    end
+  end
+
+  describe "#scanned" do
+    it "should return already scanned elements" do
+      @a.position = 3
+      @a.scanned.should == [1,2,3]
+    end
+  end
+
+  describe "#scanned_size" do
+    it "should return number of scanned elements" do
+      @a.position = 3
+      @a.scanned_size.should be 3
+    end
+  end
+
+  describe "#rest" do
+    it "should return remaining elements" do
+      @a.position = 1
+      @a.rest.should == [2,3,4,5]
+    end
+  end
+
+  describe "#rest_size" do
+    it "should return number of remaining elements" do
+      @a.position = 1
+      @a.rest_size.should be 4
+    end
+  end
+
+  describe "#scan" do
+    context "without blk" do
+      it "should return array element at current position and advance pointer" do
+        @a.position = 2
+        @a.scan.should be 3
+        @a.position.should be 3
+      end
+
+      it "should not advance pointer with false argument" do
+        @a.scan(false)
+        @a.position.should be 0
+      end
+
+      it "should not advance pointer if at eoa" do
+        @a.position = 4
+        @a.scan
+        @a.position.should be 4
+      end
+    end
+
+    context "with blk" do
+      it "should return false for false block" do
+        @a.scan { |el| el == 6 }.should be_false
+      end
+
+      it "should return array element at current position for true block and advance position by 1" do
+        @a.position = 2
+        @a.scan { |el| el == 3 }.should be 3
+        @a.position.should be 3
+      end
+
+      it "should not advance pointer with false argument" do
+        @a.scan(false) { |el| el == 3 }.should be false
+        @a.position.should be 0
+      end
+    end
+  end
+
+  describe "#scan_until" do
+    it "should return array from current position to position before the block evaluated to true and move pointer" do
+      @a.scan_until { |el| el == 3 }.should == [1,2]
+      @a.position.should be 2
+    end
+
+    it "should return false when block is false and not move pointer." do
+      @a.scan_until { |el| el == 8 }.should be_false
+      @a.position.should be 0
+    end
+
+    it "should include the element for which the block evaluated true when true argument is given." do
+      @a.scan_until(true) { |el| el == 3 }.should == [1,2,3]
+      @a.position.should be 3
+    end
+
+    it "should rest pointer at eoa when true argument is given and the truthy result is at eoa." do
+      @a.scan_until(true) { |el| el == 5 }.should == [1,2,3,4,5]
+      @a.position.should == @a.eoa
+    end
+
+    it "raises ArgumentError without block" do
+      expect { @a.look_behind_until }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#peek" do
+    it "should return next element without argument" do
+      @a.position = 1
+      @a.peek.should == 2
+    end
+
+    it "should array of next elements by argument number" do
+      @a.peek(1).should == [1]
+      @a.peek(2).should == [1,2]
+    end
+  end
+
+  describe "#peek_until" do
+    it "should return array of next elements between current position and the element for which the block is true" do
+      @a.position = 1
+      @a.peek_until { |el| el == 5 }.should == [2,3,4]
+    end
+
+    it "should return empty array if block is false" do
+      @a.peek_until { |el| el == 6 }.should == []
+    end
+
+    it "raises ArgumentError without block" do
+      expect { @a.look_behind_until }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#look_behind" do
+    it "should return element behind pointer (i.e. pointer position - 1), when no arguemnt is given" do
+      @a.pos = 2
+      @a.look_behind.should be 2
+    end
+
+    it "should array of previous elements by argument number (reverse order)" do
+      @a.pos = 4
+      @a.look_behind(1).should == [4]
+      @a.look_behind(2).should == [4,3]
+    end
+
+    it "should return nil when there is nothing behind without argument" do
+      @a.look_behind.should be_nil
+    end
+
+    it "should return empty array when there is nothing behind with argument" do
+      @a.look_behind(3).should == []
+    end
+
+    it "should return everything behind when argument number is larger than number of elements behind" do
+      @a.pos = 2
+      @a.look_behind(4).should == [2,1]
+    end
+  end
+
+  describe "#look_behind_until" do
+    it "should return arguemnt of previous element between current position and the element for which the block is true - in reverse order" do
+      @a.pos = 4
+      @a.look_behind_until { |el| el == 2 }.should == [4,3]
+    end
+
+    it "should return empty array if block is false" do
+      @a.look_behind_until { |el| el == 1 }.should == []
+    end
+
+    it "raises ArgumentError without block" do
+      expect { @a.look_behind_until }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#find" do
+    it "should return next element after pointer for true block" do
+      @a.position = 1
+      @a.find { |x| x == 3 }.should be 3
+    end
+
+    it "should return nil for no find - e.g. pointer is already behind the looked up element" do
+      @a.position = 3
+      @a.find { |x| x == 0 }.should be_nil
+    end
+  end
+
+  describe "#next" do
+    it "is an alias for #find" do
+      @a.position = 1
+      @a.next { |x| x == 3 }.should be 3
+    end
+  end
+
+  describe "#previous" do
+    it "should return previous element in front of pointer for true block" do
+      @a.position = 3
+      @a.previous { |x| x == 2 }.should be 2
+    end
+  end
+
+  describe "#rr" do
+    it "should add to results history and return the argument" do
+      @a.rr(1).should be 1
+      @a.res_hist.stack.should == [1]
+    end
+  end
+
+  describe "#to_a" do
+    it "should return simple array" do
+      @a.to_a.should == [1,2,3,4,5]
+    end
+  end
+
+  describe "#to_s" do
+    it "should return simple array to_s" do
+      @a.to_s.should == "[1, 2, 3, 4, 5]"
+    end
+  end
+
+  describe "#inspect" do
+    it "should return pointer information" do
+      @a.pos = 2
+      @a.inspect.should == "Pointer at 2/4. Current element: 3"
+    end
+  end
+end

data/spec/lib/hist_spec.rb

@@ -0,0 +1,55 @@
+require_relative "../../lib/hist"
+
+describe Hist do
+  describe "#initialize" do
+    it "should come with default stack size 10" do
+      Hist.new.max_size.should be 10
+    end
+
+    it "should take max sizes as argument" do
+      Hist.new(11).max_size.should be 11
+    end
+  end
+
+  describe "#[]" do
+    it "delegates [] to stack" do
+      a = Hist.new
+      a.push(1) and a.push(2)
+      a[1].should be 1
+      a[0].should be 2
+    end
+  end
+
+  describe "#push" do
+    before :each do
+      @a = Hist.new(3)
+    end
+
+    it "should push new element to stack" do
+      @a.push(1)
+      @a.stack.should == [1]
+    end
+
+    it "should not take more elements than max size" do
+      @a.instance_variable_set(:@stack, [1,2,3])
+      @a.push(4)
+      @a.stack.should == [4,1,2]
+    end
+  end
+
+  describe "#recent" do
+    before :each do
+      @a = Hist.new(3)
+      @a.instance_variable_set(:@stack, [1,2,3])
+    end
+
+    it "should return recently added element to stack without argument" do
+      @a.recent.should be 1
+    end
+
+    it "should return array of recently added elements according to argument number" do
+      @a.recent(2).should == [1,2]
+    end
+  end
+end
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: array_scanner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- LFDM
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-22 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: ArrayScanner that mimics ruby's std lib StringScanner
+email:
+- 1986gh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- array_scanner.gemspec
+- lib/array_scanner.rb
+- lib/array_scanner/version.rb
+- lib/hist.rb
+- spec/lib/array_scanner_spec.rb
+- spec/lib/hist_spec.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.3
+signing_key: 
+specification_version: 4
+summary: Class for traversing an array, remembering the position of a pointer and
+  recent scan operations.
+test_files:
+- spec/lib/array_scanner_spec.rb
+- spec/lib/hist_spec.rb