mida 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1d5a6aea8cdf0891e2e766c740e806539a8947c
-  data.tar.gz: 0f748e487ad3e4347cfde3ced305bc71288bf6df
+  metadata.gz: ce860318419bb6c7035970ea76944a6b163760c1
+  data.tar.gz: e7dd59518fe23b26b56e6da0bf5c7fb75f6b242b
 SHA512:
-  metadata.gz: 490a74f5db41dd292883bbfd5d738431516c2ef6089936af1f7593f4ae53460724860a433eb545ac4f51a40d6ef69363275af907ab44c3738fbac7b60e5d7d29
-  data.tar.gz: a333750b5de42b1f2b99cf1d0a15827251d02d3870f75a4862265b8ad8fff4b1c98a84ca623bcd9cd3ff7f08d7a4330f78779b6c1ffbab5d47f201548acdef48
+  metadata.gz: fb8a525521ad35f8fc5bcde98361d163d891b95535403b150bb251c5635f297d554f10192b8e2de38d8e5ee2cc2ff0c68bb48bcc3b47a5b61668c306574855a7
+  data.tar.gz: 7077836f38c96eeedc201ad945d8e2eff1a6495f1547fe301f19061122f6f958633d55cf2494def351c87ef7d0bf7222f1cfab3a906da1472b5714c194d2e70b

data/.gitignore

@@ -2,6 +2,7 @@
 *.swp
 
 # Gem pkg directory
+Gemfile.lock
 pkg/
 *.gem
 *.rbc

data/.travis.yml

@@ -1,8 +1,13 @@
 language: ruby
+sudo: false
+cache:
+  bundler: true
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
+  - 2.2.4
+  - 2.3.0
 branches:
   only:
     - master
+env:
+  global:
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true

data/lib/mida/datatype/enumeration.rb

@@ -11,15 +11,13 @@ module Mida
     # [[DataType, Regexp], [DataType, Regexp]]
     class Enumeration < Generic
 
-      Enumeration.reveal(:class)
-
       # Raises +ArgumentError+ if value not valid value
       def initialize(value)
-        value_is_valid = self.class::VALID_VALUES.any? do |valid_value|
+        value_is_valid = (class << self; self end).superclass::VALID_VALUES.any? do |valid_value|
           @parsedValue = valid_value[0].parse(value)
           @parsedValue.to_s =~ valid_value[1]
         end
-        raise ArgumentError unless value_is_valid 
+        raise ::ArgumentError unless value_is_valid 
       end
 
     end

data/lib/mida/datatype/generic.rb

@@ -1,10 +1,8 @@
-require 'blankslate'
-
 module Mida
   module DataType
 
     # The base DataType Parser
-    class Generic < BlankSlate
+    class Generic < BasicObject
       
       # Convenience method, same as +new+
       def self.parse(value)

data/lib/mida/datatype/iso8601date.rb

@@ -12,7 +12,7 @@ module Mida
       def initialize(value)
         @parsedValue = ::DateTime.iso8601(value)
       rescue => e
-        raise ArgumentError, e
+        raise ::ArgumentError, e
       end
 
       def to_s

data/lib/mida/document.rb

@@ -16,7 +16,7 @@ module Mida
     # [page_url] The url of target used for form absolute urls. This must
     #            include the filename, e.g. index.html.
     def initialize(target, page_url=nil)
-      @doc = Nokogiri(target)
+      @doc = target.kind_of?(Nokogiri::XML::Document) ? target : Nokogiri(target)
       @page_url = page_url
       @items = extract_items
     end

data/lib/mida/version.rb

@@ -1,3 +1,3 @@
 module Mida
-  VERSION = "0.3.9"
+  VERSION = "0.4.0"
 end

data/mida.gemspec

@@ -18,10 +18,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extra_rdoc_files = ['README.rdoc', 'LICENCE.rdoc', 'CHANGELOG.rdoc']
   spec.rdoc_options << '--main' << 'README.rdoc'
-  spec.add_dependency('blankslate', '3.1.3')
   spec.add_dependency('nokogiri', '>= 1.6')
-  spec.add_dependency('addressable', '~> 2.3.8')
+  spec.add_dependency('addressable', '~> 2.4')
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
 end

data/spec/datatype/boolean_spec.rb

