datapackage 0.0.1

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright 2013 The Open Data Institute
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# DataPackage.rb
+
+A ruby library for working with [Data Packages](http://dataprotocols.org/data-packages/).
+
+[![Build Status](http://jenkins.theodi.org/job/datapackage.rb-master/badge/icon)](http://jenkins.theodi.org/job/datapackage.rb-master/)
+[![Code Climate](https://codeclimate.com/github/theodi/datapackage.rb.png)](https://codeclimate.com/github/theodi/datapackage.rb)
+[![Dependency Status](https://gemnasium.com/theodi/datapackage.rb.png)](https://gemnasium.com/theodi/datapackage.rb)
+
+The library is intending to support:
+
+* Parsing and using data package metadata and data
+* Validating data packages to ensure they conform with the Data Package specification
+
+## Installation
+
+Add the gem into your Gemfile:
+
+        gem 'datapackage.rb', :git => "git://github.com/theodi/datapackage.rb.git"
+
+Note: gem release to come
+
+## Basic Usage
+
+Require the gem, if you need to:
+
+    require 'datapackage.rb'
+
+Parsing a datapackage from a remote location:
+
+    package = DataPackage::Package.new( "http://example.org/datasets/a" )
+    
+This assumes that `http://example.org/datasets/a/datapackage.json` exists, or specifically load a JSON file:
+
+    package = DataPackage::Package.new( "http://example.org/datasets/a/datapackage.json" )
+    
+Similarly you can load a package from a local JSON file, or specify a directory:
+
+    package = DataPackage::Package.new( "/my/data/package" )
+    package = DataPackage::Package.new( "/my/data/package/datapackage.json" )
+    
+There are a set of helper methods for accessing data from the package, e.g:
+
+    package = DataPackage::Package.new( "/my/data/package" )
+    package.name
+    package.title
+    package.licenses
+    package.resources
+    
+These currently just return the raw JSON structure, but this might change in future.
+
+## Package Validation
+
+The library supports validating packages. It can be used to validate both the metadata for the package (`datapackage.json`) 
+and the integrity of the package itself, e.g. whether the data files exist.
+
+### Validating a Package
+
+Quickly checking the validity of a package can be achieve as follows:
+
+    package.valid?
+    
+To expose more detail on errors and warnings:
+
+    messages = package.validate() # or package.validate(:datapackage)
+
+This returns an object with two keys: `:errors` and `:warnings`. These are arrays of messages.
+
+Warnings might include notes on missing metadata elements (e.g. package `licenses`) which are not required by the DataPackage specification 
+but which SHOULD be included.
+
+It is possible to treat all warnings as errors by performing strict validation:
+
+    package.valid?(true)
+
+Warnings are currently generated for:
+
+* Missing `README.md` files from packages
+* Missing `licenses` key from `datapackage.json`
+* Missing `datapackage_version` key from `datapackage.json`
+
+### Selecting a Validation Profile
+
+The library contains two validation classes, one for the core Data Package specification and the other for the Simple Data Format 
+rules. By default the library uses the more liberal Data Package rules.
+
+The required profile can be specified in one of two ways. Either as a parameter to the validation methods:
+
+    package.valid?(:datapackage)
+    package.valid?(:simpledataformat)
+    package.validate(:datapackage)
+    package.validate(:simpledataformat)
+
+Or, by using a `DataPackage::Validation` class:
+
+    validator = DataPackage::SimpleDataFormatValidator.new
+    validator.valid?( package )
+    validator.validate( package )
+
+### Approach to Validation
+
+The library will support validating packages against the general rules specified in the 
+[DataPackage specification](http://dataprotocols.org/data-packages/) as well as the stricter requirements given in the 
+[Simple Data Format specification](http://dataprotocols.org/simple-data-format/) (SDF). 
+ 
+SDF is essentially a profile of DataPackage which includes some additional restrictions on 
+how data should be published and described. For example all data is to be published as CSV files.
+
+The validation in the library is divided into two parts:
+
+* Metadata validation -- checking that the structure of the `datapackage.json` file is correcgt
+* Integrity checking -- checking that the overall package and data files appear to be in order
+
+#### Metadata Validation
+
+The basic structure of `datapackage.json` files are validated using [JSON Schema](http://json-schema.org/). This provides a simple 
+declarative way to describe the expected structure of the package metadata. 
+
+The schema files can be found in the `etc` directory of the project and could be used in other applications. The schema files can 
+be customised to support local validation checks (see below).
+
+#### Integrity Checking
+
+While the metadata for a package might be correct, there are other ways in which the package could be invalid. For example, 
+data files might be missing or incorrectly described.
+
+The metadata validation is therefore supplemented with some custom code that performs some other checks:
+
+* (Both profiles) All resources described in the package must be accessible, e.g. the local file exists or a URL responds successfully to a `HEAD`
+* (`:simpledataformat`) All resources must be CSV files
+* (`:simpledataformat`) All resources must have a valid JSON Table Schema
+* (`:simpledataformat`) CSV `dialect` descriptions must be valid
+* (`:simpledataformat`) All fields declared in the schema must be present in the CSV file
+* (`:simpledataformat`) All fields present in the CSV file must be present in the schema
+
+### Customising the Validation Code
+
+The library provides several extension points for customising the way that packages are validated.
+
+#### Supplying Custom JSON Schemas
+
+Custom JSON schemas can be provided to allow validation to be tweaked for local conventions. An options hash can be 
+provided to the constructor of a `DataPackage::Validator` object, this can be used to map schema names to custom 
+schemas.
+
+(Any options passed to the constructor of a `DataPackage::Package` object will also be passed to its validator)
+  
+For example to create a new validation profile called `my-validation-rules` and then apply it:
+
+    opts = {
+        :schema => {
+            :my-validation-rules => "/path/to/json/schema.json"
+        }
+    }
+    package = DataPackage::Package.new( url )
+    package.valid?(:my-validation-rules)
+
+This will cause the code to create a custom `DataPackage::Validator` instance that will apply the supplied schema. This class 
+does not provide any integrity checks.
+
+To mix a custom schema with the existing integrity checking, you must manually create a `Validator` instance. E.g:
+
+    opts = {
+        :schema => {
+            :my-validation-rules => "/path/to/json/schema.json"
+        }
+    }
+    validator = DataPackage::SimpleDataFormatValidator(:my-validation-rules, opts)
+    validator.valid?( package )
+
+Custom schemas must be valid JSON files that conforms to the JSON Schema v4 specification. The absolute path to the schema file must be 
+provided.
+
+Validation is performed using the [json-schema](https://github.com/hoxworth/json-schema) gem which has some documented restrictions.
+     
+The built-in schema files can also be overridden in this way, e.g. by specifying an alternate location for the `:datapackage` schema.
+
+#### Custom Integrity Checking
+
+Integrity checking can be customized by creating new sub-classes of `DataPackage::Validator` or one of the existing sub-classes. 
+
+The following methods can be implemented:
+
+* `validate_metadata(package, messages)` -- perform additional metadata checking after JSON schema is provided.
+* `validate_resource(package, resource, messages)` -- called for each resource in the package

data/etc/README.md

@@ -0,0 +1,18 @@
+This directory contains some JSON Schema documents for validating:
+
+* `datapackage-schema.json` -- [datapackage.json](http://dataprotocols.org/data-packages/) package files
+* `jsontable-schema.json` -- [JSON Table Schemas](http://dataprotocols.org/json-table-schema/) objects
+* `csvddf-dialect-schema.json` -- [CSV Dialect Description Format](http://dataprotocols.org/csv-dialect/) dialect objects
+
+The JSON Table Schemas and CSV Dialect Description Format both define JSON object structures that can appear in `datapackage.json` files (via the `schema` and `dialect` keywords). In the main `datapackage-schema.json` object, these keywords are only validated as simple objects. 
+
+In the application the subsidiary schemas are automatically applied to relevant keys. This could be improved by using JSON Schema cross-referencing.
+
+Other potential improvements include:
+
+* Add `data` keyword validation to `datapackage-schema.json`
+* Add `format` keywords for validating email addresses and date/date-times
+* Or, add `pattern` for validating dates
+* Improve regexs used in various places
+
+

data/etc/csvddf-dialect-schema.json

@@ -0,0 +1,24 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "title": "CSVDDF",
+    "description": "JSON Schema for validating CSVDDF dialect structures",
+    "type": "object",
+    "properties": {
+        "delimiter": {
+            "type": "string"
+        },
+        "doublequote": {
+            "type": "boolean"
+        },
+        "lineterminator": {
+            "type": "string"
+        },
+        "quotechar": {
+            "type": "string"
+        },
+        "skipinitialspace": {
+            "type": "boolean"
+        }
+    },
+    "required": [ "delimiter", "doublequote", "lineterminator", "quotechar", "skipinitialspace" ]
+}

data/etc/datapackage-schema.json

@@ -0,0 +1,208 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "title": "DataPackage",
+    "description": "JSON Schema for validating datapackage.json files",
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "pattern": "^([a-z\\.\\_\\-])+$"
+        },
+        "licences": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "id": { "type": "string" },
+                    "url": { "type": "string" }
+                },
+                "anyOf": [
+                    { "title": "id required", "required": ["id"] },
+                    { "title": "url required", "required": ["url"] }
+                ]
+            }
+        },
+        "datapackage_version": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "homepage": {
+            "type": "string"
+        },
+        "version": {
+            "type": "string"
+        },
+        "sources": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": { "type": "string" },
+                    "web": { "type": "string" },
+                    "email": { "type": "string" }
+                },
+                "anyOf": [
+                        { "title": "name required", "required": ["name"] },
+                        { "title": "web required", "required": ["web"] },
+                        { "title": "email required", "required": ["email"] }
+                ]
+            }
+        },
+        "keywords": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "last_modified": {
+            "type": "string"
+        },
+        "image": {
+            "type": "string"
+        },
+        "bugs": {
+            "type": "string"
+        },
+        "maintainers": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "email": {
+                        "type": "string"
+                    },
+                    "web": {
+                        "type": "string"
+                    }
+                },
+                "required": ["name"]
+            }
+        },
+        "contributors": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "email": {
+                        "type": "string"
+                    },
+                    "web": {
+                        "type": "string"
+                    }
+                },
+                "required": ["name"]
+            }
+        },
+        "publisher": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "email": {
+                        "type": "string"
+                    },
+                    "web": {
+                        "type": "string"
+                    }
+                },
+                "required": ["name"]
+            }
+        },
+        "dependencies": {
+            "type": "object"
+        },
+        "resources": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string"
+                    },
+                    "path": {
+                        "type": "string"
+                    },
+                    "name": {
+                        "type": "string"
+                    },
+                    "format": {
+                        "type": "string"
+                    },
+                    "mediatype": {
+                        "type": "string",
+                        "pattern": "^(.+)/(.+)$"
+                    },
+                    "encoding": {
+                        "type": "string"
+                    },
+                    "bytes": {
+                        "type": "integer"
+                    },
+                    "hash": {
+                        "type": "string",
+                        "pattern": "^([a-fA-F0-9]{32})$"
+                    },
+                    "modified": {
+                        "type": "string"
+                    },
+                    "schema": {
+                        "type": "object"
+                    },
+                    "dialect": {
+                        "type": "object"
+                    },
+                    "sources": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": { "type": "string" },
+                                "web": { "type": "string" },
+                                "email": { "type": "string" }
+                            },
+                            "anyOf": [
+                                    { "title": "name required", "required": ["name"] },
+                                    { "title": "web required", "required": ["web"] },
+                                    { "title": "email required", "required": ["email"] }
+                            ]
+                        }
+                    },
+                    "licences": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": { "type": "string" },
+                                "url": { "type": "string" }
+                            },
+                            "anyOf": [
+                                { "title": "id required", "required": ["id"] },
+                                { "title": "url required", "required": ["url"] }
+                            ]
+                        }
+                    }
+                },
+                "anyOf": [
+                        { "title": "url required", "required": ["url"] },
+                        { "title": "path required", "required": ["path"] }
+                ]   
+            }
+        }
+    },
+    "required": ["name", "resources"]
+}

