comma 4.2.0 → 4.5.0

data/spec/comma/data_extractor_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 # comma do
@@ -8,7 +10,6 @@ require 'spec_helper'
 # end
 
 describe Comma::DataExtractor do # rubocop:disable Metrics/BlockLength
-
   before do
     @isbn = Isbn.new('123123123', '321321321')
     @book = Book.new('Smalltalk-80', 'Language and Implementation', @isbn)
@@ -17,47 +18,42 @@ describe Comma::DataExtractor do # rubocop:disable Metrics/BlockLength
   end
 
   describe 'when no parameters are provided' do
-
     it 'should use the string value returned by sending the method name on the object' do
-      @data.should include('Language and Implementation')
+      expect(@data).to include('Language and Implementation')
     end
   end
 
   describe 'when given a string description as a parameter' do
-
     it 'should use the string value returned by sending the method name on the object' do
-      @data.should include('Smalltalk-80')
+      expect(@data).to include('Smalltalk-80')
     end
   end
 
   describe 'when an hash is passed as a parameter' do
-
     describe 'with a string value' do
-
       it 'should use the string value, returned by sending the hash key to the object' do
-        @data.should include('123123123')
-        @data.should include('321321321')
+        expect(@data).to include('123123123')
+        expect(@data).to include('321321321')
       end
 
       it 'should not fail when an associated object is nil' do
-        lambda { Book.new('Smalltalk-80', 'Language and Implementation', nil).to_comma }.should_not raise_error
+        expect { Book.new('Smalltalk-80', 'Language and Implementation', nil).to_comma }.not_to raise_error
       end
     end
   end
-
 end
 
 describe Comma::DataExtractor, 'id attribute' do
   before do
     @data = Class.new(Struct.new(:id)) do
       comma do
-        id 'ID' do |id| '42' end
+        id 'ID' do |_id| '42' end
       end
     end.new(1).to_comma
   end
 
   it 'id attribute should yield block' do
-    @data.should include('42')
+    expect(@data).to include('42')
   end
 end
 
@@ -68,13 +64,13 @@ describe Comma::DataExtractor, 'with static column method' do
         __static_column__
         __static_column__ 'STATIC'
         __static_column__ 'STATIC' do '' end
-        __static_column__ 'STATIC' do |o| o.name end
+        __static_column__ 'STATIC', &:name
       end
     end.new(1, 'John Doe').to_comma
   end
 
   it 'should extract headers' do
-    @data.should eq([nil, nil, '', 'John Doe'])
+    expect(@data).to eq([nil, nil, '', 'John Doe'])
   end
 end
 
@@ -84,12 +80,12 @@ describe Comma::DataExtractor, 'nil value' do
       comma do
         name
         name 'Name'
-        name 'Name' do |name| nil end
+        name 'Name' do |_name| nil end
       end
     end.new(1, nil).to_comma
   end
 
   it 'should extract nil' do
-    @data.should eq([nil, nil, nil])
+    expect(@data).to eq([nil, nil, nil])
   end
 end

data/spec/comma/header_extractor_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 # comma do
@@ -8,7 +10,6 @@ require 'spec_helper'
 # end
 
 describe Comma::HeaderExtractor do # rubocop:disable Metrics/BlockLength
-
   before do
     @isbn = Isbn.new('123123123', '321321321')
     @book = Book.new('Smalltalk-80', 'Language and Implementation', @isbn)
@@ -17,37 +18,30 @@ describe Comma::HeaderExtractor do # rubocop:disable Metrics/BlockLength
   end
 
   describe 'when no parameters are provided' do
-
     it 'should use the method name as the header name, humanized' do
-      @headers.should include('Description')
+      expect(@headers).to include('Description')
     end
   end
 
   describe 'when given a string description as a parameter' do
-
     it 'should use the string value, unmodified' do
-      @headers.should include('Title')
+      expect(@headers).to include('Title')
     end
   end
 
   describe 'when an hash is passed as a parameter' do
-
     describe 'with a string value' do
-
       it 'should use the string value, unmodified' do
-        @headers.should include('ISBN-10')
+        expect(@headers).to include('ISBN-10')
       end
     end
 
     describe 'with a non-string value' do
-
       it 'should use the non string value converted to a string, humanized' do
-        @headers.should include('Issuer')
+        expect(@headers).to include('Issuer')
       end
     end
-
   end
-
 end
 
 describe Comma::HeaderExtractor, 'with static column method' do
@@ -62,6 +56,6 @@ describe Comma::HeaderExtractor, 'with static column method' do
   end
 
   it 'should extract headers' do
-    @headers.should eq(['', 'STATIC', 'STATIC'])
+    expect(@headers).to eq(['', 'STATIC', 'STATIC'])
   end
 end

data/spec/comma/rails/active_record_spec.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 if defined? ActiveRecord
 
   describe Comma, 'generating CSV from an ActiveRecord object' do # rubocop:disable Metrics/BlockLength
-
     class Picture < ActiveRecord::Base
-      belongs_to :imageable, :polymorphic => true
+      belongs_to :imageable, polymorphic: true
 
       comma :pr_83 do
-        imageable :name => 'Picture'
+        imageable name: 'Picture'
       end
     end
 
     class Person < ActiveRecord::Base
-      scope(:teenagers, lambda { where(:age => 13..19) })
+      scope(:teenagers, -> { where(age: 13..19) })
 
       comma do
         name
@@ -26,18 +27,18 @@ if defined? ActiveRecord
         job :title
       end
 
-      has_many :pictures, :as => :imageable
+      has_many :pictures, as: :imageable
     end
 
     class Job < ActiveRecord::Base
       belongs_to :person
 
       comma do
-        person_formatter :name => 'Name'
+        person_formatter name: 'Name'
       end
 
       def person_formatter
-        @person_formatter ||= PersonFormatter.new(self.person)
+        @person_formatter ||= PersonFormatter.new(person)
       end
     end
 
@@ -52,51 +53,51 @@ if defined? ActiveRecord
     end
 
     before(:all) do
-      #Setup AR model in memory
-      ActiveRecord::Base.connection.create_table :pictures, :force => true do |table|
+      # Setup AR model in memory
+      ActiveRecord::Base.connection.create_table :pictures, force: true do |table|
         table.column :name, :string
         table.column :imageable_id, :integer
         table.column :imageable_type, :string
       end
 
-      ActiveRecord::Base.connection.create_table :people, :force => true do |table|
+      ActiveRecord::Base.connection.create_table :people, force: true do |table|
         table.column :name, :string
         table.column :age, :integer
       end
       Person.reset_column_information
 
-      ActiveRecord::Base.connection.create_table :jobs, :force => true do |table|
+      ActiveRecord::Base.connection.create_table :jobs, force: true do |table|
         table.column :person_id, :integer
         table.column :title, :string
       end
       Job.reset_column_information
 
-      @person = Person.new(:age => 18, :name => 'Junior')
-      @person.build_job(:title => 'Nice job')
+      @person = Person.new(age: 18, name: 'Junior')
+      @person.build_job(title: 'Nice job')
       @person.save!
-      Picture.create(:name => 'photo.jpg', :imageable_id => @person.id, :imageable_type => 'Person')
+      Picture.create(name: 'photo.jpg', imageable_id: @person.id, imageable_type: 'Person')
     end
 
-    describe "#to_comma on scopes" do
-      it 'should extend ActiveRecord::NamedScope::Scope to add a #to_comma method which will return CSV content for objects within the scope' do
-        Person.teenagers.to_comma.should == "Name,Age\nJunior,18\n"
+    describe '#to_comma on scopes' do
+      it 'should extend ActiveRecord::NamedScope::Scope to add a #to_comma method which will return CSV content for objects within the scope' do # rubocop:disable Metrics/LineLength
+        expect(Person.teenagers.to_comma).to eq "Name,Age\nJunior,18\n"
       end
 
       it 'should find in batches' do
         scope = Person.teenagers
-        scope.should_receive(:find_each).and_yield @person
+        expect(scope).to receive(:find_each).and_yield @person
         scope.to_comma
       end
 
       it 'should fall back to iterating with each when scope has limit clause' do
         scope = Person.limit(1)
-        scope.should_receive(:each).and_yield @person
+        expect(scope).to receive(:each).and_yield @person
         scope.to_comma
       end
 
       it 'should fall back to iterating with each when scope has order clause' do
         scope = Person.order(:age)
-        scope.should_receive(:each).and_yield @person
+        expect(scope).to receive(:each).and_yield @person
         scope.to_comma
       end
     end
@@ -112,7 +113,7 @@ if defined? ActiveRecord
             end
           end
 
-        I18n.config.backend.store_translations(:ja, {:activerecord => {:attributes => {:person => {:age => '年齢', :name => '名前'}}}})
+        I18n.config.backend.store_translations(:ja, activerecord: { attributes: { person: { age: '年齢', name: '名前' } } })
         @original_locale = I18n.locale
         I18n.locale = :ja
       end
