roqua-csv_export 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a79aadf9c4962f616080afd55cf135bc0cb2e6dbf434f39a4503bcf33059561
+  data.tar.gz: e0b88f7020f55e3d66987bd847360648e1cf49f0ade702455878452978ac466e
+SHA512:
+  metadata.gz: 6e933d46c4d967409656f0498ce46daee0f61a50222d0d9587283fa411e8d7dc7753170d12c5ff825e93850306a20196776be5f734cd3e5fbcdcc774a61e05b9
+  data.tar.gz: f7d8c837215327291c4622a1608a7bcc5cf836d3936c4cafb86aa98fd92fec4d56280f3f2b46059cac45d7cf93c5083fb9f515fe8d4f2ac21b23aae62c4e4ef7

data/README.md

@@ -0,0 +1,44 @@
+# Roqua CSV export from sqlite export
+
+## Description
+
+Takes a sqlite export and some export_version definitions and generates a csv file for each questionnaire in each version.
+
+## Examples
+
+```ruby
+require 'roqua-csv_export'
+Roqua::CsvExport.generate sqlite_path: Pathname.new('spec/fixtures/sql_export.db'),
+                          export_versions_path: Pathname.new('spec/fixtures/export_versions'),
+                          output_path: Pathname.new('tmp/data_exports'),
+                          organization_key: 'demo',
+                          anonymous_data_in_exports: false # the default.
+```
+
+See [generate method](docs/Roqua/CsvExport#generate-class_method)
+
+## Requirements
+
+## Install
+
+    $ gem install roqua-csv_export
+
+## Developing
+
+* Download source
+* run `bundle`
+* run `guard`
+* write your test and see them fail
+* write your code until the spec pass.
+
+## Changelog
+
+### 0.1.0
+
+First version.
+
+## Copyright
+
+Copyright (c) 2017 Roqua
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit(-1)
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task test: :spec
+task default: :spec
+
+# run bundle in parent dir to update Gemfile.lock
+task :release do
+  Bundler.with_clean_env do
+    `bundle --gemfile=../Gemfile`
+  end
+  `git add ../Gemfile.lock && git commit -m 'update roqua-csv_export in Gemfile.lock'`
+end
+
+require "bundler/gem_tasks"
+
+require 'yard'
+YARD::Rake::YardocTask.new
+task doc: :yard

data/lib/roqua-csv_export.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require ::File.expand_path('../roqua/csv_export', __FILE__)

data/lib/roqua/csv_export.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'sequel'
+require 'roqua/csv_export/version'
+require 'roqua/csv_export/models'
+
+module Roqua
+  module CsvExport
+    extend ActiveSupport::Autoload
+
+    autoload :CsvExportQuestionnaireVersion
+    autoload :ExportVersions
+    autoload :MetaData
+    autoload :Config
+
+    DB = Sequel.sqlite
+
+    # Generate te export files.
+    # When done, output_path will contain a directory for each export_version.
+    # Each directory will contain csv file for each questionnare.
+    # @see Config#initialize Config for list of attributes
+    def self.generate(**attrs)
+      require 'csv'
+      require 'json'
+      config = Config.new(**attrs)
+      load_db(DB, config.sqlite_path)
+      create_indexes
+
+      FileUtils.mkdir_p config.output_path
+      do_export config.export_versions, config
+    end
+
+    private
+
+    def self.load_db(db, path)
+      source = SQLite3::Database.new(path.to_s)
+
+      db.synchronize do |memory_db|
+        backup = SQLite3::Backup.new(memory_db, 'main', source, 'main')
+        backup.step(-1)
+        backup.finish
+      end
+    ensure
+      source.close
+    end
+
+    def self.create_indexes
+      Sequel.extension :migration
+      Sequel.migration do
+        change do
+          alter_table(:responses) do
+            add_index :questionnaire_key
+          end
+        end
+      end
+    end
+
+    def self.questionnaire_keys
+      Models::Response.distinct.select_map(:questionnaire_key)
+    end
+
+    def self.do_export(export_versions, config)
+      questionnaire_keys.each do |questionnaire_key|
+        responses = CsvExport::Models::Response \
+                      .eager(:dossier, :team, :entered_by, :respondent, :response_values, :response_flags, :response_textvars, :team, measurement: :protocol)
+                      .where(questionnaire_key: questionnaire_key)
+                      .order(:id)
+
+        CsvExportQuestionnaireVersion.with_versions_for(questionnaire_key,
+                                                        config) do |versions|
+          responses.paged_each do |response|
+            versions.each do |version|
+              version.write_response(response)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roqua/csv_export/config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport
+  # Configuration for an export run.
+  # Each argument to new has a corresponding getter, with export_versions using export_versions_path to load the data.
+  class Config
+    ATTRS = %i(sqlite_path
+               export_versions
+               export_versions_path
+               organization_key
+               output_path
+               anonymous_data_in_exports)
+
+    attr_reader *ATTRS
+
+    # @param sqlite_path [Pathname] full path to sql_export.db.
+    # @param export_versions [ExportVersions] the versions to export. Can pass path instead.
+    # @param export_versions_path [Pathname] path to directory with json files, to load export_versions from.
+    # @param organization_key [String] will be prepended to csv_file_names.
+    # @param output_path [Pathname] to write a directory per export_version to.
+    # @param anonymous_data_in_exports [Boolean] when true, external_identifier and respondent#id will be exported
+    #                                            for anonymous responses.
+    def initialize(sqlite_path:,
+                   export_versions: nil,
+                   export_versions_path: nil,
+                   organization_key:,
+                   output_path:,
+                   anonymous_data_in_exports: false)
+      local_variables.each do |attr|
+        instance_variable_set("@#{attr}", binding.local_variable_get(attr))
+      end
+    end
+
+    def export_versions
+      @export_versions ||= ::Roqua::CsvExport::ExportVersions.new(export_versions_path)
+    end
+  end
+end

data/lib/roqua/csv_export/csv_export_questionnaire_version.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport
+  # Used to write a single csv file for one export_version of one questionnaire.
+  #
+  class CsvExportQuestionnaireVersion
+    attr_reader :config
+
+    # For each version in export_versions, call {.open}, yield the instances and {#close} them.
+    #
+    # @yield [questionnaire_versions]
+    # @yieldparam version [Array<CsvExportQuestionnaireVersion>]
+    # @return [void]
+    def self.with_versions_for(questionnaire_key, config)
+      versions = config.export_versions.keys.map do |export_version_key|
+        open export_version_key,
+             export_version_mapping: config.export_versions.mapping_for(questionnaire_key, export_version_key),
+             config: config
+      end.compact
+
+      yield versions
+
+    ensure
+
+      versions&.each do |version|
+        version.close
+      end
+    end
+
+    # Creates new object with given params and calls #open on it.
+    # @return [CsvExportQuestionnaireVersion]
+    def self.open(*args)
+      self.new(*args).tap do |questionnaire_version|
+        questionnaire_version.open
+      end
+    end
+
+    # @param export_version_key [String] used to build directory name.
+    # @param export_version_mapping [Array<Hash>] Information on each column for the csv file in order.
+    # @param config [Config]
+    # @see ExportVersions#[] ExportsVersions for format of mapping.
+    def initialize(export_version_key, export_version_mapping:, config:)
+      @config = config
+      @export_version_key = export_version_key
+      @export_version_mapping = export_version_mapping
+    end
+
+    # opens file to write and writes headers to it.
+    # @return [void]
+    def open
+      `mkdir -p #{export_version_path}`
+      @file = CSV.open(csv_path, "w", col_sep: ';', force_quotes: true)
+      @file << export_version_mapping.map { |column| column['header'] }
+    end
+
+    # write the respomse to the file in the format of export_version
+    # @param response [Models::Response]
+    def write_response(response)
+      file << export_version_mapping \
+                .map { |column| get_value(column, response) }
+                .map { |value| format(value) }
+    end
+
+    # close the file.
+    # @return [void]
+    def close
+      file.close
+    end
+
+    private
+
+    attr_reader :export_version_key,
+                :export_version_mapping,
+                :file
+
+    def export_version_path
+      config.output_path.join("#{config.organization_key}_#{export_version_key}")
+    end
+
+    def csv_path
+      # find questionnaire key for the export_version (should be added explicitly to export_version json)
+      path_key = export_version_mapping.find{ |m| m['key'] == 'completed_at'}['header'][0..-14]
+      export_version_path.join("#{path_key}_#{Time.now.strftime("%Y-%m-%d")}.csv")
+    end
+
+    def get_value(column, response)
+      case column['source_type']
+      when 'metadata' then MetaData.send(column['key'], response)
+      when 'variable' then response.variable(column['key'])
+      when 'score'    then response.score(column['key'], column['sub_key'])
+      when 'flag'     then response.flag(column['key']) == '1' ? 'true' : ''
+      when 'textvar'  then response.textvar(column['key'])
+      end
+    end
+
+    def format(value)
+      case value
+      when Time, Date, DateTime
+        value.strftime("%d-%m-%Y %H:%M:%S")
+      when Hash
+        value.to_json
+      when String
+        value.tr("\r\n", ' ')
+      else
+        value
+      end
+    end
+  end
+end

data/lib/roqua/csv_export/export_versions.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require 'json'
+
+module Roqua::CsvExport
+  # Reads json files with export_version info and caches them.
+  class ExportVersions
+    def initialize(mapping_files_directory_path)
+      @base_dir = mapping_files_directory_path
+      @export_versions = {}
+    end
+
+    # Returns column information for specified version for each variable in each questionnaire.
+    #
+    # Each column_hash looks like:
+    #   {"key": "tot",
+    #    "sub_key": "other",
+    #    "header": "all_quests_tot_o",
+    #    "source_type": "score"}
+    # Where header is the header within the csv file.
+    #
+    # @return [Hash] !{"fields" => {"oq45" => [{column_hash}, ...}}
+    def [](key)
+      @export_versions[key] ||= ::JSON.parse(File.read(File.join(@base_dir, "#{key}.json")))
+    end
+
+    def dig(key, *keys)
+      self[key].dig(*keys)
+    end
+
+    # @return [Array<String>] all the available versions, sorted oldest first.
+    def keys
+      Dir["#{@base_dir}/*.json"].map {|f| File.basename(f, File.extname(f)) }.sort
+    end
+
+    # Returns mapping for the questionnaire.
+    # First tries given export_version_key, but if the questonnaires wasn't defined then yet,
+    # it finds the first export_version that did define it.
+    # @return [Array<Hash>]
+    # @see []
+    def mapping_for(questionnaire_key, export_version_key)
+      dig(export_version_key, 'fields', questionnaire_key) \
+      || keys.lazy
+             .reject { |key| key <= export_version_key }
+             .map { |key| dig(key, 'fields', questionnaire_key) }
+             .reject(&:nil?)
+             .first
+    end
+  end
+end

data/lib/roqua/csv_export/meta_data.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport
+  # For each metadata key in export_versions, define a function to get the value for it for a given response.
+  module MetaData
+    extend self
+
+    def anonymous(response)
+      response.anonymous ? 'anonymous' : ''
+    end
+
+    def birth_year(response)
+      nil # deprecated
+    end
+
+    def compl_by(response)
+      return nil unless response.completed_at
+      return nil if response.anonymous && response.entered_by&.external_identifier.nil?
+
+      response.entered_by&.external_identifier || response.dossier.external_identifier
+    end
+
+    def completed_at(response)
+      response.completed_at
+    end
+
+    def date(response)
+      response.observation_time
+    end
+
+    def emailed_at(response)
+      nil # deprecated
+    end
+
+    def gender(response)
+      nil #deprecated
+    end
+
+    def hide_pii_from_researchers(response)
+      response.hide_pii_from_researchers ? "hide" : "show"
+    end
+
+    def hide_values_from_professionals(response)
+      response.hide_values_from_professionals ? "hide" : "show"
+    end
+
+    def id(response)
+      response.id
+    end
+
+    def invited_at(response)
+      nil # deprecated
+    end
+
+    def location(response)
+      response.team&.name
+    end
+
+    def measurement(response)
+      response.measurement&.name
+    end
+
+    def non_response(response)
+      response.non_response&.id
+    end
+
+    def notes(response)
+      response.notes
+    end
+
+    def open_from(response)
+      response.open_from
+    end
+
+    def patient_id(response)
+      return nil if response.anonymous
+
+      response.dossier.external_identifier
+    end
+
+    def project(response)
+      nil # deprecated
+    end
+
+    def protocol(response)
+      response.measurement&.protocol&.name
+    end
+
+    def respondent_id(response)
+      return nil if response.anonymous
+
+      response.respondent&.id
+    end
+
+    def respondent_label(response)
+      response.respondent&.label || 'Medewerker'
+    end
+
+    def respondent_type(response)
+      response.respondent&.type || 'profess'
+    end
+
+    def roqua_id(response)
+      nil # deprecated
+    end
+
+    def started_at(response)
+      response.started_at
+    end
+
+    def variant(response)
+      response.questionnaire_variant
+    end
+  end
+end

data/lib/roqua/csv_export/models.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Roqua
+  module CsvExport
+    module Models
+      extend ActiveSupport::Autoload
+
+      autoload :Dossier
+      autoload :Measurement
+      autoload :NonResponse
+      autoload :Professional
+      autoload :Protocol
+      autoload :Respondent
+      autoload :Response
+      autoload :ResponseFlag
+      autoload :ResponseTextvar
+      autoload :ResponseValue
+      autoload :ResponseScore
+      autoload :Team
+    end
+  end
+end

data/lib/roqua/csv_export/models/dossier.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Dossier < Sequel::Model
+    one_to_many :responses
+  end
+end

data/lib/roqua/csv_export/models/measurement.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Measurement < Sequel::Model
+    many_to_one :protocol
+    one_to_many :responses
+  end
+end

data/lib/roqua/csv_export/models/non_response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class NonResponse < Sequel::Model
+    one_to_many :responses
+  end
+end

data/lib/roqua/csv_export/models/professional.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Professional < Sequel::Model
+    one_to_many :responses
+  end
+end

data/lib/roqua/csv_export/models/protocol.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Protocol < Sequel::Model
+    one_to_many :measurements
+  end
+end

data/lib/roqua/csv_export/models/respondent.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Respondent < Sequel::Model
+    one_to_many :responses
+
+    def label
+      super.presence || default_label
+    end
+
+    def default_label
+      case type
+      when 'patient'       then "Patiënt"
+      when 'parent'        then "1e Ouder"
+      when 'second_parent' then "2e Ouder"
+      when 'teacher'       then "Leraar"
+      when 'caregiver'     then "Mantelzorger"
+      when 'profess'       then "Medewerker"
+      end
+    end
+  end
+end

data/lib/roqua/csv_export/models/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Response < Sequel::Model
+    many_to_one :dossier
+    many_to_one :measurement
+    many_to_one :questionnaire
+    many_to_one :team
+    many_to_one :entered_by, class: Professional
+    many_to_one :respondent
+    many_to_one :non_response
+    one_to_many :response_flags
+    one_to_many :response_scores
+    one_to_many :response_textvars
+    one_to_many :response_values
+
+    # List of answers to questions.
+    # @return [Hash{String=>String}] !{'v_1' => '3', ...}
+    def variable_hash
+      @variable_hash ||= response_values.each_with_object({}) do |response_value, hash|
+        hash[response_value.question_key] = response_value.data
+      end
+    end
+
+    # List of calculated scores.
+    # @return [Hash{String=>Hash{String}}] !{'tot' => {'value' => '15', ...}, ...}
+    def score_hash
+      @response_score_hash ||= response_scores.each_with_object({}) do |response_score, hash|
+        (hash[response_score.score_key] ||= {})[response_score.score_subkey] = response_score.data
+      end
+    end
+
+    # Get answer belonging to given key.
+    # @param key [String] e.g. "v_1"
+    # @return [String] The value for specified question_key
+    def variable(key)
+      variable_hash[key]
+    end
+
+    # Retrieve a score value. main value for a score will usually have sub_key "value".
+    # @param key [String] e.g. "tot"
+    # @param sub_key [String] e.g. "value" or "interpretation"
+    # @return [String]
+    def score(key, sub_key)
+      score_hash.dig(key, sub_key)
+    end
+
+    # @param key [String] prepended with questionnaire_key
+    # @return [String]
+    def flag(key)
+      response_flags.find { |response_flag| response_flag.key == key }.value
+    end
+
+    # @param key [String] prepended with questionnaire_key.
+    # @return [String]
+    def textvar(key)
+      response_textvars.find { |response_textvar| response_textvar.key == key }.value
+    end
+  end
+end

data/lib/roqua/csv_export/models/response_flag.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class ResponseFlag < Sequel::Model
+    many_to_one :response
+  end
+end

data/lib/roqua/csv_export/models/response_score.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class ResponseScore < Sequel::Model
+    many_to_one :response
+  end
+end

data/lib/roqua/csv_export/models/response_textvar.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class ResponseTextvar < Sequel::Model
+    many_to_one :response
+  end
+end

data/lib/roqua/csv_export/models/response_value.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class ResponseValue < Sequel::Model
+    many_to_one :response
+  end
+end

data/lib/roqua/csv_export/models/team.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua::CsvExport::Models
+  class Team < Sequel::Model
+    one_to_many :responses
+  end
+end

data/lib/roqua/csv_export/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roqua
+  module CsvExport
+    VERSION = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: roqua-csv_export
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Henk van der Veen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: fabrication
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: create csv exports from the sqlite export and the export_version json
+email: henk.van.der.veen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/roqua-csv_export.rb
+- lib/roqua/csv_export.rb
+- lib/roqua/csv_export/config.rb
+- lib/roqua/csv_export/csv_export_questionnaire_version.rb
+- lib/roqua/csv_export/export_versions.rb
+- lib/roqua/csv_export/meta_data.rb
+- lib/roqua/csv_export/models.rb
+- lib/roqua/csv_export/models/dossier.rb
+- lib/roqua/csv_export/models/measurement.rb
+- lib/roqua/csv_export/models/non_response.rb
+- lib/roqua/csv_export/models/professional.rb
+- lib/roqua/csv_export/models/protocol.rb
+- lib/roqua/csv_export/models/respondent.rb
+- lib/roqua/csv_export/models/response.rb
+- lib/roqua/csv_export/models/response_flag.rb
+- lib/roqua/csv_export/models/response_score.rb
+- lib/roqua/csv_export/models/response_textvar.rb
+- lib/roqua/csv_export/models/response_value.rb
+- lib/roqua/csv_export/models/team.rb
+- lib/roqua/csv_export/version.rb
+homepage: https://docs.roqua.net
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: create csv exports from the sqlite export
+test_files: []