data/etc/jsontable-schema.json

@@ -0,0 +1,34 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "title": "JSON Table Schema",
+    "description": "JSON Schema for validating JSON Table structures",
+    "type": "object",
+    "properties": {
+        "fields": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "title": {
+                        "type": "string"
+                    },
+                    "description": {
+                        "type": "string"
+                    },
+                    "type": {
+                        "enum": [ "string", "number", "integer", "date", "time", "datetime", "boolean", "binary", "object", "geopoint", "geojson", "array", "any" ]
+                    },
+                    "format": {
+                        "type": "string"
+                    }
+                },
+                "required": ["name"]
+            }
+        }
+    },
+    "required": ["fields"]
+}

data/lib/datapackage/package.rb

@@ -0,0 +1,160 @@
+require 'open-uri'
+
+module DataPackage
+    
+    class Package
+                
+        attr_reader :metadata, :opts
+                
+        # Parse a data package
+        #
+        # Supports reading data from JSON file, directory, and a URL
+        #
+        # package:: Hash or a String
+        # opts:: Options used to customize reading and parsing
+        def initialize(package, opts={})
+            @opts = opts
+            #TODO base directory/url            
+            if package.class == Hash
+                @metadata = package
+            else
+                if !package.start_with?("http") && File.directory?(package)
+                    package = File.join(package, opts[:default_filename] || "datapackage.json")
+                end
+                if package.start_with?("http") && !package.end_with?("datapackage.json")
+                    package = URI.join(package, "datapackage.json")
+                end                    
+                @location = package.to_s
+                @metadata = JSON.parse( open(package).read )                
+            end
+        end
+        
+        #Returns the directory for a local file package or base url for a remote
+        #Returns nil for an in-memory object (because it has no base as yet)
+        def base
+            #user can override base
+            return @opts[:base] if @opts[:base]
+            return "" unless @location
+            #work out base directory or uri
+            if local?
+                return File.dirname( @location )
+            else
+                return @location.split("/")[0..-2].join("/")
+            end
+        end
+        
+        #Is this a local package? Returns true if created from an in-memory object or a file/directory reference
+        def local?             
+            return !@location.start_with?("http") if @location
+            return true
+        end
+        
+        def name
+            @metadata["name"]
+        end
+        
+        def title
+            @metadata["title"]
+        end
+        
+        def description
+            @metadata["description"]
+        end
+        
+        def homepage
+            @metadata["homepage"]
+        end
+        
+        def licenses
+            @metadata["licenses"] || []
+        end
+        alias_method :licences, :licenses
+        
+        #What version of datapackage specification is this using?
+        def datapackage_version
+            @metadata["datapackage_version"]
+        end
+        
+        #What is the version of this specific data package?
+        def version
+            @metadata["version"]
+        end
+        
+        def sources
+            @metadata["sources"] || []
+        end
+        
+        def keywords
+            @metadata["keywords"] || []
+        end
+        
+        def last_modified
+            DateTime.parse @metadata["last_modified"] rescue nil 
+        end
+        
+        def image
+            @metadata["image"]
+        end
+        
+        def maintainers
+            @metadata["maintainers"] || []
+        end
+        
+        def contributors
+            @metadata["contributors"] || []
+        end
+        
+        def publisher
+            @metadata["publisher"] || []
+        end
+        
+        def resources
+            @metadata["resources"] || []
+        end
+        
+        def dependencies
+            @metadata["dependencies"]
+        end
+        
+        def property(property, default=nil)
+            @metadata[property] || default
+        end
+        
+        def valid?(profile=:datapackage, strict=false)
+            validator = DataPackage::Validator.create(profile, @opts)
+            return validator.valid?(self, strict)
+        end
+        
+        def validate(profile=:datapackage)
+            validator = DataPackage::Validator.create(profile, @opts)
+            return validator.validate(self)
+        end
+        
+        def resolve_resource(resource)
+            return resource["url"] || resolve( resource["path"] )
+        end
+        
+        def resolve(path)
+            if local?
+                return File.join( base , path) if base != ""
+                return path
+            else
+                return URI.join(base, path)
+            end
+        end
+        
+        def resource_exists?(location)
+            if !location.to_s.start_with?("http")                
+                return File.exists?( location )
+            else
+                begin
+                    status = RestClient.head( location ).code
+                    return status == 200 
+                rescue => e
+                    return false
+                end                
+            end
+        end
+             
+    end
+end

data/lib/datapackage/validator.rb

@@ -0,0 +1,176 @@
+module DataPackage
+    
+    #Base class for validators
+    class Validator
+                
+        def Validator.create(profile, opts={})
+            if profile == :simpledataformat
+                return SimpleDataFormatValidator.new(profile, opts)
+            end
+            if profile == :datapackage
+                return DataPackageValidator.new(profile, opts)
+            end
+            return Validator.new(profile, opts)
+        end
+                
+        def initialize(schema_name, opts={})
+            @schema_name = schema_name
+            @opts = opts
+        end
+        
+        def valid?(package, strict=false)
+            messages = validate( package )
+            return messages[:errors].empty? if !strict
+            return messages[:errors].empty? && messages[:warnings].empty? 
+        end
+        
+        def validate( package )
+            return validate_integrity( package, validate_with_schema(package) )
+        end
+
+        def validate_with_schema(package)
+            schema = load_schema(@schema_name)
+            messages = {
+                :errors => JSON::Validator.fully_validate(schema, package.metadata, :errors_as_objects => true),
+                :warnings => [] 
+            }
+            validate_metadata(package, messages)
+            return messages
+        end
+
+        def validate_integrity(package, messages={ :errors=>[], :warnings=>[] } )            
+            package.resources.each do |resource|
+                validate_resource(package, resource, messages)
+            end
+            
+            messages
+        end
+
+        protected 
+        
+        #implement to perform additional validation on metadata
+        def validate_metadata(package, messages)
+        end
+        
+        #implement for per-resource validation
+        def validate_resource(package, resource, messages)
+        end
+        
+        protected
+        
+        def load_schema(profile)
+            if @opts[:schema] && @opts[:schema][profile]
+                if !File.exists?( @opts[:schema][profile] )
+                    raise "User supplied schema file does not exist: #{@opts[:schema][profile]}"
+                end                 
+                return JSON.parse( File.read( @opts[:schema][profile] ) )
+            end
+            schema_file = file_in_etc_directory( "#{profile}-schema.json" )
+            if !File.exists?( schema_file )
+                raise "Unable to read schema file #{schema_file} for validation profile #{profile}"
+            end
+            return JSON.parse( File.read( schema_file ) )
+        end
+                
+        private
+        
+        def file_in_etc_directory(filename)
+            File.join( File.dirname(__FILE__), "..", "..", "etc", filename )
+        end
+                
+    end
+    
+    #Extends base class with some additional checks for DataPackage conformance.
+    #
+    #These include some warnings about missing metadata elements and an existence
+    #check for all resources 
+    class DataPackageValidator < Validator
+        def initialize(schema_name=:datapackage, opts={})
+            super(:datapackage, opts)
+        end        
+        
+        def validate_metadata(package, messages)
+            #not required, but recommended
+            prefix = "The package does not include a"
+            messages[:warnings] << "#{prefix} 'licenses' property" if package.licenses.empty?
+            messages[:warnings] << "#{prefix} 'datapackage_version' property" unless package.datapackage_version 
+            messages[:warnings] << "#{prefix} README.md file" unless package.resource_exists?( package.resolve("README.md") )            
+        end
+        
+        def validate_resource(package, resource, messages)
+            if !package.resource_exists?( package.resolve_resource( resource ) )
+                messages[:errors] << "Resource #{resource["url"] || resource["path"]} does not exist"
+            end            
+        end
+        
+    end
+    
+    #Validator that checks whether a package conforms to the Simple Data Format profile
+    class SimpleDataFormatValidator < DataPackageValidator
+        
+        def initialize(schema_name=:datapackage, opts={})
+            super(:datapackage, opts)
+            @jsontable_schema = load_schema(:jsontable)
+            @csvddf_schema = load_schema("csvddf-dialect")
+        end
+        
+        def validate_resource(package, resource, messages)
+            super(package, resource, messages)
+            
+            if !csv?(resource)
+                messages[:errors] << "#{resource["name"]} is not a CSV file"
+            else                
+                if !resource["schema"]
+                    messages[:errors] << "#{resource["name"]} does not have a schema"
+                else
+                    messages[:errors] +=
+                        JSON::Validator.fully_validate(@jsontable_schema, 
+                            resource["schema"], :errors_as_objects => true)                                                           
+                end            
+                if resource["dialect"]
+                    messages[:errors] +=
+                        JSON::Validator.fully_validate(@csvddf_schema, 
+                            resource["dialect"], :errors_as_objects => true)                                
+                end
+                
+                if resource["schema"] && resource["schema"]["fields"]
+                    fields = resource["schema"]["fields"]
+                    declared_fields = fields.map{ |f| f["name"] }
+                    headers = headers(package, resource)
+                    
+                    #set algebra to finding fields missing from schema and/or CSV file
+                    missing_fields = declared_fields - headers
+                    if missing_fields != []
+                        messages[:errors] << 
+                            "Declared schema has fields not present in CSV file (#{missing_fields.join(",")})"
+                    end
+                    undeclared_fields = headers - declared_fields
+                    if undeclared_fields != []
+                        messages[:errors] << "CSV file has fields missing from schema (#{undeclared_fields.join(",")})"
+                    end                    
+                end
+                
+            end
+            
+        end
+        
+        def csv?(resource)
+            resource["mediatype"] == "text/csv" ||
+            resource["format"] == "csv"       
+        end  
+        
+        def headers(package, resource)
+            headers = []
+            opts = dialect_to_csv_options(resource["dialect"])
+            CSV.open( package.resolve_resource(resource), "r", opts) do |csv|
+                headers = csv.shift
+            end
+            return headers
+        end
+                            
+        def dialect_to_csv_options(dialect)
+            return {}
+        end
+    end
+        
+end

data/lib/datapackage/version.rb

@@ -0,0 +1,3 @@
+module DataPackage
+  VERSION = "0.0.1"
+end

data/lib/datapackage.rb

@@ -0,0 +1,11 @@
+require 'date'
+require 'uri'
+require 'net/http'
+require 'csv'
+require 'json'
+require 'json-schema'
+require 'rest-client'
+
+require 'datapackage/version'
+require 'datapackage/validator'
+require 'datapackage/package'

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: datapackage
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Leigh Dodds
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: 
+email:
+- leigh@ldodds.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- etc/jsontable-schema.json
+- etc/datapackage-schema.json
+- etc/README.md
+- etc/csvddf-dialect-schema.json
+- lib/datapackage.rb
+- lib/datapackage/validator.rb
+- lib/datapackage/package.rb
+- lib/datapackage/version.rb
+- LICENSE.md
+- README.md
+homepage: http://github.com/theodi/datapackage.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Library for working with data packages
+test_files: []
+has_rdoc: