publisci 0.1.2

data/lib/bio-publisci/dataset/dataset.rb

@@ -0,0 +1,11 @@
+module PubliSci
+  class Dataset
+    extend PubliSci::Interactive
+    extend PubliSci::Registry
+
+    def self.configuration
+      @config ||= Dataset::Configuration.new
+    end
+
+  end
+end

data/lib/bio-publisci/dataset/dataset_for.rb

@@ -0,0 +1,186 @@
+require 'open-uri'
+module PubliSci
+  class Dataset
+    extend PubliSci::Interactive
+
+    def self.reader_registry
+      @reader_registry ||= {}
+    end
+
+    def self.register_reader(extension,klass)
+      reader_registry[extension] = klass
+    end
+
+    def self.for(object, options={}, ask_on_ambiguous=true)
+      if options == false || options == true
+        ask_on_ambiguous = options
+        options = {}
+      end
+
+      if object.is_a? String
+        if File.exist? object
+          if File.extname(object).size > 0
+            extension = File.extname(object)
+          elsif File.basename(object)[0] == '.' && File.basename(object).count('.') == 1
+            extension = File.basename(object)
+          else
+            raise "Can't load file #{object}; file type inference not yet implemented"
+          end
+
+          if reader_registry.keys.include? extension
+            reader_registry[extension].new.automatic(object,options,ask_on_ambiguous)
+          else
+            case extension
+            when ".RData"
+              r_object(object, options, ask_on_ambiguous)
+            when /.csv/i
+              PubliSci::Readers::CSV.new.automatic(object,nil,options,ask_on_ambiguous)
+            when /.arff/i
+              PubliSci::Readers::ARFF.new.generate_n3(object)
+            else
+              # false
+              raise "Unkown Extension #{extension}"
+            end
+          end
+        elsif object =~ %r{htt(p|ps)://.+}
+          self.for(download(object).path, options, ask_on_ambiguous) || RDF::Statement.new(RDF::URI(object), RDF::URI('http://semanticscience.org/resource/hasValue'), IO.read(download(object).path)).to_s
+          # raise res
+          # self.for_remote(object)
+        else
+          raise "Unable to find reader for String '#{object}'"
+          # TODO: better handling of missing readers; need this way for raw strings for now
+          # false
+        end
+      elsif object.is_a? Rserve::REXP
+        r_object(object, options, ask_on_ambiguous)
+      else
+        raise "not recognize Ruby objects of this type yet (#{object})"
+      end
+    end
+
+    def self.download(uri)
+      out = Tempfile.new(uri.split('/').last)
+      out.write open(uri).read
+      out.close
+      out
+    end
+
+    def self.r_object(object, options={}, ask_on_ambiguous=true)
+      if object.is_a? String
+        con = Rserve::Connection.new
+        vars = con.eval("load('#{File.absolute_path object}')")
+        if vars.to_ruby.size > 1 && ask_on_ambiguous
+          puts "Which variable? #{vars.to_ruby}"
+          var = vars.to_ruby[gets.to_i]
+        else
+          var = vars.to_ruby[0]
+        end
+
+        r_classes = con.eval("class(#{var})").to_ruby
+
+        if r_classes.include? "data.frame"
+          df = PubliSci::Readers::Dataframe.new
+          unless options[:dimensions] || !ask_on_ambiguous
+            dims = con.eval("names(#{var})").to_ruby
+            puts "Which dimensions? #{dims}"
+            selection = gets.chomp
+            if selection.size > 0
+              options[:dimensions] = selection.split(',').map(&:to_i).map{|i| dims[i]}
+            end
+          end
+          unless options[:measures] || !ask_on_ambiguous
+            meas = con.eval("names(#{var})").to_ruby
+            puts "Which measures? #{meas} "
+            selection = gets.chomp
+            if selection.size > 0
+              options[:measures] = selection.split(',').map(&:to_i).map{|i| meas[i]}
+            end
+          end
+
+          df.generate_n3(con.eval(var),var,options)
+
+        elsif r_classes.include? "cross"
+          bc = PubliSci::Readers::RCross.new
+
+          unless options[:measures] || !ask_on_ambiguous
+            pheno_names = con.eval("names(#{var}$pheno)").to_ruby
+            puts "Which phenotype traits? #{pheno_names}"
+            selection = gets.chomp
+            if selection.size > 0
+              options[:measures] = selection.split(',').map(&:to_i).map{|i| pheno_names[i]}
+            end
+          end
+
+          base = var
+          if ask_on_ambiguous
+            puts "Output file base?"
+            base = gets.chomp
+            base = var unless base.size > 0
+          end
+
+          bc.generate_n3(con, var, base, options)
+
+        elsif r_classes.include? "matrix"
+          mat = PubliSci::Readers::RMatrix.new
+
+          unless options[:measures] || !ask_on_ambiguous
+            puts "Row label"
+            rows = gets.chomp
+            rows = "row" unless rows.size > 0
+
+            puts "Column label"
+            cols = gets.chomp
+            cols = "column" unless cols.size > 0
+
+            puts "Entry label"
+            vals = gets.chomp
+            vals = "value" unless vals.size > 0
+
+            options[:measures] = [cols,rows,vals]
+          end
+
+          base = var
+          if ask_on_ambiguous
+            puts "Output file base?"
+            base = gets.chomp
+            base = var unless base.size > 0
+          end
+
+          mat.generate_n3(con, var, base, options)
+        else
+          raise "no PubliSci::Readers found for #{r_classes}"
+        end
+
+      elsif object.is_a? Rserve::REXP
+        if object.attr.payload["class"].payload.first
+
+          df = PubliSci::Readers::Dataframe.new
+
+          var = nil
+
+          if ask_on_ambiguous
+            var = interact("Dataset name?",nil)
+          end
+
+          unless options[:dimensions] || !ask_on_ambiguous
+            dims = object.payload.names
+            selection = interact("Which dimensions?","row",dims){|s| puts s; nil}
+            options[:dimensions] = selection if selection
+          end
+
+          unless options[:measures] || !ask_on_ambiguous
+            meas = object.payload.names
+            options[:measures] = interact("Which measures?",meas,meas)
+          end
+
+          df.generate_n3(object,var,options)
+        else
+          raise "support for other Rserve objects coming shortly"
+        end
+
+      else
+        raise "#{object} is not an R object"
+      end
+    end
+  end
+end

data/lib/bio-publisci/dataset/interactive.rb

@@ -0,0 +1,72 @@
+module PubliSci
+  module Interactive
+    #to be called by other classes if user input is required
+
+    #take message, options, defaults. can be passed block to handle default as well
+    def interact(message, default, options=nil)
+      puts message + " (#{default})\n[#{options}]"
+      str = gets.chomp
+      if str.size > 0
+        if options
+          if str.split(',').all?{|s| Integer(s) rescue nil}
+            str.split(',').map(&:to_i).map{|i| options[i]}
+          else
+            str.split(',').each{|s| raise "unkown selection #{s}" unless options.include? s.strip}
+            str.split(',').map(&:strip)
+          end
+        else
+          str
+        end
+      elsif block_given?
+        yield str
+      else
+        default
+      end
+    end
+
+    # def interactive(options={})
+    #   options = defaults.merge(options)
+    #   qb = {}
+
+    #   puts "load config from file? [y/N]"
+    #   if gets.chomp == "y"
+    #     #use yaml or DSL file to configure
+    #   else
+    #     qb[:dimensions] = dimensions()
+    #     qb[:measures] = measures()
+    #   end
+
+    #   puts "load data from file? [y/N]"
+    #   if gets.chomp == "y"
+    #     #attempt to load dataset from file, ask user to resolve problems or ambiguity
+    #   else
+    #   end
+    #   qb
+    # end
+
+    # def dimensions
+    #   puts "Enter a list of dimensions, separated by commas"
+    #   arr = gets.chomp.split(",")
+    #   dims = {}
+
+    #   arr.map{|dim|
+    #     puts "What is the range of #{dim.chomp.strip}? [:coded]"
+    #     type = gets.chomp
+    #     type = :coded if type == ":coded" || type == ""
+    #     dims[dim.chomp.strip] = {type: type}
+    #   }
+
+    #   dims
+    # end
+
+    # def measures
+    #   puts "Enter a list of measures, separated by commas"
+    #   arr = gets.chomp.split(",")
+    #   meas = []
+
+    #   arr.map{|m| meas << m.chomp.strip}
+
+    #   meas
+    # end
+  end
+end

data/lib/bio-publisci/dsl/config.rb

@@ -0,0 +1,34 @@
+module PubliSci
+  module DSL
+    class Configuration
+      def self.defaults
+        {
+          output: :generate_n3,
+          abbreviate: false,
+          repository: :in_memory,
+          repository_url: 'http://localhost:8080/'
+        }
+      end
+
+      defaults.keys.each{|k|
+        default = defaults[k]
+        define_method(k) do |input=nil|
+          var = instance_variable_get :"@#{k}"
+          if var
+            var
+          else
+            instance_variable_set :"@#{k}", default
+          end
+
+          if input
+            instance_variable_set :"@#{k}", input
+          end
+
+          instance_variable_get :"@#{k}"
+        end
+
+        attr_writer k
+      }
+    end
+  end
+end

data/lib/bio-publisci/dsl/dataset_dsl.rb

@@ -0,0 +1,93 @@
+module PubliSci
+  class Dataset
+    module DSL
+
+      class Instance
+        include Dataset::DSL
+
+        def initialize
+          Dataset.registry.clear
+        end
+      end
+
+      # def interactive(value=nil)
+      #   set_or_get('interactive',value)
+      # end
+
+      def object(file=nil)
+        add_or_get('object',file)
+      end
+      alias_method :source, :object
+
+      def dimension(*args)
+        if args.size == 0
+          add_or_get('dimension',nil)
+        else
+          args.each{|arg|
+            add_or_get('dimension',arg)
+          }
+        end
+      end
+
+      def measure(*args)
+        if args.size == 0
+          add_or_get('measure',nil)
+        else
+          args.each{|arg|
+            add_or_get('measure',arg)
+          }
+        end
+      end
+
+      def option(opt=nil,value=nil)
+        if opt == nil || value == nil
+          @dataset_generator_options
+        else
+          (@dataset_generator_options ||= {})[opt] = value
+        end
+      end
+      alias_method :options, :option
+
+      def settings
+        Dataset.configuration
+      end
+
+      def generate_n3
+        opts = {}
+        %w{dimension measure}.each{|field|
+          opts[field.to_sym] = send(field.to_sym) if send(field.to_sym)
+        }
+        interact = settings.interactive
+        if options
+          opts = opts.merge(options)
+        end
+        object().map{|obj|
+          Dataset.for(obj,opts,interact)
+        }.join("\n")
+      end
+
+      private
+      def set_or_get(var,input=nil)
+        ivar = instance_variable_get("@#{var}")
+
+        if input
+          instance_variable_set("@#{var}", input)
+        else
+          ivar
+        end
+      end
+
+      def add_or_get(var,input)
+        ivar = instance_variable_get("@#{var}")
+
+        if input
+          instance_variable_set("@#{var}", []) unless ivar
+          instance_variable_get("@#{var}") << input
+          instance_variable_get("@#{var}")
+        else
+          ivar
+        end
+      end
+    end
+  end
+end

data/lib/bio-publisci/dsl/dsl.rb

@@ -0,0 +1,72 @@
+module PubliSci
+  module DSL
+    attr_reader :base_url
+
+    class Instance
+      include PubliSci::DSL
+    end
+    # Use to set base url for whole script; helps when referring to dataset
+    # resources from metadata and
+    def base_url=(url)
+      @base_url = url
+      Prov.base_url=url
+    end
+
+    def data(&block)
+      inst=PubliSci::Dataset::DSL::Instance.new
+      inst.instance_eval(&block)
+      @_dsl_data ||= [] << inst
+      inst
+    end
+
+    def metadata(&block)
+      inst=PubliSci::Metadata::DSL::Instance.new
+      inst.instance_eval(&block)
+      @_dsl_metadata = inst
+      inst
+    end
+
+    def provenance(&block)
+      inst=PubliSci::Prov::DSL::Instance.new
+      inst.instance_eval(&block)
+      @_dsl_prov = inst
+      inst
+    end
+
+    def configuration
+      @_dsl_config ||= DSL::Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def settings
+      configuration
+    end
+
+    def generate_n3
+      out = ""
+      @_dsl_data.each{|dat| out << dat.generate_n3 } if @_dsl_data
+      out << @_dsl_metadata.generate_n3 if @_dsl_metadata
+      out << @_dsl_prov.generate_n3 if @_dsl_prov
+      out
+    end
+
+    def to_repository(turtle_string=generate_n3)
+      repo = settings.repository
+      case repo
+      when :in_memory
+        repo = RDF::Repository.new
+      when :fourstore
+        repo = RDF::FourStore::Repository.new('http://localhost:8080')
+      end
+      f=Tempfile.new(['repo','.ttl'])
+      f.write(turtle_string)
+      f.close
+      repo.load(f.path, :format => :ttl).to_s
+      f.unlink
+      repo
+    end
+  end
+end