spec/happymapper_spec.rb in nokogiri-happymapper-0.7.0 vs spec/happymapper_spec.rb in nokogiri-happymapper-0.8.0

@@ -549,139 +549,139 @@
   element :author, String, namespace: 'p', tag: 'author'
 end
 
 describe HappyMapper do
   describe 'being included into another class' do
-    before do
-      @klass = Class.new do
+    let(:klass) do
+      Class.new do
         include HappyMapper
 
         def self.name
           'Boo'
         end
       end
     end
 
-    it 'should set attributes to an array' do
-      expect(@klass.attributes).to eq([])
+    it 'sets attributes to an array' do
+      expect(klass.attributes).to eq([])
     end
 
-    it 'should set @elements to a hash' do
-      expect(@klass.elements).to eq([])
+    it 'sets @elements to a hash' do
+      expect(klass.elements).to eq([])
     end
 
-    it 'should allow adding an attribute' do
+    it 'allows adding an attribute' do
       expect do
-        @klass.attribute :name, String
-      end.to change(@klass, :attributes)
+        klass.attribute :name, String
+      end.to change(klass, :attributes)
     end
 
-    it 'should allow adding an attribute containing a dash' do
+    it 'allows adding an attribute containing a dash' do
       expect do
-        @klass.attribute :'bar-baz', String
-      end.to change(@klass, :attributes)
+        klass.attribute :'bar-baz', String
+      end.to change(klass, :attributes)
     end
 
-    it 'should be able to get all attributes in array' do
-      @klass.attribute :name, String
-      expect(@klass.attributes.size).to eq(1)
+    it 'is able to get all attributes in array' do
+      klass.attribute :name, String
+      expect(klass.attributes.size).to eq(1)
     end
 
-    it 'should allow adding an element' do
+    it 'allows adding an element' do
       expect do
-        @klass.element :name, String
-      end.to change(@klass, :elements)
+        klass.element :name, String
+      end.to change(klass, :elements)
     end
 
-    it 'should allow adding an element containing a dash' do
+    it 'allows adding an element containing a dash' do
       expect do
-        @klass.element :'bar-baz', String
-      end.to change(@klass, :elements)
+        klass.element :'bar-baz', String
+      end.to change(klass, :elements)
     end
 
-    it 'should be able to get all elements in array' do
-      @klass.element(:name, String)
-      expect(@klass.elements.size).to eq(1)
+    it 'is able to get all elements in array' do
+      klass.element(:name, String)
+      expect(klass.elements.size).to eq(1)
     end
 
-    it 'should allow has one association' do
-      @klass.has_one(:user, User)
-      element = @klass.elements.first
+    it 'allows has one association' do
+      klass.has_one(:user, User)
+      element = klass.elements.first
       expect(element.name).to eq('user')
       expect(element.type).to eq(User)
       expect(element.options[:single]).to eq(true)
     end
 
-    it 'should allow has many association' do
-      @klass.has_many(:users, User)
-      element = @klass.elements.first
+    it 'allows has many association' do
+      klass.has_many(:users, User)
+      element = klass.elements.first
       expect(element.name).to eq('users')
       expect(element.type).to eq(User)
       expect(element.options[:single]).to eq(false)
     end
 
-    it 'should default tag name to lowercase class' do
-      expect(@klass.tag_name).to eq('boo')
+    it 'defaults tag name to lowercase class' do
+      expect(klass.tag_name).to eq('boo')
     end
 
     it 'generates no tag name for anonymous class' do
       @anon = Class.new { include HappyMapper }
       expect(@anon.tag_name).to be_nil
     end
 
-    it 'should default tag name of class in modules to the last constant lowercase' do
+    it 'defaults tag name of class in modules to the last constant lowercase' do
       module Bar; class Baz; include HappyMapper; end; end
       expect(Bar::Baz.tag_name).to eq('baz')
     end
 
-    it 'should allow setting tag name' do
-      @klass.tag('FooBar')
-      expect(@klass.tag_name).to eq('FooBar')
+    it 'allows setting tag name' do
+      klass.tag('FooBar')
+      expect(klass.tag_name).to eq('FooBar')
     end
 
-    it 'should allow setting a namespace' do
-      @klass.namespace(namespace = 'boo')
-      expect(@klass.namespace).to eq(namespace)
+    it 'allows setting a namespace' do
+      klass.namespace(namespace = 'boo')
+      expect(klass.namespace).to eq(namespace)
     end
 
-    it 'should provide #parse' do
-      expect(@klass).to respond_to(:parse)
+    it 'provides #parse' do
+      expect(klass).to respond_to(:parse)
     end
   end
 
   describe '#attributes' do
-    it 'should only return attributes for the current class' do
+    it 'onlies return attributes for the current class' do
       expect(Post.attributes.size).to eq(7)
       expect(Status.attributes.size).to eq(0)
     end
   end
 
   describe '#elements' do
-    it 'should only return elements for the current class' do
+    it 'onlies return elements for the current class' do
       expect(Post.elements.size).to eq(0)
       expect(Status.elements.size).to eq(10)
     end
   end
 
   describe '#content' do
-    it 'should take String as default argument for type' do
+    it 'takes String as default argument for type' do
       State.content :name
       address = Address.parse(fixture_file('address.xml'))
       expect(address.state.name).to eq('Lower Saxony')
       address.state.name.class == String
     end
 
-    it 'should work when specific type is provided' do
+    it 'works when specific type is provided' do
       Rate.content :value, Float
       Product.has_one :rate, Rate
       product = Product.parse(fixture_file('product_default_namespace.xml'), single: true)
       expect(product.rate.value).to eq(120.25)
       product.rate.class == Float
     end
   end
 
-  it 'should parse xml attributes into ruby objects' do
+  it 'parses xml attributes into ruby objects' do
     posts = Post.parse(fixture_file('posts.xml'))
     expect(posts.size).to eq(20)
     first = posts.first
     expect(first.href).to eq('http://roxml.rubyforge.org/')
     expect(first.hash).to eq('19bba2ab667be03a19f67fb67dc56917')
@@ -695,20 +695,20 @@
             ' Ruby classes to be custom-mapped to XML. ROXML takes care of the' \
             ' marshalling and unmarshalling of mapped attributes so that developers can' \
             ' focus on building first-class Ruby classes.')
   end
 
-  it 'should parse xml elements to ruby objcts' do
+  it 'parses xml elements to ruby objcts' do
     statuses = Status.parse(fixture_file('statuses.xml'))
     expect(statuses.size).to eq(20)
     first = statuses.first
-    expect(first.id).to eq(882281424)
+    expect(first.id).to eq(882_281_424)
     expect(first.created_at).to eq(Time.utc(2008, 8, 9, 5, 38, 12))
     expect(first.source).to eq('web')
     expect(first.truncated).to be_falsey
     expect(first.in_reply_to_status_id).to eq(1234)
-    expect(first.in_reply_to_user_id).to eq(12345)
+    expect(first.in_reply_to_user_id).to eq(12_345)
     expect(first.favorited).to be_falsey
     expect(first.user.id).to eq(4243)
     expect(first.user.name).to eq('John Nunemaker')
     expect(first.user.screen_name).to eq('jnunemaker')
     expect(first.user.location).to eq('Mishawaka, IN, US')
@@ -718,32 +718,32 @@
     expect(first.user.url).to eq('http://addictedtonew.com')
     expect(first.user.protected).to be_falsey
     expect(first.user.followers_count).to eq(486)
   end
 
-  it 'should parse xml containing the desired element as root node' do
+  it 'parses xml containing the desired element as root node' do
     address = Address.parse(fixture_file('address.xml'), single: true)
     expect(address.street).to eq('Milchstrasse')
     expect(address.postcode).to eq('26131')
     expect(address.housenumber).to eq('23')
     expect(address.city).to eq('Oldenburg')
     expect(address.country.class).to eq(Country)
   end
 
-  it 'should parse text node correctly' do
+  it 'parses text node correctly' do
     address = Address.parse(fixture_file('address.xml'), single: true)
     expect(address.country.name).to eq('Germany')
     expect(address.country.code).to eq('de')
   end
 
