dwcr 0.0.8

data/lib/dwcr/metaschema/xml_parsable.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+#
+module DwCR
+  #
+  module Metaschema
+    #
+    module XMLParsable
+      # Validates the meta.xml file
+      # will raise errors if the file is not valid
+      # currently only covers validation against multiple core instances
+      def self.validate_meta(xml)
+        raise ArgumentError, 'Root is not archive' unless xml.root.name == 'archive'
+
+        xml_elements = xml.root.elements
+        xml_core = xml_elements.css 'core'
+        raise ArgumentError, 'Missing core node' if xml_core.empty?
+        raise ArgumentError, 'Multiple core nodes' if xml_core.count > 1
+
+        xml_elements -= xml_core
+        xml_xtns = xml_elements.css 'extension'
+        xml_elements -= xml_xtns
+        raise ArgumentError, 'Invalid node' unless xml_elements.empty?
+
+        xml
+      end
+
+      # Loads the _meta.xml_ file from path
+      # if _path_ is a directory, will try to locate the _meta.xml_ file in _path_
+      # wil default to working directory if no _path_ is given
+      def self.load_meta(path = nil)
+        path ||= Dir.pwd
+        meta = File.directory?(path) ? File.join(path, 'meta.xml') : path
+        xml = File.open(meta) { |f| Nokogiri::XML(f) }
+        XMLParsable.validate_meta xml
+      end
+
+      # Parses the _default_ value from an xml node
+      # applies to _field_ nodes
+      def default_from(xml)
+        xml.attributes['default']&.value
+      end
+
+      # Returns +true+ id the xml node represenst the _core_
+      # +false+ otherwise
+      # applies to child nodes of _archive_ (entities)
+      def is_core_from(xml)
+        case xml.name
+        when 'core'
+          true
+        when 'extension'
+          false
+        else
+          raise ArgumentError, "invalid node name: '#{xml.name}'"
+        end
+      end
+
+      # Returns the index of a _field_ node
+      # or the _coreid_ of an _extension_ node
+      # applies to _field_ and _extension_ nodes
+      def index_from(xml)
+        key_index = xml.css('coreid')&.first
+        return xml.attributes['index']&.value&.to_i unless key_index
+        key_index.attributes['index'].value.to_i
+      end
+
+      # Returns the index of the key column in
+      # the _core_ (_id_)
+      # or an _extension_ (_coreid_)
+      # applies to child nodes of _archive_ (entities)
+      def key_column_from(xml)
+        key_tag = is_core_from(xml) ? 'id' : 'coreid'
+        xml.css(key_tag).first.attributes['index'].value.to_i
+      end
+
+      # Returns an array with the names for any files
+      # associated with a child node of _archive_ (_core_ or _extension_)
+      # applies to child nodes of _archive_ (entities)
+      def files_from(xml)
+        xml.css('files').css('location').map(&:text)
+      end
+
+      # Returns the term for an entity or attribute
+      # applies to _field_ nodes and child nodes of _archive_ (entities)
+      def term_from(xml)
+        term = xml.attributes['rowType'] || xml.attributes['term']
+        term&.value
+      end
+
+      # Updates an instance of the model class the mixin is included in
+      # with values parsed from xml
+      # applies to _field_ nodes
+      def update_from(xml, *fields)
+        update values_from(xml, *fields)
+        save
+      end
+
+      # Returns the XMLParsable method that corresponds to
+      # the method name of the class the mixin is included to
+      def method(method_name)
+        method_name.to_s + '_from'
+      end
+
+      # Returns a hash with model attributes as keys,
+      # values parsed from xml as values
+      # applies to _field_ nodes
+      def values_from(xml, *attrs)
+        values = attrs.map { |attr| send(method(attr), xml) }
+        attrs.zip(values).to_h.compact
+      end
+    end
+  end
+end

