easy_data 0.0.2 → 0.0.4

data/README

@@ -12,6 +12,13 @@ In config/routes.rb at the end of routes declarations include:
 
 EasyDataRouting.routes(map)
 
+After, in [RAILS_HOME]/Rakefile copy this line:
+
+require "easy_data/tasks" 
+
+At the end, execute the next task:
+
+rake easy_data:install RAILS_ENV=development
 
 Commandas and Query
 ======================

data/Rakefile

@@ -2,3 +2,7 @@ require 'bundler/gem_tasks'
 
 require 'yard'  #Documentation gem
 require 'hpricot'
+
+
+
+

data/easy_data.gemspec

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
+
+
 require "easy_data/version"
 
 Gem::Specification.new do |s|
@@ -21,7 +23,8 @@ Gem::Specification.new do |s|
   #gem dependencies:
   #All is not necesary, only is for study his methods
 
-    #s.add_dependency(%q<addressable>, ["= 2.2.4"])
+    s.add_dependency(%q<hpricot>, [">= 0.8.4"])
+    s.add_dependency(%q<haml>, [">= 3.0.0"])
     #s.add_dependency(%q<rdf>, [">= 0"])
     #s.add_dependency(%q<haml>, [">= 3.0.0"])
     #s.add_dependency(%q<nokogiri>, [">= 1.3.3"])

data/lib/controllers/easy_datas_controller.rb

@@ -1,40 +1,141 @@
 require "action_controller"
-
+require "action_view"
+require "builder"
 
 class EasyDatasController < ActionController::Base
+  
+  layout 'easy_data_layout'
 
   def show
-    begin
+    
+   # begin
       model = eval params[:model].to_s
-       
-      if params[:id]
-        @request = model.find params[:id]
-      else
-        @request={}
-        relations = {}
-        @request["model"] = params[:model].to_s
-        @request["attributes"] = model.columns.map{|att| att.name}.join(", ")
-        
-        model.reflections.each do |relation,values|  
-           relations[relation] = {"model" => values.class_name,"type" => values.macro.to_s} 
-        end 
-        @request["relations"] = relations
+      conditions = parser_params(params[:params]||nil)
+      rdf = ModelRdf.new      
 
+      unless conditions.empty?
+        @reply = model.find :all, :conditions => conditions
+      else
+        @reply = model.find :all
       end
-
-      render :xml => @request
-    rescue
-      raise ActionController::RoutingError.new('Not Found')    
-    end
+      @host="http://"+request.env["HTTP_HOST"]          
+      
+      @rdf_model = rdf.get_model_rdf(@reply,params[:model],"http://"+request.env["HTTP_HOST"])
+      
+      @xml = Builder::XmlMarkup.new
+      respond_to do |format|
+        format.html
+        format.xml # render :template => "/rdf/request.xml.builder"   
+      end
+       #render :file => "/rdf/request",:content_type => "application/xml",:locals => {:rdf_model => @rdf_model}
+   # rescue
+   #   raise ActionController::RoutingError.new('Not Found')    
+   # end
+  
   end
 
   def describe_api
       models = DataModels.load_models
       list = {}
       models.each do |mod|
-       list[mod] = "foaf/#{mod}"
+       list[mod.gsub("::","_")] = "#{mod.gsub("::","_")}"
       end
 
       render :xml => list
   end
+
+  def custom_rdf
+    @models = DataModels.load_models
+  end
+
+  def model_attributes
+    
+    rdf = ModelRdf.new
+    
+    @model_attributes = rdf.get_attributes_model(params[:model])
+    @model = params[:model]
+
+    render :partial => "model_attributes",:layout => nil
+
+  end
+
+  def model_attributes_edit
+
+     rdf = ModelRdf.new
+
+     @model_attributes = rdf.get_attributes_model(params[:model])
+     @model = params[:model]
+     @namespaces = EasyData::RDF::Namespaces.list_form
+     
+     render :partial => "model_attributes_edit",:layout => nil
+  
+  end
+
+  def load_properties
+  
+     unless params[:id] == ""
+       namespace = "EasyData::RDF::#{params[:id].upcase}"
+
+       rdf = ModelRdf.new    
+ 
+       @namespace = params[:id]
+       @model_attributes = rdf.get_attributes_model(params[:model])
+    
+       properties = (eval namespace).properties_form
+  
+       render :inline => "<span>Property:</span><%= select type+'_property',attribute,properties,{:prompt => 'Select a property...'} -%><span class='rdf_info'>(Current value: <%= current_value%>)</span>",
+                        :locals => {:properties => properties,
+                                    :type => params[:type],
+                                    :attribute => params[:attribute],
+                                    :current_value => @model_attributes[params[:type]][params[:attribute]][:property]}
+     else
+       render :inline => ""
+     end
+  end
+  def custom_attributes
+
+     rdf = ModelRdf.new
+     @model = params[:model]
+
+     params["rdf_type_attributes"].each do |att,value|
+       if params["attributes_property"][att] != "" && value != ""
+        rdf.update_attributes_model(params[:model],att,'namespace',value)
+        rdf.update_attributes_model(params[:model],att,'property',params["attributes_property"][att])
+        rdf.update_attributes_model(params[:model],att,'privacy',rdf.privacy(params[:privacy][att].to_i))
+       end
+     end
+    
+     params["rdf_type_associations"].each do |assoc,value|
+       if value != "" && params["associations_property"][assoc] != ""
+        rdf.update_associations_model(params[:model],assoc,'namespace',value)
+        rdf.update_associations_model(params[:model],assoc,'property',params["associations_property"][assoc])
+        rdf.update_associations_model(params[:model],assoc,'privacy',rdf.privacy(params[:privacy][assoc].to_i))
+       end
+     end
+
+     rdf.save
+
+     @model_attributes = rdf.get_attributes_model(@model)
+     
+     render :partial => "model_attributes",:layout => nil
+  end
+
+  private 
+
+  def parser_params (params = nil)
+     
+     conditions = {}
+
+     if params.nil? || params == 'ALL'
+       return conditions
+     else
+       params = params.split("$")
+       params.each do |p|
+         p = p.split(':')
+         conditions[p[0].downcase.to_sym] = p[1]   
+       end
+       return conditions
+     end
+  end
+
 end

