env_lint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7074acbb267701af05f8e2f5307fb5d8f563a1dc
+  data.tar.gz: 1f07d11602f9e8230159f83a0719b3cfdb503047
+SHA512:
+  metadata.gz: f1895359dbf17fca012f7ed52ff250ba0ea60b0edfd493691aabbf7b424f4d209d4b8d07c747a9b91e856f6e30f8b478c6fc07462f1592e6ba0a5c720226ae32
+  data.tar.gz: 564fa51150c32279cfcdc4fc965dd0e6b72c1c90d75b9c8ec33fe516394cb8c26fce7034c39d86446c24830275d624689ca4b6caf9ed4c9253df15b2add49573

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+
+script: "bundle exec rspec"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in env_lint.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tim Fischbach
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Env Lint
+
+<img src="https://travis-ci.org/tf/env_lint.png" data-bindattr-466="466" title="Build Status Images">
+
+Check environment variables accoring to a `.env.example` file.
+
+* Avoid spelling errors in variable names in your code or on the
+  command line
+* Ensure all relevant environment variables are described in the
+  `.env.example` file.
+* Ensure all required environment variables are configured before
+  deploying a new version of an app
+* Ease setting up a new development machine
+
+# Status
+
+Only tested with [recap](https://github.com/tomafro/recap) capistrano
+tasks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'env_lint'
+
+## Usage
+
+Define a `.env.example` file:
+
+    # Explain each variable in comments like this one
+    APP_NAME=my_app
+    
+    # Comments are also recognized if they span multiple
+    # lines
+    FEATURE=true
+    
+    # Optional variables
+    # OPTIONAL_VAR="set me if you like"
+
+### Rake Task
+
+Require it in your `Rakefile`:
+
+    require 'env_lint/tasks'
+
+Now you can check your environment:
+
+    $ rake env:lint
+    => Complains if non optional variables are missing
+
+If special steps are needed 
+
+### Capistrano Task
+
+Require it in your `Capfile`:
+
+    require 'env_lint/capistrano'
+
+Now you can check your servers:
+
+    $ cap env:lint
+    => Complains if non optional variables are missing
+
+You might want to lint the environment automatically before each
+deploy.
+
+    before 'deploy', 'env:lint'
+
+Lint variable names before setting them:
+
+    before 'env:set', 'env:lint_args'
+    
+    $ cap env:set APP_NAME=myapp
+    => Complains if APP_NAME is defined
+
+### Lint at Runtime
+
+Access ENV through a `LintedEnv`:
+
+    require 'env_lint'
+
+    class MyApp
+      LINTED_ENV = EnvLint::LintedEnv.from_file('.env.example')
+      
+      def self.env
+        LINTED_ENV
+      end
+    end
+
+Accessing env variables:
+
+    # Ensures APP_NAME is defined in .env.example
+    MyApp.env.fetch(:app_name, 'App name')
+
+    # Ensures APP_NAME is non optional in .env.example
+    MyApp.env.fetch(:app_name)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/env_lint.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'env_lint/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'env_lint'
+  spec.version       = EnvLint::VERSION
+  spec.authors       = ['Tim Fischbach']
+  spec.email         = ['mail@timfischbach.de']
+  spec.summary       = 'Lint the environment according by .env.example'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'formatador'
+  spec.add_runtime_dependency 'capistrano', '~> 2.9'
+
+  spec.add_development_dependency 'rspec', '3.0.0.beta1'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/lib/env_lint/capistrano.rb

@@ -0,0 +1,51 @@
+require 'env_lint'
+require 'capistrano'
+
+module EnvLint
+  module Capistrano
+    def self.load_into(config, formatter)
+      config.load do
+        set(:env_definition_file) { '.env.example' }
+        set(:env_probe_command) { "su - #{application_user} -c 'export'" }
+
+        namespace :env do
+          desc 'Check that every non optional ENV variable is defined.'
+          task :lint do
+            begin
+              EnvLint.verify_export_output(env_definition_file, capture(env_probe_command, via: :sudo))
+              formatter.ok('env looks ok')
+            rescue EnvLint::MissingVariables => e
+              formatter.missing_variables(e.dot_env_file, e.missing_variables)
+              abort
+            rescue EnvLint::Error => e
+              formatter.error(e.message)
+              abort
+            end
+          end
+
+          desc 'Lint args passed to command.'
+          task :lint_args do
+            begin
+              EnvLint.verify_args(env_definition_file, env_args)
+            rescue EnvLint::UnknownVariables => e
+              formatter.unknown_variables(e.dot_env_file, e.unknown_variables)
+              abort
+            rescue EnvLint::Error => e
+              formatter.error(e.message)
+              abort
+            end
+          end
+
+          def env_args
+            ARGV[1..-1]
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  EnvLint::Capistrano.load_into(Capistrano::Configuration.instance(:must_exist),
+                                Formatter.new)
+end

data/lib/env_lint/dot_env_file.rb

@@ -0,0 +1,48 @@
+module EnvLint
+  class DotEnvFile
+    attr_reader :name, :variables
+
+    def initialize(name, variables)
+      @name = name
+      @variables = variables
+
+      @variables_by_name = variables.each_with_object({}) do |variable, hash|
+        hash[variable.name] = variable
+      end
+    end
+
+    def find_variable(name)
+      @variables_by_name[name]
+    end
+
+    def verify_no_missing(variable_names)
+      find_missing(variable_names).tap do |missing_variables|
+        raise(MissingVariables.new(self, missing_variables)) if missing_variables.any?
+      end
+    end
+
+    def verify_no_unknown(variable_names)
+      find_unknown(variable_names).tap do |unknown_names|
+        raise(UnknownVariables.new(self, unknown_names)) if unknown_names.any?
+      end
+    end
+
+    def self.from_file(file_name)
+      new(file_name, DotEnvParser.new.parse(File.read(file_name)))
+    end
+
+    private
+
+    def find_missing(variable_names)
+      @variables.find_all do |variable|
+        !variable.optional? && !variable_names.include?(variable.name)
+      end
+    end
+
+    def find_unknown(variable_names)
+      variable_names.find_all do |name|
+        !@variables_by_name.key?(name)
+      end
+    end
+  end
+end

data/lib/env_lint/dot_env_parser.rb

@@ -0,0 +1,39 @@
+module EnvLint
+  class DotEnvParser
+    def parse(text)
+      comment_lines = []
+
+      variables = text.lines.each_with_object([]) do |line, result|
+        if match = line.strip.match(ASSIGNMENT)
+          optional, name, value = match.captures
+          value ||= ''
+          value = value.strip.sub(/\A(['"])(.*)\1\z/, '\2')
+
+          result << Variable.new(name, value, !!optional, comment_lines * "\n")
+          comment_lines = []
+        elsif match = line.strip.match(COMMENT)
+          comment_lines << match.captures.first
+        elsif line.strip.empty?
+          comment_lines = []
+        else
+          raise(UnrecognizedDotEnvLine.new(line))
+        end
+      end
+
+      variables
+    end
+
+    COMMENT = /\A#\s*(.*)\z/
+
+    ASSIGNMENT = /
+      \A
+      (\#\s*)?          # optional variable marker
+      ([\w\.]+)         # key
+      =                 # separator
+      (                 # optional value begin
+        [^#\n]+         #   unquoted value
+      )?                # value end
+      \z
+     /x
+  end
+end

data/lib/env_lint/env_key_parser.rb

@@ -0,0 +1,11 @@
+module EnvLint
+  class EnvKeyParser
+    def parse_args(args)
+      args.map { |arg| arg.split('=').first if arg.include?('=') }.compact
+    end
+
+    def parse_export_output(text)
+      parse_args(text.split(/[\n\r]/).map { |line| line.gsub('declare -x', '').strip })
+    end
+  end
+end

data/lib/env_lint/errors.rb

@@ -0,0 +1,62 @@
+module EnvLint
+  class Error < StandardError
+  end
+
+  class UnrecognizedDotEnvLine < Error
+    attr_reader :line
+
+    def initialize(line)
+      super("Unrecognized line in dot env file: '#{line}'")
+      @line = line
+    end
+  end
+
+  class VariableError < StandardError
+    attr_reader :variable_name
+
+    def initialize(variable_name, message)
+      super(message)
+      @variable_name = variable_name
+    end
+  end
+
+  class UnknownVariable < VariableError
+    def initialize(variable_name)
+      super(variable_name, "Unknown variable #{variable_name}.")
+    end
+  end
+
+  class DefaultValueRequiredForOptionalVariable < VariableError
+    def initialize(variable_name)
+      super(variable_name, "Non optional variable #{variable_name} used without default value.")
+    end
+  end
+
+  class MissingVariable < VariableError
+    def initialize(variable_name)
+      super(variable_name, "Missing variable #{variable_name}. Check your .env file")
+    end
+  end
+
+  class MissingVariables < Error
+    attr_reader :dot_env_file, :missing_variables
+
+    def initialize(dot_env_file, missing_variables)
+      @dot_env_file = dot_env_file
+      @missing_variables = missing_variables
+
+      super("Missing variables #{missing_variables * ', '}.")
+    end
+  end
+
+  class UnknownVariables < Error
+    attr_reader :dot_env_file, :unknown_variables
+
+    def initialize(dot_env_file, unknown_variables)
+      @dot_env_file = dot_env_file
+      @unknown_variables = unknown_variables
+
+      super("Unknown variables #{unknown_variables * ', '}.")
+    end
+  end
+end

data/lib/env_lint/formatter.rb

@@ -0,0 +1,49 @@
+require 'formatador'
+
+module EnvLint
+  class Formatter
+    def initialize(out = Formatador)
+      @out = out
+    end
+
+    def missing_variables(dot_env_file, variables)
+      error("Missing env variables:\n")
+
+      variables.each do |variable|
+        @out.display_line("  [yellow]#{variable.name}[/] - #{variable.comment}")
+      end
+
+      new_line
+      info("Either set the variable or make it optional in the #{dot_env_file.name} file.")
+    end
+
+    def unknown_variables(dot_env_file, variable_names)
+      error("Unknown env variables:\n")
+
+      variable_names.each do |name|
+        @out.display_line("  [yellow]#{name}[/]")
+      end
+
+      new_line
+      info("Only variables descibred in #{dot_env_file.name} can be used.")
+    end
+
+    def error(message)
+      @out.display_line("* [red]#{message}[/]")
+    end
+
+    def ok(message)
+      @out.display_line("* [green]#{message}[/]")
+    end
+
+    private
+
+    def info(message)
+      @out.display_line("  #{message}")
+    end
+
+    def new_line
+      @out.display_line('')
+    end
+  end
+end

data/lib/env_lint/linted_env.rb

@@ -0,0 +1,29 @@
+module EnvLint
+  class LintedEnv
+    def initialize(env, dot_env_file)
+      @env = env
+      @dot_env_file = dot_env_file
+    end
+
+    def fetch(name, *args, &block)
+      name = name.to_s.upcase if name.is_a?(Symbol)
+      variable = @dot_env_file.find_variable(name)
+
+      raise(UnknownVariable.new(name)) unless variable
+
+      if variable.optional? && args.empty? && !block_given?
+        raise(DefaultValueRequiredForOptionalVariable.new(name))
+      end
+
+      block ||= lambda do |i|
+        args.any? ? args.first : raise(MissingVariable.new(name))
+      end
+
+      @env.fetch(name, &block)
+    end
+
+    def self.from_file(file_name)
+      new(ENV, DotEnvFile.from_file(file_name))
+    end
+  end
+end

data/lib/env_lint/tasks.rb

@@ -0,0 +1,21 @@
+namespace :env do
+  desc 'Ensure every non optional ENV variable is defined.'
+  task :lint => :load do
+    begin
+      EnvLint.verify_hash(env_definition_file, ENV)
+      EnvLint.formatter.ok('env looks ok')
+    rescue EnvLint::MissingVariables => e
+      EnvLint.formatter.missing_variables(e.dot_env_file, e.missing_variables)
+      abort
+    rescue EnvLint::Error => e
+      EnvLint.formatter.error(e.message)
+    end
+  end
+
+  task :load do
+  end
+
+  def env_definition_file
+    ENV['DEFINITION'] || '.env.example'
+  end
+end

data/lib/env_lint/variable.rb

@@ -0,0 +1,5 @@
+module EnvLint
+  class Variable < Struct.new(:name, :value, :optional, :comment)
+    alias_method :optional?, :optional
+  end
+end

data/lib/env_lint/version.rb

@@ -0,0 +1,3 @@
+module EnvLint
+  VERSION = "0.0.1"
+end

data/lib/env_lint.rb

@@ -0,0 +1,24 @@
+require 'env_lint/dot_env_file'
+require 'env_lint/dot_env_parser'
+require 'env_lint/formatter'
+require 'env_lint/env_key_parser'
+require 'env_lint/errors'
+require 'env_lint/linted_env'
+require 'env_lint/variable'
+require 'env_lint/version'
+
+module EnvLint
+  def self.verify_hash(env_definition_file, env)
+    DotEnvFile.from_file(env_definition_file).verify_no_missing(env.keys)
+  end
+
+  def self.verify_export_output(env_definition_file, export_output)
+    DotEnvFile.from_file(env_definition_file)
+      .verify_no_missing(EnvKeyParser.new.parse_export_output(export_output))
+  end
+
+  def self.verify_args(env_definition_file, args)
+    DotEnvFile.from_file(env_definition_file)
+      .verify_no_unknown(EnvKeyParser.new.parse_args(args))
+  end
+end

data/spec/env_lint/capistrano_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'env_lint/capistrano'
+
+module EnvLint
+  describe Capistrano do
+    let :config do
+      ::Capistrano::Configuration.new
+    end
+
+    let :namespace do
+      config.env
+    end
+
+    let :formatter do
+      instance_double(Formatter, ok: true, missing_variables: true, unknown_variables: true, error: true)
+    end
+
+    before do
+      config.set(:application_user, 'myapp')
+
+      EnvLint::Capistrano.load_into(config, formatter)
+    end
+
+    describe 'env:lint' do
+      it 'calls verify_export_output with result of capute' do
+        config.set(:env_definition_file, '.env.example')
+
+        allow(namespace).to receive(:capture).and_return('declare -x APP=1')
+        expect(EnvLint).to receive(:verify_export_output).with('.env.example', 'declare -x APP=1')
+
+        config.find_and_execute_task('env:lint')
+      end
+
+      it 'passes missing variables to formatter and aborts' do
+        dot_env_file = {}
+        variables = ['APP']
+
+        allow(namespace).to receive(:capture).and_return('declare -x APP=1')
+        allow(EnvLint).to receive(:verify_export_output).and_raise(MissingVariables.new(dot_env_file, variables))
+        expect(namespace).to receive(:abort)
+        expect(formatter).to receive(:missing_variables).with(dot_env_file, variables)
+
+        config.find_and_execute_task('env:lint')
+      end
+
+      it 'passes error message to formatter and aborts' do
+        dot_env_file = {}
+        variables = ['APP']
+
+        allow(namespace).to receive(:capture).and_return('declare -x APP=1')
+        allow(EnvLint).to receive(:verify_export_output).and_raise(Error.new('message'))
+        expect(namespace).to receive(:abort)
+        expect(formatter).to receive(:error).with('message')
+
+        config.find_and_execute_task('env:lint')
+      end
+    end
+
+    describe 'env:lint_args' do
+      it 'calls verify_args with result of capute' do
+        config.set(:env_definition_file, '.env.example')
+
+        allow(namespace).to receive(:env_args).and_return(['APP=1'])
+        expect(EnvLint).to receive(:verify_args).with('.env.example', ['APP=1'])
+
+        config.find_and_execute_task('env:lint_args')
+      end
+
+      it 'passes missing variables to formatter and aborts' do
+        dot_env_file = {}
+        variables = ['APP']
+
+        allow(namespace).to receive(:env_args).and_return(['APP=1'])
+        allow(EnvLint).to receive(:verify_args).and_raise(UnknownVariables.new(dot_env_file, variables))
+        expect(namespace).to receive(:abort)
+        expect(formatter).to receive(:unknown_variables).with(dot_env_file, variables)
+
+        config.find_and_execute_task('env:lint_args')
+      end
+
+      it 'passes error message to formatter and aborts' do
+        dot_env_file = {}
+        variables = ['APP']
+
+        allow(namespace).to receive(:env_args).and_return(['APP=1'])
+        allow(EnvLint).to receive(:verify_args).and_raise(Error.new('message'))
+        expect(namespace).to receive(:abort)
+        expect(formatter).to receive(:error).with('message')
+
+        config.find_and_execute_task('env:lint_args')
+      end
+    end
+  end
+end

data/spec/env_lint/dot_env_file_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module EnvLint
+  describe DotEnvFile do
+    describe '#verify_no_missing' do
+      it 'passes if all non optional variables are present in the env' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+
+        expect {
+          dot_env_file.verify_no_missing(['APP'])
+        }.not_to raise_error
+      end
+
+      it 'raises an exception listing undefined non optional variables' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP'), Variable.new('URL')])
+
+        expect {
+          dot_env_file.verify_no_missing(['APP'])
+        }.to raise_error(MissingVariables)
+      end
+
+      it 'lists undefined non optional variables in exception' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP'), Variable.new('URL'), Variable.new('OTHER')])
+
+        begin
+          dot_env_file.verify_no_missing(['APP'])
+        rescue MissingVariables => e
+          expect(e.missing_variables.size).to eq(2)
+          expect(e.missing_variables.first.name).to eq('URL')
+          expect(e.missing_variables.last.name).to eq('OTHER')
+        end
+      end
+
+      it 'passes if optional variable is not defined' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP', '', true)])
+
+        expect {
+          dot_env_file.verify_no_missing([''])
+        }.not_to raise_error
+      end
+    end
+
+    describe '#verfy_no_unknown' do
+      it 'passes if all variables of the env are known' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+
+        expect {
+          dot_env_file.verify_no_unknown(['APP'])
+        }.not_to raise_error
+      end
+
+      it 'raises an exception if a variable is unknown' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+
+        expect {
+          dot_env_file.verify_no_unknown(['APP', 'UNKNOWN', 'OTHER'])
+        }.to raise_error(UnknownVariables)
+      end
+
+      it 'lists unknown variables in exception' do
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+
+        begin
+          dot_env_file.verify_no_unknown(['APP', 'UNKNOWN', 'OTHER'])
+        rescue UnknownVariables => e
+          expect(e.unknown_variables.size).to eq(2)
+          expect(e.unknown_variables.first).to eq('UNKNOWN')
+          expect(e.unknown_variables.last).to eq('OTHER')
+        end
+      end
+    end
+  end
+end

data/spec/env_lint/dot_env_parser_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module EnvLint
+  describe DotEnvParser do
+    describe '#parse' do
+      it 'recognizes variables' do
+        variables = DotEnvParser.new.parse(<<-END)
+          APP=myapp
+        END
+
+        expect(variables.first.name).to eq('APP')
+        expect(variables.first.value).to eq('myapp')
+      end
+
+      it 'recognizes double quoted values' do
+        variables = DotEnvParser.new.parse(<<-END)
+          APP="my app"
+        END
+
+        expect(variables.first.value).to eq('my app')
+      end
+
+      it 'recognizes single quoted values' do
+        variables = DotEnvParser.new.parse(<<-END)
+          APP='my app'
+        END
+
+        expect(variables.first.value).to eq('my app')
+      end
+
+      it 'handles empty assignments' do
+        variables = DotEnvParser.new.parse(<<-END)
+          APP=
+        END
+
+        expect(variables.first.value).to eq('')
+      end
+
+      it 'ignores blank linkes' do
+        variables = DotEnvParser.new.parse(<<-END)
+          APP1=myapp
+
+          APP2=myapp
+        END
+
+        expect(variables.count).to eq(2)
+        expect(variables.first.name).to eq('APP1')
+        expect(variables.last.name).to eq('APP2')
+      end
+
+      it 'recognizes optional variables' do
+        variables = DotEnvParser.new.parse(<<-END)
+          # APP=myapp
+          #OTHER=myapp
+          APP=myapp
+        END
+
+        expect(variables[0]).to be_optional
+        expect(variables[1]).to be_optional
+        expect(variables[2]).not_to be_optional
+      end
+
+      it 'recognizes comments' do
+        variables = DotEnvParser.new.parse(<<-END)
+          # The name of the app
+          APP=myapp
+        END
+
+        expect(variables.first.comment).to eq('The name of the app')
+      end
+
+      it 'recognizes multi line comments' do
+        variables = DotEnvParser.new.parse(<<-END)
+          # The name of the app
+          # and here the text goes on
+          APP=myapp
+        END
+
+        expect(variables.first.comment).to eq("The name of the app\nand here the text goes on")
+      end
+
+      it 'starts new comment at blank line' do
+        variables = DotEnvParser.new.parse(<<-END)
+          # This is some header which is not related
+          # to the following variable
+
+          # This is the comment
+          APP=myapp
+        END
+
+        expect(variables.first.comment).to eq('This is the comment')
+      end
+
+      it 'raises exception for unrecognized line' do
+        text = <<-END
+          what is this?
+        END
+
+        expect {
+          DotEnvParser.new.parse(text)
+        }.to raise_error(UnrecognizedDotEnvLine)
+      end
+    end
+  end
+end

data/spec/env_lint/env_key_parser_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module EnvLint
+  describe EnvKeyParser do
+    describe '.parse_args' do
+      it 'recognizes assignments' do
+        parser = EnvKeyParser.new
+
+        keys = parser.parse_args(['APP=myname', 'NAME=test'])
+
+        expect(keys).to eq(['APP', 'NAME'])
+      end
+
+      it 'ignores other args' do
+        parser = EnvKeyParser.new
+
+        keys = parser.parse_args(['env:set', 'APP=myname'])
+
+        expect(keys).to eq(['APP'])
+      end
+    end
+
+    describe '.parse_export_output' do
+      it 'recognizes assignments' do
+        parser = EnvKeyParser.new
+
+        keys = parser.parse_export_output(<<-END)
+          declare -x APP="myapp"
+          declare -x NAME="test"
+        END
+
+        expect(keys).to eq(['APP', 'NAME'])
+      end
+    end
+  end
+end

data/spec/env_lint/linted_env_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module EnvLint
+  describe LintedEnv do
+    describe '#fetch' do
+      it 'returns value from env for known variable' do
+        env = {'APP' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch('APP')).to eq('myapp')
+      end
+
+      it 'translates symbols to uppercase strings' do
+        env = {'APP_NAME' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP_NAME')])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch(:app_name)).to eq('myapp')
+      end
+
+      it 'raises exception for unknown variable' do
+        env = {'APP' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect {
+          linted_env.fetch('APP')
+        }.to raise_error(UnknownVariable)
+      end
+
+      it 'raises exception for undefined variable' do
+        env = {}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect {
+          linted_env.fetch('APP')
+        }.to raise_error(MissingVariable)
+      end
+
+      it 'returns default value for undefined variable' do
+        env = {}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch('APP', 'default')).to eq('default')
+      end
+
+      it 'returns default from block for undefined variable' do
+        env = {}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP')])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch('APP') { 'default' }).to eq('default')
+      end
+
+      it 'raises exception if optional variable is used without default' do
+        env = {'APP' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP', '', true)])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect {
+          linted_env.fetch('APP')
+        }.to raise_error(DefaultValueRequiredForOptionalVariable)
+      end
+
+      it 'allows to use optional variable with default value' do
+        env = {'APP' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP', '', true)])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch('APP', 'default')).to eq('myapp')
+      end
+
+      it 'allows to use optional variable with block' do
+        env = {'APP' => 'myapp'}
+        dot_env_file = DotEnvFile.new('.env.example', [Variable.new('APP', '', true)])
+        linted_env = LintedEnv.new(env, dot_env_file)
+
+        expect(linted_env.fetch('APP') { 'block' }).to eq('myapp')
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe EnvLint do
+  SANDBOX_DIR = File.join(File.dirname(__FILE__), 'tmp')
+
+  around do |example|
+    clean_up_sandbox
+    in_sandbox { example.run }
+  end
+
+  describe '.verify_hash' do
+    it 'passes when hash is complete' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+
+      expect {
+        EnvLint.verify_hash('.env.example', {'APP' => 'some name'})
+      }.not_to raise_error
+    end
+
+    it 'fails when hash is missing non optional variable' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+
+      expect {
+        EnvLint.verify_hash('.env.example', {'OTHER' => 'other'})
+      }.to raise_error(EnvLint::MissingVariables)
+    end
+  end
+
+  describe '.verify_args' do
+    it 'passes when all args are known' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+        OTHER=other
+      END
+
+      expect {
+        EnvLint.verify_args('.env.example', ['APP=name'])
+      }.not_to raise_error
+    end
+
+    it 'fails when there are unknown args' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+
+      expect {
+        EnvLint.verify_args('.env.example', ['OTHER=name'])
+      }.to raise_error(EnvLint::UnknownVariables)
+    end
+  end
+
+  describe '.verify_export_output' do
+    it 'passes when the env is complete' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+      export_output = <<-END
+        declare -x APP="myapp"
+        declare -x OTHER="other"
+      END
+
+      expect {
+        EnvLint.verify_export_output('.env.example', export_output)
+      }.not_to raise_error
+    end
+
+    it 'fails when the env is missing non optional variable' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+      export_output = <<-END
+        declare -x OTHER="other"
+      END
+
+      expect {
+        EnvLint.verify_export_output('.env.example', export_output)
+      }.to raise_error(EnvLint::MissingVariables)
+    end
+  end
+
+  describe EnvLint::LintedEnv do
+    it 'allows to read defined variables from ENV' do
+      File.write('.env.example', <<-END)
+        APP=myapp
+      END
+      allow(ENV).to receive(:fetch).with('APP').and_return('value')
+
+      linted_env = EnvLint::LintedEnv.from_file('.env.example')
+
+      expect(linted_env.fetch(:app)).to eq('value')
+    end
+  end
+
+  private
+
+  def clean_up_sandbox
+    FileUtils.rm_rf(SANDBOX_DIR)
+    FileUtils.mkdir_p(SANDBOX_DIR)
+  end
+
+  def in_sandbox(&block)
+    Dir.chdir(SANDBOX_DIR, &block)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec'
+
+require 'env_lint'
+
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: env_lint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tim Fischbach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: formatador
+  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: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: 
+email:
+- mail@timfischbach.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- env_lint.gemspec
+- lib/env_lint.rb
+- lib/env_lint/capistrano.rb
+- lib/env_lint/dot_env_file.rb
+- lib/env_lint/dot_env_parser.rb
+- lib/env_lint/env_key_parser.rb
+- lib/env_lint/errors.rb
+- lib/env_lint/formatter.rb
+- lib/env_lint/linted_env.rb
+- lib/env_lint/tasks.rb
+- lib/env_lint/variable.rb
+- lib/env_lint/version.rb
+- spec/env_lint/capistrano_spec.rb
+- spec/env_lint/dot_env_file_spec.rb
+- spec/env_lint/dot_env_parser_spec.rb
+- spec/env_lint/env_key_parser_spec.rb
+- spec/env_lint/linted_env_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Lint the environment according by .env.example
+test_files:
+- spec/env_lint/capistrano_spec.rb
+- spec/env_lint/dot_env_file_spec.rb
+- spec/env_lint/dot_env_parser_spec.rb
+- spec/env_lint/env_key_parser_spec.rb
+- spec/env_lint/linted_env_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb