spread2rdf 0.0.1pre.1 → 0.0.1

data/lib/spread2rdf/spreadsheet/sheet_mapping_context.rb

@@ -1,90 +0,0 @@
-module Spread2RDF
-  class Spreadsheet
-    class Sheet
-      class MappingContext < Spreadsheet::MappingContext
-
-        self.attributes = {
-            row_range:  nil
-        }
-
-        alias sheet element
-
-        def initialize(sheet, parent_context = nil, attr = {})
-          super
-          @objects = ( sheet.columns - [ sheet.subject_column ] ).map do |column|
-            column.map(row_range, self).compact.presence
-          end.compact
-          return if @objects.empty?
-          subject_description
-          statements_to_object
-          worksheet.graph << self.graph
-        end
-
-        ########################################################################
-        # subject mapping
-
-        # TODO: every new context instance (for the same cell) returns a different bnode, it must be stored ...
-        def subject
-          @subject ||= case subject_mapping_mode
-             when :bnode         then RDF::Node.new
-             when :from_column   then subject_resource_from_column
-             else raise 'unknown subject mapping type'
-           end
-        end
-        alias subject_resource subject
-
-        def subject_resource_type
-          sheet.subject.try(:fetch, :type, nil) or
-              (sheet.subject.try(:fetch, :sub_class_of, nil) && RDF::RDFS.Class) or
-              nil
-        end
-
-        def subject_namespace
-          subject_namespace_name =
-              sheet.subject.try(:fetch, :uri, nil).try(:fetch, :namespace, nil)
-          Namespace.resolve_to_namespace(subject_namespace_name)
-        end
-
-      private
-
-        def subject_mapping_mode
-          case
-            when ( sheet.subject.try(:fetch, :uri, nil) || sheet.subject ) == :bnode
-              :bnode
-            else
-              :from_column
-          end
-        end
-
-        def subject_name_suffix
-          cells = row_range.map do |row|
-            cell_value(row: row, column: sheet.subject_column.coord).presence
-          end.compact
-          raise "no subject found for #{sheet} in #{row_range}" if cells.empty?
-          raise "multiple subjects found for #{sheet} in #{row_range}: #{cells.inspect}" if cells.count > 1
-          cells.first
-        end
-
-        def subject_resource_from_column
-          namespace = subject_namespace
-          subject_suffix = Helper.resource_name(subject_name_suffix)
-          #puts "subject resource for #{sheet} in #{range}: " + RDF::URI.new("#{namespace}#{subject_suffix}" )
-          RDF::URI.new("#{namespace}#{subject_suffix}")
-        end
-
-        def subject_description
-          type = subject_resource_type
-          statement(subject, RDF.type, type) unless type.nil?
-          if type == RDF::RDFS.Class &&
-              super_class = sheet.subject.try(:fetch, :sub_class_of, nil)
-            statement(subject, RDF::RDFS.subClassOf, super_class)
-          end
-        end
-
-        def statements_to_object
-        end
-
-      end
-    end
-  end
-end

data/lib/spread2rdf/spreadsheet/sub_sheet_mapping_context.rb

@@ -1,55 +0,0 @@
-module Spread2RDF
-  class Spreadsheet
-    class SubSheet
-      class MappingContext < Sheet::MappingContext
-
-        self.attributes = {
-        }
-
-        alias sub_sheet element
-        alias column_block element
-
-        private
-
-        ##########################################################################
-        # Statement mapping
-        # TODO: Duplication Column::MappingContext ! Share it ?
-
-        def statement_mapping_mode
-          case
-            when column_block.statement == :none then :ignore
-            when column_block.statement == :none then :ignore
-            when column_block.predicate.nil?     then :ignore
-            when restriction_mode                then :restriction
-            else                                      :default
-          end
-        end
-
-        def restriction_mode
-          restriction_mode = column_block.statement
-          case restriction_mode
-            when :restriction then RDF::OWL.hasValue
-            when Hash         then restriction_mode[:restriction]
-            else nil
-          end
-        end
-
-        def statements_to_object
-          case statement_mapping_mode
-            when :default
-              statement(parent_context.subject, column_block.predicate, subject)
-            when :restriction
-              restriction_class = RDF::Node.new
-              statements(
-                  [ parent_context.subject, RDF::RDFS.subClassOf, restriction_class ],
-                  [ restriction_class, RDF.type, RDF::OWL.Restriction ],
-                  [ restriction_class, RDF::OWL.onProperty, column_block.predicate ],
-                  [ restriction_class, restriction_mode, subject ]
-              )
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/spread2rdf/spreadsheet/worksheet.rb

@@ -1,49 +0,0 @@
-module Spread2RDF
-  class Spreadsheet
-    class Worksheet < Sheet
-
-      self.attributes = {
-      }
-
-      attr_reader :cell_mapping
-      attr_reader :graph
-
-      def initialize(parent, options={}, &block)
-        super
-        @cell_mapping = {}
-        @graph = RDF::Repository.new
-      end
-
-      def init
-        index_columns!
-      end
-
-=begin
-      def cell_mapping_by_name(name)
-
-      end
-
-      def cell_mapping_by_coord(coord)
-
-      end
-=end
-
-      def index_columns!
-        column_index = start_coord.column_as_number
-        each_column do |column|
-          column.instance_variable_set :@coord,
-                                       Roo::Base.number_to_letter(column_index)
-          column_index += 1
-        end
-      end
-
-      def row_range
-        range = roo { (Coord[start].row .. spreadsheet.roo.last_row) }
-        range.begin <= range.end ? range : nil
-      end
-
-    private
-
-    end
-  end
-end

data/lib/spread2rdf/spreadsheet.rb

@@ -1,92 +0,0 @@
-require 'spread2rdf/spreadsheet/coord'
-require 'spread2rdf/spreadsheet/element'
-require 'spread2rdf/spreadsheet/mapping_context'
-require 'spread2rdf/spreadsheet/sheet'
-require 'spread2rdf/spreadsheet/sub_sheet'
-require 'spread2rdf/spreadsheet/worksheet'
-require 'spread2rdf/spreadsheet/sheet_mapping_context'
-require 'spread2rdf/spreadsheet/sub_sheet_mapping_context'
-require 'spread2rdf/spreadsheet/column'
-require 'spread2rdf/spreadsheet/column_mapping_context'
-
-require 'spread2rdf/spreadsheet/sheet_dsl'
-require 'spread2rdf/spreadsheet/mapping_dsl'
-
-module Spread2RDF
-  class Spreadsheet
-
-    attr_reader :name
-    attr_reader :worksheet
-    attr_reader :worksheet_mapping
-    attr_reader :input_file
-    attr_reader :roo
-
-    def initialize(name, &block)
-      @name = name
-      @worksheet = {}
-      @worksheet_mapping = {}
-      @schema_spec = block
-    end
-
-    def spreadsheet
-      self
-    end
-
-    def worksheets
-      @worksheet.values
-    end
-
-    def templates
-      @template.values
-    end
-
-    def read(filename)
-      @input_file = filename
-      load_roo
-      load_schema
-      load_resources
-      self
-    end
-
-    def graph
-      graph = RDF::Repository.new
-      worksheets.each { |worksheet| graph << worksheet.graph }
-      graph
-    end
-    alias to_rdf graph
-
-  private
-
-    # TODO: make this work with other spreadsheets than Excel
-    def load_roo
-      options = {}
-      options[:packed], options[:file_warning] = :zip, :ignore if
-          File.extname(@input_file).downcase == '.xlsm'
-      @roo = Roo::Excelx.new(@input_file, options)
-    end
-
-    def load_schema
-      Spreadsheet::MappingDSL.new(self).instance_exec(&@schema_spec)
-      worksheets.each { |worksheet| worksheet.init }
-    end
-
-    def load_resources
-      worksheets.each do |worksheet|
-        next if worksheet.column.empty?
-        worksheet.map
-      end
-    end
-
-    class << self
-      def definition(*args, &block)
-        definitions << new(*args, &block)
-      end
-      private :new
-
-      def definitions
-        @@definitions ||= []
-      end
-    end
-
-  end
-end