spout 0.12.1 → 0.13.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b714b2cbb3e35b82c5dc6acde94423ead958e6f
-  data.tar.gz: 1bc6918aa8565d51dc49489c8b502d66e9c915ff
+  metadata.gz: 415a16b52a348d3d3c7361b6ea226e7d7aa10edc
+  data.tar.gz: '08bbf0c3477b4689a0cc4dbacc52750ec53a7eb2'
 SHA512:
-  metadata.gz: 066a9868c637823fe5016f024a52d6ffb14df7541553f0e29329f648c164eff4caca0b4849af2538f64a41bcb39b0a4491400c3e9573d0efb3e5f7c700803e9d
-  data.tar.gz: 9bd04ed7f2ff8fe8c24d17cae04a60cdbc57564ed4e6901eeda59a7a181518cc41d789cf40fe7e4711b23cf1feb10d05137bfb39d5e81d38c5228af2b76eafa9
+  metadata.gz: 97b50714ade02df37afd4fac776bbd5d4515db7e628b5acee6639d1f711c025cf6ed6c5e6bd2b9f0c0826061487adc85c44d44683520556bd3d12e43ac2a7d6f
+  data.tar.gz: 26a33f2ffdeb525e047a10efc87324d8a935a5bb47f60780ffff55237f56f39dbc70b4530abd871fc29851a2171ff38d35ac64c7c24c6bd7c038af4b7efdec2d

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.13.0
+
+### Enhancements
+- **Importer Changes**
+  - Added option to preserve case of input using the `--preserve-case` flag
+    - `spout import <variables.csv> --preserve-case`
+
 ## 0.12.1 (April 3, 2017)
 
 ### Bug Fix

data/README.md

@@ -16,7 +16,7 @@ Spout has been used extensively to curate and clean datasets available on the
 
 Add this line to your application's Gemfile:
 
-    gem 'spout'
+    gem "spout"
 
 And then execute:
 
