mida 0.3.2 → 0.3.3

data/spec/datatype/boolean_spec.rb

@@ -2,26 +2,39 @@ require 'mida/datatype'
 
 describe Mida::DataType::Boolean do
 
-  it '#extract should raise an exception if some other text' do
-    test = lambda {Mida::DataType::Boolean.extract('hello')}
+  it '#parse should raise an exception if a invalid text passed' do
+    test = lambda {Mida::DataType::Boolean.parse('example')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract should raise an exception if value is empty' do
-    test = lambda {Mida::DataType::Boolean.extract('')}
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Boolean.parse('')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract should return true for "True" whatever the case' do
+  it '#parse should return true for "True" whatever the case' do
     ['true', 'True', 'TRUE', 'tRUE'].each do |true_text|
-      Mida::DataType::Boolean.extract(true_text).should be_true
+      Mida::DataType::Boolean.parse(true_text).should be_true
     end
   end
 
-  it '#extract should return false for "False" whatever the case' do
+  it '#parse should return false for "False" whatever the case' do
     ['false', 'False', 'FALSE', 'fALSE'].each do |false_text|
-      Mida::DataType::Boolean.extract(false_text).should be_false
+      Mida::DataType::Boolean.parse(false_text).should be_false
     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'
+  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
+  end
+
 end

data/spec/datatype/enumeration_spec.rb

@@ -0,0 +1,30 @@
+require 'mida/datatype'
+require 'mida/datatype/url'
+
+describe Mida::DataType::Enumeration do
+  before :all do
+    class BookType < Mida::DataType::Enumeration
+      VALID_VALUES = [
+        [::Mida::DataType::URL, %r{http://example.com/ebook}i],
+        [::Mida::DataType::URL, %r{http://example.com/paperback}i]
+      ]
+    end
+  end
+
+  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)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {BookType.parse('')}
+    test.should 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
+  end
+
+end

data/spec/datatype/float_spec.rb

@@ -2,22 +2,20 @@ require 'mida/datatype'
 
 describe Mida::DataType::Float do
 
-  it '#extract should raise an exception if not a number' do
-    test = lambda {Mida::DataType::Float.extract('hello')}
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Float.parse('hello')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract should raise an exception if value is empty' do
-    test = lambda {Mida::DataType::Float.extract('')}
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Float.parse('')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract? should return the input value as a Float if a floating point' do
-    Mida::DataType::Float.extract("3.14").should == 3.14
-  end
-
-  it '#extract? should return the input value as a Float if a integer' do
-    Mida::DataType::Float.extract("3").should == 3
+  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
   end
 
 end

data/spec/datatype/generic_spec.rb

@@ -0,0 +1,44 @@
+require 'mida/datatype'
+
+describe Mida::DataType::Generic do
+
+  before do
+    class Number < Mida::DataType::Generic
+      def initialize(value)
+        @parsedValue = Float(value)  
+      end
+    end
+  end
+
+  it '#parse should provide pass value straight to #new' do
+    number = Number.parse('2.34')
+    number == 2.34
+  end
+
+  it "should provide access to the underlying type's methods" do
+    number = Number.new('2.34')
+    number.floor.should == 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'
+  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/
+  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
+
+    (number == 2.44).should be_false
+    (number == '2.44').should be_false
+    (number == Number.new('2.44')).should be_false
+  end
+
+end

data/spec/datatype/integer_spec.rb

@@ -2,22 +2,25 @@ require 'mida/datatype'
 
 describe Mida::DataType::Integer do
 
-  it '#extract should raise an exception if not a number' do
-    test = lambda {Mida::DataType::Integer.extract('hello')}
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Integer.parse('hello')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract should raise an exception if value is empty' do
-    test = lambda {Mida::DataType::Integer.extract('')}
+  it '#parse should raise an exception if not an integer' do
+    test = lambda {Mida::DataType::Integer.parse('3.14')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract? should raise an exception if a floating point number' do
-    test = lambda {Mida::DataType::Integer.extract('3.14')}
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Integer.parse('')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract? should return the input value as a Integer if a integer' do
-    Mida::DataType::Integer.extract("3").should == 3
+  it '#parse should accept a valid number' do
+    integer_text = '3'
+    integer = Mida::DataType::Integer.parse(integer_text)
+    integer.to_s.should == integer_text
   end
+
 end

data/spec/datatype/iso8601date_spec.rb

@@ -2,19 +2,26 @@ require 'mida/datatype'
 
 describe Mida::DataType::ISO8601Date do
 
-  it '#extract should raise an exception if some other text' do
-    test = lambda {Mida::DataType::ISO8601Date.extract('27th Aug 2009')}
+  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)
   end
 
-  it '#extract should raise an exception if value is empty' do
-    test = lambda {Mida::DataType::ISO8601Date.extract('')}
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::ISO8601Date.parse('')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract? should return the input value' do
-    date = "2009-08-27T01:13:04+05:10"
-    Mida::DataType::ISO8601Date.extract(date).should == DateTime.parse(date)
-    Mida::DataType::ISO8601Date.extract(date).to_s.should == date
+  context 'when passed a valid date' do
+    before do
+      @date_text = "2009-08-27T01:13:04+05:10"
+      @date = Mida::DataType::ISO8601Date.parse(@date_text)
+    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"
+    end
+
   end
+
 end

data/spec/datatype/number_spec.rb

@@ -2,22 +2,20 @@ require 'mida/datatype'
 
 describe Mida::DataType::Number do
 
-  it '#extract should raise an exception if not a number' do
-    test = lambda {Mida::DataType::Number.extract('hello')}
+  it '#parse should raise an exception if not a number' do
+    test = lambda {Mida::DataType::Number.parse('hello')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract should raise an exception if value is empty' do
-    test = lambda {Mida::DataType::Number.extract('')}
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::Number.parse('')}
     test.should raise_error(ArgumentError)
   end
 
-  it '#extract? should return the input value as a number if a floating point' do
-    Mida::DataType::Number.extract("3.14").should == 3.14
-  end
-
-  it '#extract? should return the input value as a number if a integer' do
-    Mida::DataType::Number.extract("3").should == 3
+  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
   end
 
 end

data/spec/datatype/text_spec.rb

@@ -2,13 +2,15 @@ require 'mida/datatype'
 
 describe Mida::DataType::Text do
 
-  it '#extract should return an empty string if an empty string passed' do
-    value = ''
-    Mida::DataType::Text.extract(value).should == value
+  it '#parse should accept an empty string' do
+    text = Mida::DataType::Text.parse('')
+    text.should == ''
   end
 
-  it '#extract should return the input value' do
-    value = 'A Test Value'
-    Mida::DataType::Text.extract(value).should == value
+  it '#parse should return the input value' do
+    test_text = 'Some text'
+    text = Mida::DataType::Text.parse(test_text)
+    text.should == test_text
   end
+
 end

data/spec/datatype/url_spec.rb

@@ -0,0 +1,27 @@
+require 'mida/datatype'
+require 'yaml'
+
+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)
+  end
+
+  it '#parse should raise an exception if value is empty' do
+    test = lambda {Mida::DataType::URL.parse('')}
+    test.should 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
+  end
+
+
+  it '#parse should accept a valid url' do
+    url_text = 'http://example.com/test/'
+    url = Mida::DataType::URL.parse(url_text)
+  end
+end

data/spec/document_spec.rb

@@ -85,27 +85,6 @@ describe Mida::Document, 'when initialized' do
     end
   end
 
-  context 'with validation on' do
-    before do
-      @md = Mida::Document.new(@html)
-    end
-
-    it 'should reject properties for items of known vocabularies that are not valid' do
-      @md.items[0].properties.should == {}
-    end
-  end
-
-  context 'with validation off' do
-    before do
-      @md = Mida::Document.new(@html, false)
-    end
-
-    it 'should accept properties for items of known vocabularies even if not valid' do
-      @md.items[0].properties['itemreviewed'].should ==
-        ['Romeo Pizza', 'Some Other Pizza']
-    end
-  end
-
   after do
     Mida::Vocabulary.unregister(Review)
   end

data/spec/item_spec.rb

@@ -82,7 +82,9 @@ describe Mida::Item, 'when initialized with an itemscope of a known type' do
       has_many 'date' do
         extract Mida::DataType::ISO8601Date, Mida::DataType::Text
       end
-      has_many 'url'
+      has_many 'url' do
+        extract Mida::DataType::URL
+      end
     end
 
     itemscope = mock(Mida::Itemscope)
@@ -106,7 +108,8 @@ describe Mida::Item, 'when initialized with an itemscope of a known type' do
   end
 
   it 'should return has_many properties as an array' do
-    @item.properties['url'].should == ['http://example.com/user/lorry']
+    @item.properties['url'].length == 1
+    @item.properties['url'].first.to_s.should == 'http://example.com/user/lorry'
   end
 
   it 'should accept datatypes that are valid' do
@@ -114,25 +117,18 @@ describe Mida::Item, 'when initialized with an itemscope of a known type' do
   end
 
   it 'should accept datatypes that are valid' do
-    @item.properties['date'][1].should == Date.iso8601('2009-10-02')
+    @item.properties['date'][1].should.to_s == Date.iso8601('2009-10-02').rfc822
   end
 
   it '#properties should return the same properties as the itemscope' do
-    @item.properties.should == {
-      'name' => 'Lorry Woodman',
-      'date' => ['2nd October 2009', Date.iso8601('2009-10-02')],
-      'url' => ['http://example.com/user/lorry']
-    }
+    @item.properties.keys.should == ['name', 'date', 'url']
+    @item.properties['date'].length == 2
   end
 
   it '#to_h should return the correct type and properties' do
     @item.to_h.should == {
       type: 'http://example.com/vocab/person',
-      properties: {
-        'name' => 'Lorry Woodman',
-        'date' => ['2nd October 2009', Date.iso8601('2009-10-02')],
-        'url' => ['http://example.com/user/lorry']
-      }
+      properties: @item.properties
     }
   end
 
@@ -153,10 +149,10 @@ describe Mida::Item, 'when initialized with an itemscope of a known type that do
       end
     end
 
-    @itemscope = mock(Mida::Itemscope)
-    @itemscope.stub!(:type).and_return("http://example.com/vocab/person")
-    @itemscope.stub!(:id).and_return(nil)
-    @itemscope.stub!(:properties).and_return(
+    itemscope = mock(Mida::Itemscope)
+    itemscope.stub!(:type).and_return("http://example.com/vocab/person")
+    itemscope.stub!(:id).and_return(nil)
+    itemscope.stub!(:properties).and_return(
       { 'name' => ['Lorry Woodman'],
         'tel' => ['000004847582', '111111857485'],
         'url' => ['http://example.com/user/lorry'],
@@ -164,42 +160,19 @@ describe Mida::Item, 'when initialized with an itemscope of a known type that do
         'dob' => 'When I was born'
       }
     )
+    @item = Mida::Item.new(itemscope)
   end
 
-  context 'when validation selected' do
-    before do
-      @item = Mida::Item.new(@itemscope)
-    end
-
-    it '#vocabulary should return the correct vocabulary' do
-      @item.vocabulary.should == Person
-    end
-
-    it 'should not keep properties that have too many values' do
-      @item.properties.should_not have_key('tel')
-    end
-
-    it 'should not keep properties that have the wrong DataType' do
-      @item.properties.should_not have_key('dob')
-    end
+  it '#vocabulary should return the correct vocabulary' do
+    @item.vocabulary.should == Person
   end
 
-  context 'when validation not selected' do
-    before do
-      @item = Mida::Item.new(@itemscope, false)
-    end
-
-    it '#vocabulary should return the correct vocabulary' do
-      @item.vocabulary.should == Person
-    end
-
-    it 'should keep properties even if they have too many values' do
-      @item.properties.should have_key('tel')
-    end
+  it 'should not keep properties that have too many values' do
+    @item.properties.should_not have_key('tel')
+  end
 
-    it 'should keep properties even if they have the wrong DataType' do
-      @item.properties.should have_key('dob')
-    end
+  it 'should not keep properties that have the wrong DataType' do
+    @item.properties.should_not have_key('dob')
   end
 
 end
@@ -255,6 +228,22 @@ describe Mida::Item, 'when initialized with an itemscope containing another corr
     @item.properties['tel'][0].should == '000004847582'
   end
 
+  it "#to_h shouldnt return nested items properly" do
+    @item.to_h.should == {
+      type: 'http://example.com/vocab/person',
+      properties: {
+        'name' => 'Lorry Woodman',
+        'tel' => [ '000004847582',
+                   { type: 'http://example.com/vocab/tel',
+                     properties: { 'dial_code' => '0248583',
+                                   'number' => '000004847582'
+                     }
+                   }
+        ]
+      }
+    }
+  end
+
 end
 
 describe Mida::Item, 'when initialized with an itemscope that has a property type that is a child of the specified type' do
@@ -316,6 +305,10 @@ end
 
 describe Mida::Item, 'when initialized with an itemscope containing another invalid itemscope' do
   before do
+    # Make sure the class is redefined afresh to make sure that
+    # inherited() hook is called
+    Mida::Vocabulary.unregister(Person)
+    Object.send(:remove_const, :Person)
     class Person < Mida::Vocabulary
       itemtype %r{http://example.com/vocab/person}
       has_one 'name'