@@ -125,25 +126,25 @@ if defined? ActiveRecord
       end
 
       it 'should i18n-ize header values' do
-        Person.teenagers.to_comma.should match(/^名前,年齢/)
+        expect(Person.teenagers.to_comma).to match(/^名前,年齢/)
       end
     end
 
     describe 'github issue 75' do
       it 'should find association' do
-        lambda { Person.all.to_comma(:issue_75) }.should_not raise_error
+        expect { Person.all.to_comma(:issue_75) }.not_to raise_error
       end
     end
 
     describe 'with accessor' do
       it 'should not raise exception' do
-        Job.all.to_comma.should eq("Name\nJunior\n")
+        expect(Job.all.to_comma).to eq("Name\nJunior\n")
       end
     end
 
     describe 'github pull-request 83' do
       it 'should not raise NameError' do
-        lambda { Picture.all.to_comma(:pr_83) }.should_not raise_exception(NameError)
+        expect { Picture.all.to_comma(:pr_83) }.not_to raise_error
       end
     end
   end
@@ -174,29 +175,29 @@ if defined? ActiveRecord
     end
 
     before(:all) do
-      #Setup AR model in memory
-      ActiveRecord::Base.connection.create_table :animals, :force => true do |table|
+      # Setup AR model in memory
+      ActiveRecord::Base.connection.create_table :animals, force: true do |table|
         table.column :name, :string
         table.column :type, :string
       end
 
-      @dog = Dog.new(:name => 'Rex')
+      @dog = Dog.new(name: 'Rex')
       @dog.save!
-      @cat = Cat.new(:name => 'Kitty')
+      @cat = Cat.new(name: 'Kitty')
       @cat.save!
     end
 
     it 'should return and array of data content, as defined in comma block in child class' do
-      @dog.to_comma.should == %w[Dog-Rex]
+      expect(@dog.to_comma).to eq %w[Dog-Rex]
     end
 
-    #FIXME: this one is failing - the comma block from Dog is executed instead of the one from the super class
+    # FIXME: this one is failing - the comma block from Dog is executed instead of the one from the super class
     it 'should return and array of data content, as defined in comma block in super class, if not present in child' do
-      @cat.to_comma.should == %w[Super-Kitty]
+      expect(@cat.to_comma).to eq %w[Super-Kitty]
     end
 
     it 'should call definion in parent class' do
-      lambda { @dog.to_comma(:with_type) }.should_not raise_error
+      expect { @dog.to_comma(:with_type) }.not_to raise_error
     end
   end
 end

data/spec/comma/rails/data_mapper_collection_spec.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 if defined? DataMapper
 
   describe Comma, 'generating CSV from an DataMapper object' do # rubocop:disable Metrics/BlockLength
-
     class Person
       include DataMapper::Resource
 
@@ -30,9 +31,9 @@ if defined? DataMapper
     after(:all) do
     end
 
-    describe "case" do
+    describe 'case' do
       before do
-        @person = Person.new(:age => 18, :name => 'Junior')
+        @person = Person.new(age: 18, name: 'Junior')
         @person.save
       end
 

data/spec/comma/rails/mongoid_spec.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 if defined? Mongoid
 
   describe Comma, 'generating CSV from an Mongoid object' do
-
     class Person
       include Mongoid::Document
 
-      field :name, :type => String
-      field :age, :type => Integer
+      field :name, type: String
+      field :age, type: Integer
 
-      scope :teenagers, between(:age => 13..19)
+      scope :teenagers, between(age: 13..19)
 
       comma do
         name
@@ -22,13 +23,13 @@ if defined? Mongoid
       Mongoid.purge!
     end
 
-    describe "case" do
+    describe 'case' do
       before do
-        @person = Person.new(:age => 18, :name => 'Junior')
+        @person = Person.new(age: 18, name: 'Junior')
         @person.save
       end
 
-      it 'should extend ActiveRecord::NamedScope::Scope to add a #to_comma method which will return CSV content for objects within the scope' do
+      it 'should extend ActiveRecord::NamedScope::Scope to add a #to_comma method which will return CSV content for objects within the scope' do # rubocop:disable Metrics/LineLength
         Person.teenagers.to_comma.should == "Name,Age\nJunior,18\n"
       end
 

data/spec/controllers/users_controller_spec.rb

@@ -1,69 +1,66 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 if defined?(Rails)
 
   RSpec.describe UsersController, type: :controller do # rubocop:disable Metrics/BlockLength
-
-    describe "rails setup" do
-
+    describe 'rails setup' do
       it 'should capture the CSV renderer provided by Rails' do
         mock_users = [mock_model(User), mock_model(User)]
         allow(User).to receive(:all).and_return(mock_users)
 
-        mock_users.should_receive(:to_comma).once
+        expect(mock_users).to receive(:to_comma).once
 
-        get :index, :format => :csv
+        get :index, format: :csv
       end
-
     end
 
-    describe "controller" do # rubocop:disable Metrics/BlockLength
+    describe 'controller' do # rubocop:disable Metrics/BlockLength
       before(:all) do
-        @user_1 = User.create!(:first_name => 'Fred', :last_name => 'Flintstone')
-        @user_2 = User.create!(:first_name => 'Wilma', :last_name => 'Flintstone')
+        @user_1 = User.create!(first_name: 'Fred', last_name: 'Flintstone')
+        @user_2 = User.create!(first_name: 'Wilma', last_name: 'Flintstone')
       end
 
       it 'should not affect html requested' do
         get :index
 
-        response.status.should eq 200
-        response.content_type.should eq 'text/html'
-        response.body.should          == 'Users!'
+        expect(response.status).to eq 200
+        expect(response.media_type).to eq 'text/html'
+        expect(response.body).to eq 'Users!'
       end
 
-      it "should return a csv when requested" do
-        get :index, :format => :csv
+      it 'should return a csv when requested' do
+        get :index, format: :csv
 
-        response.status.should eq 200
-        response.content_type.should eq 'text/csv'
-        response.header["Content-Disposition"].should include('filename="data.csv"')
+        expect(response.status).to eq 200
+        expect(response.media_type).to eq 'text/csv'
+        expect(response.header['Content-Disposition']).to include('filename="data.csv"')
 
-        expected_content =<<-CSV.gsub(/^\s+/,'')
+        expected_content = <<-CSV.gsub(/^\s+/, '')
         First name,Last name,Name
         Fred,Flintstone,Fred Flintstone
         Wilma,Flintstone,Wilma Flintstone
         CSV
 
-        response.body.should              == expected_content
+        expect(response.body).to eq expected_content
       end
 
       describe 'with comma options' do
-
         it 'should allow the style to be chosen from the renderer' do
-          #Must be passed in same format (string/symbol) eg:
+          # Must be passed in same format (string/symbol) eg:
           # format.csv  { render User.all, :style => :shortened }
 
-          get :with_custom_style, :format => :csv
+          get :with_custom_style, format: :csv
 
-          expected_content =<<-CSV.gsub(/^\s+/,'')
+          expected_content = <<-CSV.gsub(/^\s+/, '')
           First name,Last name
           Fred,Flintstone
           Wilma,Flintstone
           CSV
 
-          response.body.should              == expected_content
+          expect(response.body).to eq expected_content
         end
-
       end
 
       describe 'with custom options' do # rubocop:disable Metrics/BlockLength
@@ -80,105 +77,121 @@ if defined?(Rails)
         end
 
         it 'should allow a filename to be set' do
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :filename => 'my_custom_name' } }
+          get_ :with_custom_options, format: :csv, params: { custom_options: { filename: 'my_custom_name' } }
 
-          response.status.should eq 200
-          response.content_type.should eq 'text/csv'
-          response.header["Content-Disposition"].should include('filename="my_custom_name.csv"')
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/csv'
+          expect(response.header['Content-Disposition']).to include('filename="my_custom_name.csv"')
         end
 
-        it "should allow a custom filename with spaces" do
+        it 'should allow a custom filename with spaces' do
           require 'shellwords'
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :filename => 'filename with a lot of spaces' } }
+          params = { custom_options: { filename: 'filename with a lot of spaces' } }
+          get_ :with_custom_options, format: :csv, params: params
 
-          response.status.should eq 200
-          response.content_type.should eq 'text/csv'
-          response.header["Content-Disposition"].should include('filename="filename with a lot of spaces.csv"')
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/csv'
+          expect(response.header['Content-Disposition']).to include('filename="filename with a lot of spaces.csv"')
 
-          filename_string = response.header["Content-Disposition"].split('=').last
+          filename_string = response.header['Content-Disposition'].split('=').last
           # shellsplit honors quoted strings
-          filename_string.shellsplit.length.should == 1
+          expect(filename_string.shellsplit.length).to eq 1
         end
 
         it 'should allow a file extension to be set' do
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :extension => :txt } }
+          get_ :with_custom_options, format: :csv, params: { custom_options: { extension: :txt } }
 