@@ -143,7 +143,7 @@ tests, or just a subset of Spout tests.
 `test/dictionary_test.rb`
 
 ```ruby
-require 'spout/tests'
+require "spout/tests"
 
 class DictionaryTest < Minitest::Test
   # This line includes all default Spout Dictionary tests
@@ -152,7 +152,7 @@ end
 ```
 
 ```ruby
-require 'spout/tests'
+require "spout/tests"
 
 class DictionaryTest < Minitest::Test
   # You can include only certain Spout tests by including them individually
@@ -185,13 +185,13 @@ class DictionaryTest < Minitest::Test
   # that can be used to write custom tests.
   include Spout::Helpers::Iterators
 
-  VALID_UNITS = ['minutes', 'hours']
+  VALID_UNITS = ["minutes", "hours"]
 
   @variables.select { |v| %w(numeric integer).include?(v.type) }.each do |variable|
     define_method("test_units: #{variable.path}") do
       message = "\"#{variable.units}\"".colorize(:red) + " invalid units.\n" +
                 "             Valid types: " +
-                VALID_UNITS.sort_by(&:to_s).collect { |u| u.inspect.colorize(:white) }.join(', ')
+                VALID_UNITS.sort_by(&:to_s).collect { |u| u.inspect.colorize(:white) }.join(", ")
       assert VALID_UNITS.include?(variable.units), message
     end
   end

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
 

data/bin/spout

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require File.expand_path('../../lib/spout', __FILE__)
+require File.expand_path("../../lib/spout", __FILE__)
 
 Spout.launch(ARGV)

data/lib/spout/commands/coverage.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'erb'
-require 'fileutils'
-require 'yaml'
+require "erb"
+require "fileutils"
+require "yaml"
 
-require 'spout/helpers/subject_loader'
-require 'spout/models/coverage_result'
-require 'spout/helpers/number_helper'
-require 'spout/helpers/config_reader'
-require 'spout/helpers/array_statistics'
+require "spout/helpers/subject_loader"
+require "spout/models/coverage_result"
+require "spout/helpers/number_helper"
+require "spout/helpers/config_reader"
+require "spout/helpers/array_statistics"
 
 module Spout
   module Commands
@@ -18,8 +18,8 @@ module Spout
 
       def initialize(standard_version, argv)
         @standard_version = standard_version
-        @console = !argv.delete('--console').nil?
-        @variable_files = Dir.glob('variables/**/*.json')
+        @console = !argv.delete("--console").nil?
+        @variable_files = Dir.glob("variables/**/*.json")
         @valid_ids = []
         @number_of_rows = nil
         @config = Spout::Helpers::ConfigReader.new
@@ -38,10 +38,10 @@ module Spout
           scr = Spout::Models::CoverageResult.new(method, @subjects.collect(&method.to_sym).compact_empty.uniq)
           @matching_results << [csv_files, method, scr]
         end
-        variable_ids = Dir.glob('variables/**/*.json').collect { |file| file.gsub(%r{^(.*)/|\.json$}, '').downcase }
+        variable_ids = Dir.glob("variables/**/*.json").collect { |file| file.gsub(%r{^(.*)/|\.json$}, "").downcase }
         @extra_variable_ids = (variable_ids - @subject_loader.all_methods.keys).sort
         @subject_loader.load_variable_domains!
-        domain_ids = Dir.glob('domains/**/*.json').collect { |file| file.gsub(%r{^(.*)/|\.json$}, '').downcase }
+        domain_ids = Dir.glob("domains/**/*.json").collect { |file| file.gsub(%r{^(.*)/|\.json$}, "").downcase }
         @extra_domain_ids = (domain_ids - @subject_loader.all_domains).sort
         @matching_results.sort! do |a, b|
           [b[2].number_of_errors, a[0].to_s, a[1].to_s] <=> [a[2].number_of_errors, b[0].to_s, b[1].to_s]
@@ -53,16 +53,16 @@ module Spout
                                 .select { |mr| mr[0].include?(csv_file) && mr[2].number_of_errors.zero? }.count
           @coverage_results << [csv_file, total_column_count, mapped_column_count]
         end
-        coverage_folder = File.join(Dir.pwd, 'coverage')
+        coverage_folder = File.join(Dir.pwd, "coverage")
         FileUtils.mkpath coverage_folder
-        coverage_file = File.join(coverage_folder, 'index.html')
-        File.open(coverage_file, 'w+') do |file|
-          erb_location = File.join(File.dirname(__FILE__), '../views/index.html.erb')
+        coverage_file = File.join(coverage_folder, "index.html")
+        File.open(coverage_file, "w+") do |file|
+          erb_location = File.join(File.dirname(__FILE__), "../views/index.html.erb")
           file.puts ERB.new(File.read(erb_location)).result(binding)
         end
         unless @console
-          open_command = 'open' unless RUBY_PLATFORM.match(/darwin/).nil?
-          open_command = 'start' unless RUBY_PLATFORM.match(/mingw/).nil?
+          open_command = "open" unless RUBY_PLATFORM.match(/darwin/).nil?
+          open_command = "start" unless RUBY_PLATFORM.match(/mingw/).nil?
           system "#{open_command} #{coverage_file}" if %w(start open).include?(open_command)
         end
         puts "#{coverage_file}\n\n"

data/lib/spout/commands/deploy.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'colorize'
-require 'net/http'
-require 'io/console'
+require "colorize"
+require "net/http"
+require "io/console"
 
-require 'spout/helpers/subject_loader'
-require 'spout/helpers/config_reader'
-require 'spout/helpers/quietly'
-require 'spout/helpers/send_file'
-require 'spout/helpers/semantic'
-require 'spout/helpers/json_request'
+require "spout/helpers/subject_loader"
+require "spout/helpers/config_reader"
+require "spout/helpers/quietly"
+require "spout/helpers/send_file"
+require "spout/helpers/semantic"
+require "spout/helpers/json_request"
 
 # - **User Authorization**
 #   - User authenticates via token, the user must be a dataset editor
@@ -41,34 +41,34 @@ module Spout
       include Spout::Helpers::Quietly
 
       INDENT_LENGTH = 23
-      INDENT = ' ' * INDENT_LENGTH
+      INDENT = " " * INDENT_LENGTH
 
       attr_accessor :token, :version, :slug, :url, :config, :environment, :webserver_name, :subjects
 
       def initialize(argv, version)
-        argv.shift # Remove 'download' command from argv list
+        argv.shift # Remove "download" command from argv list
         @environment = argv.shift
         @version = version
-        @skip_checks = !(argv.delete('--skip-checks').nil? && argv.delete('--no-checks').nil?)
+        @skip_checks = !(argv.delete("--skip-checks").nil? && argv.delete("--no-checks").nil?)
 
-        @skip_tests = !(argv.delete('--skip-tests').nil? && argv.delete('--no-tests').nil?)
-        @skip_coverage = !(argv.delete('--skip-coverage').nil? && argv.delete('--no-coverage').nil?)
+        @skip_tests = !(argv.delete("--skip-tests").nil? && argv.delete("--no-tests").nil?)
+        @skip_coverage = !(argv.delete("--skip-coverage").nil? && argv.delete("--no-coverage").nil?)
 
-        @skip_variables = !(argv.delete('--skip-variables').nil? && argv.delete('--no-variables').nil?)
-        @skip_dataset = !(argv.delete('--skip-dataset').nil? && argv.delete('--no-dataset').nil?)
-        @skip_dictionary = !(argv.delete('--skip-dictionary').nil? && argv.delete('--no-dictionary').nil?)
-        @skip_documentation = !(argv.delete('--skip-documentation').nil? && argv.delete('--no-documentation').nil?)
-        @clean = !(argv.delete('--no-resume').nil? && argv.delete('--clean').nil?)
-        @skip_server_scripts = !(argv.delete('--skip-server-scripts').nil? && argv.delete('--no-server-scripts').nil?)
-        @archive_only = !(argv.delete('--archive-only').nil?)
+        @skip_variables = !(argv.delete("--skip-variables").nil? && argv.delete("--no-variables").nil?)
+        @skip_dataset = !(argv.delete("--skip-dataset").nil? && argv.delete("--no-dataset").nil?)
+        @skip_dictionary = !(argv.delete("--skip-dictionary").nil? && argv.delete("--no-dictionary").nil?)
+        @skip_documentation = !(argv.delete("--skip-documentation").nil? && argv.delete("--no-documentation").nil?)
+        @clean = !(argv.delete("--no-resume").nil? && argv.delete("--clean").nil?)
+        @skip_server_scripts = !(argv.delete("--skip-server-scripts").nil? && argv.delete("--no-server-scripts").nil?)
+        @archive_only = !(argv.delete("--archive-only").nil?)
 
         token_arg = argv.find { |arg| /^--token=/ =~ arg }
         argv.delete(token_arg)
-        @token = token_arg.gsub(/^--token=/, '') if token_arg
+        @token = token_arg.gsub(/^--token=/, "") if token_arg
 
         rows_arg = argv.find { |arg| /^--rows=(\d*)/ =~ arg }
         argv.delete(rows_arg)
-        @number_of_rows = rows_arg.gsub(/--rows=/, '').to_i if rows_arg
+        @number_of_rows = rows_arg.gsub(/--rows=/, "").to_i if rows_arg
 
         @argv = argv
 
@@ -98,12 +98,12 @@ module Spout
       end
 
       def config_file_load
-        print '   `.spout.yml` Check: '
+        print "   `.spout.yml` Check: "
         @config = Spout::Helpers::ConfigReader.new
 
         @slug = @config.slug
 
-        if @slug == ''
+        if @slug == ""
           message = "#{INDENT}Please specify a dataset slug in your `.spout.yml` file!".colorize(:red) + " Ex:\n---\nslug: mydataset\n".colorize(:orange)
           failure(message)
         end
@@ -113,7 +113,7 @@ module Spout
           failure(message)
         end
 
-        matching_webservers = @config.webservers.select { |wh| /^#{@environment}/i =~ wh['name'].to_s.downcase }
+        matching_webservers = @config.webservers.select { |wh| /^#{@environment}/i =~ wh["name"].to_s.downcase }
         if matching_webservers.count == 0
           message = "#{INDENT}0 webservers match '#{@environment}'.".colorize(:red) + " The following webservers exist in your `.spout.yml` file:\n" + "#{INDENT}#{@config.webservers.collect{|wh| wh['name'].to_s.downcase}.join(', ')}".colorize(:white)
           failure(message)
@@ -122,17 +122,17 @@ module Spout
           failure(message)
         end
 
-        @webserver_name = matching_webservers.first['name'].to_s.strip rescue @webserver_name = ''
-        @url = URI.parse(matching_webservers.first['url'].to_s.strip) rescue @url = nil
+        @webserver_name = matching_webservers.first["name"].to_s.strip rescue @webserver_name = ""
+        @url = URI.parse(matching_webservers.first["url"].to_s.strip) rescue @url = nil
 
-        if @url.to_s == ''
+        if @url.to_s == ""
           message = "#{INDENT}Invalid URL format for #{matching_webservers.first['name'].to_s.strip.downcase} webserver: ".colorize(:red) + "'#{matching_webservers.first['url'].to_s.strip}'".colorize(:white)
           failure(message)
         end
 
-        puts 'PASS'.colorize(:green)
-        puts '        Target Server: ' + "#{@url}".colorize(:white)
-        puts '       Target Dataset: ' + "#{@slug}".colorize(:white)
+        puts "PASS".colorize(:green)
+        puts "        Target Server: " + "#{@url}".colorize(:white)
+        puts "       Target Dataset: " + "#{@slug}".colorize(:white)
       end
 
       # - **Version Check**
@@ -141,7 +141,7 @@ module Spout
       #   - "v#{VERSION}" matches HEAD git tag annotation
       def version_check
         if @skip_checks
-          puts '        Version Check: ' + 'SKIP'.colorize(:blue)
+          puts "        Version Check: " + "SKIP".colorize(:blue)
           return
         end
 
@@ -149,19 +149,19 @@ module Spout
           `git status --porcelain`
         end
 
-        print '     Git Status Check: '
-        if stdout.to_s.strip == ''
-          puts 'PASS'.colorize(:green) + ' ' + 'nothing to commit, working directory clean'.colorize(:white)
+        print "     Git Status Check: "
+        if stdout.to_s.strip == ""
+          puts "PASS".colorize(:green) + " " + "nothing to commit, working directory clean".colorize(:white)
         else
-          message = "#{INDENT}working directory contains uncomitted changes\n#{INDENT}use `".colorize(:red) + '--skip-checks'.colorize(:white) + '` to ignore this step'.colorize(:red)
+          message = "#{INDENT}working directory contains uncomitted changes\n#{INDENT}use `".colorize(:red) + "--skip-checks".colorize(:white) + "` to ignore this step".colorize(:red)
           failure message
         end
 