data/lib/dwcr/schema.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# This module provides functionality to create a
+# SQLite database from a DarwinCoreArchive
+# and provides an ORM layer using http://sequel.jeremyevans.net
+# Sequel::Model instances are created from the DwCA's meta.xml file
+module DwCR
+  # Creates the table for +entity+ (a Entity instanc)
+  # inserts foreign key for entities
+  # skips the _coreid_ field declared in _extensions_ in the DwCA meta.xml
+  # (this field is redundant, because relationships are re-established upon
+  # import using SQL primary and foreign keys)
+  # inserts the proper SQL foreign key into _extensions_
+  # adds columns for any +attributes+ associated with +entity+
+  def self.create_schema_table(entity)
+    DB.create_table? entity.table_name do
+      primary_key :id
+      foreign_key :entity_id, :entities
+      foreign_key entity.core.foreign_key, entity.core.table_name if entity.core
+      entity.attributes.each do |a|
+        column(*a.to_table_column) unless a.foreign_key?
+      end
+    end
+  end
+
+  # Creates the database schema for the DwCA nodes
+  # _options_:
+  # - +type:+ +true+ or +false+
+  # - +length:+ +true+ or +false+
+  # if options are given, the schema will be updated
+  # based on the DwCA files actual content,
+  # analysing each column for type and length
+  def self.create_schema(archive, **options)
+    Metaschema.update(archive, options)
+    archive.entities.each { |entity| DwCR.create_schema_table(entity) }
+  end
+
+  # Loads models for all Entity instances in the Archive instance
+  # if no explicit Archive instance is given, it will load the first
+  def self.load_models(archive = Metaschema::Archive.first)
+    archive.entities.map do |entity|
+      entity_model = DwCR.create_model(entity)
+      Metaschema::Entity.associate(:one_to_many,
+                                       entity.table_name,
+                                       class: entity_model)
+      entity_model
+    end
+  end
+
+  # Loads the contents of all CSV files associated with an archive
+  # into the shema tables
+  def self.load_contents_for(archive)
+    archive.core.content_files.each(&:load)
+    archive.extensions.each do |extension|
+      extension.content_files.each(&:load)
+    end
+  end
+end

data/lib/dwcr.rb

@@ -0,0 +1,15 @@
+require 'csv'
+require 'json'
+require 'nokogiri'
+require 'psych'
+require 'sequel'
+require 'sqlite3'
+
+require_relative 'dwca_content_analyzer/file_set'
+require_relative 'dwcr/dynamic_model_queryable'
+require_relative 'dwcr/dynamic_models'
+require_relative 'dwcr/metaschema/metaschema'
+require_relative 'dwcr/schema'
+
+Sequel.extension :inflector
+require_relative 'dwcr/inflections'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: dwcr
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+platform: ruby
+authors:
+- Martin Stein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-12 00:00:00.000000000 Z
+dependencies: []
+description: |+
+  # DwCR
+  DwCA in a SQLite database complete with
+  [Sequel](https://github.com/jeremyevans/sequel) models.
+
+  ## Command Line Tool
+
+  ### Create a new DwCR file
+
+  From within the directory of a DwC Archive:
+
+  ```ruby
+  dwcr new -t dwcr-test.db
+  ```
+
+  will create the file in the directory, named after the directory
+
+  see `dwcr new --help` for options
+
+  ### Load an existing DwCR file
+
+  ```ruby
+  dwcr load ~/documents/dwca/dwcr-test.db
+  ```
+
+email: loveablelobster@fastmail.fm
+executables:
+- dwcr
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/dwcr
+- lib/cli/help.yml
+- lib/cli/load.rb
+- lib/cli/new.rb
+- lib/cli/shell.rb
+- lib/dwca_content_analyzer/column.rb
+- lib/dwca_content_analyzer/csv_converters.rb
+- lib/dwca_content_analyzer/file_contents.rb
+- lib/dwca_content_analyzer/file_set.rb
+- lib/dwcr.rb
+- lib/dwcr/dynamic_model_queryable.rb
+- lib/dwcr/dynamic_models.rb
+- lib/dwcr/inflections.rb
+- lib/dwcr/metaschema/archive.rb
+- lib/dwcr/metaschema/attribute.rb
+- lib/dwcr/metaschema/content_file.rb
+- lib/dwcr/metaschema/entity.rb
+- lib/dwcr/metaschema/metaschema.rb
+- lib/dwcr/metaschema/metaschema_tables.yml
+- lib/dwcr/metaschema/xml_parsable.rb
+- lib/dwcr/schema.rb
+homepage: https://github.com/loveablelobster/DwCR
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- SQLite
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: DwCA stored in a SQLite database, with Sequel models
+test_files: []