class PubliSci::DataSet::ORM::DataCube

Attributes

dimensions[RW]
labels[RW]
measures[RW]
meta[RW]
obs[RW]

Public Class Methods

load(graph,options={},verbose=false) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 34
def self.load(graph,options={},verbose=false)


  graph = load_string(graph) unless graph =~ /^http/

  # puts get_hashes(execute_from_file('dimension_ranges.rq',graph))
  dimensions = Hash[get_hashes(execute_from_file('dimension_ranges.rq',graph),"to_s").map{|solution|
    #TODO coded properties should be found via SPARQL queries
    if solution[:range].split('/')[-2] == "code"
      type = :coded
    else
      type = solution[:range].to_s
    end
    [solution[:dimension], {type: type}]
  }]
  puts "dimensions: #{dimensions}" if verbose

  codes = execute_from_file('code_resources.rq',graph).to_h.map{|sol|
    [sol[:dimension].to_s, sol[:codeList].to_s, sol[:class].to_s]
  }
  puts "codes: #{codes}" if verbose

  measures = execute_from_file('measures.rq',graph).to_h.map{|m| m[:measure].to_s}
  puts "measures: #{measures}" if verbose

  name = execute_from_file('dataset.rq',graph).to_h.first[:label]
  puts "dataset: #{name}" if verbose

  obs = execute_from_file('observations.rq',graph)
  observations = observation_hash(obs)
  puts "observations: #{observations}" if verbose

  # simple_observations = observation_hash(obs,true)

  labels = execute_from_file('observation_labels.rq', graph)
  labels = Hash[labels.map{|sol|
    [sol[:observation].to_s, sol[:label].to_s]
  }]

  new_opts = {
    measures: measures,
    dimensions: dimensions,
    observations: observations.values,
    name: name,
    labels: labels.values,
    codes: codes
  }

  options = options.merge(new_opts)
  puts "creating #{options}" if verbose
  self.new(options)
end
new(options={},do_parse = true) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 22
def initialize(options={},do_parse = true)
  @dimensions = {}
  @measures = []
  @obs = []
  @generator_options = {}
  @options = {}

  @meta = {}

  parse_options options if do_parse
end

Public Instance Methods

add_dimension(name, type=:coded) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 163
def add_dimension(name, type=:coded)
  @dimensions[name.to_s] = {type: type}
end
add_measure(name) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 167
def add_measure(name)
  @measures << name
end
add_observation(data) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 171
def add_observation(data)
  data = Hash[data.map{|k,v| [k.to_s, v]}]
  obs = Observation.new(data)
  check_integrity([obs.data],@dimensions.keys,@measures) if @options[:validate_each]
  @obs << obs
end
add_publisher(label,uri) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 198
def add_publisher(label,uri)
  publishers << {label: label, uri: uri}
end
add_subject(id) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 202
def add_subject(id)
  subject << id
end
author() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 206
def author
  @meta[:creator] ||= ""
end
author=(author) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 210
def author=(author)
  @meta[:creator] = author
end
date() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 222
def date
  @meta[:date] ||= "#{Time.now.day}-#{Time.now.month}-#{Time.now.year}"
end
date=(date) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 226
def date=(date)
  @meta[:date] =  date
end
description() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 214
def description
  @meta[:description] ||= ""
end
description=(description) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 218
def description=(description)
  @meta[:description] = description
end
insert(observation) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 178
def insert(observation)
  @obs << observation
end
parse_options(options) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 87
def parse_options(options)
  if options[:dimensions]
    options[:dimensions].each{|name,details|
      add_dimension(name, details[:type] || :coded)
    }
  end

  if options[:measures]
    options[:measures].each{|m| @measures << m}
  end

  if options[:observations]
    options[:observations].each{|obs_data| add_observation obs_data}
  end

  @generator_options = options[:generator_options] if options[:generator_options]
  @options[:skip_metadata] = options[:skip_metadata] if options[:skip_metadata]

  if options[:name]
    @name = options[:name]
  else
    raise "No dataset name specified!"
  end

  if options[:validate_each]
    @options[:validate_each] = options[:validate_each]
  end

  if options[:labels]
    @labels = options[:labels]
  end

  if options[:codes]
    @codes = options[:codes]
  end
end
publishers() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 182
def publishers
  @meta[:publishers] ||= []
end
publishers=(publishers) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 186
def publishers=(publishers)
  @meta[:publishers] = publishers
end
subjects() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 190
def subjects
  @meta[:subject] ||= []
end
subjects=(subjects) click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 194
def subjects=(subjects)
  @meta[:subject]=subjects
end
to_h() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 230
def to_h
  {
    measures: @measures,
    dimensions: @dimensions,
    observations: @obs.map{|o| o.data}
  }
end
to_n3() click to toggle source
# File lib/publisci/dataset/ORM/data_cube_orm.rb, line 124
def to_n3

  #create labels if not specified
  unless @labels.is_a?(Array) && @labels.size == @obs.size
    if @labels.is_a? Symbol
      #define some automatic labeling methods
    else
      @labels = (1..@obs.size).to_a.map(&:to_s)
    end
  end
  data = {}


  #collect observation data
  check_integrity(@obs.map{|o| o.data}, @dimensions.keys, @measures)
  @obs.map{|obs|
    (@measures | @dimensions.keys).map{ |component|
     (data[component] ||= []) <<  obs.data[component]
    }
  }


  @codes = @dimensions.map{|d,v| d if v[:type] == :coded}.compact unless @codes
  str = generate(@measures, @dimensions.keys, @codes, data, @labels, @name, @generator_options)
  unless @options[:skip_metadata]
    fields = {
      publishers: publishers(),
      subject: subjects(),
      author: author(),
      description: description(),
      date: date(),
      var: @name,
    }
    # puts basic(fields,@generator_options)
    str += "\n" + basic(fields)
  end
  str
end