spread2rdf 0.0.1pre.1 → 0.0.1

data/lib/spread2rdf/mapping/sheet.rb

@@ -0,0 +1,80 @@
+module Spread2RDF
+  module Mapping
+    class Sheet < Element
+
+      def initialize(sheet, parent)
+        super
+        @resources = []
+      end
+
+      def map
+        #puts "processing #{self} in #{row_range}"
+        return [] if row_range.nil? or schema.columns.empty?
+        rows_per_resource.each do |resource_range|
+          @resources << Mapping::Resource.new(schema, self, resource_range)
+        end
+        self
+      end
+
+      def rows_per_resource
+        return [] if row_range.nil?
+        @rows_per_resource ||= begin
+          rows = if fix_row_count = schema.fix_row_count_per_resource
+                   row_range.find_all do |row|
+                     (row - row_range.begin) % fix_row_count == 0
+                   end
+                 else
+                   subject_column_coord = schema.subject_column.try(:coord)
+                   raise "no subject column for #{self}" if subject_column_coord.blank?
+                   row_range.find_all do |row|
+                     not cell(row: row, column: subject_column_coord).blank?
+                   end
+                 end
+          rows_per_resource = []
+          rows.each_with_index do |first_row, i|
+            last_row = (i+1 == rows.count ? row_range.end : rows[i+1]-1)
+            rows_per_resource << Range.new(first_row, last_row)
+          end
+          rows_per_resource
+        end
+      end
+
+      ##########################################################################
+      # Mapping::Element structure
+
+      def worksheet
+        return self if self.is_a? Worksheet
+        parent = self.parent
+        parent = parent.parent until parent.is_a? Worksheet or parent.nil?
+        parent
+      end
+
+      attr_reader :resources
+      alias _children_ resources
+
+      def resource_by_row(row)
+        index = rows_per_resource.find_index { |range| range.include? row }
+        resource_by_index(index)
+      end
+
+      def resource_by_index(index)
+        @resources[index]
+      end
+
+      ##########################################################################
+      # Roo helper
+
+      def cell_value(coord)
+        value = ROO.cell(coord, schema.worksheet.source_name)
+        value = value.strip if value.is_a? String
+        value
+      end
+      alias cell cell_value
+
+      def roo(&block)
+        ROO.roo(schema.worksheet.source_name, &block)
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/mapping/spreadsheet.rb

@@ -0,0 +1,56 @@
+module Spread2RDF
+  module Mapping
+    class Spreadsheet < Element
+
+      attr_reader :input_file
+
+      def initialize(schema, filename)
+        super(schema, nil)
+        @worksheets = {}
+        @input_file = filename
+        ROO.load(filename)
+      end
+
+      def map
+        schema.sorted_worksheets.each do |worksheet_schema|
+          worksheet!(worksheet_schema)
+        end
+        self
+      end
+
+      def worksheet_schema(name)
+        case name
+          when Schema::Worksheet then name
+          when String, Symbol    then schema.worksheet[name]
+          else raise ArgumentError
+        end
+      end
+
+      ##########################################################################
+      # Mapping::Element structure
+
+      def spreadsheet
+        self
+      end
+
+      def worksheets
+        @worksheets.values
+      end
+      alias _children_ worksheets
+
+      def worksheet(name)
+        @worksheets[worksheet_schema(name).name]
+      end
+
+      def worksheet!(name)
+        worksheet_schema = worksheet_schema(name)
+        @worksheets[worksheet_schema.name] || begin
+          @worksheets[worksheet_schema.name] = mapping =
+              Mapping::Worksheet.new(worksheet_schema, self)
+          mapping.map
+        end
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/mapping/statement.rb

@@ -0,0 +1,22 @@
+module Spread2RDF
+  module Mapping
+    module Statement
+
+      def statements_to_object(object)
+        case schema.statement_mapping_mode
+          when :default
+            statement(subject, predicate, object)
+          when :restriction
+            restriction_class = RDF::Node.new
+            statements(
+                [ subject, RDF::RDFS.subClassOf, restriction_class ],
+                [ restriction_class, RDF.type, RDF::OWL.Restriction ],
+                [ restriction_class, RDF::OWL.onProperty, predicate ],
+                [ restriction_class, schema.restriction_mode, object ]
+            )
+        end
+      end
+      private :statements_to_object
+    end
+  end
+end

data/lib/spread2rdf/mapping/worksheet.rb

@@ -0,0 +1,12 @@
+module Spread2RDF
+  module Mapping
+    class Worksheet < Sheet
+
+      def row_range
+        range = roo { |roo| (Coord[schema.start].row .. roo.last_row) }
+        range.begin <= range.end ? range : nil
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/namespace.rb

