imw 0.2.18 → 0.3.0

data/spec/imw/formats/sgml_spec.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__),'../../spec_helper')
-
-describe IMW::Formats::Xml do
-  # just spec Xml now as the others are identical
-
-  before do
-    @sample = IMW.open(File.join(IMWTest::DATA_DIR, 'formats/sgml/sample.xml'))
-  end
-
-  it "should be able to load the XML" do
-    ((@sample.load/"genus").first/"name").first.inner_text.should == 'Mandrillus'
-  end
-
-  it "should yield the XML when load is given a block" do
-    @sample.load do |xml|
-      ((xml/"genus").first/"name").first.inner_text.should == 'Mandrillus'
-    end
-  end
-
-  it "should parse the XML" do
-    @sample.parse(:species => ['species[@id]'])[:species].size.should == 130
-  end
-end
-

data/spec/imw/formats/yaml_spec.rb

@@ -1,19 +0,0 @@
-require File.join(File.dirname(__FILE__),'../../spec_helper')
-
-describe IMW::Formats::Yaml do
-
-  before do
-    @sample = IMW.open(File.join(IMWTest::DATA_DIR, 'formats/yaml/sample.yaml')).load
-  end
-
-  it "should be able to parse the YAML" do
-    @sample['Lophocebus'].first[:id].should == 94
-  end
-
-  it "should be able to write YAML" do
-    data = { 'foobar' => 3, 'bazbooz' => 4 }
-    IMW.open!('test.yaml') { |f| f.emit(data) }
-    IMW.open('test.yaml').load['foobar'].should == 3
-  end
-  
-end

data/spec/imw/metadata/contains_metadata_spec.rb

@@ -1,56 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-
-describe IMW::Metadata::ContainsMetadata do
-
-  before do
-    class Foo
-      attr_accessor :contents
-      def path     ;  IMWTest::TMP_DIR ; end
-      def basename ;  File.basename(IMWTest::TMP_DIR) ; end
-      include IMW::Metadata::ContainsMetadata
-    end
-    @foo = Foo.new
-    @foo.contents = []
-  end
-
-  describe 'finding the default metadata URI' do
-    it "should return the default metadata URI when 'contents' is empty" do
-      @foo.default_metadata_uri.should == File.join(IMWTest::TMP_DIR, File.basename(IMWTest::TMP_DIR) + ".icss.yaml")
-    end
-
-    it "should return the default metadata URI when 'contents' doesn't contain any metadata files" do
-      @foo.contents.concat ['bar.txt', 'crazy_file.yaml', 'foo.json'].map { |p| File.join(IMWTest::TMP_DIR, p) }
-      @foo.default_metadata_uri.should == File.join(IMWTest::TMP_DIR, File.basename(IMWTest::TMP_DIR) + ".icss.yaml")
-    end
-
-    %w[my-projects.icss.yaml stupid-crazy-fool-of-a-dataset-icss.json foobar-25.metadata.buzz.yml].each do |basename|
-      it "should return the metadata URI when 'contents' contains a URI matching '#{basename}'" do
-        @foo.contents.concat ['bar.txt', 'crazy_file.yaml', 'foo.json', basename].map { |p| File.join(IMWTest::TMP_DIR, p) }
-        @foo.default_metadata_uri.should == File.join(IMWTest::TMP_DIR, basename)
-      end
-    end
-  end
-
-
-  describe 'returning its metadata' do
-    it "should return 'nil' when no metadata exists on disk" do
-      @foo.metadata.should be_nil
-    end
-
-    it "should return Metadata when metadata exists on disk" do
-      IMW.open!(@foo.default_metadata_uri) do |f|
-        f.write <<YAML
----
-foo:
-  description: bar
-  fields: baz
-YAML
-      end
-      @foo.metadata.class.should == IMW::Metadata
-      @foo.metadata['foo']['description'].should == 'bar'
-    end
-  end
-  
-  
-
-end

