trick_bag 0.30.0

data/spec/trick_bag/enumerables/buffered_enumerable_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../../spec_helper'
+require 'trick_bag/enumerables/buffered_enumerable'
+
+module TrickBag
+module Enumerables
+
+  describe BufferedEnumerable do
+
+    context 'when created with lambdas' do
+      # Returns an object that returns chunks of incrementing integers.
+      let(:fetcher) do
+        object = 0
+        ->(array, chunk_size) do
+          chunk_size.times do
+            object += 1
+            array << object
+          end
+        end
+      end
+
+      specify 'the values and number of fetches are correct' do
+        chunk_fetch_calls = 0
+        object_count = 0
+
+        fetch_notifier = ->(fetched_objects) do
+          chunk_fetch_calls += 1
+          object_count += fetched_objects.size
+        end
+
+        e = BufferedEnumerable.create_with_lambdas(4, fetcher, fetch_notifier).to_enum
+        (1..10).each do |n|
+          expect(e.next).to eq(n)
+        end
+        expect(chunk_fetch_calls).to eq(3)
+        expect(object_count).to eq(12)
+      end
+    end
+
+
+    context "when instantiating a subclass" do
+      specify 'the values and number of fetches are correct' do
+        create_test_class = ->() do
+          class BufferedEnumerableSubclass < BufferedEnumerable
+
+            attr_accessor :chunk_fetch_calls, :object_count
+
+            def initialize(chunk_size)
+              super
+              @chunk_fetch_calls = 0
+              @object_count = 0
+            end
+
+            def fetch_notify
+              @chunk_fetch_calls += 1
+              @object_count += data.size
+            end
+
+            def fetch
+              @object ||= 0
+              chunk_size.times do
+                @object += 1
+                self.data << @object
+              end
+              require 'pry'; binding.pry if self.data.is_a?(Fixnum)
+            end
+          end
+        end
+
+        create_test_class.()
+        enumerable = BufferedEnumerableSubclass.new(4)
+        enumerator = enumerable.each
+
+        (1..10).each do |n|
+          expect(enumerator.next).to eq(n)
+        end
+        expect(enumerable.chunk_fetch_calls).to eq(3)
+        expect(enumerable.object_count).to eq(12)
+        ::TrickBag::Meta::Classes.undef_class(:BufferedEnumerableSubclass, TrickBag)
+      end
+    end
+
+
+    context "an Array implementation" do
+
+      create_array_subclass = -> do
+        class ArrayBufferedEnumerable < BufferedEnumerable
+
+          def initialize(chunk_size, array)
+            super(chunk_size)
+            @array = array
+          end
+
+          def fetch
+            num_times = [chunk_size, @array.size].min
+            num_times.times { @data << @array.shift }
+          end
+        end
+      end
+
+      it 'should fulfill its basic functions' do
+        create_array_subclass.()
+        enumerable = ArrayBufferedEnumerable.new(4, (0..5).to_a)
+        enumerator = enumerable.each
+
+        (0..5).to_a.each do |n|
+          expect(enumerator.next).to eq(n)
+        end
+        expect(->{ enumerator.next }).to raise_error(StopIteration)
+        expect(enumerable.chunk_count).to eq(2)
+
+        ::TrickBag::Meta::Classes.undef_class(:ArrayBufferedEnumerable, TrickBag)
+
+      end
+    end
+  end
+end
+end

data/spec/trick_bag/enumerables/compound_enumerable_spec.rb

@@ -0,0 +1,141 @@
+require_relative '../../spec_helper'
+require 'trick_bag/enumerables/compound_enumerable'
+
+module TrickBag
+module Enumerables
+
+  describe CompoundEnumerable do
+
+    context 'input validations' do
+
+      specify 'an initialization error will be raised if no enumerables are specified' do
+        expect(->{ CompoundEnumerable.array_enumerable() }).to raise_error
+        expect(->{ CompoundEnumerable.hash_enumerable([:key]) }).to raise_error
+      end
+
+      specify 'an initialization error will be raised if mode is not :yields_arrays or :yields_hashes' do
+        expect(->{ CompoundEnumerable.new(:bad_mode, [], [])}).to raise_error
+      end
+
+      specify 'an initialization error will be raised if key array size != enumerables size in :yields_hashes mode' do
+        expect(->{ CompoundEnumerable.new(:yields_hashes, [:key1, :key2], [])}).to raise_error
+        expect(->{ CompoundEnumerable.hash_enumerable([:key1, :key2], [])}).to raise_error
+      end
+    end
+
+
+
+    context "as array" do
+
+      context 'with 1 enumerable' do
+        specify 'Gets its values then raises a StopIteration error' do
+          array = [1, 2]
+          e = CompoundEnumerable.array_enumerable(array).each
+          expect(e.next).to eq(1)
+          expect(e.next).to eq(2)
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+
+      context 'with 2 enumerables' do
+        specify 'offers correct values in the correct order' do
+          outer = %w(A B)
+          inner = [1, 2]
+          e = CompoundEnumerable.array_enumerable(outer, inner).each
+          expect(e.next).to eq(['A', 1])
+          expect(e.next).to eq(['A', 2])
+          expect(e.next).to eq(['B', 1])
+          expect(e.next).to eq(['B', 2])
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+
+      context 'with 3 enumerables' do
+        specify 'offers correct values in the correct order' do
+          domains = %w(aaa.com  zzz.com)
+          qtypes = %w(A  NS)
+          qclasses = %w(IN  CH)
+          e = CompoundEnumerable.array_enumerable(domains, qtypes, qclasses).each
+
+          expect(e.next).to eq(['aaa.com', 'A', 'IN'])
+          expect(e.next).to eq(['aaa.com', 'A', 'CH'])
+          expect(e.next).to eq(['aaa.com', 'NS', 'IN'])
+          expect(e.next).to eq(['aaa.com', 'NS', 'CH'])
+          expect(e.next).to eq(['zzz.com', 'A', 'IN'])
+          expect(e.next).to eq(['zzz.com', 'A', 'CH'])
+          expect(e.next).to eq(['zzz.com', 'NS', 'IN'])
+          expect(e.next).to eq(['zzz.com', 'NS', 'CH'])
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+      context 'is an Enumerable' do
+        it "provides the 'take' method" do
+          expect(->{ CompoundEnumerable.array_enumerable([1, 2, 3]).take(2)}).not_to raise_error
+        end
+      end
+    end
+
+
+    context "as hash" do
+
+      context 'with 1 enumerable' do
+        specify 'Gets its values then raises a StopIteration error' do
+          array = [1, 2]
+          e = CompoundEnumerable.hash_enumerable([:number], array).each
+          expect(e.next).to eq({ number: 1 })
+          expect(e.next).to eq({ number: 2 })
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+
+      context 'with 2 enumerables' do
+        specify 'offers correct values in the correct order' do
+          outer = %w(A B)
+          inner = [1, 2]
+          e = CompoundEnumerable.hash_enumerable([:outer, :inner], outer, inner).each
+          expect(e.next).to eq({ outer: 'A', inner: 1 })
+          expect(e.next).to eq({ outer: 'A', inner: 2 })
+          expect(e.next).to eq({ outer: 'B', inner: 1 })
+          expect(e.next).to eq({ outer: 'B', inner: 2 })
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+
+      context 'with 3 enumerables' do
+        specify 'offers correct values in the correct order' do
+          domains = %w(aaa.com  zzz.com)
+          qtypes = %w(A  NS)
+          qclasses = %w(IN  CH)
+          keys = [:domain, :qtype, :qclass]
+          e = CompoundEnumerable.hash_enumerable(keys, domains, qtypes, qclasses).each
+
+          expect(e.next).to eq({ domain: 'aaa.com', qtype: 'A', qclass: 'IN' })
+          expect(e.next).to eq({ domain: 'aaa.com', qtype: 'A', qclass: 'CH' })
+          expect(e.next).to eq({ domain: 'aaa.com', qtype: 'NS', qclass: 'IN' })
+          expect(e.next).to eq({ domain: 'aaa.com', qtype: 'NS', qclass: 'CH' })
+
+          expect(e.next).to eq({ domain: 'zzz.com', qtype: 'A', qclass: 'IN' })
+          expect(e.next).to eq({ domain: 'zzz.com', qtype: 'A', qclass: 'CH' })
+          expect(e.next).to eq({ domain: 'zzz.com', qtype: 'NS', qclass: 'IN' })
+          expect(e.next).to eq({ domain: 'zzz.com', qtype: 'NS', qclass: 'CH' })
+          expect(->{ e.next }).to raise_error(StopIteration)
+        end
+      end
+
+      context 'is an Enumerable' do
+        it "provides the 'take' method" do
+          expect(->{ CompoundEnumerable.hash_enumerable([:num], [1, 2, 3]).take(2)}).not_to raise_error
+
+          values = CompoundEnumerable.hash_enumerable([:num], [1, 2, 3]).take(2)
+          expect(values).to eq([{ num: 1 }, { num: 2 }])
+        end
+      end
+    end
+  end
+end
+end

data/spec/trick_bag/enumerables/filtered_enumerable_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../../spec_helper'
+require 'trick_bag/enumerables/filtered_enumerable'
+
+module TrickBag
+module Enumerables
+
+  describe FilteredEnumerable do
+
+    let (:even_filter) { ->(n) { n.even? } }
+    specify 'with no filter it behaves as a regular enumberable' do
+      e = FilteredEnumerable.new([1,2,3])
+      expect(e.to_a).to eq([1, 2, 3])
+    end
+
+    specify 'an even number filter works correctly when filter passed to constructor' do
+      e = FilteredEnumerable.new((1..10).to_a, even_filter)
+      expect(e.to_a).to eq([2, 4, 6, 8, 10])
+    end
+
+    specify 'an even number filter works correctly when filter passed after creation' do
+      e = FilteredEnumerable.new((1..10).to_a)
+      e.filter = even_filter
+      expect(e.to_a).to eq([2, 4, 6, 8, 10])
+    end
+
+    specify 'works as an enumerator' do
+      e = FilteredEnumerable.new((1..5).to_a, even_filter)
+      enumerator = e.each
+      expect(enumerator.next).to eq(2)
+      expect(enumerator.next).to eq(4)
+      expect(-> { enumerator.next }).to raise_error(StopIteration)
+    end
+  end
+end
+end

data/spec/trick_bag/io/temp_files_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+require 'trick_bag/io/temp_files'
+
+module TrickBag::Io
+
+describe TempFiles do
+
+  it 'creates a readable file with the correct content' do
+    TempFiles.file_containing('foo') do |filespec|
+      expect(File.read(filespec)).to eq('foo')
+    end
+  end
+
+  it 'deletes the file when done' do
+    filespec = nil
+    TempFiles.file_containing('foo') do |fspec|
+      filespec = fspec
+    end
+    expect(File.exist?(filespec)).to be_false
+  end
+
+  it 'uses the prefix in the filespec' do
+    prefix = 'jsiapewrqms'
+    TempFiles.file_containing('', prefix) do |filespec|
+      filename = File.split(filespec).last
+      expect(filename.start_with?(prefix)).to be_true
+    end
+  end
+end
+end

data/spec/trick_bag/io/text_mode_status_updater_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+require 'trick_bag/io/text_mode_status_updater'
+
+module TrickBag
+module Io
+  describe TextModeStatusUpdater do
+
+    it 'instantiates without error' do
+      expect(->{ TextModeStatusUpdater.new(->{ '' }) }).not_to raise_error
+    end
+
+    it 'creates a TextModeStatusUpdater' do
+      expect(TextModeStatusUpdater.new(->{ '' })).to be_a(TextModeStatusUpdater)
+    end
+
+    specify 'the output string contains the content provided by the passed lambda' do
+      string_io = StringIO.new
+      updater = TextModeStatusUpdater.new(->{ 'status' }, string_io, true)
+      updater.print
+      expect(string_io.string).to match(/status/)
+    end
+  end
+end
+end

data/spec/trick_bag/meta/classes_spec.rb

@@ -0,0 +1,211 @@
+require_relative '../../spec_helper'
+require 'trick_bag/meta/classes'
+
+module TrickBag
+module Meta
+
+describe Classes do
+
+  after(:each) { Classes.undef_class('ClassPatchTestClass') }
+
+
+####################################################### class?
+
+context 'class?' do
+
+  it 'should recognize String as a class' do
+    expect(Classes.class?('String')).to be_true
+  end
+
+  it 'should recognize that RUBY_PLATFORM is defined but is not a class' do
+    expect(Classes.class?('RUBY_PLATFORM')).to be_false
+  end
+
+  it 'should recognize a nonexistent constant as not being a class' do
+    expect(Classes.class?('Afjkdiurqpweruwiqopurqpweriuqewprzvxcvzxcvzxvzvzvzvcxzvzv')).to be_false
+  end
+end
+
+
+####################################################### undef_class
+
+  context 'undef_class' do
+    it 'should remove the class' do
+      fn = -> do
+        class ClassPatchTestClass; end
+        ClassPatchTestClass.new # to illustrate that it's available
+        Classes.undef_class('ClassPatchTestClass', TrickBag::Meta)
+      end
+      fn.()
+      expect(->{ ClassPatchTestClass.new }).to raise_error
+    end
+  end
+
+
+####################################################### private_attr_reader
+
+  context 'private_attr_reader' do
+
+    after(:each) { Classes.undef_class('ClassPatchTestClass') }
+
+    fn_create_class = ->do
+      class ClassPatchTestClass
+
+        extend Classes
+
+        private_attr_reader :foo
+
+        def initialize
+          @foo = 123
+          puts "foo = #{self.foo}"
+        end
+      end
+    end
+
+
+      it "should be visible inside the class" do
+      expect(fn_create_class).not_to raise_error
+    end
+
+    it "should be invisible outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo }).to raise_error
+    end
+  end
+
+
+####################################################### private_attr_writer
+
+  context 'private_attr_writer' do
+
+    fn_create_class = ->do
+      class ClassPatchTestClass
+
+        extend Classes
+
+        private_attr_writer :foo
+
+        def initialize
+          self.foo = 123
+        end
+      end
+    end
+
+
+    it "should be visible inside the class" do
+      expect(fn_create_class).not_to raise_error
+    end
+
+    it "should be invisible outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo = 456}).to raise_error
+    end
+
+  end
+
+####################################################### private_attr_accessor
+
+  context 'private_attr_accessor' do
+
+    fn_create_class = ->do
+      class ClassPatchTestClass
+
+        extend Classes
+
+        private_attr_accessor :foo
+
+        def initialize
+          self.foo = 123
+          puts self.foo
+        end
+      end
+    end
+
+
+    it "should be visible inside the class" do
+      expect(fn_create_class).not_to raise_error
+    end
+
+    it "should be invisible outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo = 456}).to raise_error
+      expect(->{ ClassPatchTestClass.new.foo }).to raise_error
+    end
+
+  end
+
+
+####################################################### private_attr_writer_public_reader
+
+  context 'attr_access(:public, :private, :foo)' do
+
+    fn_create_class = ->do
+      class ClassPatchTestClass
+
+        extend Classes
+
+        attr_access :public, :private, :foo
+
+        def initialize
+          self.foo = 123
+          self.foo
+        end
+      end
+    end
+
+
+    it "should be readable and writable inside the class" do
+      expect(fn_create_class).not_to raise_error
+    end
+
+    it "should be readable outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo }).not_to raise_error
+    end
+
+    it "should not be writable outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo = 456}).to raise_error
+    end
+  end
+
+  context 'attr_access(:private, :none, :foo)' do
+
+    fn_create_class = ->do
+      class ClassPatchTestClass
+
+        extend Classes
+
+        attr_access :private, :none, :foo
+
+        def initialize
+          @foo = 1
+          self.foo
+        end
+      end
+    end
+
+
+    it "should be readable inside the class" do
+      expect(fn_create_class).not_to raise_error
+    end
+
+
+    it "should not be readable outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo }).to raise_error
+    end
+
+    it "should not be readable outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo }).to raise_error
+    end
+
+    it "should not be writable outside the class" do
+      fn_create_class.()
+      expect(->{ ClassPatchTestClass.new.foo = 456}).to raise_error
+    end
+  end
+end
+end
+end