spread2rdf 0.1.4 → 0.1.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGJiMTM4NmY0YzNmY2IwZDkyMWFmZTRjMDY2MDk5ZmE1NWEyMTdjOQ==
+    ODFlMzQ3MWRiYzJhMmU5MzI5Mzk0MGZhMWE1NDMyNGZjYjZiNWYxMw==
   data.tar.gz: !binary |-
-    MGJkOWUyOTI2MTA4YjgwOTdlNDZmOTY4MDZhOTcxMjA0ZWI3MmEwMg==
+    YTE1MzNmNzhlMjI1ODc2ZDlhMzVlY2Q3Y2NkZDUzNDY2MWViZmY4Mw==
 SHA512:
   metadata.gz: !binary |-
-    MzE5Y2M3ZGZhMjc2NzFhYTg4Yzk1ZGFmMDExNTQ4YmYzNzQyOWIyZGNhNzgy
-    MDA5NzZmNDI5MGNmMDE4OTVjOWI0ODc5NWEzNGY4OTY3MDI3YTkyYjk5NGNm
-    NzBkOTYzYTUyYWUzOTU1NzJhNTQ0NDg1ODhkMzBkMTAzNGViN2U=
+    ZTA3MzY0YzQ3ZTUxZmMzNTRlNjkzYjdjNjFmZGVhNjY3YTc1M2MxODQ5YzUz
+    M2MyYjc0MjJhYzQzZTBlNGU5YzdjZDk0Nzk1Mzg3ZmI3ZTNlOGY1ZTM3MTVi
+    Y2Y4ODZlYzk0NjljYTVjZDYwMmY1MGMyZTQ3ZDI0NjhkNTQwMjk=
   data.tar.gz: !binary |-
-    YzY0ZWQ0MjBmNGViZDQzYTAwYzM2ZDc0MDY0YzBkNmU1ZGQ4MDBlODg1MGMy
-    YWU0MmRhY2UwNWI5YzMwNDU2Zjc1ZGVlZjg2ZjM5NjM3MmQwYTU1ZjZjOWVk
-    ZTdiYzg5ZmRkOWUzN2JhNjFlMzQ5MGE4MTQwNzhiNWRmM2E1ODg=
+    ZmVjMGQwNGZlY2MzMjJmZDQwOGFkZTMxMTc1YWQyZTU5NzY3YmU1MDczYzE3
+    NTQyZmFmOWY3Nzk5ZGZiMjJhOWJmYjdmZGM3ZTVhMGYxMzMwNDM2M2MxY2Ey
+    NzVhNWVlZTRkM2M0ZGIxMTljMDEyYTZjYjQ0ZDRmOTgzYjIzNDc=

data/README.md