data/lib/data_models/data_models.rb

@@ -1,33 +1,39 @@
 module DataModels
   
    def self.load_models
-  
      models = []
-     
-      #To test executable /bin/linked_data
-      #Dir["/home/jnillo/Documentos/Proyectos/redmine/app/models/**/*.rb"].each do |file|
-      #   models << file.gsub('/home/jnillo/Documentos/Proyectos/redmine/app/models/',"").gsub('.rb','').gsub(":","")
-      #end
  
-     
-       Dir["#{RAILS_ROOT}/app/models/**/*.rb"].each do |file|
-         models << file.gsub(RAILS_ROOT+'/app/models/',"").gsub('.rb','').classify.gsub(":","")
-       end
-     
+     Dir["#{RAILS_ROOT}/app/models/**/*.rb"].each do |file|
+       models << file.gsub(RAILS_ROOT+'/app/models/',"").gsub('.rb','').classify
+     end
+ 
      models
-  
   end
 
-  def self.model_attributes(model)
-  	
-  	clase = eval model
-  	
-  	clase.columns.map{|att| [att.name,att.type]}
-  	
+  def self.model_attributes(model)      
+      model.columns.map{|att| att.name}.join(", ")
+  end
+
+  def self.model_relations(model)
+
+    relations = {}
+	
+    model.reflections.each do |relation,values|  
+      relations[relation] = {"model" => values.class_name,"type" => values.macro.to_s} 
+    end   	
+   
+    relations
   end
 
   def self.build_models_yaml_file
+    self.models
+  end
 
-  	self.models
+  def self.get_model_data(model)
+    begin 
+      eval model 
+    rescue 
+      eval model.pluralize 
+    end
   end
 end

data/lib/data_models/model_rdf.rb

@@ -0,0 +1,156 @@
+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 
+   def initialize
+     @model_rdf = YAML::load(File.open("#{RAILS_ROOT}/config/easy_data/rdf_info.yaml"))
+   end
+
+   # Return datas storeds in the configuration's yaml file
+   def get_models
+      self.model_rdf
+   end
+
+   #Return attributes of model stored in the configuration yaml file
+   def get_attributes_model(model)
+      self.model_rdf[model] 
+   end
+
+   # update attributes with rdf properties.
+   def update_attributes_model(model,attribute,param,value)
+      self.model_rdf[model]['attributes'][attribute][param.to_sym] = value
+   end
+   
+   def update_associations_model(model,association,param,value)
+      self.model_rdf[model]['associations'][association][param.to_sym] = value
+   end
+   
+   # Return privacy of a attribute 
+   def privacy(index)
+     @@privacy[index]
+   end
+   
+   # Save changes in rdf_info.yaml (configuration's yaml file)
+   def save
+     file = File.open("#{RAILS_ROOT}/config/easy_data/rdf_info.yaml",'w')
+     file.puts YAML::dump(self.model_rdf)
+     file.close
+   end
+
+   #######################################################################
+   # Building RDF                           
+   #######################################################################
+
+   def get_model_rdf(query,model,host)
+     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}/#{element.class.to_s}/#id:#{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
+     #Generating of rdf variable
+   end
+
+   def get_header(attributes)
+      headers = {}
+      
+      (attributes["attributes"].merge(attributes["associations"])).each do |att,properties|
+        if properties != "no publication" && properties[:namespace] != 'not defined'
+          headers["xmlns:#{properties[:namespace]}"] = (eval "EasyData::RDF::#{properties[:namespace].upcase}.get_uri") #EasyData.get_uri_namespace(properties[:namespace])
+        end
+      end         
+      headers
+   end
+
+   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
+         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
+       end  
+      end
+      
+      properties
+   
+    end
+
+    def get_associations_tag(element)
+       
+       associations = get_attributes_model(element.class.to_s)
+       
+       if associations.nil?
+         associations = get_attributes_model(element.class.base_class.to_s)
+       end
+       properties = {}       
+       element.class.reflections.each do |ref,value|
+         rel = eval "element.#{ref}"
+        
+         if exist_info_assoc(rel.to_a,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               ##
+    ########################################################################
+
+    def can_see?(privacy)
+      privacy=="Public" || (privacy=="Private" && !@current_user.nil?)
+    end
+
+    def exist_info_att(attributes,value)
+       attributes[:namespace] != "not defined" && 
+       attributes[:property] !="not defined" &&
+       !value.nil?     
+    end
+
+    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