nucleus 0.1.0 → 0.2.0

data/spec/integration/api/auth_spec.rb

@@ -1,58 +1,58 @@
-require 'spec/integration/integration_spec_helper'
-
-describe Nucleus::API::V1::Auth do
-  after { Nucleus::TestDataGenerator.clean }
-
-  let!(:vendor_a) { create(:vendor) }
-  let!(:vendor_b) { create(:vendor) }
-  let!(:provider_a) { create(:provider, vendor: vendor_a.id) }
-  let!(:provider_b) { create(:provider, vendor: vendor_b.id) }
-  let!(:endpoint_a) { create(:endpoint, provider: provider_a.id) }
-  let!(:endpoint_b) { create(:endpoint, provider: provider_b.id) }
-  let!(:adapter_a) { create(:adapter, id: endpoint_a.id, adapter_clazz: Nucleus::Adapters::V1::Heroku) }
-  let!(:adapter_b) { create(:adapter, id: endpoint_b.id, adapter_clazz: Nucleus::Adapters::V1::CloudFoundryV2) }
-
-  # tests case when 'use RequestStore::Middleware' was not applied
-  context 'With alternating endpoint requests' do
-    before do
-      allow_any_instance_of(Nucleus::Adapters::V1::Heroku).to receive(:auth_client) do
-        token_auth = double(Nucleus::Adapters::TokenAuthClient)
-        allow(token_auth).to receive(:authenticate) { token_auth }
-        allow(token_auth).to receive(:auth_header) { { 'Authorization' => 'bearer 1234567890' } }
-        token_auth
-      end
-      allow_any_instance_of(Nucleus::Adapters::V1::CloudFoundryV2).to receive(:auth_client) do
-        oauth = double(Nucleus::Adapters::OAuth2AuthClient)
-        allow(oauth).to receive(:authenticate) { oauth }
-        allow(oauth).to receive(:auth_header) { { 'Authorization' => 'bearer 0987654321' } }
-        allow(oauth).to receive(:refresh) { oauth }
-        oauth
-      end
-
-      allow_any_instance_of(Nucleus::Adapters::V1::Heroku).to receive(:applications).and_wrap_original do |m, _|
-        unless m.receiver.send(:headers)['Authorization'] == 'bearer 1234567890'
-          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
-        end
-        []
-      end
-      call_count = 0
-      allow_any_instance_of(Nucleus::Adapters::V1::CloudFoundryV2).to receive(:applications).and_wrap_original do |m, _|
-        unless m.receiver.send(:headers)['Authorization'] == 'bearer 0987654321'
-          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
-        end
-        call_count += 1
-        fail Nucleus::Errors::EndpointAuthenticationError, 'Fail 1st attempt' if call_count == 1
-        []
-      end
-    end
-    it 'credentials are not re-used for different requests' do
-      headers_a = { 'HTTP_AUTHORIZATION' => 'Basic ' + ['username_a:password_a'].pack('m*').gsub(/\n/, '') }
-      get "/endpoints/#{endpoint_a.id}/applications", headers_a
-      expect(response.status).to eq(200)
-
-      headers_b = { 'HTTP_AUTHORIZATION' => 'Basic ' + ['username_b:password_b'].pack('m*').gsub(/\n/, '') }
-      get "/endpoints/#{endpoint_b.id}/applications", headers_b
-      expect(response.status).to eq(200)
-    end
-  end
-end
+require 'spec/integration/integration_spec_helper'
+
+describe Nucleus::API::V1::Auth do
+  after { Nucleus::TestDataGenerator.clean }
+
+  let!(:vendor_a) { create(:vendor) }
+  let!(:vendor_b) { create(:vendor) }
+  let!(:provider_a) { create(:provider, vendor: vendor_a.id) }
+  let!(:provider_b) { create(:provider, vendor: vendor_b.id) }
+  let!(:endpoint_a) { create(:endpoint, provider: provider_a.id) }
+  let!(:endpoint_b) { create(:endpoint, provider: provider_b.id) }
+  let!(:adapter_a) { create(:adapter, id: endpoint_a.id, adapter_clazz: Nucleus::Adapters::V1::Heroku) }
+  let!(:adapter_b) { create(:adapter, id: endpoint_b.id, adapter_clazz: Nucleus::Adapters::V1::CloudFoundryV2) }
+
+  # tests case when 'use RequestStore::Middleware' was not applied
+  context 'With alternating endpoint requests' do
+    before do
+      allow_any_instance_of(Nucleus::Adapters::V1::Heroku).to receive(:auth_client) do
+        token_auth = double(Nucleus::Adapters::TokenAuthClient)
+        allow(token_auth).to receive(:authenticate) { token_auth }
+        allow(token_auth).to receive(:auth_header) { { 'Authorization' => 'bearer 1234567890' } }
+        token_auth
+      end
+      allow_any_instance_of(Nucleus::Adapters::V1::CloudFoundryV2).to receive(:auth_client) do
+        oauth = double(Nucleus::Adapters::OAuth2AuthClient)
+        allow(oauth).to receive(:authenticate) { oauth }
+        allow(oauth).to receive(:auth_header) { { 'Authorization' => 'bearer 0987654321' } }
+        allow(oauth).to receive(:refresh) { oauth }
+        oauth
+      end
+
+      allow_any_instance_of(Nucleus::Adapters::V1::Heroku).to receive(:applications).and_wrap_original do |m, _|
+        unless m.receiver.send(:headers)['Authorization'] == 'bearer 1234567890'
+          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
+        end
+        []
+      end
+      call_count = 0
+      allow_any_instance_of(Nucleus::Adapters::V1::CloudFoundryV2).to receive(:applications).and_wrap_original do |m, _|
+        unless m.receiver.send(:headers)['Authorization'] == 'bearer 0987654321'
+          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
+        end
+        call_count += 1
+        fail Nucleus::Errors::EndpointAuthenticationError, 'Fail 1st attempt' if call_count == 1
+        []
+      end
+    end
+    it 'credentials are not re-used for different requests' do
+      headers_a = { 'HTTP_AUTHORIZATION' => 'Basic ' + ['username_a:password_a'].pack('m*').delete("\n") }
+      get "/endpoints/#{endpoint_a.id}/applications", headers_a
+      expect(response.status).to eq(200)
+
+      headers_b = { 'HTTP_AUTHORIZATION' => 'Basic ' + ['username_b:password_b'].pack('m*').delete("\n") }
+      get "/endpoints/#{endpoint_b.id}/applications", headers_b
+      expect(response.status).to eq(200)
+    end
+  end
+end

data/spec/test_suites.rake

@@ -1,31 +1,31 @@
-require 'rspec/core/rake_task'
-
-SPEC_SUITES = [
-  { id: :unit, title: 'unit tests', pattern: 'spec/unit/**/*_spec.rb' },
-  { id: :adapters, title: 'adapter tests', pattern: 'spec/adapter/**/*_spec.rb' },
-  { id: :integration, title: 'integration tests', pattern: 'spec/integration/**/*_spec.rb' }
-]
-
-namespace :spec do
-  namespace :suite do
-    SPEC_SUITES.each do |suite|
-      desc "Run all specs in #{suite[:title]} spec suite"
-      RSpec::Core::RakeTask.new(suite[:id]) do |t|
-        t.pattern = suite[:pattern]
-        t.verbose = false
-        t.fail_on_error = false
-      end
-    end
-    desc 'Run all spec suites'
-    task :all do
-      require 'English'
-      failed = []
-      SPEC_SUITES.each do |suite|
-        p "Running spec suite #{suite[:id]} ..."
-        Rake::Task["spec:suite:#{suite[:id]}"].execute
-        failed << suite[:id] unless $CHILD_STATUS.success?
-      end
-      fail "Spec suite#{failed.length > 1 ? 's' : ''} '#{failed.join(', ')}' failed" unless failed.empty?
-    end
-  end
-end
+require 'rspec/core/rake_task'
+
+SPEC_SUITES = [
+  { id: :unit, title: 'unit tests', pattern: 'spec/unit/**/*_spec.rb' },
+  { id: :adapters, title: 'adapter tests', pattern: 'spec/adapter/**/*_spec.rb' },
+  { id: :integration, title: 'integration tests', pattern: 'spec/integration/**/*_spec.rb' }
+].freeze
+
+namespace :spec do
+  namespace :suite do
+    SPEC_SUITES.each do |suite|
+      desc "Run all specs in #{suite[:title]} spec suite"
+      RSpec::Core::RakeTask.new(suite[:id]) do |t|
+        t.pattern = suite[:pattern]
+        t.verbose = false
+        t.fail_on_error = false
+      end
+    end
+    desc 'Run all spec suites'
+    task :all do
+      require 'English'
+      failed = []
+      SPEC_SUITES.each do |suite|
+        p "Running spec suite #{suite[:id]} ..."
+        Rake::Task["spec:suite:#{suite[:id]}"].execute
+        failed << suite[:id] unless $CHILD_STATUS.success?
+      end
+      fail "Spec suite#{failed.length > 1 ? 's' : ''} '#{failed.join(', ')}' failed" unless failed.empty?
+    end
+  end
+end

data/spec/unit/common/helpers/auth_helper_spec.rb

@@ -1,73 +1,73 @@
-require 'spec_helper'
-
-describe Nucleus::Adapters::AuthenticationRetryWrapper do
-  let!(:adapter) { double('adapter') }
-  let!(:auth_client) { double('auth_client') }
-  let!(:calculator) { double('calculator') }
-  let!(:user) { 'my fictionary user' }
-  let!(:pass) { 'my fictionary password' }
-  let!(:fake_env) { { 'HTTP_AUTHORIZATION' => 'Basic ' + ["#{user}:#{pass}"].pack('m*').gsub(/\n/, '') } }
-  before do
-    cache_key = 'a unique cache key!'
-    cache_dao = double(Nucleus::API::DB::CacheDao)
-    allow(cache_dao).to receive(:get) do |key|
-      key.end_with?('adapter') ? adapter : cache_key
-    end
-    RequestStore.store[:cache_key] = cache_key
-    allow(adapter).to receive(:cache)
-    allow(adapter).to receive(:cache_key)
-    allow(adapter).to receive(:cached) { auth_client }
-  end
-
-  describe '#with_authentication' do
-    context 'when cache is outdated' do
-      before do
-        counted = 0
-        expect  = 1
-        allow(calculator).to receive(:calc) do
-          fail(Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client)) if (counted += 1) <= expect
-          1
-        end
-      end
-
-      context 'and refresh was ok' do
-        it 'response is returned in repeated call' do
-          expect(auth_client).to receive(:refresh).once
-          expect(calculator).to receive(:calc).exactly(2).times
-          Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
-        end
-      end
-      context 'and refresh failed' do
-        before do
-          allow(auth_client).to receive(:refresh).and_raise(
-            Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client))
-        end
-        context 'but authentication succeeded' do
-          before { allow(adapter).to receive(:authenticate) { 'authentication result' } }
-          it 'response is returned in repeated call after the authentication' do
-            expect(auth_client).to receive(:authenticate).once
-            expect(calculator).to receive(:calc).exactly(2).times
-            Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
-          end
-        end
-        context 'and authentication failed' do
-          it 'finally fails' do
-            expect(auth_client).to receive(:authenticate).once.and_raise(Nucleus::Errors::EndpointAuthenticationError,
-                                                                         'error')
-            expect(calculator).to receive(:calc).exactly(1).times
-            expect do
-              Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
-            end.to raise_error(Nucleus::Errors::EndpointAuthenticationError)
-          end
-        end
-      end
-    end
-  end
-
-  describe '#re_authenticate' do
-    it 'calls authentication on the adapter' do
-      expect(auth_client).to receive(:authenticate).once.with(user, pass)
-      Nucleus::Adapters::AuthenticationRetryWrapper.re_authenticate(adapter, fake_env)
-    end
-  end
-end
+require 'spec_helper'
+
+describe Nucleus::Adapters::AuthenticationRetryWrapper do
+  let!(:adapter) { double('adapter') }
+  let!(:auth_client) { double('auth_client') }
+  let!(:calculator) { double('calculator') }
+  let!(:user) { 'my fictionary user' }
+  let!(:pass) { 'my fictionary password' }
+  let!(:fake_env) { { 'HTTP_AUTHORIZATION' => 'Basic ' + ["#{user}:#{pass}"].pack('m*').delete("\n") } }
+  before do
+    cache_key = 'a unique cache key!'
+    cache_dao = double(Nucleus::API::DB::CacheDao)
+    allow(cache_dao).to receive(:get) do |key|
+      key.end_with?('adapter') ? adapter : cache_key
+    end
+    RequestStore.store[:cache_key] = cache_key
+    allow(adapter).to receive(:cache)
+    allow(adapter).to receive(:cache_key)
+    allow(adapter).to receive(:cached) { auth_client }
+  end
+
+  describe '#with_authentication' do
+    context 'when cache is outdated' do
+      before do
+        counted = 0
+        expect  = 1
+        allow(calculator).to receive(:calc) do
+          fail(Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client)) if (counted += 1) <= expect
+          1
+        end
+      end
+
+      context 'and refresh was ok' do
+        it 'response is returned in repeated call' do
+          expect(auth_client).to receive(:refresh).once
+          expect(calculator).to receive(:calc).exactly(2).times
+          Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+        end
+      end
+      context 'and refresh failed' do
+        before do
+          allow(auth_client).to receive(:refresh).and_raise(
+            Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client))
+        end
+        context 'but authentication succeeded' do
+          before { allow(adapter).to receive(:authenticate) { 'authentication result' } }
+          it 'response is returned in repeated call after the authentication' do
+            expect(auth_client).to receive(:authenticate).once
+            expect(calculator).to receive(:calc).exactly(2).times
+            Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+          end
+        end
+        context 'and authentication failed' do
+          it 'finally fails' do
+            expect(auth_client).to receive(:authenticate).once.and_raise(Nucleus::Errors::EndpointAuthenticationError,
+                                                                         'error')
+            expect(calculator).to receive(:calc).exactly(1).times
+            expect do
+              Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+            end.to raise_error(Nucleus::Errors::EndpointAuthenticationError)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#re_authenticate' do
+    it 'calls authentication on the adapter' do
+      expect(auth_client).to receive(:authenticate).once.with(user, pass)
+      Nucleus::Adapters::AuthenticationRetryWrapper.re_authenticate(adapter, fake_env)
+    end
+  end
+end

data/spec/unit/common/oauth2_auth_client_spec.rb

@@ -6,7 +6,7 @@ describe Nucleus::Adapters::OAuth2AuthClient do
       url = 'theurl'
       check_certs = false
       client = Nucleus::Adapters::OAuth2AuthClient.new url, check_certs
-      expect(client.instance_variable_get :@auth_url).to be url
+      expect(client.instance_variable_get(:@auth_url)).to be url
       expect(client.verify_ssl).to be check_certs
     end
   end

data/tasks/compatibility.rake

@@ -1,113 +1,113 @@
-require 'rspec/core/rake_task'
-
-namespace :evaluation do
-  namespace :compatibility do
-    task load: :environment do
-      # TODO: choose API version
-      api_version = 'v1'
-      stub = Nucleus::Adapters.const_get(api_version.upcase).const_get('Stub').new 'https://api.example.org'
-
-      adapter_dao = Nucleus::API::DB::AdapterDao.instance(api_version)
-      endpoint_dao = Nucleus::API::DB::EndpointDao.instance(api_version)
-      provider_dao = Nucleus::API::DB::ProviderDao.instance(api_version)
-      vendor_dao = Nucleus::API::DB::VendorDao.instance(api_version)
-      @vendor_results = {}
-
-      adapter_dao.all.each do |adapter_index_entry|
-        vendor_name = vendor_dao.get(provider_dao.get(endpoint_dao.get(adapter_index_entry.id).provider).vendor).name
-        next if @vendor_results.key?(vendor_name)
-        adapter_results = {}
-        adapter = adapter_index_entry.adapter_clazz.new('https://api.example.org', 'http://apps.example.org', true)
-        stub.public_methods(false).each do |method_name|
-          args = []
-          method = stub.method(method_name)
-          method.arity.times { |time| args.push(time) }
-          begin
-            adapter.send(method_name, *args)
-            implemented = true
-          rescue Nucleus::Errors::AdapterMissingImplementationError
-            implemented = false
-          rescue StandardError
-            implemented = true
-          end
-          adapter_results[method_name] = implemented
-        end
-        @vendor_results[vendor_name] = adapter_results
-      end
-    end
-
-    task markdown: :load do
-      # table header
-      puts "Method / Vendor|#{@vendor_results.keys.join('|')}"
-
-      # column styles
-      alignment = ':--'
-      @vendor_results.length.times { |_time| alignment << '|:-:' }
-      puts alignment
-
-      lines = []
-      @vendor_results.each do |_vendor, results|
-        results.each_with_index do |(method, supported), line|
-          lines[line] = "#{method}" unless lines[line]
-          lines[line] << "|#{supported ? '&#10003;' : '&#10007;'}"
-        end
-      end
-
-      lines.each do |line|
-        puts line
-      end
-    end
-
-    task :latex, [:save_to] => :load do |_t, args|
-      all_lines = []
-      all_lines << "\\begin{longtable}{|L{7cm}|#{'c|' * @vendor_results.length}}"
-      next_line = '  \\multicolumn{1}{l}{\\Large{\\textbf{Adapter compatibility}}}'
-      @vendor_results.keys.each do |vendor|
-        next_line += " & \\multicolumn{1}{l}{\\turn{60}{#{vendor}}}"
-      end
-      next_line += ' \\\\\\hline'
-      all_lines << next_line
-      all_lines << '  \\endhead'
-      all_lines << '  \\rowcolor{white}'
-      all_lines << '  \\caption{List of methods that are supported by Nucleus per vendor}'\
-        '\\label{table:evaluation_adapter_compatibility}%'
-      all_lines << '  \\endlastfoot'
-
-      lines = []
-      @vendor_results.each do |_vendor, results|
-        results.each_with_index do |(method, supported), line|
-          lines[line] = "#{method}" unless lines[line]
-          lines[line] << " & #{supported ? '\\ding{51}' : '\\cellcolor{failedtablebg}\\ding{55}'}"
-        end
-      end
-
-      # format and print all lines
-      lines.each_with_index do |line, index|
-        if index != lines.length - 1
-          all_lines << "  #{line.gsub(/_/, '\_')} \\\\\\hline"
-        else
-          # special treatment for the last line
-          all_lines << "  #{line.gsub(/_/, '\_')} \\\\\\hhline{|=|#{'=|' * @vendor_results.length}}"
-        end
-      end
-
-      # print general statistics
-      total_methods = @vendor_results.collect { |_v, tests| tests.length }.uniq.first
-      supported_count = @vendor_results.collect { |_v, tests| tests.find_all { |_m, s| s }.length }
-      all_lines << "  Supported methods & #{supported_count.join(' & ')} \\\\\\hline"
-      to_print = supported_count.collect do |supported|
-        "#{format('%g', format('%.1f', (supported / total_methods.to_f * 100)))} \\%"
-      end
-
-      all_lines << "  Supported degree & #{to_print.join(' & ')} \\\\\\hline"
-
-      all_lines << '\\end{longtable}'
-
-      # print lines
-      all_lines.each { |line| puts line }
-
-      # and save to file if requested
-      File.open(args.save_to, 'w') { |file| file.write all_lines.join("\n") } if args.save_to
-    end
-  end
-end
+require 'rspec/core/rake_task'
+
+namespace :evaluation do
+  namespace :compatibility do
+    task load: :environment do
+      # TODO: choose API version
+      api_version = 'v1'
+      stub = Nucleus::Adapters.const_get(api_version.upcase).const_get('Stub').new 'https://api.example.org'
+
+      adapter_dao = Nucleus::API::DB::AdapterDao.instance(api_version)
+      endpoint_dao = Nucleus::API::DB::EndpointDao.instance(api_version)
+      provider_dao = Nucleus::API::DB::ProviderDao.instance(api_version)
+      vendor_dao = Nucleus::API::DB::VendorDao.instance(api_version)
+      @vendor_results = {}
+
+      adapter_dao.all.each do |adapter_index_entry|
+        vendor_name = vendor_dao.get(provider_dao.get(endpoint_dao.get(adapter_index_entry.id).provider).vendor).name
+        next if @vendor_results.key?(vendor_name)
+        adapter_results = {}
+        adapter = adapter_index_entry.adapter_clazz.new('https://api.example.org', 'http://apps.example.org', true)
+        stub.public_methods(false).each do |method_name|
+          args = []
+          method = stub.method(method_name)
+          method.arity.times { |time| args.push(time) }
+          begin
+            adapter.send(method_name, *args)
+            implemented = true
+          rescue Nucleus::Errors::AdapterMissingImplementationError
+            implemented = false
+          rescue StandardError
+            implemented = true
+          end
+          adapter_results[method_name] = implemented
+        end
+        @vendor_results[vendor_name] = adapter_results
+      end
+    end
+
+    task markdown: :load do
+      # table header
+      puts "Method / Vendor|#{@vendor_results.keys.join('|')}"
+
+      # column styles
+      alignment = ':--'
+      @vendor_results.length.times { |_time| alignment << '|:-:' }
+      puts alignment
+
+      lines = []
+      @vendor_results.each do |_vendor, results|
+        results.each_with_index do |(method, supported), line|
+          lines[line] = method.to_s unless lines[line]
+          lines[line] << "|#{supported ? '&#10003;' : '&#10007;'}"
+        end
+      end
+
+      lines.each do |line|
+        puts line
+      end
+    end
+
+    task :latex, [:save_to] => :load do |_t, args|
+      all_lines = []
+      all_lines << "\\begin{longtable}{|L{7cm}|#{'c|' * @vendor_results.length}}"
+      next_line = '  \\multicolumn{1}{l}{\\Large{\\textbf{Adapter compatibility}}}'
+      @vendor_results.keys.each do |vendor|
+        next_line += " & \\multicolumn{1}{l}{\\turn{60}{#{vendor}}}"
+      end
+      next_line += ' \\\\\\hline'
+      all_lines << next_line
+      all_lines << '  \\endhead'
+      all_lines << '  \\rowcolor{white}'
+      all_lines << '  \\caption{List of methods that are supported by Nucleus per vendor}'\
+        '\\label{table:evaluation_adapter_compatibility}%'
+      all_lines << '  \\endlastfoot'
+
+      lines = []
+      @vendor_results.each do |_vendor, results|
+        results.each_with_index do |(method, supported), line|
+          lines[line] = method.to_s unless lines[line]
+          lines[line] << " & #{supported ? '\\ding{51}' : '\\cellcolor{failedtablebg}\\ding{55}'}"
+        end
+      end
+
+      # format and print all lines
+      lines.each_with_index do |line, index|
+        all_lines << if index != lines.length - 1
+                       "  #{line.gsub(/_/, '\_')} \\\\\\hline"
+                     else
+                       # special treatment for the last line
+                       "  #{line.gsub(/_/, '\_')} \\\\\\hhline{|=|#{'=|' * @vendor_results.length}}"
+                     end
+      end
+
+      # print general statistics
+      total_methods = @vendor_results.collect { |_v, tests| tests.length }.uniq.first
+      supported_count = @vendor_results.collect { |_v, tests| tests.find_all { |_m, s| s }.length }
+      all_lines << "  Supported methods & #{supported_count.join(' & ')} \\\\\\hline"
+      to_print = supported_count.collect do |supported|
+        "#{format('%g', format('%.1f', (supported / total_methods.to_f * 100)))} \\%"
+      end
+
+      all_lines << "  Supported degree & #{to_print.join(' & ')} \\\\\\hline"
+
+      all_lines << '\\end{longtable}'
+
+      # print lines
+      all_lines.each { |line| puts line }
+
+      # and save to file if requested
+      File.open(args.save_to, 'w') { |file| file.write all_lines.join("\n") } if args.save_to
+    end
+  end
+end