solis 0.64.0

data/lib/solis/shape/reader/simple_sheets/sheet.rb

@@ -0,0 +1,59 @@
+class Sheet
+  include Enumerable
+  def initialize(worksheet)
+    @worksheet = worksheet
+    @last_sync = Time.now
+  end
+
+  def title
+    @worksheet.title
+  end
+
+  def each
+    @worksheet.rows(skip=1).each do |row|
+      yield make_record_from_row(row)
+    end
+  end
+
+  def header
+    @header ||= @worksheet.rows[0].map{|m| m.downcase.gsub(' ','_').gsub('#', '_hash').gsub('%','_percent')}
+  end
+
+  def [](index)
+    row_as_record(@worksheet.rows(skip=0)[index])
+  end
+
+  def count
+    @worksheet.num_rows - 1
+  end
+
+  private
+  def sync
+    if (Time.now.to_i - @last_sync.to_i) > 600
+      @worksheet.synchronize
+    end
+  end
+
+  def row_as_record(row)
+    sync
+    result = []
+    return result if row.nil?
+    if row && row.is_a?(Array) && row.first.is_a?(Array)
+      result = row.map do |m|
+        m.is_a?(Array) ? make_record_from_row(m) : m
+      end
+    else
+      result = make_record_from_row(row)
+    end
+    result
+  end
+
+  def make_record_from_row(row)
+    return nil if row.nil?
+    result = {}
+    row.each_index do |i|
+      result.store(self.header[i], row[i])
+    end
+    result
+  end
+end

data/lib/solis/shape/reader/simple_sheets/worksheet.rb

@@ -0,0 +1,173 @@
+  class Worksheet
+    attr_reader :properties, :title, :spreadsheet
+
+    def initialize(spreadsheet, properties)
+      @spreadsheet = spreadsheet
+      set_properties(properties)
+      @cells = nil
+      @input_values = nil
+      @numeric_values = nil
+      @modified = Set.new
+    end
+
+    def sheet_id
+      @properties.sheet_id
+    end
+
+    def gid
+      sheet_id.to_s
+    end
+
+    def [](*args)
+      (row, col) = parse_cell_args(args)
+      cells[[row, col]] || ''
+    end
+
+    def rows(skip = 0)
+      nc = num_cols
+      result = ((1 + skip)..num_rows).map do |row|
+        (1..nc).map { |col| self[row, col] }.freeze
+      end
+      result.freeze
+    end
+
+    def num_rows
+      reload_cells unless @cells
+      # Memoizes it because this can be bottle-neck.
+      # https://github.com/gimite/google-drive-ruby/pull/49
+      @num_rows ||=
+        @input_values
+          .reject { |(_r, _c), v| v.empty? }
+          .map { |(r, _c), _v| r }
+          .max ||
+          0
+    end
+
+    # Column number of the right-most non-empty column.
+    def num_cols
+      reload_cells unless @cells
+      # Memoizes it because this can be bottle-neck.
+      # https://github.com/gimite/google-drive-ruby/pull/49
+      @num_cols ||=
+        @input_values
+          .reject { |(_r, _c), v| v.empty? }
+          .map { |(_r, c), _v| c }
+          .max ||
+          0
+    end
+
+    private
+    def parse_cell_args(args)
+      if args.size == 1 && args[0].is_a?(String)
+        cell_name_to_row_col(args[0])
+      elsif args.size == 2 && args[0].is_a?(Integer) && args[1].is_a?(Integer)
+        if args[0] >= 1 && args[1] >= 1
+          args
+        else
+          raise(
+            ArgumentError,
+            format(
+              'Row/col must be >= 1 (1-origin), but are %d/%d',
+              args[0], args[1]
+            )
+          )
+        end
+      else
+        raise(
+          ArgumentError,
+          format(
+            "Arguments must be either one String or two Integer's, but are %p",
+            args
+          )
+        )
+      end
+    end
+
+    def cell_name_to_row_col(cell_name)
+      unless cell_name.is_a?(String)
+        raise(
+          ArgumentError, format('Cell name must be a string: %p', cell_name)
+        )
+      end
+      unless cell_name.upcase =~ /^([A-Z]+)(\d+)$/
+        raise(
+          ArgumentError,
+          format(
+            'Cell name must be only letters followed by digits with no ' \
+            'spaces in between: %p',
+            cell_name
+          )
+        )
+      end
+      col = 0
+      Regexp.last_match(1).each_byte do |b|
+        # 0x41: "A"
+        col = col * 26 + (b - 0x41 + 1)
+      end
+      row = Regexp.last_match(2).to_i
+      [row, col]
+    end
+
+    def cells
+      reload_cells unless @cells
+      @cells
+    end
+
+    def set_properties(properties)
+      @properties = properties
+      @title = @remote_title = properties.title
+      @index = properties.index
+      if properties.grid_properties.nil?
+        @max_rows = @max_cols = 0
+      else
+        @max_rows = properties.grid_properties.row_count
+        @max_cols = properties.grid_properties.column_count
+      end
+      @meta_modified = false
+    end
+
+    def reload_cells
+      response =
+        @spreadsheet.sheets_service.get_spreadsheet(
+          @spreadsheet.id,
+          ranges: "'%s'" % @remote_title,
+          fields: 'sheets.data.rowData.values(formattedValue,userEnteredValue,effectiveValue)'
+        )
+      update_cells_from_api_sheet(response.sheets[0])
+    end
+
+    def update_cells_from_api_sheet(api_sheet)
+      rows_data = api_sheet.data[0].row_data || []
+
+      @num_rows = rows_data.size
+      @num_cols = 0
+      @cells = {}
+      @input_values = {}
+      @numeric_values = {}
+
+      rows_data.each_with_index do |row_data, r|
+        next if !row_data.values
+        @num_cols = row_data.values.size if row_data.values.size > @num_cols
+        row_data.values.each_with_index do |cell_data, c|
+          k = [r + 1, c + 1]
+          @cells[k] = cell_data.formatted_value || ''
+          @input_values[k] = extended_value_to_str(cell_data.user_entered_value)
+          @numeric_values[k] =
+            cell_data.effective_value && cell_data.effective_value.number_value ?
+              cell_data.effective_value.number_value.to_f : nil
+        end
+      end
+
+      @modified.clear
+    end
+
+    def extended_value_to_str(extended_value)
+      return '' if !extended_value
+      value =
+        extended_value.number_value ||
+          extended_value.string_value ||
+          extended_value.bool_value ||
+          extended_value.formula_value
+      value.to_s
+    end
+  end