-  it 'should treat Nokogiri::XML::Document as root' do
+  it 'treats Nokogiri::XML::Document as root' do
     doc = Nokogiri::XML(fixture_file('address.xml'))
     address = Address.parse(doc)
     expect(address.class).to eq(Address)
   end
 
-  it 'should parse xml with default namespace (amazon)' do
+  it 'parses xml with default namespace (amazon)' do
     file_contents = fixture_file('pita.xml')
     items = PITA::Items.parse(file_contents, single: true)
     expect(items.total_results).to eq(22)
     expect(items.total_pages).to eq(3)
     first  = items.items[0]
@@ -756,11 +756,11 @@
     expect(first.product_group).to eq('<ProductGroup>Book</ProductGroup>')
     expect(second.asin).to eq('047022388X')
     expect(second.manufacturer).to eq('Wrox')
   end
 
-  it 'should parse xml that has attributes of elements' do
+  it 'parses xml that has attributes of elements' do
     items = CurrentWeather.parse(fixture_file('current_weather.xml'))
     first = items[0]
     expect(first.temperature).to eq(51)
     expect(first.feels_like).to eq(51)
     expect(first.current_condition).to eq('Sunny')
@@ -772,25 +772,25 @@
     expect(feed.link.first.href).to eq('http://www.example.com')
     expect(feed.link.last.href).to eq('http://www.example.com/tv_shows.atom')
   end
 
   it 'parses xml with optional elements with embedded attributes' do
-    expect { CurrentWeather.parse(fixture_file('current_weather_missing_elements.xml')) }.to_not raise_error
+    expect { CurrentWeather.parse(fixture_file('current_weather_missing_elements.xml')) }.not_to raise_error
   end
 
   it 'returns nil rather than empty array for absent values when :single => true' do
     address = Address.parse('<?xml version="1.0" encoding="UTF-8"?><foo/>', single: true)
     expect(address).to be_nil
   end
 
-  it 'should return same result for absent values when :single => true, regardless of :in_groups_of' do
+  it 'returns same result for absent values when :single => true, regardless of :in_groups_of' do
     addr1 = Address.parse('<?xml version="1.0" encoding="UTF-8"?><foo/>', single: true)
     addr2 = Address.parse('<?xml version="1.0" encoding="UTF-8"?><foo/>', single: true, in_groups_of: 10)
     expect(addr1).to eq(addr2)
   end
 
-  it 'should parse xml with nested elements' do
+  it 'parses xml with nested elements' do
     radars = Radar.parse(fixture_file('radar.xml'))
     first = radars[0]
     expect(first.places.size).to eq(1)
     expect(first.places[0].name).to eq('Store')
     second = radars[1]
@@ -799,53 +799,53 @@
     expect(third.places.size).to eq(2)
     expect(third.places[0].name).to eq('Work')
     expect(third.places[1].name).to eq('Home')
   end
 
-  it 'should parse xml with element name different to class name' do
+  it 'parses xml with element name different to class name' do
     game = QuarterTest::Game.parse(fixture_file('quarters.xml'))
     expect(game.q1.start).to eq('4:40:15 PM')
     expect(game.q2.start).to eq('5:18:53 PM')
   end
 
-  it 'should parse xml that has elements with dashes' do
+  it 'parses xml that has elements with dashes' do
     commit = GitHub::Commit.parse(fixture_file('commit.xml'))
     expect(commit.message).to eq('move commands.rb and helpers.rb into commands/ dir')
     expect(commit.url).to eq('http://github.com/defunkt/github-gem/commit/c26d4ce9807ecf57d3f9eefe19ae64e75bcaaa8b')
     expect(commit.id).to eq('c26d4ce9807ecf57d3f9eefe19ae64e75bcaaa8b')
     expect(commit.committed_date).to eq(Date.parse('2008-03-02T16:45:41-08:00'))
     expect(commit.tree).to eq('28a1a1ca3e663d35ba8bf07d3f1781af71359b76')
   end
 