-          response.status.should eq 200
-          response.content_type.should eq 'text/csv'
-          response.header["Content-Disposition"].should include('filename="data.txt"')
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/csv'
+          expect(response.header['Content-Disposition']).to include('filename="data.txt"')
         end
 
         it 'should allow mime type to be set' do
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :mime_type => 'text/plain' } }
-          response.status.should eq 200
-          response.content_type.should      == 'text/plain'
+          get_ :with_custom_options, format: :csv, params: { custom_options: { mime_type: 'text/plain' } }
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/plain'
         end
 
-        describe 'headers' do
+        it 'should allow bom to be set' do
+          get_ :with_custom_options, format: :csv, params: { custom_options: { with_bom: true } }
+
+          expected_content = <<-CSV.gsub(/^\s+/, '')
+          \xEF\xBB\xBFFirst name,Last name,Name
+          Fred,Flintstone,Fred Flintstone
+          Wilma,Flintstone,Wilma Flintstone
+          CSV
 
+          expect(response.body). to eq expected_content
+        end
+
+        describe 'headers' do
           it 'should allow toggling on' do
-            get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :write_headers => 'true' } }
+            get_ :with_custom_options, format: :csv, params: { custom_options: { write_headers: 'true' } }
 
-            response.status.should eq 200
-            response.content_type.should eq 'text/csv'
+            expect(response.status).to eq 200
+            expect(response.media_type).to eq 'text/csv'
 
-            expected_content =<<-CSV.gsub(/^\s+/,'')
+            expected_content = <<-CSV.gsub(/^\s+/, '')
             First name,Last name,Name
             Fred,Flintstone,Fred Flintstone
             Wilma,Flintstone,Wilma Flintstone
             CSV
 
-            response.body.should              == expected_content
+            expect(response.body).to eq expected_content
           end
 
           it 'should allow toggling off' do
-            get_ :with_custom_options, :format => :csv, :params => { :custom_options => {:write_headers => false} }
+            get_ :with_custom_options, format: :csv, params: { custom_options: { write_headers: false } }
 
-            response.status.should eq 200
-            response.content_type.should eq 'text/csv'
+            expect(response.status).to eq 200
+            expect(response.media_type).to eq 'text/csv'
 
-            expected_content =<<-CSV.gsub(/^\s+/,'')
+            expected_content = <<-CSV.gsub(/^\s+/, '')
             Fred,Flintstone,Fred Flintstone
             Wilma,Flintstone,Wilma Flintstone
             CSV
 
-            response.body.should              == expected_content
+            expect(response.body).to eq expected_content
           end
-
         end
 
         it 'should allow forcing of quotes' do
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :force_quotes => true } }
+          get_ :with_custom_options, format: :csv, params: { custom_options: { force_quotes: true } }
 
-          response.status.should eq 200
-          response.content_type.should eq 'text/csv'
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/csv'
 
-          expected_content =<<-CSV.gsub(/^\s+/,'')
+          expected_content = <<-CSV.gsub(/^\s+/, '')
           "First name","Last name","Name"
           "Fred","Flintstone","Fred Flintstone"
           "Wilma","Flintstone","Wilma Flintstone"
           CSV
 
-          response.body.should              == expected_content
+          expect(response.body).to eq expected_content
         end
 
         it 'should allow combinations of options' do
-          get_ :with_custom_options, :format => :csv, :params => { :custom_options => { :write_headers => false, :force_quotes => true, :col_sep => '||', :row_sep => "ENDOFLINE\n" } }
-
-          response.status.should eq 200
-          response.content_type.should eq 'text/csv'
-
-          expected_content =<<-CSV.gsub(/^\s+/,'')
+          params = {
+            custom_options: {
+              write_headers: false,
+              force_quotes: true,
+              col_sep: '||',
+              row_sep: "ENDOFLINE\n"
+            }
+          }
+          get_ :with_custom_options, format: :csv, params: params
+
+          expect(response.status).to eq 200
+          expect(response.media_type).to eq 'text/csv'
+
+          expected_content = <<-CSV.gsub(/^\s+/, '')
           "Fred"||"Flintstone"||"Fred Flintstone"ENDOFLINE
           "Wilma"||"Flintstone"||"Wilma Flintstone"ENDOFLINE
           CSV
 
-          response.body.should              == expected_content
+          expect(response.body).to eq expected_content
         end
-
       end
-
     end
-
   end
 end