@@ -9,20 +9,449 @@ for specifying the mapping rules for this conversion.
 * Supports Excel/Excelx, Google spreadsheets, OpenOffice, LibreOffice and CSV
   spreadsheets as input, thanks to [Roo](https://github.com/Empact/roo).
   (Currently, it's tested for Excel only.
-  If you have a problem with another spreadsheet type,
+  If you have problems with other spreadsheet types,
   [raise an issue](https://github.com/marcelotto/spread2rdf/issues).)
 * Supports many RDF serialization formats for the output, thanks to
   [RDF.rb](https://github.com/ruby-rdf/rdf).
-* Mapping definitions are compilable to executables, which can be run without
-  Ruby installed.
+* Mapping definitions can be compiled to executables, which are runnable without
+  having Ruby installed
 
 ## Installation
 
-Install [Ruby](http://www.ruby-lang.org/) and execute the following command
-in a terminal:
+Install [Ruby](http://www.ruby-lang.org/) and execute:
 
     $ gem install spread2rdf
 
+## Command-line interface
+
+For a full description of available parameters, run:
+
+    $ spread2rdf --help
+
+## How it works
+
+Write a mapping file for the spreadsheet that should be converted to RDF.
+Apply the mapping using the ```spread2rdf```
+command-line interface or a compiled version of the mapping file.
+
+### Example mapping file
+
+```ruby
+require 'spread2rdf'
+
+module Spread2RDF
+  Schema.definition 'ProSysMod-Data' do
+
+    namespaces(
+      PSM:    'http://example.com/ProSysMod/ontology#',
+      QUDT:   'http://qudt.org/schema/qudt#'
+    )
+
+    worksheet 'RDF-Export', name: :Settings do
+      NS[:Base]                = cell(:B7)
+      NS[:PSM_MaterialElement] = cell(:B9)
+    end
+
+    worksheet 'MaterialelementeKlassen',
+              name:    :MaterialElementClasses,
+              start:   :B5,
+              subject: { uri: { namespace: PSM_MaterialElement },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.MaterialElement
+              } do
+      column :name, predicate: RDFS.label
+      column :uri
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object:    { from: :MaterialElementClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.materialParameter,
+                                statement: :restriction do
+        column :name,        predicate: PSM.parameterName
+        column :description, predicate: PSM.parameterDescription
+
+        column :min,   predicate: PSM.parameterMinQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :exact, predicate: PSM.parameterQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :max,   predicate: PSM.parameterMaxQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :unit, object: lambda do |value|
+          statements(
+               [ object, QUDT.numericValue, value.to_i ],
+               [ object, QUDT.unit, object_of_column(:unit) ] )
+        end
+      end
+    end
+
+    worksheet 'Materialelemente',
+              name:   :MaterialElements,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_MaterialElement },
+                         type: PSM.MaterialElement
+              } do
+      column :name, predicate: RDFS.label
+      column :uri
+
+      column :type,             predicate: RDF.type,
+                                object:    { from: :MaterialElementClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                   predicate: PSM.materialParameter,
+                   &parameter_block
+
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.materialParameter do
+        column :name,        predicate: PSM.parameterName
+        column :description, predicate: PSM.parameterDescription
+
+        column :min,   predicate: PSM.parameterMinQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :exact, predicate: PSM.parameterQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :max,   predicate: PSM.parameterMaxQuantity,
+                       object:    { uri: :bnode, type: QUDT.QuantityValue },
+                       &quantity_mapping
+        column :unit, object: lambda do |value|
+          statements(
+               [ object, QUDT.numericValue, value.to_i ],
+               [ object, QUDT.unit, object_of_column(:unit) ] )
+        end
+      end
+    end
+  end
+end
+```
+
+A complete example file, showcasing most of the features, can be found
+[in the examples directory](examples/ProSysMod.s2r.rb).
+
+### Mapping definition file
+
+A mapping file is a Ruby file containing a definition like this:
+
+```ruby
+require 'spread2rdf'
+
+module Spread2RDF
+  Schema.definition 'Name-of-the-mapping-schema' do
+
+  end
+end
+```
+
+The name is purely descriptive and currently not used for anything else.
+The definition block contains the description of your spreadsheets schema and
+the conversion rules for mapping the cells to RDF.
+
+### URIs and namespaces
+
+URIs can be written in the form ```Namespace.suffix```, where the namespace is
+written in uppercase.
+The most common namespaces like ```RDF, RDFS, OWL, SKOS, XSD, DC, FOAF``` (all
+predefined [RDF.rb vocabularies](http://rubydoc.info/github/ruby-rdf/rdf/master/RDF/Vocabulary))
+are available without prior declaration.
+Additional namespaces can be defined statically using the ```namespace``` method
+in the schema definition block:
+```ruby
+module Spread2RDF
+  Schema.definition 'Name-of-the-mapping-schema' do
+    namespaces(
+      EX:   'http://www.example.com/',
+      QUDT: 'http://qudt.org/schema/qudt#'
+    )
+  end
+end
+```
+If you want to declare a namespace dynamically, from the contents
+of a cell for example, an element can be added to the hash of namespaces
+```NS```. The name is given as a Ruby symbol:
+```ruby
+worksheet 'Settings' do
+  NS[:EX] = cell(:B7)
+end
+```
+
+### Worksheet schema definitions
+The schema definition block should contain a worksheet definition for every
+worksheet to be processed.
+It consists of
+- the keyword ```worksheet```,
+- followed by the name of the worksheet used in the spreadsheet as a string,
+- a list of named parameters (described below),
+- and a block with column or column block definitions or arbitrary cell
+  processing as in the ```Settings``` worksheet above.
+The order of the worksheet definitions is not significant.
+
+###### ```name``` parameter
+If you want to refer to a worksheet (e.g. in the ```subject``` parameter) with
+a different name than the one used in the spreadsheet (because it contains
+whitespaces for example), you can define it with this parameter.
+
+###### ```start``` parameter
+A Ruby symbol pointing to the upper-left cell of the data to be converted.
+Assuming the first row is a header (which is irrelevant for the conversion), the
+default value for this parameter is ```:A2```.
+
+###### ```subject``` parameter
+This parameter specifies the construction of subject resources from rows.
+It expects a hash with further sub-parameters as its value:
+- ```uri```: Defines the rules to construct an URI for the subject.
+  Possible values are:
+  - ```:bnode```: Construct a blank node for every subject.
+  - Another hash if a full URI should be constructed with the following possible
+    parameters:
+    - ```column```: The name of a column as a Ruby symbol, which contains the
+      base value for the construction of an URI for a subject.
+      In the following I will call this the subject column.
+      The default value for this is ```:uri```.
+    - ```namespace```: The namespace used to construct an URI for a subject by
+      concatenation with the corresponding value of the subject column.
+      If this is not specified, it is assumed that the subject column contains
+      absolute URIs.
+- ```type```: The URI of the RDFS class every subject should be an element of,
+  i.e. for every subject a ```rdf:type``` statement is produced with this URI as
+  its object.
+- ```sub_class_of```: The URI of a RDFS class every subject should be a
+  ```rdfs:subClassOf``` of,
+  i.e. for every subject a ```rdfs:subClassOf``` statement is produced with
+  this URI as its object.
+- ```column```: shortcut for the ```column``` sub-parameter of the ```uri``` parameter
+
+Note that the rows for a subject might span multiple rows of a worksheet, for
+example when a column contains multiple rows with values for the same subject.
+The range of rows for a subject is defined by the subject column according to
+the following criteria:
+- The first row for a subject is the row with a non-empty value in the subject
+  column (by default the column ```:uri```).
+- The last row for a subject is the last row with an empty value in the subject
+  column or the last row of the worksheet.
+
+### Column schema definitions
+A column definition consists of
+- the keyword ```column```,
+- followed by a Ruby symbol with the arbitrary name of the column,
+- an optional list of named parameters (described below),
+- and an optional block with custom logic (described below).
+The order of column definitions is significant and must correspond to the
+order of columns in the worksheet.
+For columns which should be ignored, the parameters must be omitted.
+Note, that the first column is defined by the ```start``` parameter of the
+worksheet.
+
+###### ```predicate``` parameter
+The URI of the RDF property which should be used for constructing of triples for
+values of this column.
+Leaving this parameter unspecified has the same effect as setting ```statement```
+to ```:none``` (see below).
+
+###### ```object``` parameter
+This parameter specifies the construction of an object resource or value for a
+row and expects a hash with further sub-parameters as its value:
+- ```language```:
+  A string or Ruby symbol with a language to be used to tag the string value of
+  the generated triple.
+- ```uri```:
+  Specifies the rule for the generation of a resource for the object
+  of a triple. Currently, the following values are possible:
+  - ```:bnode```:
+    Generate a blank node. Primarily used in conjunction with the specification
+    of a Ruby block for custom logic (see below), where additional statements
+    about this object are generated.
+  - A Hash with a ```namespace``` key and a namespace as the value, which is
+    used to construct an URI by concatenating it with the corresponding cell
+    value of the column.
+- ```type```:
+  The URI of the RDFS class every object resource should be an element of, i.e.
+  for every object a ```rdf:type``` statement is produced with this URI as its
+  object.
+- ```from```:
+  Allows the specification of other data sources from which a resource is
+  referenced with a value of the column.
+  The graph of this data source is therefore queried for a resource with the
+  value of the column as its ```rdfs:label``` (currently this property is hard
+  coded, but could be made configurable).
+  The value of this parameter can be a Hash with one or a combination of the
+  following keys or a single Ruby symbol as a shortcut ```worksheet``` or a
+  single string or hash as a shortcut for ```data_source```.
+  - ```worksheet```: The name of a worksheet, whose generated output graph
+    should be queried.
+  - ```data_source```: A single filename or an array of filenames of RDF files,
+    which should be queried.
+    In case of relative paths the directory of the input spreadsheet and the
+    directories specified with the ```-I``` CLI parameter are used for the file
+    search.
+    Although not tested, also URLs to hosted RDF data should be possible instead
+    of filenames, due to RDF.rb.
+Instead of a hash with object construction parameter, it is also possible to
+specify a Ruby proc with arbitrary object construction logic.
+This block gets the value of a cell and should return the mapped value to be
+used as the object of the corresponding generated triple.
+
+###### ```statement``` parameter
+This parameter allows the configuration of the triple generation.
+Currently, the following values are possible:
+- ```:none```:
+  Don't generate a triple.
+  Useful in conjunction with Ruby blocks for custom logic.
+  Leaving the ```predicate``` parameter unspecified has the same effect.
+- ```:inverse```:
+  Use the subject resource (from the subject column) as the object and the
+  mapped value of a cell as the subject of the generated statement.
+- ```:restriction```:
+  This parameter value makes only sense, when the subject is a OWL class.
+  Instead of generating a triple of the form
+  ```subject predicate object .```,
+  where ```subject``` is the resource from the subject column,
+  ```predicate``` the value specified in the ```predicate``` parameter,
+  and ```object``` the mapped value from the cell of a column,
+  the following statements are generated:
+
+```
+  subject rdfs:subClassOf [
+    rdf:type owl:Restriction ;
+    owl:onProperty predicate ;
+    restriction_property object
+  ] .
+```
+
+  ```restriction_property``` is ```owl:hasValue``` by default, but can be
+  changed by giving a hash as the value of ```statement``` parameter, containing
+  ```:restriction``` as a key and the URI of restriction property as its value.
+
+###### Custom logic with Ruby blocks
+The optional Ruby block can be used to generate further statements (or perform
+custom actions in general) to the values of a column.
+This block gets the cell value as an argument, but is executed in the context of
+the [Cell class](lib/spread2rdf/mapping/cell.rb), so the mapped value can be
+accessed via the ```object``` method.
+It's also possible to access the value or mapped value of another column of the
+same row with the methods ```value_of_column``` or ```object_of_column```.
+A single statement can be generated with the ```statement``` method, which
+expects three arguments for the subject, predicate and object.
+Multiple statements at once can be generated with the ```statements``` method,
+which takes an arbitrary number of array arguments containing the three subject,
+predicate and object elements of a triple.
+
+### Column block definitions
+A column block is used to define a sub sheet of a worksheet, meaning a series of
+columns (or further columns blocks) which are treated like a sheet, i.e.
+introducing subject resources, which are used as the subject of the triples
+generated for these columns, while the subjects itself become objects of the
+triples for the outer sheet (or column block).
+
+A column block definition consists of
+- the keyword ```column_block```,
+- followed by a Ruby symbol with an arbitrary name of the column block,
+- an optional list of named parameters,
+- and a Ruby block with column or further column block definitions.
+All parameters of worksheets (except ```start```) and columns (the ```object```
+parameter) can be used as parameters of a column block definition.
+
+### Templates
+Templates are a way to associate a name with a Ruby block in a worksheet,
+for later reuse of definition blocks or mapping blocks.
+A template definition consists of
+- the keyword ```template```,
+- followed by a name as a Ruby symbol,
+- and a block.
+After a template definition the block can be accessed directly by using the defined
+name.
+
+Example:
+```ruby
+module Spread2RDF
+  Schema.definition 'Example' do
+    template :quantity_mapping do |value|
+      statements(
+          [ object, QUDT.numericValue, value.to_i ],
+          [ object, QUDT.unit, object_of_column(:unit) ] )
+    end
+
+    worksheet 'Example sheet' do
+      column :uri
+      column :value, predicate: PSM.parameterMaxQuantity,
+                     object:    { uri: :bnode, type: QUDT.QuantityValue },
+                     &quantity_mapping
+      column :unit, object: unit_mapping # unit_mapping is a predefined custom object mapping to QUDT units
+    end
+  end
+end
+```
+
+Another usage for templates is the definition of a sequence of columns in a worksheet
+definition, by calling the ```include``` method with the template name (in this case
+as Ruby symbol) in a worksheet definition (at the appropriate position).
+
+Example:
+```ruby
+module Spread2RDF
+  Schema.definition 'Example' do
+    template :default_columns do
+      column :name, predicate: RDFS.label
+      column :uri
+    end
+
+    worksheet 'Example sheet' do
+      include :default_columns
+    end
+  end
+end
+```
+
+## Executable mappings
+It's possible to make a schema mapping definition executable as a command-line
+application by placing a ```Schema.execute``` call after the schema definition
+in a mapping file.
+With that, the mapping file can be used as an executable script file, which
+behaves like ```spread2rdf``` with the schema mapping parameter ```-s```
+implicitly set to this schema mapping, supporting all of its possible
+parameters  (except ```-s``` obviously).
+
+Example: A file ```example-mapping.s2r``` with the following definition
+```ruby
+#!/usr/bin/env ruby
+
+module Spread2RDF
+  Schema.definition 'Example' do
+    # ...
+  end
+  Schema.execute
+end
+```
+can be executed as follows (assuming your system can handle the shebang line or
+has Ruby files associated with the ruby interpreter):
+
+    $ example-mapping.s2r example.xls
+
+This call is equivalent to this:
+
+    $ spread2rdf -s example-mapping.s2r example.xls
+
+### Compilation of mappings
+An executable mapping can also be compiled to a Windows executable with the
+```-c``` option of the ```spread2rdf``` command-line interface like this:
+
+    $ spread2rdf -c example-mapping.s2r
+
+The resulting executable can then be used like the executable Ruby mapping file,
+but without the need of an installed Ruby, since this is compiled into the
+executable.
+
+    $ example-mapping.exe example.xls
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
 ## Author
 
 * Marcel Otto

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/examples/ProSysMod.s2r.rb

@@ -0,0 +1,334 @@
+#!/usr/bin/env ruby
+require 'spread2rdf'
+
+module Spread2RDF
+  Schema.definition 'ProSysMod-Data' do
+
+    namespaces(
+      PSM:    'http://homepages.uni-paderborn.de/fbauer/ProSysMod/ontology#',
+      QUDT:   'http://qudt.org/schema/qudt#'
+    )
+
+    machine_classifications = %w[
+        PSM-Lagermittel-Klassifikation.ttl
+        PSM-Foerdermittel-Klassifikation.ttl
+    ]
+
+    worksheet 'RDF-Export', name: :Settings do
+      NS[:Base]                = cell(:B7)
+      NS[:PSM_MaterialElement] = cell(:B9)
+      NS[:PSM_Process]         = cell(:B10)
+      NS[:PSM_Resource]        = cell(:B11)
+      NS[:PSM_Characteristic]  = cell(:B12)
+      NS[:PSM_Quality]         = cell(:B13)
+    end
+
+    template :default_columns do
+      column :name, predicate: RDFS.label
+      column :uri
+    end
+
+    template :quantity_mapping do |value|
+      statements(
+          [ object, QUDT.numericValue, value.to_i ],
+          [ object, QUDT.unit, object_of_column(:unit) ] )
+    end
+
+    template :parameter_block do
+      column :name,        predicate: PSM.characteristic,
+                           object:    { language: 'de',
+                                        from: {
+                                          worksheet:   :Characteristics,
+                                          data_source: 'PSM-Merkmale.ttl' } }
+      #column :description, predicate: RDFS.comment
+      column :quality,     predicate: PSM.parameterQuality,
+                           object:    { from: {
+                                          worksheet:   :Qualities,
+                                          data_source: 'PSM-Qualitaeten.ttl' } }
+      column :min,   predicate: PSM.parameterMinQuantity,
+                     object:    { uri: :bnode, type: QUDT.QuantityValue },
+                     &quantity_mapping
+      column :exact, predicate: PSM.parameterQuantity,
+                     object:    { uri: :bnode, type: QUDT.QuantityValue },
+                     &quantity_mapping
+      column :max,   predicate: PSM.parameterMaxQuantity,
+                     object:    { uri: :bnode, type: QUDT.QuantityValue },
+                     &quantity_mapping
+      column :unit, object: unit_mapping
+      column :valuation_method, predicate: PSM.usedByValuationMethod,
+                                object:    { from: :ValuationMethods }
+    end
+
+    worksheet 'Merkmale',
+              name: :Characteristics,
+              start:   :B5,
+              subject: { uri: { namespace: PSM_Characteristic },
+                         type: PSM.Characteristic
+              } do
+      column :name_de, predicate: RDFS.label, object: { language: 'de' }
+      column :name_en, predicate: RDFS.label, object: { language: 'en' }
+      column :uri
+    end
+
+    worksheet 'Qualitaeten',
+              name:    :Qualities,
+              start:   :B5,
+              subject: { uri: { namespace: PSM_Quality },
+                         type:             RDF::RDFS.Class,
+                         #sub_class_of:     PSM.Quality
+              } do
+      include :default_columns
+      column :elements, predicate: RDF.type, object: { uri: { namespace: PSM_Quality } },
+                        statement: :inverse do |value|
+        statement( object, RDF::RDFS.label, value)
+      end
+    end
+
+    worksheet 'Services',
+              start:   :B5,
+              subject: { type: PSM.Service } do
+      include :default_columns
+    end
+
+    worksheet 'Bewertungsmethoden',
+              name:    :ValuationMethods,
+              start:   :B5,
+              subject: { type: PSM.ValuationMethod } do
+      include :default_columns
+    end
+
+    worksheet 'MaterialelementeKlassen',
+              name:    :MaterialElementClasses,
+              start:   :B5,
+              subject: { uri: { namespace: PSM_MaterialElement },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.MaterialElement
+              } do
+      include :default_columns
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object:    { from: :MaterialElementClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.materialParameter,
+                                statement: :restriction,
+                                &parameter_block
+    end
+
+    worksheet 'Materialelemente',
+              name:   :MaterialElements,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_MaterialElement },
+                         type: PSM.MaterialElement
+              } do
+      include :default_columns
+
+      column :type,             predicate: RDF.type,
+                                object:    { from: :MaterialElementClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                   predicate: PSM.materialParameter,
+                   &parameter_block
+    end
+
+    worksheet 'ProzesseKlassen',
+              name:  :ProcessClasses,
+              start: :B5,
+              subject: { uri: { namespace: PSM_Process },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.Process
+              } do
+      include :default_columns
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object:    { from: :ProcessClasses }
+      column :input,            predicate: PSM.input,
+                                object: { from: :MaterialElements },
+                                statement: :restriction # TODO: Should we allow here Classes also, for which a subProperty with a restricted rdfs:range is introduced
+      column :output,           predicate: PSM.ouput,
+                                object: { from: :MaterialElements },
+                                statement: :restriction # TODO: dto.
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.processParameter,
+                                statement: :restriction,
+                                &parameter_block
+    end
+
+    worksheet 'Prozesse',
+              name:  :Processes,
+              start: :B5,
+              subject: { uri:  { namespace: PSM_Process },
+                         type: PSM.Process
+              } do
+      include :default_columns
+
+      column :type,             predicate: RDF.type,
+                                object:    { from: :ProcessClasses }
+      column :input,            predicate: PSM.input,
+                                object: { from: :MaterialElements }
+      column :output,           predicate: PSM.output,
+                                object: { from: :MaterialElements }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.processParameter,
+                                &parameter_block
+    end
+
+    worksheet 'WerkzeugeKlassen',
+              name:   :ToolClasses,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.Tool
+              } do
+      include :default_columns
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object:    { from: :ToolClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.resourceParameter,
+                                statement: :restriction,
+                                &parameter_block
+    end
+
+    worksheet 'Werkzeuge',
+              name:   :Tools,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type: PSM.Tool
+              } do
+      include :default_columns
+
+      column :type,             predicate: RDF.type,
+                                object:  { from: :ToolClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.resourceParameter,
+                                &parameter_block
+    end
+
+    worksheet 'VorrichtungenKlassen',
+              name:   :DeviceClasses,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.Device
+              } do
+      include :default_columns
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object:    { from: :DeviceClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.resourceParameter,
+                                statement: :restriction,
+                                &parameter_block
+    end
+
+    worksheet 'Vorrichtungen',
+              name:   :Devices,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type: PSM.Device
+              } do
+      include :default_columns
+
+      column :type,             predicate: RDF.type,
+                                object:  { from: :DeviceClasses }
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.resourceParameter,
+                                &parameter_block
+    end
+
+    worksheet 'WerkerKlassen',
+              name:   :WorkerClasses,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.Worker
+              } do
+      include :default_columns
+
+      column :sub_class_of,       predicate: RDFS.subClassOf,
+                                  object:    { from: :WorkerClasses }
+      column :supported_services, predicate: PSM.supportsService,
+                                  object:    { from: :Services },
+                                  statement: :restriction
+      column_block :parameter,    subject: { uri: :bnode, type: PSM.Parameter },
+                                  predicate: PSM.resourceParameter,
+                                  statement: :restriction,
+                                  &parameter_block
+    end
+
+    worksheet 'Werker',
+              name:   :Workers,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type: PSM.Worker
+              } do
+      include :default_columns
+
+      column :type,               predicate: RDF.type,
+                                  object:  { from: :WorkerClasses }
+      column :supported_services, predicate: PSM.supportsService,
+                                  object:    { from: :Services }
+      column_block :parameter,    subject: { uri: :bnode, type: PSM.Parameter },
+                                  predicate: PSM.resourceParameter,
+                                  &parameter_block
+    end
+
+    worksheet 'MaschinenKlassen',
+              name:   :MachineClasses,
+              start:  :B5,
+              subject: { uri: { namespace: PSM_Resource },
+                         type:         RDF::RDFS.Class,
+                         sub_class_of: PSM.Machine
+              } do
+      include :default_columns
+
+      column :sub_class_of,     predicate: RDFS.subClassOf,
+                                object: { from: {
+                                       worksheet: :MachineClasses,
+                                       data_source: machine_classifications } }
+
+      column :tools     # ignored
+      column :devices   # ignored
+      column :workers   # ignored
+      column :required_services, predicate: PSM.requiresService,
+                                 object:    { from: :Services },
+                                 statement: :restriction
+      column :processes # ignored
+
+      column_block :parameter,  subject: { uri: :bnode, type: PSM.Parameter },
+                                predicate: PSM.resourceParameter,
+                                statement: :restriction,
+                                &parameter_block
+    end
+
+    worksheet 'Maschinen',
+                name:     :Machines,
+                start:    :B5,
+                subject: { uri:  { namespace: PSM_Resource },
+                           type: PSM.Machine
+                        } do
+      include :default_columns
+
+      column :type,              predicate: RDFS.subClassOf,
+                                 object: { from: {
+                                       worksheet:   :MachineClasses,
+                                       data_source: machine_classifications } }
+
+      column :tools,             predicate: PSM.hasTool,
+                                 object:    { from: :Tools }
+      column :devices,           predicate: PSM.hasDevice,
+                                 object:    { from: :Devices }
+      column :workers,           predicate: PSM.hasWorker,
+                                 object:    { from: :Workers }
+      column :required_services, predicate: PSM.requiresService,
+                                 object:    { from: :Services }
+      column :processes,         predicate: PSM.realizeProcess,
+                                 object:    { from: :Processes }
+
+      column_block :parameter,   subject: { uri: :bnode, type: PSM.Parameter },
+                                 predicate: PSM.resourceParameter,
+                                 &parameter_block
+    end
+
+  end
+  Schema.execute
+end

data/lib/spread2rdf/mapping/cell.rb

@@ -35,6 +35,8 @@ module Spread2RDF
         value.blank?
       end
 
+    private
+
       def map_to_object(value)
         case schema.object_mapping_mode
           when :to_string     then map_to_literal(value)
@@ -44,7 +46,6 @@ module Spread2RDF
           else raise 'internal error: unknown column mapping mode'
         end
       end
-      private :map_to_object
 
       def map_to_literal(value)
         if language = schema.try(:object).try(:fetch, :language, nil)
@@ -53,7 +54,6 @@ module Spread2RDF
           value
         end
       end
-      private :map_to_literal
 
       def resolve_resource_ref
         source = schema.object[:from]
@@ -65,7 +65,6 @@ module Spread2RDF
           raise "#{self}: couldn't find a resource for #{value} in any of the defined sources"
         end
       end
-      private :resolve_resource_ref
 
       def resolve_resource_ref_from_worksheet(worksheet_name)
         worksheet = spreadsheet.worksheet(worksheet_name)
@@ -73,7 +72,6 @@ module Spread2RDF
         source_predicate = RDF::RDFS.label # TODO: make this configurable via a attribute in the schema definition
         query_subject(worksheet.graph, source_predicate, value, worksheet)
       end
-      private :resolve_resource_ref_from_worksheet
 
       def resolve_resource_ref_from_data_sources(data_sources)
         raise ArgumentError, "expecting an Array, but got #{data_sources}" unless data_sources.is_a? Array
@@ -83,13 +81,11 @@ module Spread2RDF
         end
         nil
       end
-      private :resolve_resource_ref_from_data_sources
 
       def resolve_resource_ref_from_data_source(data_source)
         source_predicate = RDF::RDFS.label # TODO: make this configurable via a attribute in the schema definition
         query_subject(data_source, source_predicate, value)
       end
-      private :resolve_resource_ref_from_data_source
 
       def query_subject(data_source, predicate, value, data_source_name = nil)
         data_source_name ||= "data source #{data_source}"
@@ -121,11 +117,12 @@ module Spread2RDF
         #puts "executing block of #{@___column___} in row #{row}"
         self.instance_exec(value, &block) if block_given?
       end
-      private :exec
 
       ##########################################################################
       # Element#_children_
 
+      public
+
       def _children_
         nil
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spread2rdf
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Marcel Otto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-17 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -181,6 +181,7 @@ files:
 - Rakefile
 - VERSION
 - bin/spread2rdf
+- examples/ProSysMod.s2r.rb
 - lib/spread2rdf.rb
 - lib/spread2rdf/attributes.rb
 - lib/spread2rdf/cli.rb