easy_data3 0.0.2

data/lib/data_models/linked_data_graph.rb

@@ -0,0 +1,80 @@
+class LinkedDataGraph
+
+   def self.build(models)
+      
+    models.each do |model|
+      graph = {}
+      
+      #graph[:models] = get_attributes_ponderations(models)
+      graph[:assoc] = get_associations(model)
+      
+      generate_graph(graph,model) if !graph[:assoc].empty?
+    end
+   end
+
+   private
+
+   def self.get_attributes_ponderations(model)
+     associations = {}
+     
+      model = eval model
+      if model.respond_to?:reflections
+       associations[model.to_s.gsub("::","_")] = model.reflections.count
+      else
+       associations[model.to_s.gsub("::","_")] = 0 
+      end
+     
+   end
+
+   def self.get_associations(model)
+     assoc = []
+     
+     model = eval model
+       if model.respond_to?:reflections
+         model.reflections.each do |name,info|
+           mod_assoc = info.name.to_s.camelize
+           begin
+              eval mod_assoc
+           rescue
+             begin
+              eval mod_assoc.pluralize
+              mod_assoc = (mod_assoc.pluralize)
+             rescue
+                 (mod_assoc = info.options[:source].to_s.camelize)if info.options[:source]
+             end
+           end
+           if mod_assoc
+             assoc << mod_assoc
+           end
+         end
+       end
+     assoc
+   end
+
+   def self.generate_graph(graph_info,model)
+      model = model.gsub("::","_")
+      file = File.open("#{RAILS_ROOT}/public/images/linked_data_graphs/linked_data_#{model}.dot",'w')
+      
+      file.puts "digraph G {"
+      #file.puts 'size="15,15";'
+      file.puts 'graph [rotate=0, rankdir="LR"]'
+      file.puts 'node [color="#333333", style=filled,shape=box, fontname="Trebuchet MS"]'
+      file.puts 'edge [color="#666666", arrowhead="open", fontname="Trebuchet MS", fontsize="11"]'
+      file.puts model.to_s+'  [fillcolor="#116611", fontcolor="white"]'
+
+      #Draw nodes
+
+      graph_info[:assoc].each do |assoc|
+         file.puts assoc.to_s+' [fillcolor="#294b76", fontcolor="white"]'
+         file.puts '"'+model+'" -> "'+assoc.to_s+'"[dir=none];'
+      end
+
+
+      file.puts "}"
+
+      file.close
+
+      system "dot -Tpng #{RAILS_ROOT}/public/images/linked_data_graphs/linked_data_#{model}.dot -o #{RAILS_ROOT}/public/images/linked_data_graphs/linked_data_#{model}.png"
+      system "rm #{RAILS_ROOT}/public/images/linked_data_graphs/linked_data_#{model}.dot"
+   end
+end

data/lib/data_models/model_rdf.rb