@@ -1,5 +1,9 @@
 module Spread2RDF
   module Namespace
+    DEFAULTS = {
+        UNIT: ::RDF::Vocabulary.new('http://qudt.org/vocab/unit#')
+    }
+
     class << self
       def [](name)
         name = name.to_sym
@@ -18,7 +22,7 @@ module Spread2RDF
       end
 
       def namespace
-        @namespace ||= {}
+        @namespace ||= DEFAULTS
       end
 
       def namespaces
@@ -32,7 +36,7 @@ module Spread2RDF
           when RDF::Vocabulary, RDF::URI, String
             namespace_descriptor.to_s
           else
-            raise "invalid namespace: #{namespace_descriptor.inspect}"
+            raise "invalid namespace: #{namespace_descriptor.inspect}:#{namespace_descriptor.class}"
         end
       end
 

data/lib/spread2rdf/roo_helper.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+module Spread2RDF
+  class RooAdapter
+    include Singleton
+
+    def initialize
+
+    end
+
+    # TODO: make this work with other spreadsheets than Excel
+    def load(file)
+      options = {}
+      options[:packed], options[:file_warning] = :zip, :ignore if
+          File.extname(file).downcase == '.xlsm'
+      @roo = Roo::Excelx.new(file, options)
+    end
+
+    def select_worksheet(worksheet)
+      @roo.default_sheet = worksheet
+    end
+
+    def roo(worksheet = nil)
+      return @roo if worksheet.nil?
+      last_default_sheet = @roo.default_sheet
+      select_worksheet(worksheet)
+      return @roo unless block_given?
+      result = yield @roo
+      @roo.default_sheet = last_default_sheet
+      result
+    end
+
+    def cell(coord, worksheet = nil)
+      coord = Coord[coord] unless coord.is_a? Coord
+      #if worksheet
+        @roo.cell(coord.column, coord.row, worksheet)
+      #else
+      #  @roo.cell(coord.column, coord.row)
+      #end
+    end
+
+  end
+
+  ROO = RooAdapter.instance
+
+end

data/lib/spread2rdf/schema/column.rb

@@ -0,0 +1,37 @@
+module Spread2RDF
+  module Schema
+    class Column < Element
+      include StatementMapping
+
+      self.attributes = {
+          predicate:  nil,
+          object:     nil,
+          statement:  nil
+      }
+
+      attr_reader :coord # this is set by Worksheet#index_columns!
+
+      alias sheet parent
+
+      def to_s
+        "#{super} of #{sheet}"
+      end
+
+      def object_mapping_mode
+        case
+          when object.nil?         then :to_string
+          when object.is_a?(Proc)  then :custom
+          when !object[:uri].nil?  then :new_resource
+          when !object[:from].nil? then :resource_ref
+          else
+            raise "mapping specification error: don't know how to map #{self}"
+        end
+      end
+
+      def cell_mapping
+        object if object.is_a?(Proc)
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/{spreadsheet/sub_sheet.rb → schema/column_block.rb}

@@ -1,6 +1,7 @@
 module Spread2RDF