-        changelog = File.open('CHANGELOG.md', &:readline).strip rescue changelog = ''
+        changelog = File.open("CHANGELOG.md", &:readline).strip rescue changelog = ""
         if changelog.match(/^## #{@version.split('.')[0..2].join('.')}/)
           puts "         CHANGELOG.md: " + "PASS".colorize(:green) + " " + changelog.colorize(:white)
         else
-          print '         CHANGELOG.md: '
+          print "         CHANGELOG.md: "
           message = "#{INDENT}Expected: ".colorize(:red) + "## #{@version}".colorize(:white) +
                   "\n#{INDENT}  Actual: ".colorize(:red) + changelog.colorize(:white)
           failure message
@@ -171,30 +171,30 @@ module Spout
           `git describe --exact-match HEAD --tags`
         end
 
-        print '        Version Check: '
+        print "        Version Check: "
         tag = stdout.to_s.strip
         if "v#{@version}" != tag
-          message = "#{INDENT}Version specified in `VERSION` file ".colorize(:red) + "'v#{@version}'".colorize(:white) + ' does not match git tag on HEAD commit '.colorize(:red) + "'#{tag}'".colorize(:white)
+          message = "#{INDENT}Version specified in `VERSION` file ".colorize(:red) + "'v#{@version}'".colorize(:white) + " does not match git tag on HEAD commit ".colorize(:red) + "'#{tag}'".colorize(:white)
           failure message
         else
-          puts 'PASS'.colorize(:green) + ' VERSION ' + "'v#{@version}'".colorize(:white) + ' matches git tag ' + "'#{tag}'".colorize(:white)
+          puts "PASS".colorize(:green) + " VERSION " + "'v#{@version}'".colorize(:white) + " matches git tag " + "'#{tag}'".colorize(:white)
         end
       end
 
       def test_check
         if @skip_tests
-          puts '          Spout Tests: ' + 'SKIP'.colorize(:blue)
+          puts "          Spout Tests: " + "SKIP".colorize(:blue)
           return
         end
 
-        print '          Spout Tests: '
+        print "          Spout Tests: "
 
         stdout = quietly do
           `spout t`
         end
 
         if stdout.match(/[^\d]0 failures, 0 errors,/)
-          puts 'PASS'.colorize(:green)
+          puts "PASS".colorize(:green)
         else
           message = "#{INDENT}spout t".colorize(:white) + " had errors or failures".colorize(:red) + "\n#{INDENT}Please fix all errors and failures and then run spout deploy again."
           failure message
@@ -203,22 +203,22 @@ module Spout
 
       def coverage_check
         if @skip_coverage
-          puts '     Dataset Coverage: ' + 'SKIP'.colorize(:blue)
+          puts "     Dataset Coverage: " + "SKIP".colorize(:blue)
           return
         end
 
-        puts '     Dataset Coverage: ' + 'NOT IMPLEMENTED'.colorize(:yellow)
+        puts "     Dataset Coverage: " + "NOT IMPLEMENTED".colorize(:yellow)
       end
 
       def user_authorization
-        puts  '  Get your token here: ' + "#{@url}/token".colorize(:blue).on_white.underline
-        print '     Enter your token: '
-        @token = STDIN.noecho(&:gets).chomp if @token.to_s.strip == ''
+        puts  "  Get your token here: " + "#{@url}/token".colorize(:blue).on_white.underline
+        print "     Enter your token: "
+        @token = STDIN.noecho(&:gets).chomp if @token.to_s.strip == ""
         (json, _status) = Spout::Helpers::JsonRequest.get("#{@url}/datasets/#{@slug}/a/#{@token}/editor.json")
-        if json.is_a?(Hash) && json['editor']
-          puts 'AUTHORIZED'.colorize(:green)
+        if json.is_a?(Hash) && json["editor"]
+          puts "AUTHORIZED".colorize(:green)
         else
-          puts 'UNAUTHORIZED'.colorize(:red)
+          puts "UNAUTHORIZED".colorize(:red)
           puts "#{INDENT}You are not set as an editor on the #{@slug} dataset or you mistyped your token."
           raise DeployError
         end
@@ -226,7 +226,7 @@ module Spout
 
       def upload_variables
         if @skip_variables
-          puts '     Upload Variables: ' + 'SKIP'.colorize(:blue)
+          puts "     Upload Variables: " + "SKIP".colorize(:blue)
           return
         end
         load_subjects_from_csvs
@@ -235,122 +235,122 @@ module Spout
 
       def load_subjects_from_csvs
         @dictionary_root = Dir.pwd
-        @variable_files = Dir.glob(File.join(@dictionary_root, 'variables', '**', '*.json'))
+        @variable_files = Dir.glob(File.join(@dictionary_root, "variables", "**", "*.json"))
         @subject_loader = Spout::Helpers::SubjectLoader.new(@variable_files, [], @version, @number_of_rows, @config.visit)
         @subject_loader.load_subjects_from_csvs!
         @subjects = @subject_loader.subjects
       end
 
       def graph_generation
-        # failure ''
-        require 'spout/commands/graphs'
-        @argv << '--clean' if @clean
+        # failure ""
+        require "spout/commands/graphs"
+        @argv << "--clean" if @clean
         Spout::Commands::Graphs.new(@argv, @version, true, @url, @slug, @token, @webserver_name, @subjects)
-        puts "\r     Upload Variables: " + 'DONE          '.colorize(:green)
+        puts "\r     Upload Variables: " + "DONE          ".colorize(:green)
       end
 
       def dataset_uploads
         if @skip_dataset
-          puts '      Dataset Uploads: ' + 'SKIP'.colorize(:blue)
+          puts "      Dataset Uploads: " + "SKIP".colorize(:blue)
           return
         end
 
-        available_folders = (Dir.exist?('csvs') ? Dir.entries('csvs').select { |e| File.directory? File.join('csvs', e) }.reject { |e| ['.', '..'].include?(e) }.sort : [])
+        available_folders = (Dir.exist?("csvs") ? Dir.entries("csvs").select { |e| File.directory? File.join("csvs", e) }.reject { |e| [".", ".."].include?(e) }.sort : [])
         semantic = Spout::Helpers::Semantic.new(@version, available_folders)
         csv_directory = semantic.selected_folder
         csv_files = Dir.glob("csvs/#{csv_directory}/**/*.csv")
 
         csv_files.each_with_index do |csv_file, index|
           print "\r      Dataset Uploads: " + "#{index + 1} of #{csv_files.count}".colorize(:green)
-          folder = csv_file.gsub(%r{^csvs/#{csv_directory}}, '').gsub(/#{File.basename(csv_file)}$/, '')
-          folder = folder.gsub(%r{/$}, '')
+          folder = csv_file.gsub(%r{^csvs/#{csv_directory}}, "").gsub(/#{File.basename(csv_file)}$/, "")
+          folder = folder.gsub(%r{/$}, "")
           @created_folders << "datasets#{folder}"
-          @created_folders << 'datasets/archive'
+          @created_folders << "datasets/archive"
           @created_folders << "datasets/archive/#{@version}#{folder}"
           upload_file(csv_file, "datasets#{folder}") unless @archive_only
           upload_file(csv_file, "datasets/archive/#{@version}#{folder}")
         end
-        puts "\r      Dataset Uploads: " + 'DONE          '.colorize(:green)
+        puts "\r      Dataset Uploads: " + "DONE          ".colorize(:green)
       end
 
       def data_dictionary_uploads
         if @skip_dictionary
-          puts '   Dictionary Uploads: ' + 'SKIP'.colorize(:blue)
+          puts "   Dictionary Uploads: " + "SKIP".colorize(:blue)
           return
         end
 
-        print '   Dictionary Uploads:'
+        print "   Dictionary Uploads:"
 
-        require 'spout/commands/exporter'
-        Spout::Commands::Exporter.new(@version, ['--quiet'])
+        require "spout/commands/exporter"
+        Spout::Commands::Exporter.new(@version, ["--quiet"])
 
         csv_files = Dir.glob("exports/#{@version}/*.csv")
         csv_files.each_with_index do |csv_file, index|
           print "\r   Dictionary Uploads: " + "#{index + 1} of #{csv_files.count}".colorize(:green)
-          @created_folders << 'datasets'
-          @created_folders << 'datasets/archive'
+          @created_folders << "datasets"
+          @created_folders << "datasets/archive"
           @created_folders << "datasets/archive/#{@version}"
-          upload_file(csv_file, 'datasets') unless @archive_only
+          upload_file(csv_file, "datasets") unless @archive_only
           upload_file(csv_file, "datasets/archive/#{@version}")
         end
-        puts "\r   Dictionary Uploads: " + 'DONE          '.colorize(:green)
+        puts "\r   Dictionary Uploads: " + "DONE          ".colorize(:green)
       end
 
       def markdown_uploads
         if @skip_documentation
-          puts 'Documentation Uploads: ' + 'SKIP'.colorize(:blue)
+          puts "Documentation Uploads: " + "SKIP".colorize(:blue)
           return
         end
 
-        print 'Documentation Uploads:'
+        print "Documentation Uploads:"
         markdown_files = Dir.glob(%w(CHANGELOG.md KNOWNISSUES.md))
         markdown_files.each_with_index do |markdown_file, index|
           print "\rDocumentation Uploads: " + "#{index + 1} of #{markdown_files.count}".colorize(:green)
-          @created_folders << 'datasets'
-          @created_folders << 'datasets/archive'
+          @created_folders << "datasets"
+          @created_folders << "datasets/archive"
           @created_folders << "datasets/archive/#{@version}"
-          upload_file(markdown_file, 'datasets') unless @archive_only
+          upload_file(markdown_file, "datasets") unless @archive_only
           upload_file(markdown_file, "datasets/archive/#{@version}")
         end
-        puts "\rDocumentation Uploads: " + 'DONE          '.colorize(:green)
+        puts "\rDocumentation Uploads: " + "DONE          ".colorize(:green)
       end
 
       def trigger_server_updates
         if @skip_server_scripts
-          puts 'Launch Server Scripts: ' + 'SKIP'.colorize(:blue)
+          puts "Launch Server Scripts: " + "SKIP".colorize(:blue)
           return
         end
 
-        print 'Launch Server Scripts: '
+        print "Launch Server Scripts: "
         params = { auth_token: @token, dataset: @slug, version: @version, folders: @created_folders.compact.uniq }
         (json, _status) = Spout::Helpers::JsonRequest.post("#{@url}/api/v1/dictionary/refresh.json", params)
-        if json.is_a?(Hash) && json['refresh'] == 'success'
-          puts 'DONE'.colorize(:green)
+        if json.is_a?(Hash) && json["refresh"] == "success"
+          puts "DONE".colorize(:green)
         else
-          puts 'FAIL'.colorize(:red)
+          puts "FAIL".colorize(:red)
           raise DeployError
         end
       end
 
       def set_default_dataset_version
         if @archive_only
-          puts '  Set Default Version: ' + 'SKIP'.colorize(:blue)
+          puts "  Set Default Version: " + "SKIP".colorize(:blue)
           return
         end
-        print '  Set Default Version: '
+        print "  Set Default Version: "
         params = { auth_token: @token, dataset: @slug, version: @version }
         (json, _status) = Spout::Helpers::JsonRequest.post(
           "#{@url}/api/v1/dictionary/update_default_version.json", params
         )
-        if json.is_a?(Hash) && json['version_update'] == 'success'
+        if json.is_a?(Hash) && json["version_update"] == "success"
           puts @version.to_s.colorize(:green)
         else
-          failure("#{INDENT}Unable to set default version\n#{INDENT}to " + @version.to_s.colorize(:white) + ' for ' + @slug.to_s.colorize(:white) + ' dataset.')
+          failure("#{INDENT}Unable to set default version\n#{INDENT}to " + @version.to_s.colorize(:white) + " for " + @slug.to_s.colorize(:white) + " dataset.")
         end
       end
 
       def failure(message)
-        puts 'FAIL'.colorize(:red)
+        puts "FAIL".colorize(:red)
         puts message
         raise DeployError
       end

data/lib/spout/commands/exporter.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'csv'
-require 'json'
-require 'fileutils'
-require 'colorize'
+require "csv"
+require "json"
+require "fileutils"
+require "colorize"
 
-require 'spout/helpers/config_reader'
+require "spout/helpers/config_reader"
 
 module Spout
   module Commands
     # Exports the JSON data dictionary to a CSV format.
     class Exporter
       def initialize(standard_version, argv)
-        @quiet = !argv.delete('--quiet').nil?
+        @quiet = !argv.delete("--quiet").nil?
         @standard_version = standard_version
         @config = Spout::Helpers::ConfigReader.new
         expanded_export!
@@ -22,24 +22,24 @@ module Spout
 
       def expanded_export!
         folder = "exports/#{@standard_version}"
-        puts '      create'.colorize(:green) + "  #{folder}" unless @quiet
+        puts "      create".colorize(:green) + "  #{folder}" unless @quiet
         FileUtils.mkpath folder
         generic_export(
           folder,
-          'variables',
+          "variables",
           %w(
             id display_name description type units domain labels calculation
             commonly_used forms
           )
         )
-        generic_export(folder, 'domains', %w(value display_name description), true)
-        generic_export(folder, 'forms', %w(id display_name code_book))
+        generic_export(folder, "domains", %w(value display_name description), true)
+        generic_export(folder, "forms", %w(id display_name code_book))
       end
 
       def generic_export(folder, type, keys, include_domain_name = false)
         export_file = export_file_name(type)
-        puts '      export'.colorize(:blue) + "  #{folder}/#{export_file}" unless @quiet
-        CSV.open("#{folder}/#{export_file}", 'wb') do |csv|
+        puts "      export".colorize(:blue) + "  #{folder}/#{export_file}" unless @quiet
+        CSV.open("#{folder}/#{export_file}", "wb") do |csv|
           csv << if include_domain_name
                    %w(folder domain_id) + keys
                  else
@@ -56,7 +56,7 @@ module Spout
                 end
               else
                 csv << [relative_folder] + keys.collect do |key|
-                  json[key].is_a?(Array) ? json[key].join(';') : json[key].to_s
+                  json[key].is_a?(Array) ? json[key].join(";") : json[key].to_s
                 end
               end
             end
@@ -65,7 +65,7 @@ module Spout
       end
 
       def export_file_name(type)
-        if @config.slug == ''
+        if @config.slug == ""
           "#{type}.csv"
         else
           "#{@config.slug}-data-dictionary-#{@standard_version}-#{type}.csv"
@@ -73,11 +73,11 @@ module Spout
       end
 
       def generic_folder_path(file, type)
-        file.gsub(/#{type}\//, '').split('/')[0..-2].join('/')
+        file.gsub(/#{type}\//, "").split("/")[0..-2].join("/")
       end
 
       def extract_domain_name(file)
-        file.gsub(/domains\//, '').split('/').last.to_s.gsub(/.json/, '')
+        file.gsub(/domains\//, "").split("/").last.to_s.gsub(/.json/, "")
       end
     end
   end