@@ -0,0 +1,344 @@
+require "yaml"
+
+class ModelRdf 
+    
+   #######################################################################
+   # Attributes declarations
+   #######################################################################
+   @@privacy = ["Hidden","Public","Authenticated"]
+   
+   attr_accessor :model_rdf
+
+
+   #######################################################################
+   # Query methods
+   #######################################################################   
+
+   #Read the document of attributes relations with rdf properties
+   # @return [Object] return a ModelRdf's instance whit rdf info 
+   def initialize
+     @model_rdf = YAML::load(File.open("#{RAILS_ROOT}/config/easy_data/rdf_info.yaml"))
+   end
+
+   # Return datas stored in the RDF informations yaml file
+   # @return [Hash] return RDF informations
+   def get_models
+      self.model_rdf
+   end
+   
+   # Return data stored in the RDF informations yaml file about publicated models
+   # @return [Hash] return RDF information about public access information of publicated models
+   def get_public_models
+      models = []
+      self.load_models.each do |mod|
+        if self.public?(mod) 
+          models << mod
+        end
+      end
+   end
+   
+   # Return data stored in the RDF informations yaml file about publicated models.
+   # @return [Hash] return RDF information about not hidden rdf information's models. 
+   def get_not_hidden_models
+     models = []
+     self.load_models.each do |mod|
+       unless self.hidden?(mod) 
+         models << mod
+       end
+     end
+     models
+   end
+ 
+   # Check if the model is public
+   # @param [Symbol] model's name
+   # @return [Boolean] true or false
+   def public?(model)
+      self.model_rdf[model][:privacy] == "Public"
+   end 
+
+   # Check if the model is private
+   # @param [Symbol] model's name
+   # @return [Boolean] true or false
+   def private?(model)
+      self.model_rdf[model][:privacy] == "Private"
+   end
+
+   # Check if the model is hidden
+   # @param [Symbol] model's name
+   # @return [Boolean] true or false
+   def hidden?(model)
+      self.model_rdf[model][:privacy] == "Hidden"
+   end
+
+   # Model RDF informations and privacy
+   # @param [String] model's name
+   # @return [Hash] hash with RDF and privacy information about the model 
+   def get_rdf_info_model(model)
+      {:namespace => self.model_rdf[model][:namespace],:property => self.model_rdf[model][:property]}
+   end
+
+   # Return attributes of model stored in the configuration yaml file
+   # @param [String] model's name  
+   # @return [Hash] Return all information about the model and his data.
+   def get_attributes_model(model)
+      self.model_rdf[model] 
+   end
+   
+   # Return all models which they are assocciations of current model
+   # @param [String] current model name
+   # @return [Array] list of models which the are assocciations with current model.
+   def get_associations_model(model)
+      associations = self.model_rdf[model]['associations'].keys
+      models = DataModels.load_models
+      hash_associations = {}
+
+      associations.each do |assc|
+        if models.include?assc.camelize
+          hash_associations[assc] = assc 
+        elsif eval(model+'.reflections[:'+assc+'].class_name')
+          hash_associations[assc] = eval(model+'.reflections[:'+assc+'].class_name')
+        else
+          hash_associations[assc] = eval(model+'.reflections[:'+assc+'].options[:class_name]')
+        end
+      end
+
+      hash_associations
+   end
+
+   # RDFa: Return attributes of model RDF info
+   # @param [String] model's name
+   # @return [String] model's rdf information to insert in HTML tag
+   def model(model)
+     info = get_rdf_info_model(model)
+     if info[:property] && info[:property]!= "not defined"
+      " typeof='#{info[:namespace]}:#{info[:property]}'"
+     else
+      " "
+     end
+   end
+  
+   def add_model(model,attributes)
+       self.model_rdf[model] = attributes
+   end 
+   
+   def delete_model(model)
+       self.model_rdf.delete(model)
+   end
+   # Update model rdf info
+   # @param [String] model's name
+   # @param [String] model's property to be updated
+   # @param [Strign] new value 
+   # @return [Boolean] true or false if the operation has finished correctly. 
+   def update_model(model,param,value)
+      self.model_rdf[model][param.to_sym] = value
+   end
+
+   # update attributes with rdf properties.
+   # @param [String] model's name
+   # @param [String] model's attribute
+   # @param [String] attribute's property to be updated
+   # @param [Strign] new value 
+   # @return [Boolean] true or false if the operation has finished correctly. 
+   def update_attributes_model(model,attribute,param,value)
+      self.model_rdf[model]['attributes'][attribute][param.to_sym] = value
+   end
+   
+   # RDFa: Return attribute rdf info
+   # @param [String] model's name
+   # @param [Strign] model's attribute
+   # @return [String] RDF information about model's attribute to insert in HTML tag.
+   def attribute(model,attribute)
+      att_rdf = self.model_rdf[model]['attributes'][attribute]
+      " property='#{att_rdf[:namespace]}:#{att_rdf[:property]}'"
+   end
+
+   # update associations with rdf properties.
+   # @param [String] model's name
+   # @param [String] model's attribute
+   # @param [String] association's property to be updated
+   # @param [Strign] new value 
+   # @return [Boolean] true or false if the operation has finished correctly. 
+   def update_associations_model(model,association,param,value)
+      self.model_rdf[model]['associations'][association][param.to_sym] = value
+   end
+
+   # RDFa: return a string with all prefix used to describes attributes
+   # @param [String] model's name
+   # @return [String] list of prefix to be used in RDFa information
+   def get_prefix(model)
+      prefix = []
+      data_model = get_attributes_model(model)
+      data_model["attributes"].each do |att,info|
+       if info[:namespace] && info[:namespace] != 'not defined'
+        puts info[:namespace]
+        prefix << "xmls:#{info[:namespace]}=#{(eval "EasyData::RDF::#{info[:namespace].upcase}.get_uri")} "
+       end
+      end
+      data_model["associations"].each do |assoc,info|
+       if info[:namespace] && info[:namespace] != 'not defined'
+        prefix << "xmls:#{info[:namespace]}=#{(eval "EasyData::RDF::#{info[:namespace].upcase}.get_uri")} "
+       end
+      end
+
+      if data_model[:namespace] && data_model[:namespace] != 'not defined'
+        prefix << "xmls:#{data_model[:namespace]}=#{(eval "EasyData::RDF::#{data_model[:namespace].upcase}.get_uri")}"
+      end
+
+      prefix.uniq.join(" ")
+   end
+
+   # Convert index privacy to string
+   # @param [Integer] Index of privacy
+   # @return [String] Privacy label
+   def privacy(index)
+     @@privacy[index]
+   end
+   
+   # Save changes in rdf_info.yaml (configuration's yaml file)
+   # return [Boolean] true or false if operations has finished correctly
+   def save
+     file = File.open("#{RAILS_ROOT}/config/easy_data/rdf_info.yaml",'w')
+     file.puts YAML::dump(self.model_rdf)
+     file.close
+   end
+
+
+   def refresh_information
+   end
+   #######################################################################
+   # Building RDF
+   #######################################################################
+   
+   # Build a response to user's request
+   # @param [Array] Response's data   
+   # @param [String] model's name
+   # @param [String] current host
+   # @return [Hash] Response to be render in rdf file. 
+   def get_model_rdf(query,model,host)
+      
+      if public?model
+       request = {:body => "",:header => {"xmlns:rdf"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#"}}
+       elements = {}
+       models = []
+       query.each do |element|
+          elements[element.id] = {'description' => "#{host}/s/#{element.class.to_s}/#{element.id}",
+                                  'attributes' => get_properties_tag(element),
+                                  'associations' => get_associations_tag(element)
+                                 }
+       
+          models << element.class.to_s
+       end     
+    
+       attributes = {}
+       request[:body] = elements
+       models.each do |mod|
+         attributes = get_attributes_model(mod) || get_attributes_model((eval mod).base_class.to_s)
+         request[:header].merge!(get_header(attributes))
+       end
+       request
+      else
+       {}
+      end
+   end
+   # Get all namespace used to build the response
+   # @param [Array] list of attributes
+   # @return [Array] list of namespaces used to describes them.
+   def get_header(attributes)
+      headers = {}
+      
+      (attributes["attributes"].merge(attributes["associations"])).each do |att,properties|
+        if properties != "no publication" && properties[:namespace] != 'not defined' && properties[:privacy]=="Public"
+           headers["xmlns:#{properties[:namespace]}"] = (eval "EasyData::RDF::#{properties[:namespace].upcase}.get_uri") #EasyData.get_uri_namespace(properties[:namespace])
+        end
+      end    
+     
+      headers
+   end
+
+   # Return all attribute's information of a model's instance
+   # @param [Object] Model's instance
+   # @return [Hash] RDF's attributes informations about the object 
+   def get_properties_tag(element)
+
+      attributes = get_attributes_model(element.class.to_s)
+
+      # If element's class is a polimorphic class, we used base class.
+      if attributes.nil?
+        attributes = get_attributes_model(element.class.base_class.to_s)
+      end 
+
+      properties = {}
+      if element.attributes.respond_to? :each 
+       element.attributes.each do |att|
+         #conditions to methods to check if can be show
+        begin        
+         
+         if can_see?(attributes["attributes"][att.first][:privacy]) && exist_info_att(attributes["attributes"][att.first],att.second)
+           properties["#{attributes['attributes'][att.first][:namespace]}:#{attributes["attributes"][att.first][:property]}"] = att.second
+         end
+         rescue
+           puts attributes["attributes"]         
+         end
+       end  
+      end
+    
+      properties
+   
+    end
+
+    # Return all association's information of a model's instance
+    # @param [Object] Model's instance
+    # @return [Hash] RDF's association informations about the object 
+    def get_associations_tag(element)
+       
+       associations = get_attributes_model(element.class.to_s)
+       class_element = element.class
+       if associations.nil?
+         associations = get_attributes_model(element.class.base_class.to_s)
+         class_element = element.class.base_class
+       end
+       properties = {}       
+      
+       class_element.reflections.each do |ref,value|
+         
+         rel = Array(eval "element.#{ref}")||Array()
+         
+         if exist_info_assoc(rel,associations["associations"][ref.to_s]) && can_see?(associations["associations"][ref.to_s][:privacy]) && !rel.empty?
+           
+           properties.merge!({"#{associations['associations'][ref.to_s][:namespace]}:#{associations['associations'][ref.to_s][:property]}" => {:model => rel.first.class ,:id => rel.collect{|obj| obj.id}}
+          })
+         end
+       end     
+        
+       properties
+    end
+
+
+    private
+    ########################################################################
+    ##  FUNCTIONS FOR CHECK IF SHOW oR NoT THE CURRENT ITEM               ##
+    ########################################################################
+    
+    # Check if the user can see the element data
+    # @param [String] privacy
+    # @return [Boolean] true or false, if the user can see this data
+    def can_see?(privacy)
+      privacy=="Public" || (privacy=="Private" && !@current_user.nil?)
+    end
+   
+    # Check if the attribute have defined his properties
+    # 
+    def exist_info_att(attributes,value)
+       attributes[:namespace] != "not defined" && 
+       attributes[:property] !="not defined" &&
+       !value.nil?     
+    end
+
+    # Fixed
+    def exist_info_assoc(rels,rdf_info)
+       !rels.nil? && !rels.empty? && 
+        rdf_info[:namespace] != "not defined" && 
+        rdf_info[:property] != "not defined"
+
+    end
+end

data/lib/data_models/namespaces/cc.rb

@@ -0,0 +1,36 @@
+module EasyData 
+  module RDF
+   class CC < Namespaces
+     @@uri = "xmlns:cc=http://creativecommons.org/ns#"
+     @@properties= {"attributionName" => "<cc:attributionName>%value%</cc:attributionName>",
+                    "attributionURL" => "",
+                    "deprecatedOn" => "",
+                    "jurisdiction" => "",
+                    "legalcode" => "",
+                    "license" => "",
+                    "morePermissions" => "",
+                    "permits" => "",
+                    "prohibits" => "",
+                    "requires" => "" 
+                   }
+
+     # Return Namespace URI
+     def self.get_uri
+       @@uri
+     end
+         
+     #Return a list of Namespace's properties
+     def self.properties
+        @@properties.keys
+     end
+
+     def self.properties_form 
+       list = {}
+       @@properties.keys.each do |property|
+         list[property] = property
+       end
+       list
+     end 
+   end
+  end
+end

data/lib/data_models/namespaces/cert.rb

@@ -0,0 +1,33 @@
+module EasyData  
+  module RDF
+   class CERT < Namespaces
+     @@uri = "http://www.w3.org/ns/auth/cert#"
+     @@properties= {"decimal" => "",
+                    "hex" => "",
+                    "identity" => "",
+                    "public_key" => "", 
+     }
+       
+     # Return Namespace URI
+     def self.get_uri
+       @@uri
+     end
+      # Return tag to rdf doc
+     def self.to_s(property,uri,value)
+        @@properties[property].gsub("%uri%",uri).gsub('%value%',value)
+     end
+     
+     #Return a list of Namespace's properties
+     def self.properties
+        @@properties.keys
+     end
+
+     def self.properties_form 
+       list = {}
+       @@properties.keys.each do |property|
+         list[property] = property
+       end
+       list
+     end   end
+ end
+end

data/lib/data_models/namespaces/dc.rb

@@ -0,0 +1,87 @@
+module EasyData
+  module RDF
+   class DC < Namespaces
+     @@uri = "http://purl.org/dc/elements/1.1/"    
+ 
+     @@properties = {"abstract" => "",
+                     "accessRights" => "",
+                     "accrualMethod" => "",
+                     "accrualPeriodicity" => "",
+                     "accrualPolicy" => "",
+                     "alternative" => "",
+                     "audience" => "",
+                     "available" => "",
+                     "bibliographicCitation" => "",
+                     "conformsTo" => "",
+                     "contributor" => "",
+                     "coverage" => "",
+                     "created" => "",
+                     "creator" => "",
+                     "date" => "",
+                     "dateAccepted" => "",
+                     "dateCopyrighted" => "",
+                     "dateSubmitted" => "",
+                     "description" => "",
+                     "educationLevel" => "",
+                     "extent" => "",
+                     "format" => "",
+                     "hasFormat" => "",
+                     "hasPart" => "",
+                     "hasVersion" => "",
+                     "identifier" => "",
+                     "instructionalMethod" => "",
+                     "isFormatOf" => "",
+                     "isPartOf" => "",
+                     "isReferencedBy" => "",
+                     "isReplacedBy" => "",
+                     "isRequiredBy" => "",
+                     "isVersionOf" => "",
+                     "issued" => "",
+                     "language" => "",
+                     "license" => "",
+                     "mediator" => "",
+                     "medium" => "",
+                     "modified" => "",
+                     "provenance" => "",
+                     "publisher" => "",
+                     "references" => "",
+                     "relation" => "",
+                     "replaces" => "",
+                     "requires" => "",
+                     "rights" => "",
+                     "rightsHolder" => "",
+                     "source" => "",
+                     "spatial" => "",
+                     "subject" => "",
+                     "tableOfContents" => "",
+                     "temporal" => "",
+                     "title" => "",
+                     "type" => "",
+                     "valid" => ""
+                    }
+       
+     # Return Namespace URI
+     def self.get_uri
+       @@uri
+     end
+
+      # Return tag to rdf doc
+     def self.to_s(property,uri,value)
+        @@properties[property].gsub("%uri%",uri).gsub('%value%',value)
+     end
+     
+     #Return a list of Namespace's properties
+     def self.properties
+        @@properties.keys
+     end
+
+     def self.properties_form 
+       list = {}
+       @@properties.keys.each do |property|
+         list[property] = property
+       end
+       list
+     end
+   end
+  end
+end

data/lib/data_models/namespaces/dc11.rb

@@ -0,0 +1,47 @@
+module EasyData  
+  module RDF
+   class DC11 < Namespaces
+     @@uri = "http://purl.org/dc/elements/1.1/" 
+     @@properties= {"contributor" => "",
+                    "coverage" => "",
+                    "creator" => "",
+                    "date" => "",
+                    "description" => "",
+                    "format" => "",
+                    "identifier" => "",
+                    "language" => "",
+                    "publisher" => "",
+                    "relation" => "",
+                    "rights" => "",
+                    "source" => "",
+                    "subject" => "",
+                    "title" => "",
+                    "type" => "",
+                   }
+       
+     # Return Namespace URI
+     def self.get_uri
+        @@uri
+#       "http://purl.org/dc/elements/1.1/" 
+     end
+
+      # Return tag to rdf doc
+     def self.to_s(property,uri,value)
+        @@properties[property].gsub("%uri%",uri).gsub('%value%',value)
+     end
+     
+     #Return a list of Namespace's properties
+     def self.properties
+        @@properties.keys
+     end
+
+     def self.properties_form 
+       list = {}
+       @@properties.keys.each do |property|
+         list[property] = property
+       end
+       list
+     end
+   end
+  end
+end

data/lib/data_models/namespaces/doap.rb

@@ -0,0 +1,68 @@
+module EasyData
+  module RDF
+   class DOAP < Namespaces
+     @@uri = "http://usefulinc.com/ns/doap#"
+     
+     @@properties= {"'anon-root'" => "",
+    "audience" => "",
+    "blog" => "",
+    "browse" => "",
+    "'bug-database'" => "",
+    "category" => "",
+    "created" => "",
+    "description" => "",
+    "developer" => "",
+    "documenter" => "",
+    "'download-mirror'" => "",
+    "'download-page'" => "",
+    "'file-release'" => "",
+    "helper" => "",
+    "homepage" => "",
+    "implements" => "",
+    "language" => "",
+    "license" => "",
+    "location" => "",
+    "'mailing-list'" => "",
+    "maintainer" => "",
+    "module" => "",
+    "name" => "",
+    "'old-homepage'" => "",
+    "os" => "",
+    "platform" => "",
+    "'programming-language'" => "",
+    "release" => "",
+    "repository" => "",
+    "revision" => "",
+    "screenshots" => "",
+    "'service-endpoint'" => "",
+    "shortdesc" => "",
+    "tester" => "",
+    "translator" => "",
+    "vendor" => "",
+    "wiki" => ""   
+     }
+       
+     # Return Namespace URI
+     def self.get_uri
+       @@uri
+     end
+
+      # Return tag to rdf doc
+     def self.to_s(property,uri,value)
+        @@properties[property].gsub("%uri%",uri).gsub('%value%',value)
+     end
+     
+     #Return a list of Namespace's properties
+     def self.properties
+        @@properties.keys
+     end
+
+     def self.properties_form 
+       list = {}
+       @@properties.keys.each do |property|
+         list[property] = property
+       end
+       list
+     end   end
+  end
+end