-  class Spreadsheet
-    class SubSheet < Sheet
+  module Schema
+    class ColumnBlock < Sheet
+      include StatementMapping
 
       self.attributes = {
           predicate:  nil,

data/lib/spread2rdf/{spreadsheet → schema}/element.rb

@@ -1,7 +1,10 @@
+require 'forwardable'
+
 module Spread2RDF
-  class Spreadsheet
+  module Schema
     class Element
       include Attributes
+      extend Forwardable
 
       self.attributes = {
           name:         nil,
@@ -11,17 +14,14 @@ module Spread2RDF
       attr_reader :parent
       attr_reader :block
 
+      def_delegators :parent, :spreadsheet
 
-      def initialize(parent, attr={}, &block)
+      def initialize(parent, attr = {}, &block)
         @parent   = parent
         @block    = block
         init_attributes(attr)
       end
 
-      def init
-
-      end
-
       def name
         (@name or @source_name).try(:to_sym)
       end
@@ -30,21 +30,17 @@ module Spread2RDF
         (@source_name or @name).try(:to_s)
       end
 
-      def spreadsheet
-        parent.spreadsheet
+      def worksheet
+        return self if self.is_a? Worksheet
+        parent = self.parent
+        parent = parent.parent until parent.is_a? Worksheet or parent.nil?
+        parent
       end
 
       def to_s
         name = (self.name.to_s == self.source_name.to_s ?
             self.name : "#{self.name} (#{self.source_name})" )
-        "#{self.class.name.split('::').last} #{name}"
-      end
-
-    private
-
-      def create_context(parent_context, attr)
-        context_class = self.class.const_get(:MappingContext)
-        context_class.new(self, parent_context, attr)
+        "#{self.class.name.split('::').last}-schema #{name}"
       end
 
     end

data/lib/spread2rdf/schema/schema.rb

@@ -0,0 +1,19 @@
+module Spread2RDF
+  module Schema
+    class << self
+      def definition(*args, &block)
+        definitions << Spreadsheet.new(*args, &block)
+      end
+
+      def definitions
+        @@definitions ||= []
+      end
+
+      def execute(options = {})
+        CLI.run options.merge(schema: definitions.first) unless CLI.running?
+      end
+
+    end
+
+  end
+end

data/lib/spread2rdf/schema/sheet.rb

@@ -0,0 +1,87 @@
+module Spread2RDF
+  module Schema
+    class Sheet < Element
+
+      self.attributes = {
+          start:                  :A2,
+          subject:                nil,
+          row_count_per_resource: nil
+      }
+
+      def initialize(parent, attr = {}, &block)
+        super
+        @column = {}
+        @column_index = {}
+      end
+
+      def start_coord
+        Coord[start]
+      end
+
+      def column_by_coord(coord)
+        coord = Roo::Base.number_to_letter(coord) if coord.is_a? Integer
+        @column_index[coord]
+      end
+
+      def column_by_name(name = nil)
+        return @column if name.nil?
+        name = name.to_sym
+        @column[name] or ( parent.is_a?(Sheet) and parent.column(name) ) or nil
+      end
+      alias column column_by_name
+
+      def columns
+        @column.values
+      end
+
+      def column_range
+        first = columns.first.coord
+        first = first.begin if first.is_a? Range
+        last = columns.last.coord
+        last = last.end if last.is_a? Range
+        first .. last
+      end
+
+      def each_column(&block)
+        columns.each do |column|
+          if column.is_a? ColumnBlock
+            column.each_column(&block)
+          else
+            yield column
+          end
+        end
+      end
+
+      def subject_column
+        column_name = self.subject.try(:fetch, :column, nil) || :uri
+        @column[column_name]
+      end
+
+      def fix_row_count_per_resource
+        row_count_per_resource or ( !subject_column && 1 ) or nil
+      end
+
+      def subject_mapping_mode
+        case
+          when ( subject.try(:fetch, :uri, nil) || subject ) == :bnode
+            :bnode
+          else
+            :from_column
+        end
+      end
+
+      def subject_namespace
+        subject_namespace_name =
+            subject.try(:fetch, :uri, nil).try(:fetch, :namespace, nil)
+        Namespace.resolve_to_namespace(subject_namespace_name)
+      end
+
+      def subject_resource_type
+        subject.try(:fetch, :type, nil) or
+            (subject.try(:fetch, :sub_class_of, nil) && RDF::RDFS.Class) or
+            nil
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/schema/sheet_dsl.rb

@@ -0,0 +1,54 @@
+module Spread2RDF
+  module Schema
+    class Sheet
+      class DSL
+        def initialize(spreadsheet_dsl, worksheet, filename, &block)
+          @spreadsheet_dsl = spreadsheet_dsl
+          @worksheet = worksheet
+          @filename = filename
+          instance_exec(&block) if block_given?
+        end
+
+        def column(name, options={}, &block)
+          name = name.to_sym
+          column = @worksheet.column[name] ||= Column.new(@worksheet, &block)
+          column.update_attributes options.merge(name: name)
+          column # TODO: chaining logic ...?
+        end
+
+        def column_block(name, options={}, &block)
+          name = name.to_sym
+          sub_sheet = @worksheet.column[name] ||= ColumnBlock.new(@worksheet)
+          sub_sheet.update_attributes options.merge(name: name)
+          DSL.new(@spreadsheet_dsl, sub_sheet, @filename, &block)
+        end
+
+        def cell(coord, options = {}, &block)
+          content = ROO.cell(coord, @worksheet.source_name)
+          content = block.call(content) if block_given?
+          content
+        end
+
+        def include(template, *args)
+          instance_exec(*args, &__template__(template))
+        end
+
+        def __template__(name)
+          @spreadsheet_dsl.instance_variable_get(:@templates)[name]
+        end
+        private :__template__
+
+        def __cell_mapping__(name)
+          @spreadsheet_dsl.instance_variable_get(:@cell_mappings)[name] or
+              Mapping::Cell::Default.method(name).to_proc
+        end
+        private :__cell_mapping__
+
+        def method_missing(name, *args)
+          __template__(name) or __cell_mapping__(name) or super
+        end
+
+      end
+    end
+  end
+end

data/lib/spread2rdf/schema/spreadsheet.rb

@@ -0,0 +1,49 @@
+module Spread2RDF
+  module Schema
+    class Spreadsheet
+
+      attr_reader :name
+      attr_reader :worksheet
+
+      def initialize(name, &block)
+        @name = name
+        @worksheet = {}
+        @schema_spec = block
+      end
+
+      def spreadsheet
+        self
+      end
+
+      def worksheets
+        @worksheet.values
+      end
+
+      def sorted_worksheets
+        unsorted_worksheets, sorted_worksheets = worksheets, []
+        unsorted_worksheets.reject! do |worksheet|
+          worksheet.columns.empty? and sorted_worksheets << worksheet
+        end
+        while not unsorted_worksheets.empty?
+          independent = unsorted_worksheets.find_index { |worksheet|
+            unsorted_worksheets.none? do |other_worksheet|
+              worksheet.depends_on? other_worksheet
+            end
+          }
+          raise "schema contains cyclic dependencies" if independent.nil?
+          sorted_worksheets << unsorted_worksheets.delete_at(independent)
+        end
+        sorted_worksheets
+      end
+
+      def map(input_file)
+        mapping = Mapping::Spreadsheet.new(self, input_file)
+        DSL.new(self, input_file).instance_exec(&@schema_spec)
+        worksheets.each { |worksheet| worksheet.init }
+        mapping.map
+        mapping
+      end
+
+    end
+  end
+end

data/lib/spread2rdf/schema/spreadsheet_dsl.rb

@@ -0,0 +1,42 @@
+module Spread2RDF
+  module Schema
+    class Spreadsheet
+      class DSL
+
+        def initialize(schema, filename)
+          @schema = schema
+          @filename = filename
+          @templates = {}
+          @cell_mappings = {}
+        end
+
+        def namespaces(namespaces)
+          namespaces.each { |name, namespace| Namespace[name] = namespace }
+        end
+
+        def worksheet(name, options={}, &block)
+          source_name = options[:source_name] = name
+          name = ( options.delete(:name) || source_name ).to_sym
+          worksheet = @schema.worksheet[name] ||= Worksheet.new(@schema)
+          worksheet.update_attributes options.merge(name: name, source_name: source_name)
+          Sheet::DSL.new(self, worksheet, @filename, &block)
+        end
+
+        def template(name, &block)
+          raise "required block for template #{name} missing" unless block_given?
+          @templates[name.to_sym] = block
+        end
+
+        def cell_mapping(name, &block)
+          raise "required block for cell_mapping #{name} missing" unless block_given?
+          @cell_mappings[name.to_sym] = block
+        end
+
+        def method_missing(name, *args)
+          @templates[name] or super
+        end
+
+      end
+    end
+  end
+end

data/lib/spread2rdf/schema/statement_mapping_schema.rb

@@ -0,0 +1,26 @@
+module Spread2RDF
+  module Schema
+    module StatementMapping
+
+      def statement_mapping_mode
+        case
+          when statement == :none then :ignore
+          when statement == :none then :ignore
+          when predicate.nil?     then :ignore
+          when restriction_mode   then :restriction
+          else                         :default
+        end
+      end
+
+      def restriction_mode
+        case statement
+          when :restriction then RDF::OWL.hasValue
+          when Hash         then restriction_mode[:restriction]
+          else false
+        end
+      end
+
+
+    end
+  end
+end

data/lib/spread2rdf/schema/worksheet.rb

@@ -0,0 +1,47 @@
+module Spread2RDF
+  module Schema
+    class Worksheet < Sheet
+
+      def init
+        index_columns!
+      end
+
+      def index_columns!
+        index = start_coord.column_as_number
+        each_column do |column|
+          index_letter = Roo::Base.number_to_letter(index)
+          column.instance_variable_set :@coord, index_letter
+          parent = column
+          until parent.is_a? Worksheet
+            parent = parent.parent
+            column_index = parent.instance_variable_get :@column_index
+            column_index[index_letter] = column
+          end
+          index += 1
+        end
+      end
+
+      def dependent_sheets
+        references = []
+        each_column do |column|
+          if column.object_mapping_mode == :resource_ref
+            references << spreadsheet.worksheet[column.object[:from]]
+          end
+        end
+        references
+      end
+
+      def depends_on?(worksheet)
+        return false unless worksheet.is_a? Worksheet
+        return false if worksheet == self
+        dependent_sheets = self.dependent_sheets
+        return false if dependent_sheets.empty?
+        return true if dependent_sheets.include? worksheet
+        dependent_sheets.any? do |dependent_sheet|
+          dependent_sheet != self and dependent_sheet.depends_on? worksheet
+        end
+      end
+
+    end
+  end
+end