@@ -4,37 +4,37 @@ describe Mida::DataType::Boolean do
 
   it '#parse should raise an exception if a invalid text passed' do
     test = lambda {Mida::DataType::Boolean.parse('example')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::Boolean.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should return true for "True" whatever the case' do
     ['true', 'True', 'TRUE', 'tRUE'].each do |true_text|
-      Mida::DataType::Boolean.parse(true_text).should be_true
+      expect(Mida::DataType::Boolean.parse(true_text)).to be_truthy
     end
   end
 
   it '#parse should return false for "False" whatever the case' do
     ['false', 'False', 'FALSE', 'fALSE'].each do |false_text|
-      Mida::DataType::Boolean.parse(false_text).should be_false
+      expect(Mida::DataType::Boolean.parse(false_text)).to be_falsey
     end
   end
 
   it '#to_s should return proper string representation of boolean' do
-    Mida::DataType::Boolean.parse('fALSE').to_s.should == 'False'
-    Mida::DataType::Boolean.parse('tRUE').to_s.should == 'True'
+    expect(Mida::DataType::Boolean.parse('fALSE').to_s).to eq('False')
+    expect(Mida::DataType::Boolean.parse('tRUE').to_s).to eq('True')
   end
 
   it '! should negate as if a TrueClass/FalseClass' do
     true_boolean = Mida::DataType::Boolean.parse('true')
     false_boolean = Mida::DataType::Boolean.parse('false')
 
-    (!true_boolean).should be_false
-    (!false_boolean).should be_true
+    expect(!true_boolean).to be_falsey
+    expect(!false_boolean).to be_truthy
   end
 
 end

data/spec/datatype/enumeration_spec.rb

@@ -13,18 +13,18 @@ describe Mida::DataType::Enumeration do
 
   it '#parse should raise an exception if an invalid url passed' do
     test = lambda {BookType.parse('http://example.com/hardback')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {BookType.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should accept a valid value' do
     url_text = 'http://example.com/ebook'
     url = BookType.parse(url_text)
-    url.to_s.should == url_text
+    expect(url.to_s).to eq(url_text)
   end
 
 end

data/spec/datatype/float_spec.rb

@@ -4,18 +4,18 @@ describe Mida::DataType::Float do
 
   it '#parse should raise an exception if not a number' do
     test = lambda {Mida::DataType::Float.parse('hello')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::Float.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should accept a valid number' do
     float_text = '3.14'
     float = Mida::DataType::Float.parse(float_text)
-    float.to_s.should == float_text
+    expect(float.to_s).to eq(float_text)
   end
 
 end

data/spec/datatype/generic_spec.rb

@@ -17,28 +17,28 @@ describe Mida::DataType::Generic do
 
   it "should provide access to the underlying type's methods" do
     number = Number.new('2.34')
-    number.floor.should == 2
+    expect(number.floor).to eq(2)
   end
 
   it '#to_s should use the underlying types #to_s method' do
     number = Number.parse('2.34')
-    number.to_s.should == '2.34'
+    expect(number.to_s).to eq('2.34')
   end
 
   it '#to_yaml should provide a yaml representation of the items #to_s method' do
     number = Number.parse('2.34')
-    number.to_yaml.should =~ /---\s+['"]2.34['"]\n/
+    expect(number.to_yaml).to match(/---\s+['"]2.34['"]\n/)
   end
 
   it '#== should match against underlying type, string representation and self' do
     number = Number.new('2.34')
-    (number == 2.34).should be_true
-    (number == '2.34').should be_true
-    (number == number).should be_true
+    expect(number == 2.34).to be_truthy
+    expect(number == '2.34').to be_truthy
+    expect(number == number).to be_truthy
 
-    (number == 2.44).should be_false
-    (number == '2.44').should be_false
-    (number == Number.new('2.44')).should be_false
+    expect(number == 2.44).to be_falsey
+    expect(number == '2.44').to be_falsey
+    expect(number == Number.new('2.44')).to be_falsey
   end
 
 end

data/spec/datatype/integer_spec.rb

@@ -4,23 +4,23 @@ describe Mida::DataType::Integer do
 
   it '#parse should raise an exception if not a number' do
     test = lambda {Mida::DataType::Integer.parse('hello')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if not an integer' do
     test = lambda {Mida::DataType::Integer.parse('3.14')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::Integer.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should accept a valid number' do
     integer_text = '3'
     integer = Mida::DataType::Integer.parse(integer_text)
-    integer.to_s.should == integer_text
+    expect(integer.to_s).to eq(integer_text)
   end
 
 end

data/spec/datatype/iso8601date_spec.rb

@@ -4,12 +4,12 @@ describe Mida::DataType::ISO8601Date do
 
   it '#parse should raise an exception if invalid date format' do
     test = lambda {Mida::DataType::ISO8601Date.parse('27th August 2009')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::ISO8601Date.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   context 'when passed a valid date' do
@@ -19,7 +19,7 @@ describe Mida::DataType::ISO8601Date do
     end
 
     it '#to_s should return the date as an rfc822 text string' do
-      @date.to_s.should == "Thu, 27 Aug 2009 01:13:04 +0510"
+      expect(@date.to_s).to eq("Thu, 27 Aug 2009 01:13:04 +0510")
     end
 
   end

data/spec/datatype/number_spec.rb

@@ -4,18 +4,18 @@ describe Mida::DataType::Number do
 
   it '#parse should raise an exception if not a number' do
     test = lambda {Mida::DataType::Number.parse('hello')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::Number.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should accept a valid number' do
     num_text = '3.14'
     num = Mida::DataType::Number.parse(num_text)
-    num.to_s.should == num_text
+    expect(num.to_s).to eq(num_text)
   end
 
 end

data/spec/datatype/text_spec.rb

@@ -4,13 +4,13 @@ describe Mida::DataType::Text do
 
   it '#parse should accept an empty string' do
     text = Mida::DataType::Text.parse('')
-    text.should == ''
+    expect(text).to eq('')
   end
 
   it '#parse should return the input value' do
     test_text = 'Some text'
     text = Mida::DataType::Text.parse(test_text)
-    text.should == test_text
+    expect(text).to eq(test_text)
   end
 
 end

data/spec/datatype/url_spec.rb

@@ -7,23 +7,23 @@ describe Mida::DataType::URL do
 
   it '#parse should raise an exception if a bad url passed' do
     test = lambda {Mida::DataType::URL.parse('example.com')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should raise an exception if value is empty' do
     test = lambda {Mida::DataType::URL.parse('')}
-    test.should raise_error(ArgumentError)
+    expect(test).to raise_error(ArgumentError)
   end
 
   it '#parse should accept a valid url' do
     url_text = 'http://example.com/test/'
     url = Mida::DataType::URL.parse(url_text)
-    url.to_s.should == url_text
+    expect(url.to_s).to eq(url_text)
   end
 
   it '#parse should accept a valid url with special characters' do
     url_text = 'http://example.com/übergangslösung'
     url = Mida::DataType::URL.parse(url_text)
-    url.to_s.should == ::Addressable::URI.encode(url_text)
+    expect(url.to_s).to eq(::Addressable::URI.encode(url_text))
   end
 end

data/spec/document_spec.rb

@@ -11,21 +11,21 @@ def test_parsing(md, vocabulary, expected_results)
 end
 
 def test_to_h(item, expected_result)
-  item.to_h.should == expected_result
+  expect(item.to_h).to eq(expected_result)
 end
 
 def test_properties(item, expected_result)
   item.properties.each do |name, value|
-    match_array(value, expected_result[:properties][name])
+    match_array_legacy(value, expected_result[:properties][name])
   end
 end
 
-def match_array(value_array, expected_results)
+def match_array_legacy(value_array, expected_results)
   value_array.each_with_index do |element, i|
     if element.is_a?(Mida::Item)
       test_properties(element, expected_results[i])
     else
-      element.should == expected_results[i]
+      expect(element).to eq(expected_results[i])
     end
   end
 end
@@ -49,22 +49,29 @@ describe Mida::Document do
       </body></html>
     '
 
+    @nokogiri_document = Nokogiri(html)
+
     @md = Mida::Document.new(html)
   end
 
   it '#each should pass each item to the block' do
     item_num = 0
-    @md.each {|item| item.should == @md.items[item_num]; item_num += 1}
+    @md.each {|item| expect(item).to eq(@md.items[item_num]); item_num += 1}
   end
 
   it 'should have access to the Enumerable mixin methods such as #find' do
     review = @md.find {|item| item.type == 'http://data-vocabulary.org/Review'}
-    review.type.should == 'http://data-vocabulary.org/Review'
-    review.properties['itemreviewed'].should == ["Romeo Pizza"]
+    expect(review.type).to eq('http://data-vocabulary.org/Review')
+    expect(review.properties['itemreviewed']).to eq(["Romeo Pizza"])
 
     organization = @md.find {|item| item.type == 'http://data-vocabulary.org/Organization'}
-    organization.type.should == 'http://data-vocabulary.org/Organization'
-    organization.properties['name'].should == ["An org name"]
+    expect(organization.type).to eq('http://data-vocabulary.org/Organization')
+    expect(organization.properties['name']).to eq(["An org name"])
+  end
+
+  it 'should not re-parse a nokogiri document' do
+    md = Mida::Document.new(@nokogiri_document)
+    expect(md.instance_variable_get(:@doc).object_id).to eq(@nokogiri_document.object_id)
   end
 end
 
@@ -116,14 +123,14 @@ describe Mida::Document, 'when run against a full html document containing items
 
   it '#search should be able to match against items without an itemtype' do
     items = @md.search(%r{^$})
-    items.size.should == 1
-    items[0].properties['name'].should == ['An org name']
+    expect(items.size).to eq(1)
+    expect(items[0].properties['name']).to eq(['An org name'])
   end
 
   it '#search should be able to match against items with an itemtype' do
     items = @md.search(%r{^.+$})
-    items.size.should == 1
-    items[0].type.should == 'http://data-vocabulary.org/Review'
+    expect(items.size).to eq(1)
+    expect(items[0].type).to eq('http://data-vocabulary.org/Review')
   end
 end
 
@@ -152,7 +159,7 @@ describe Mida::Document, 'when run against a full html document containing two n
   end
 
   it 'should return all the itemscopes' do
-    @md.items.size.should == 2
+    expect(@md.items.size).to eq(2)
   end
 
   it 'should give the type of each itemscope if none specified' do
@@ -165,8 +172,8 @@ describe Mida::Document, 'when run against a full html document containing two n
       itemscope_names[item.type] += 1
     end
 
-    itemscope_names.size.should eq 2
-    itemscope_names.each { |name, num| num.should == 1 }
+    expect(itemscope_names.size).to eq 2
+    itemscope_names.each { |name, num| expect(num).to eq(1) }
   end
 
 
@@ -220,11 +227,11 @@ describe Mida::Document, 'when run against a full html document containing one
   end
 
   it 'should not match itemscopes with different names' do
-    @md.search(%r{nothing}).size.should == 0
+    expect(@md.search(%r{nothing}).size).to eq(0)
   end
 
   it 'should find the correct number of itemscopes' do
-    @md.items.size.should == 1
+    expect(@md.items.size).to eq(1)
   end
 
   it 'should return the correct number of itemscopes' do
@@ -232,7 +239,7 @@ describe Mida::Document, 'when run against a full html document containing one
       %r{http://data-vocabulary.org/Product},
       %r{http://data-vocabulary.org/Review-aggregate}
     ]
-    vocabularies.each {|vocabulary| @md.search(vocabulary).size.should == 1}
+    vocabularies.each {|vocabulary| expect(@md.search(vocabulary).size).to eq(1)}
 
   end
 
@@ -289,16 +296,16 @@ describe Mida::Document, 'when run against a document containing an itemscope
       %r{http://data-vocabulary.org/Product} => 1,
       %r{http://data-vocabulary.org/Review-aggregate} => 1
     }
-    vocabularies.each {|vocabulary, num| @md.search(vocabulary).size.should == num}
+    vocabularies.each {|vocabulary, num| expect(@md.search(vocabulary).size).to eq(num)}
   end
 
   it 'should return the correct number of items' do
-    @md.items.size.should == 2
+    expect(@md.items.size).to eq(2)
   end
 
   context "when no vocabulary specified or looking at the outer vocabulary" do
     it 'should return all the properties from the text with the correct values' do
-      pending("get the contains: feature working")
+      skip("get the contains: feature working")
       expected_result = {
         type: 'http://data-vocabulary.org/Product',
         properties: {
@@ -314,7 +321,7 @@ describe Mida::Document, 'when run against a document containing an itemscope
         }
       }
 
-      @md.search('http://data-vocabulary.org/Product').first.should == expected_result
+      expect(@md.search('http://data-vocabulary.org/Product').first).to eq(expected_result)
     end
   end
 end