data/spec/imw/metadata/field_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-
-describe IMW::Metadata::Field do
-
-  describe "initializing" do
-    it "should parse a string into a hash" do
-      IMW::Metadata::Field.new('foobar').should == { "name" => 'foobar' }
-    end
-
-    it "should raise an error on a Hash without a :name key" do
-      lambda { IMW::Metadata::Field.new('foo' => 'bar') }.should raise_error(IMW::ArgumentError)
-    end
-
-    it "should accept a Hash with a :name key" do
-      data = { 'name' => :foobar, 'title' => "Bazbooz", 'unit' => "m" }
-      IMW::Metadata::Field.new(data).should == data
-    end
-
-    it "should dup a field if given one" do
-      orig_field = IMW::Metadata::Field.new('foobar')
-      IMW::Metadata::Field.new(orig_field).should == orig_field
-    end
-  end
-  
-end

data/spec/imw/metadata/has_metadata_spec.rb

@@ -1,58 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-
-describe IMW::Metadata::HasMetadata do
-
-  before do
-    class Foo
-      def uri ; File.join(IMWTest::TMP_DIR, 'test', 'subdir', 'foobar.csv') ; end
-      def basename ; File.basename(uri) ; end
-      def extension ; 'csv' ; end
-      def dir ; IMW.open(File.join(IMWTest::TMP_DIR, 'test', 'subdir')) ; end
-      include IMW::Metadata::HasMetadata
-    end
-    @foo = Foo.new
-  end
-
-  it "should be able to build a schema" do
-    @foo.schema.should include(:type, :namespace, :name, :doc, :fields, :non_avro)
-  end
-  
-  describe "finding its metadata" do
-
-    before do
-      FileUtils.mkdir_p(@foo.dir.path)
-      IMWTest::Random.file(File.join(@foo.dir.path, 'foobar.csv'))
-    end
-
-    it "should return 'nil' when it can't find any metadata" do
-      @foo.metadata.should be_nil
-    end
-
-    it "should return 'nil' when a metadata file is found that doesn't describe it" do
-      IMW.open!("has_metadata_test.icss.yaml") do |f|
-        f.write <<YAML
----
-foobar.csv:
-  description: bar
-  fields: ["baz", "booz"]
-YAML
-      end
-      @foo.metadata.should be_nil
-    end
-
-#     it "should return the metadata when a metadata file is found that does describe it" do
-#       IMW.open!("has_metadata_test.icss.yaml") do |f|
-#         f.write <<YAML
-# ---
-# #{IMWTest::TMP_DIR}/test/subdir/foobar.csv:
-#   description: bar
-#   fields: ["baz", "booz"]
-# YAML
-#       end
-#       @foo.metadata.class.should == IMW::Metadata
-#       @foo.metadata[@foo]['description'].should == 'bar'
-#     end
-    
-  end
-  
-end

data/spec/imw/metadata/has_summary_spec.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-
-describe IMW::Metadata::HasSummary do
-
-  before do
-    class Foo
-      def initialize(*args) ; @args = args ; end
-      def uri ;               File.join(IMWTest::TMP_DIR, *@args) ; end
-      def basename ;          File.basename(uri) ; end
-      def extension ;         File.extname(@args.last || '').gsub(/^\./,'') ; end
-      include IMW::Metadata::HasSummary
-    end
-    @foo = Foo.new('foo', 'bar.csv')
-  end
-
-  it "should build a summary from an external summary" do
-    @foo.summary.should include(:uri, :basename, :extension)
-  end
-
-  it "should build a summary from an external summary and a schema when possible" do
-    @foo.stub!(:schema).and_return({:foo => 'bar'})
-    @foo.summary[:schema].should == {:foo => 'bar'}
-  end
-
-  it "should be able to build an external summary describing how it's situated in the world" do
-    @foo.summary[:uri].should       == File.join(IMWTest::TMP_DIR, 'foo', 'bar.csv')
-    @foo.summary[:basename].should  == 'bar.csv'
-    @foo.summary[:extension].should == 'csv'
-  end
-
-end
-

data/spec/imw/metadata/schema_spec.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-
-describe IMW::Metadata::Schema do
-
-  describe "initializing" do
-    it "should merge with a Hash" do
-      IMW::Metadata::Schema.new({:foo => 'foobar'}).should == { :foo => 'foobar' }
-    end
-
-    it "should merge with a Schema" do
-      IMW::Metadata::Schema.new(IMW::Metadata::Schema.new({:foo => 'foobar'})).should == { :foo => 'foobar' }
-    end
-
-    it "should ignore anything else" do
-      IMW::Metadata::Schema.new('foobar').should == {}
-    end
-
-    it "should accept empty args" do
-      IMW::Metadata::Schema.new.should == {}
-    end
-    
-  end
-  
-end

data/spec/imw/metadata_spec.rb

@@ -1,86 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe IMW::Metadata do
-
-  before do
-    @metadata = IMW::Metadata.new({'foobar' => {'description' => 'buzz', 'fields' => ['a','b', 'c']}, 'http://www.google.com' => { 'description' => 'google', 'fields' => ['d', 'e', 'f'] }})
-  end
-
-  describe "matching URLs without a base" do
-
-    it "should be able to look up a relative URI literally" do
-      @metadata.describes?('foobar').should be_true
-    end
-
-    it "should be able to look up a relative URI when passed an IMW::Resource" do
-      @metadata.describes?(IMW.open('foobar')).should be_true
-    end
-
-    it "should be able to look up an absolute URI literally" do
-      @metadata.describes?('http://www.google.com').should be_true
-    end
-
-    it "should rightly fail to literally look up a URI it doesn't know about" do
-      @metadata.describes?('bungler').should be_false
-    end
-    
-  end
-
-  describe "setting URLs" do
-    describe "without a base URL" do
-      it "should set 'foobar' to 'foobar'" do
-        @metadata['foobar'] = {'description' => 'bhaarg', 'fields' => ['a','b','c']}
-        @metadata.keys.should include('foobar')
-      end
-
-      it "should set '/a/b/c/foobar' to '/a/b/c/foobar'" do
-        @metadata['/a/b/c/foobar'] = {'description' => 'bhaarg', 'fields' => ['a','b','c']}
-        @metadata.keys.should include('/a/b/c/foobar')
-      end
-      
-    end
-
-    describe "with a base URL" do
-      before do
-        FileUtils.mkdir_p('chimpo')
-        @metadata.base = File.join(IMWTest::TMP_DIR, 'chimpo')
-      end
-      
-      it "should set 'foobar' to '$base/foobar'" do
-        @metadata['foobar'] = {'description' => 'bhaarg', 'fields' => ['a','b','c']}
-        @metadata.keys.should include(File.join(IMWTest::TMP_DIR, 'chimpo', 'foobar'))
-      end
-
-      it "should set '/a/b/c/foobar' to '/a/b/c/foobar'" do
-        @metadata['/a/b/c/foobar'] = {'description' => 'bhaarg', 'fields' => ['a','b','c']}
-        @metadata.keys.should include('/a/b/c/foobar')
-      end
-      
-    end
-  end
-
-  describe "matching URLs with a base" do
-
-    it "should raise an error when trying to use a base URI that doesn't exist" do
-      lambda { @metadata.base = 'chimpo' }.should raise_error(IMW::PathError)
-    end
-
-    it "should raise an error when trying to use a base URI that isn't a directory" do
-      IMW.open!('chimpo') { |f| f.write('a file') }
-      lambda { @metadata.base = 'chimpo' }.should raise_error(IMW::PathError)
-    end
-
-    it "should be able to look up a URI relative to its base" do
-      FileUtils.mkdir_p('chimpo')
-      @metadata.base = File.join(IMWTest::TMP_DIR, 'chimpo')
-      @metadata['foobar'] = {'description' => 'buzz', 'fields' => ['a','b', 'c']}
-      @metadata.describe?('foobar').should be_true
-      @metadata.describe?(IMW.open('foobar')).should be_true
-    end
-
-    it "should continue to be able to look up an absolute URI literally" do
-      @metadata.describes?('http://www.google.com').should be_true
-    end
-    
-  end
-end

data/spec/imw/parsers/line_parser_spec.rb

@@ -1,96 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-require 'ostruct'
-
-describe IMW::Parsers::LineParser do
-
-  before do
-    @path = File.join(IMWTest::DATA_DIR, 'formats/delimited/sample.csv')
-    @file = File.new(@path)
-    @fields = [:id, :name, :genus, :species]
-  end
-
-  describe "without an implemented parsing method" do
-
-    before do
-      @parser = IMW::Parsers::LineParser.new
-    end
-    
-    it "should raise an error when attempting to parse a line" do
-      lambda { @parser.parse_line "wahtever" }.should raise_error(IMW::NotImplementedError)
-    end
-
-  end
-
-  describe "with an implemented parsing method" do
-
-    before do
-
-      @parser_class = Class.new(IMW::Parsers::LineParser)
-      @parser_class.class_eval do
-        def parse_line line
-          id, name, genus, species = line.chomp.split(',')
-          { :id => id, :name => name, :genus => genus, :species => species }
-        end
-      end
-
-      @parser = @parser_class.new
-    end
-
-    it "should skip lines as needed" do
-      @parser.skip_first = 1
-      results = @parser.parse!(@file)
-      results.length.should == 130
-    end
-
-    it "should read as many lines as it's asked" do
-      results = @parser.parse!(@file, :lines => 10)
-      results.length.should == 10
-    end
-
-    describe "when parsing into hashes" do
-    
-      it "should return an array of hashes when called without a block" do
-        results = @parser.parse!(@file)
-        results.length.should == 131
-        results.first.should == { :id => "ID", :name => "Name", :genus => "Genus", :species => "Species" }
-      end
-
-      it "should pass each hash to a block when given one" do
-        results = [].tap do |array|
-          @parser.parse!(@file) do |hsh|
-            hsh.delete(:id)
-            array << hsh
-          end
-        end
-        results.length.should == 131
-        results.first.should == { :name => "Name", :genus => "Genus", :species => "Species" }
-      end
-    end
-
-    describe "when parsing into objects" do
-      before { @parser.klass = OpenStruct }
-
-      it "should return an array of objects when defined with a class" do
-        results = @parser.parse!(@file)
-        results.length.should == 131
-        results.first.class.should == OpenStruct
-      end
-      
-      it "should pass each object to a block when given one and defined with a class" do
-        @parser.klass = OpenStruct
-        results = [].tap do |array|
-          @parser.parse!(@file) do |obj|
-            obj.genus = nil
-            array << obj
-          end
-        end
-        results.length.should == 131
-        results.first.class.should == OpenStruct
-        results.first.genus.should be_blank
-      end
-    end
-  end
-end
-
-
-

data/spec/imw/parsers/regexp_parser_spec.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + "/../../spec_helper"
-require 'ostruct'
-
-describe IMW::Parsers::RegexpParser do
-
-  before do
-    @path = "foobar.dat"
-    @text = <<EOF
-151.199.53.145 14-Oct-2007:13:34:34-0500 GET /phpmyadmin/main.php HTTP/1.0
-81.227.179.120 14-Oct-2007:13:34:34-0500 GET /phpmyadmin/libraries/select_lang.lib.php HTTP/1.0
-81.3.107.173 14-Oct-2007:13:54:26-0500 GET / HTTP/1.1
-EOF
-    File.open(@path, 'w') { |f| f.write(@text) }
-    @file = File.new(@path)
-
-    @regexp = %r{^([\d\.]+) (\d{2}-\w{3}-\d{4}:\d{2}:\d{2}:\d{2}-\d{4}) (\w+) ([^\s]+) HTTP/([\d.]{3})$}
-    @fields = [:ip, :timestamp, :verb, :url, :version]
-
-    @parser = IMW::Parsers::RegexpParser.new :by_regexp => @regexp, :into_fields => @fields    
-  end
-
-  describe "parsing a line which matches its regexp" do
-    it "should return an appropriate hash" do
-      @parser.parse_line(@file.readline).should == {:ip => '151.199.53.145', :timestamp => '14-Oct-2007:13:34:34-0500', :verb => 'GET', :url => '/phpmyadmin/main.php', :version => "1.0"}
-    end
-  end
-
-  describe "parsing a line which doesn't match its regexp" do
-    before { @parser.regexp = /foobar/ }
-
-    it "return an empty hash if not parsing strictly" do
-      @parser.parse_line(@file.readline).should == {}
-    end
-
-    it "should raise an error if parsing strictly" do
-      @parser.strict = true
-      lambda { @parser.parse_line(@file.readline) }.should raise_error IMW::ParseError
-    end
-  end
-end
-
-