-  it 'should parse xml with no namespace' do
+  it 'parses xml with no namespace' do
     product = Product.parse(fixture_file('product_no_namespace.xml'), single: true)
     expect(product.title).to eq('A Title')
     expect(product.feature_bullets.bug).to eq('This is a bug')
     expect(product.feature_bullets.features.size).to eq(2)
     expect(product.feature_bullets.features[0].name).to eq('This is feature text 1')
     expect(product.feature_bullets.features[1].name).to eq('This is feature text 2')
   end
 
-  it 'should parse xml with default namespace' do
+  it 'parses xml with default namespace' do
     product = Product.parse(fixture_file('product_default_namespace.xml'), single: true)
     expect(product.title).to eq('A Title')
     expect(product.feature_bullets.bug).to eq('This is a bug')
     expect(product.feature_bullets.features.size).to eq(2)
     expect(product.feature_bullets.features[0].name).to eq('This is feature text 1')
     expect(product.feature_bullets.features[1].name).to eq('This is feature text 2')
   end
 
-  it 'should parse xml with single namespace' do
+  it 'parses xml with single namespace' do
     product = Product.parse(fixture_file('product_single_namespace.xml'), single: true)
     expect(product.title).to eq('A Title')
     expect(product.feature_bullets.bug).to eq('This is a bug')
     expect(product.feature_bullets.features.size).to eq(2)
     expect(product.feature_bullets.features[0].name).to eq('This is feature text 1')
     expect(product.feature_bullets.features[1].name).to eq('This is feature text 2')
   end
 
-  it 'should parse xml with multiple namespaces' do
+  it 'parses xml with multiple namespaces' do
     track = FedEx::TrackReply.parse(fixture_file('multiple_namespaces.xml'))
     expect(track.highest_severity).to eq('SUCCESS')
     expect(track.more_data).to be_falsey
     notification = track.notifications.first
     expect(notification.code).to eq(0)
@@ -883,11 +883,11 @@
     expect(last_event.address.state).to eq('FL')
     expect(last_event.address.zip).to eq('327506398')
     expect(track.tran_detail.cust_tran_id).to eq('20090102-111321')
   end
 
-  it 'should be able to parse google analytics api xml' do
+  it 'is able to parse google analytics api xml' do
     data = Analytics::Feed.parse(fixture_file('analytics.xml'))
     expect(data.id).to eq('http://www.google.com/analytics/feeds/accounts/[e-mail]')
     expect(data.entries.size).to eq(4)
 
     entry = data.entries[0]
@@ -897,21 +897,21 @@
     property = entry.properties[0]
     expect(property.name).to eq('ga:accountId')
     expect(property.value).to eq('85301')
   end
 
-  it 'should be able to parse google analytics profile xml with manually declared namespace' do
+  it 'is able to parse google analytics profile xml with manually declared namespace' do
     data = Analytics::Profile.parse(fixture_file('analytics_profile.xml'))
     expect(data.entries.size).to eq(6)
 
     entry = data.entries[0]
     expect(entry.title).to eq('www.homedepot.com')
     expect(entry.properties.size).to eq(6)
     expect(entry.goals.size).to eq(0)
   end
 
-  it 'should allow instantiating with a string' do
+  it 'allows instantiating with a string' do
     module StringFoo
       class Bar
         include HappyMapper
         has_many :things, 'StringFoo::Thing'
       end
@@ -920,11 +920,11 @@
         include HappyMapper
       end
     end
   end
 
-  it 'should parse family search xml' do
+  it 'parses family search xml' do
     tree = FamilySearch::FamilyTree.parse(fixture_file('family_tree.xml'))
     expect(tree.version).to eq('1.0.20071213.942')
     expect(tree.status_message).to eq('OK')
     expect(tree.status_code).to eq('200')
     expect(tree.persons.person.size).to eq(1)
@@ -934,132 +934,127 @@
     expect(tree.persons.person.first.id).to eq('KWQS-BBQ')
     expect(tree.persons.person.first.information.alternateIds.ids).not_to be_kind_of(String)
     expect(tree.persons.person.first.information.alternateIds.ids.size).to eq(8)
   end
 
-  it 'should parse multiple images' do
+  it 'parses multiple images' do
     artist = Artist.parse(fixture_file('multiple_primitives.xml'))
     expect(artist.name).to eq('value')
     expect(artist.images.size).to eq(2)
   end
 
-  it 'should parse lastfm namespaces' do
+  it 'parses lastfm namespaces' do
     l = Location.parse(fixture_file('lastfm.xml'))
     expect(l.first.latitude).to eq('51.53469')
   end
 
   describe 'Parse optional attributes' do
-    it 'should parse an empty String as empty' do
-      a = OptionalAttribute.parse(fixture_file('optional_attributes.xml'))
-      expect(a[0].street).to eq('')
+    let(:parsed_result) { OptionalAttribute.parse(fixture_file('optional_attributes.xml')) }
+
+    it 'parses an empty String as empty' do
+      expect(parsed_result[0].street).to eq('')
     end
 
-    it 'should parse a String with value' do
-      a = OptionalAttribute.parse(fixture_file('optional_attributes.xml'))
-      expect(a[1].street).to eq('Milchstrasse')
+    it 'parses a String with value' do
+      expect(parsed_result[1].street).to eq('Milchstrasse')
     end
 
-    it 'should parse a String with value' do
-      a = OptionalAttribute.parse(fixture_file('optional_attributes.xml'))
-      expect(a[2].street).to be_nil
+    it 'parses an element with no value for the attribute' do
+      expect(parsed_result[2].street).to be_nil
     end
   end
 
   describe 'Default namespace combi' do
-    before(:each) do
-      file_contents = fixture_file('default_namespace_combi.xml')
-      @book = DefaultNamespaceCombi.parse(file_contents, single: true)
-    end
+    let(:file_contents) { fixture_file('default_namespace_combi.xml') }
+    let(:book) { DefaultNamespaceCombi.parse(file_contents, single: true) }
 
-    it 'should parse author' do
-      expect(@book.author).to eq('Frank Gilbreth')
+    it 'parses author' do
+      expect(book.author).to eq('Frank Gilbreth')
     end
 
-    it 'should parse title' do
-      expect(@book.title).to eq('Cheaper by the Dozen')
+    it 'parses title' do
+      expect(book.title).to eq('Cheaper by the Dozen')
     end
 
-    it 'should parse number' do
-      expect(@book.number).to eq('1568491379')
+    it 'parses number' do
+      expect(book.number).to eq('1568491379')
     end
   end
 
   describe 'Xml Content' do
-    before(:each) do
-      file_contents = fixture_file('dictionary.xml')
-      @records = Dictionary::Record.parse(file_contents)
-    end
+    let(:records) { Dictionary::Record.parse fixture_file('dictionary.xml') }
 
-    it 'should parse XmlContent' do
-      expect(@records.first.definitions.first.text).
+    it 'parses XmlContent' do
+      expect(records.first.definitions.first.text).
         to eq('a large common parrot, <bn>Cacatua galerita</bn>, predominantly' \
               ' white, with yellow on the undersides of wings and tail and a' \
               ' forward curving yellow crest, found in Australia, New Guinea' \
               ' and nearby islands.')
     end
 
-    it "should save object's xml content" do
-      expect(@records.first.variants.first.xml_content).to eq(
+    it "saves object's xml content" do
+      expect(records.first.variants.first.xml_content).to eq(
         'white <tag>cockatoo</tag>'
       )
-      expect(@records.first.variants.last.to_html).to eq(
+      expect(records.first.variants.last.to_html).to eq(
         '<em>white</em> cockatoo'
       )
     end
   end
 
-  it 'should parse ambigous items' do
+  it 'parses ambigous items' do
     items = AmbigousItems::Item.parse(fixture_file('ambigous_items.xml'), xpath: '/ambigous/my-items')
     expect(items.map(&:name)).to eq(%w(first second third).map { |s| "My #{s} item" })
   end
 
   context Article do
-    it 'should parse the publish options for Article and Photo' do
-      expect(@article.title).not_to be_nil
-      expect(@article.text).not_to be_nil
-      expect(@article.photos).not_to be_nil
-      expect(@article.photos.first.title).not_to be_nil
-    end
+    let(:article) { Article.parse(fixture_file('subclass_namespace.xml')) }
 
-    it 'should parse the publish options for Article' do
-      expect(@article.publish_options).not_to be_nil
+    it 'parses the publish options for Article and Photo' do
+      expect(article.title).not_to be_nil
+      expect(article.text).not_to be_nil
+      expect(article.photos).not_to be_nil
+      expect(article.photos.first.title).not_to be_nil
     end
 
-    it 'should parse the publish options for Photo' do
-      expect(@article.photos.first.publish_options).not_to be_nil
+    it 'parses the publish options for Article' do
+      expect(article.publish_options).not_to be_nil
     end
 
-    it 'should only find only items at the parent level' do
-      expect(@article.photos.length).to eq(1)
+    it 'parses the publish options for Photo' do
+      expect(article.photos.first.publish_options).not_to be_nil
     end
 
-    before(:all) do
-      @article = Article.parse(fixture_file('subclass_namespace.xml'))
+    it 'onlies find only items at the parent level' do
+      expect(article.photos.length).to eq(1)
     end
   end
 
-  context 'Namespace is missing because an optional element that uses it is not present' do
-    it 'should parse successfully' do
-      @article = PartiallyBadArticle.parse(fixture_file('subclass_namespace.xml'))
-      expect(@article).not_to be_nil
-      expect(@article.title).not_to be_nil
-      expect(@article.text).not_to be_nil
-      expect(@article.photos).not_to be_nil
-      expect(@article.photos.first.title).not_to be_nil
+  describe 'Namespace is missing because an optional element that uses it is not present' do
+    it 'parses successfully' do
+      article = PartiallyBadArticle.parse(fixture_file('subclass_namespace.xml'))
+
+      aggregate_failures do
+        expect(article).not_to be_nil
+        expect(article.title).not_to be_nil
+        expect(article.text).not_to be_nil
+        expect(article.photos).not_to be_nil
+        expect(article.photos.first.title).not_to be_nil
+      end
     end
   end
 
   describe 'with limit option' do
-    it 'should return results with limited size: 6' do
+    it 'returns results with limited size: 6' do
       sizes = []
       Post.parse(fixture_file('posts.xml'), in_groups_of: 6) do |a|
         sizes << a.size
       end
       expect(sizes).to eq([6, 6, 6, 2])
     end
 
-    it 'should return results with limited size: 10' do
+    it 'returns results with limited size: 10' do
       sizes = []
       Post.parse(fixture_file('posts.xml'), in_groups_of: 10) do |a|
         sizes << a.size
       end
       expect(sizes).to eq([10, 10])
@@ -1093,30 +1088,30 @@
     it 'accepts .on_config callback' do
       expect(custom.nokogiri_config_callback).not_to be_nil
     end
 
     it 'parses according to @nokogiri_config_callback' do
-      expect { custom.parse(fixture_file('set_config_options.xml')) }.to_not raise_error
+      expect { custom.parse(fixture_file('set_config_options.xml')) }.not_to raise_error
     end
 
     it 'can clear @nokogiri_config_callback' do
       custom.with_nokogiri_config {}
       expect { custom.parse(fixture_file('set_config_options.xml')) }.
         to raise_error(Nokogiri::XML::SyntaxError)
     end
   end
 
-  context 'xml_value' do
+  describe '#xml_value' do
     it 'does not reformat the xml' do
       xml = fixture_file('unformatted_address.xml')
       address = Address.parse(xml, single: true)
 
       expect(address.xml_value).
         to eq %(<address><street>Milchstrasse</street><housenumber>23</housenumber></address>)
     end
   end
 
-  context 'xml_content' do
+  describe '#xml_content' do
     it 'does not reformat the xml' do
       xml = fixture_file('unformatted_address.xml')
       address = Address.parse(xml)
 
       expect(address.xml_content).to eq %(<street>Milchstrasse</street><housenumber>23</housenumber>)