data_kitten 1.0.0

data/lib/data_kitten/publishing_formats/linked_data.rb

@@ -0,0 +1,102 @@
+module DataKitten
+
+  module PublishingFormats
+    
+    module LinkedData
+      
+      ACCEPT_HEADER = "text/turtle, application/n-triples, application/ld+json; q=1.0,application/rdf+xml; q=0.8, */*; q=0.5"
+      
+      include RDFa
+            
+      private
+      
+      #Find first resource with one of the specified RDF types
+      def self.first_of_type(graph, classes)
+          term = nil
+          classes.each do |clazz|
+              term = graph.first_subject(
+                  RDF::Query::Pattern.new( nil, RDF.type, clazz ) )
+               break if term
+          end
+          term
+      end
+      
+      #Attempt to create an RDF graph for this object
+      #
+      #Supports content negotiation for various RDF serializations. Attempts "dataset autodiscovery" if it receives
+      #an HTML response. This leaves the RDFa Publishing Format to just parse RDFa responses
+      def self.create_graph(uri)
+        
+        resp = RestClient.get uri, 
+            :accept=>ACCEPT_HEADER            
+        return false if resp.code != 200
+
+        if resp.headers[:content_type] =~ /text\/html/
+            doc = Nokogiri::HTML( resp.body )
+            link = doc.search('link[rel=alternate]').detect { |n| n[:type] == 'application/rdf+xml' }
+            if link                
+                resp = RestClient.get link["href"], 
+                    :accept=>ACCEPT_HEADER            
+                return false if resp.code != 200
+            else
+                return false
+            end
+        end
+        
+        reader = RDF::Reader.for( :content_type => resp.headers[:content_type] )
+
+        if !reader
+            extension = File.extname( uri ).gsub(".", "")          
+            reader = RDF::Reader.for( :file_extension => extension ) if extension != ""
+        end
+        return false unless reader
+
+        graph = RDF::Graph.new()
+        graph << reader.new( StringIO.new( resp.body ))
+               
+        return graph     
+      rescue => e
+        #puts e
+        #puts e.backtrace
+        nil
+      end
+
+      #Can we create an RDF graph for this object containing the description of a dataset?
+      def self.supported?(instance)
+          graph = create_graph(instance.uri)
+          return false unless graph
+          return true if first_of_type(graph, 
+              [RDF::Vocabulary.new("http://www.w3.org/ns/dcat#").Dataset, 
+               RDF::Vocabulary.new("http://rdfs.org/ns/void#").Dataset])
+          return false          
+      end      
+      
+      public
+      
+      # The publishing format for the dataset.
+      # @return [Symbol] +:rdfa+
+      # @see Dataset#publishing_format
+      def publishing_format
+        :rdf
+      end
+            
+      def uri
+        access_url
+      end
+      
+      private
+      
+      def dataset_uri
+        access_url
+      end
+            
+      def graph
+        if !@graph
+          @graph = LinkedData.create_graph(access_url)
+        end
+        @graph   
+      end
+      
+    end
+  end
+end

data/lib/data_kitten/publishing_formats/rdfa.rb

@@ -0,0 +1,239 @@
+module DataKitten
+
+  module PublishingFormats
+    
+    module RDFa
+      
+      private
+      
+      def self.supported?(instance)
+        graph = RDF::Graph.load(instance.uri, :format => :rdfa)
+        
+        query = RDF::Query.new({
+          :dataset => {
+            RDF.type  => RDF::Vocabulary.new("http://www.w3.org/ns/dcat#").Dataset
+          }
+        })
+        
+        query.execute(graph)[0][:dataset].to_s
+      rescue
+        false
+      end
+      
+      public
+      
+      # The publishing format for the dataset.
+      # @return [Symbol] +:rdfa+
+      # @see Dataset#publishing_format
+      def publishing_format
+        :rdfa
+      end
+      
+      # A list of maintainers.
+      #
+      # @see Dataset#maintainers
+      def maintainers
+        []
+      end
+      
+      # A list of publishers.
+      #
+      # @see Dataset#publishers
+      def publishers
+        publishers = []
+        uris = metadata[dataset_uri][RDF::DC.publisher.to_s]
+        uris.each do |publisher_uri|
+          publishers << Agent.new(:name => first_value( publisher_uri, RDF::FOAF.name ), 
+                                  :homepage => first_value( publisher_uri, RDF::FOAF.homepage ), 
+                                  :mbox => first_value( publisher_uri, RDF::FOAF.mbox ))
+        end
+        return publishers
+      rescue
+        []    
+      end
+      
+      # The rights statment for the data
+      #
+      # @see Dataset#rights
+      def rights
+        rights_uri = metadata[dataset_uri][RDF::DC.rights.to_s][0]
+        if !metadata[rights_uri]
+            return Rights.new(:uri => rights_uri)
+        else
+          return Rights.new(:uri => uri, 
+                              :dataLicense => first_value( rights_uri, odrs.dataLicense ), 
+                              :contentLicense => first_value( rights_uri, odrs.contentLicense ), 
+                              :copyrightNotice => first_value( rights_uri, odrs.copyrightNotice ), 
+                              :attributionURL => first_value( rights_uri, odrs.attributionURL ),
+                              :attributionText => first_value( rights_uri, odrs.attributionText ),
+                              :copyrightHolder => first_value( rights_uri, odrs.copyrightHolder ),
+                              :databaseRightHolder => first_value( rights_uri, odrs.databaseRightHolder ),
+                              :copyrightYear => first_value( rights_uri, odrs.copyrightYear ),
+                              :databaseRightYear => first_value( rights_uri, odrs.databaseRightYear ),
+                              :copyrightStatement => first_value( rights_uri, odrs.copyrightStatement ),
+                              :databaseRightStatement => first_value( rights_uri, odrs.databaseRightStatement )
+                              )
+        end
+      rescue => e
+        #puts e
+        #puts e.backtrace
+        nil
+      end
+      
+      # A list of licenses.
+      #
+      # @see Dataset#licenses
+      def licenses
+        licenses = []
+        uris = metadata[dataset_uri][RDF::DC.license.to_s]
+        if uris.nil?
+          []
+        else
+          uris.each do |license_uri|
+            licenses << License.new(:uri => license_uri, :name => first_value( license_uri, RDF::DC.title ))
+          end
+          return licenses
+        end
+      rescue => e
+        []
+      end
+      
+      # A list of contributors.
+      #
+      # @see Dataset#contributors
+      def contributors
+        []
+      end
+      
+      # A list of distributions, referred to as +resources+ by Datapackage.
+      #
+      # @see Dataset#distributions
+      def distributions
+        distributions = []
+        uris = metadata[dataset_uri][dcat.distribution.to_s]
+        uris.each do |distribution_uri|
+          distribution = {
+            :title => first_value( distribution_uri, RDF::DC.title ),
+            :accessURL => first_value( distribution_uri, dcat.accessURL )
+          }
+          distributions << Distribution.new(self, dcat_resource: distribution)
+        end
+        return distributions
+      rescue
+        []
+      end
+      
+      # The human-readable title of the dataset.
+      #
+      # @see Dataset#data_title
+      def data_title
+        metadata[dataset_uri][dct.title.to_s][0] rescue nil
+      end
+      
+      # A brief description of the dataset
+      #
+      # @see Dataset#description
+      def description
+        metadata[dataset_uri][dct.description.to_s][0] rescue nil
+      end
+      
+      # Keywords for the dataset
+      #
+      # @see Dataset#keywords
+      def keywords
+        keywords = []
+        metadata[dataset_uri][dcat.keyword.to_s].each do |k|
+          keywords << k
+        end
+      rescue
+        []
+      end
+      
+      # Where the data is sourced from
+      #
+      # @see Dataset#sources
+      def sources
+        []
+      end
+      
+      # How frequently the data is updated.
+      #
+      # @see Dataset#update_frequency
+      def update_frequency
+        first_value( dataset_uri, dcat.accrualPeriodicity )
+      end
+      
+      def issued
+        date = first_value(dataset_uri, RDF::DC.issued) || 
+               first_value(dataset_uri, RDF::DC.created)
+        if date
+            return Date.parse( date )
+        end
+        return nil
+      end
+    
+      def modified
+        date = first_value(dataset_uri, RDF::DC.modified)
+        if date
+            return Date.parse( date )
+        end
+        return nil
+      end
+      
+      private
+            
+      def graph
+        @graph ||= RDF::Graph.load(uri, :format => :rdfa)  
+      end
+              
+      def first_value(resource, property, default=nil)
+          if metadata[resource] && metadata[resource][property.to_s]
+              return metadata[resource][property.to_s][0]
+          end
+          return default
+      end
+                
+      def metadata        
+        @metadata ||= {}
+        
+        # This is UGLY, and exists solely to make getting data out of the graph easier. We will probably change this later       
+        graph.triples.each do |triple|
+          @metadata[triple[0].to_s] ||= {}
+          @metadata[triple[0].to_s][triple[1].to_s] ||= []
+          @metadata[triple[0].to_s][triple[1].to_s] << triple[2].to_s unless @metadata[triple[0].to_s][triple[1].to_s].include? triple[2].to_s
+        end
+        
+        return @metadata
+      end
+      
+      def dataset_uri
+        query = RDF::Query.new({
+          :dataset => {
+            RDF.type  => dcat.Dataset
+          }
+        })
+        
+        query.execute(graph)[0][:dataset].to_s
+      end
+      
+      def dcat
+        RDF::Vocabulary.new("http://www.w3.org/ns/dcat#")
+      end
+      
+      def dct
+        RDF::Vocabulary.new("http://purl.org/dc/terms/")
+      end
+      
+      def odrs
+        RDF::Vocabulary.new("http://schema.theodi.org/odrs#")
+      end
+      
+      def void
+        RDF::Vocabulary.new("http://rdfs.org/ns/void#")
+      end
+            
+    end
+    
+  end
+  
+end

data/lib/data_kitten/rights.rb

@@ -0,0 +1,80 @@
+module DataKitten
+
+  # A rights statement for a {Dataset} or {Distribution}
+  #
+  class Rights
+
+    # @!attribute uri
+    #   @return [String] the URI for the rights statement
+    attr_accessor :uri
+    
+    # @!attribute dataLicense
+    #   @return [String] the license for the data in the dataset.
+    attr_accessor :dataLicense
+    
+    # @!attribute contentLicense
+    #   @return [String] the license for the content in the dataset.
+    attr_accessor :contentLicense
+    
+    # @!attribute copyrightNotice
+    #   @return [String] the copyright notice for the dataset.
+    attr_accessor :copyrightNotice
+    
+    # @!attribute attributionURL
+    #   @return [String] the attribution URL for the dataset.
+    attr_accessor :attributionURL
+
+    # @!attribute attributionText
+    #   @return [String] the attribution text for the dataset.
+    attr_accessor :attributionText
+
+    # @!attribute copyrightHolder
+    #   @return [String] the URI of the organization that holds copyright for this dataset
+    attr_accessor :copyrightHolder
+    
+    # @!attribute databaseRightHolder
+    #   @return [String] the URI of the organization that owns the database rights for this dataset
+    attr_accessor :databaseRightHolder
+          
+    # @!attribute copyrightYear
+    #   @return [String] the year in which copyright is claimed
+    attr_accessor :copyrightYear   
+   
+    # @!attribute databaseRightYear
+    #   @return [String] the year in which copyright is claimed
+    attr_accessor :databaseRightYear      
+    
+    # @!attribute copyrightStatement
+    #   @return [String] the URL of a copyright statement for the dataset
+    attr_accessor :copyrightStatement   
+    
+    # @!attribute databaseRightStatement
+    #   @return [String] the URL of a database right statement for the dataset
+    attr_accessor :databaseRightStatement       
+    
+    # Create a new Rights object.
+    #
+    # @param options [Hash] A set of options with which to initialise the license.
+    # @option options [String] :dataLicense the license for the data in the dataset
+    # @option options [String] :contentLicense the license for the content in the dataset
+    # @option options [String] :copyrightNotice the copyright notice for the dataset
+    # @option options [String] :attributionURL the attribution URL for the dataset
+    # @option options [String] :attributionText attribution name for the dataset
+    def initialize(options)
+      @uri = options[:uri]
+      @dataLicense = options[:dataLicense]
+      @contentLicense = options[:contentLicense]
+      @copyrightNotice = options[:copyrightNotice]
+      @attributionURL = options[:attributionURL]
+      @attributionText = options[:attributionText]
+      @copyrightHolder = options[:copyrightHolder]
+      @databaseRightHolder = options[:databaseRightHolder]
+      @copyrightYear = options[:copyrightYear]
+      @databaseRightYear = options[:databaseRightYear]
+      @copyrightStatement = options[:copyrightStatement]
+      @databaseRightStatement = options[:databaseRightStatement]
+    end
+
+  end  
+
+end

data/lib/data_kitten/source.rb

@@ -0,0 +1,31 @@
+module DataKitten
+  
+  # Where the data has been sourced from
+  # Follows the pattern of {http://purl.org/dc/terms/source} with a {http://www.w3.org/2000/01/rdf-schema#label} and a {http://www.w3.org/1999/02/22-rdf-syntax-ns#resource}, and with useful aliases for other vocabularies
+  
+  class Source
+    
+    # Create a new Source
+    # 
+    # @param [Hash] options the details of the Source.
+    # @option options [String] :label The name of the Source
+    # @option options [String] :resource The URI of the Source
+    #
+    def initialize(options)
+      @label = options[:label]
+      @resource = options[:resource]
+    end
+    
+    # @!attribute label
+    #   @return [String] the name of the Source
+    attr_accessor :label
+    alias_method :name, :label
+    
+    # @!attribute label
+    #   @return [String] the URI of the Source
+    attr_accessor :resource
+    alias_method :web, :resource
+    
+  end
+  
+end