data/lib/solis/shape/reader/simple_sheets.rb

@@ -0,0 +1,40 @@
+require 'google/apis/sheets_v4'
+require_relative 'simple_sheets/sheet'
+require_relative 'simple_sheets/worksheet'
+
+class SimpleSheets
+  attr_accessor :key
+  attr_reader :sheets_service, :id
+
+  def initialize(key, spreadsheet_id)
+    @id = spreadsheet_id
+    @key = key
+    @sheets_service = Google::Apis::SheetsV4::SheetsService.new
+    @sheets_service.key = @key    
+  end
+
+  def worksheets
+    spreadsheet_api = @sheets_service.get_spreadsheet(@id, fields: 'sheets.properties')
+    spreadsheet_api.sheets.map { |s| Worksheet.new(self, s.properties) }
+    #TODO: catch not found
+  rescue Google::Apis::ClientError => e
+    case e.status_code
+    when 404
+      raise "Sheet with id #{@id} NOT FOUND"
+    else
+      raise "An error occured reading sheet with id #{@id}. HTTP status code = #{e.status_code}, reason = '#{e.header.reason_phrase}'"
+    end
+  rescue Exception  => e
+    raise e
+  end
+
+  def worksheet_by_title(title)
+    worksheets.find { |ws| ws.title == title }
+  end
+
+  def worksheet_by_sheet_id(sheet_id)
+    sheet_id = sheet_id.to_i
+    worksheets.find { |ws| ws.sheet_id == sheet_id }
+  end
+
+end

data/lib/solis/shape.rb

@@ -0,0 +1,189 @@
+require_relative 'shape/reader/file'
+require_relative 'shape/reader/sheet'
+require_relative 'shape/data_types'
+
+module Solis
+  module Shape
+    def self.from_graph(graph)
+      class << self
+        def parse_graph(graph)
+          shapes = {}
+          #puts query.execute(graph).to_csv
+
+          query.execute(graph) do |solution|
+            parse_solution(shapes, solution)
+          end
+
+          # shapes = add_missing_attributes(shapes)
+          shapes
+        rescue Solis::Error::GeneralError => e
+          raise "Unable to parse shapes: #{e.message}"
+        end
+
+        def lookup_datatype(datatype, node)
+          if datatype =~ /^http:\/\/www.w3.org\/2001\/XMLSchema#/
+            case datatype
+            when /^http:\/\/www.w3.org\/2001\/XMLSchema#anyURI/
+              :string
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#duration/
+              :duration
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#integer/
+              :integer
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#int/
+              :integer
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#dateTime/
+              :datetime
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#date/
+              :date
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#time/
+              :time
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#gYear/
+              :year
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#string/
+              :string
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#boolean/
+              :boolean
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#float/
+              :float
+            when /http:\/\/www.w3.org\/2001\/XMLSchema#double/
+              :double
+            else
+              #puts datatype.split('#').last.to_sym
+              :string
+            end
+          elsif datatype =~ /http:\/\/schema.org\//
+            case datatype
+            when /http:\/\/schema.org\/temporalCoverage/
+              :temporal_coverage
+            else
+              #puts datatype.split('#').last.to_sym
+              :string
+            end
+          elsif datatype =~ /http:\/\/www.w3.org\/2006\/time/
+            case datatype
+            when /http:\/\/www.w3.org\/2006\/time#DateTimeInterval/
+              :datetime_interval
+            else
+              #puts datatype.split('#').last.to_sym
+              :string
+            end
+          elsif datatype.nil? && node.is_a?(RDF::URI)
+            node.value.split('/').last.gsub(/Shape$/, '').to_sym
+          elsif datatype =~ /^http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns/
+            case datatype
+            when /http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#langString/
+              :lang_string
+            when /http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#JSON/
+              :json
+            else
+              :string
+            end
+          else
+            :string
+          end
+        end
+
+        def parse_solution(shapes, solution)
+          shape_rdf = solution.targetClass
+          shape_node = solution.targetNode if solution.bound?(:targetNode)
+          shape_name = solution.className.value
+          attribute_name = solution.attributeName.value if solution.bound?(:attributeName)
+          comment = solution.comment.value if solution.bound?(:comment)
+          attribute_rdf = solution.attributePath.value if solution.bound?(:attributePath)
+          attribute_datatype_rdf = solution.attributeDatatype.value if solution.bound?(:attributeDatatype)
+          attribute_min_count = solution.bound?(:attributeMinCount) ? solution.attributeMinCount.value.to_i : 0
+          attribute_max_count = solution.bound?(:attributeMaxCount) ? solution.attributeMaxCount.value.to_i : nil
+          attribute_node_kind = solution.attributeNodeKind if solution.bound?(:attributeNodeKind)
+          attribute_node = solution.attributeNode if solution.bound?(:attributeNode)
+          attribute_class = solution.attributeClass if solution.bound?(:attributeClass)
+          attribute_comment = solution.attributeComment if solution.bound?(:attributeComment)
+          # if solution.bound?(:attributeOr)
+          #   pp solution
+          # end
+
+          attribute_node = attribute_class if attribute_name && attribute_datatype_rdf.nil? && attribute_node.nil?
+
+          shape = shapes.key?(shape_name) ? shapes[shape_name] : { target_class: nil, target_node: nil, attributes: {} }
+          shape[:target_class] = shape_rdf
+          shape[:target_node] = shape_node
+          shape[:comment] = comment
+
+          shape[:attributes][attribute_name] = {
+            path: attribute_rdf,
+            datatype_rdf: attribute_datatype_rdf,
+            datatype: lookup_datatype(attribute_datatype_rdf, attribute_node),
+            mincount: attribute_min_count,
+            maxcount: attribute_max_count,
+            node: attribute_node,
+            node_kind: attribute_node_kind,
+            class: attribute_class,
+            comment: attribute_comment
+          }
+
+          shape[:attributes].delete_if { |k, _| k.nil? }
+          shapes[shape_name] = shape
+        end
+
+        def query
+          SPARQL.parse %(
+PREFIX sh: <http://www.w3.org/ns/shacl#>
+PREFIX rdfv: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+SELECT ?targetClass ?targetNode ?comment ?className ?attributePath ?attributeName ?attributeDatatype
+       ?attributeMinCount ?attributeMaxCount ?attributeOr ?attributeClass
+       ?attributeNode ?attributeNodeKind ?attributeComment ?o
+WHERE {
+
+  ?s a sh:NodeShape;
+     sh:targetClass ?targetClass ;
+     sh:node ?targetNode ;
+     sh:description ?comment  ;
+     sh:name        ?className .
+     OPTIONAL{ ?s sh:property ?attributes .
+               ?attributes sh:name ?attributeName ;
+                           sh:path ?attributePath ;
+                           OPTIONAL{ ?attributes sh:datatype ?attributeDatatype } .
+                           OPTIONAL{ ?attributes sh:minCount ?attributeMinCount } .
+                           OPTIONAL{ ?attributes sh:maxCount ?attributeMaxCount } .
+                           OPTIONAL{ ?attributes sh:or       ?attributeOr } .
+                           OPTIONAL{ ?attributes sh:class    ?attributeClass } .
+                           OPTIONAL{ ?attributes sh:nodeKind ?attributeNodeKind } .
+                           OPTIONAL{ ?attributes sh:node     ?attributeNode } .
+                           OPTIONAL{ ?attributes sh:description ?attributeComment } .
+     }.
+}
+)
+        end
+
+        def add_missing_attributes(shapes)
+          shapes.each do |shape|
+            if shape[1].is_a?(Hash)
+              graph_name = shape[1][:target_class].value.split(shape[1][:target_class].path).first
+              attributes = shape[1][:attributes]
+              unless attributes.key?('id')
+                if shape[1][:target_class] == shape[1][:target_node]
+                  attributes['id'] = {
+                    "path": "#{graph_name}/id",
+                    "datatype_rdf": "http://www.w3.org/2001/XMLSchema#string",
+                    "datatype": "string",
+                    "mincount": 1,
+                    "maxcount": 1,
+                    "node": nil,
+                    "node_kind": nil,
+                    "class": nil,
+                    "comment": RDF::Literal.new("UUID", datatype: RDF::XSD.string)
+                  }
+
+                  shape[1][:attributes] = attributes
+                end
+              end
+            end
+          end
+          shapes
+        end
+      end
+
+      parse_graph(graph)
+    end
+  end
+end