envied 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46ff25f0ca1accf79ba7095db2e6b0232af3cb8c
-  data.tar.gz: f6f3572cb136f9d3e68affbfa4bafa839a203b05
+  metadata.gz: 501198780ddc5bf4762c604f90938baad9258ee4
+  data.tar.gz: 3027a30c7815e8925246e7f14d3e7ffcc7a3bfef
 SHA512:
-  metadata.gz: 70d6e4d6fb890c88bbb18c058c487e4c9bedcc0183562e6ef466f54c96c82701f635a2b7aa0af7da32747938ba14caea1098200cbd94a9d43068d9e3d54c8f14
-  data.tar.gz: a25bdf917df7f8479733e751051a08c9289c6c8beb8acc9c9068ff5b095e33c80c03e8e473e43c1f48083cddf6e8b41dfe94a82a38050d793db49e6d8edb1be8
+  metadata.gz: 826a2dfaa0ac7730c2fcaa14e14ea997b3c5b665774eed3ed91110e5950a29d982c6eb761e783a7eee4be6b3d1629483b068e5a1971b0d9eccabb9dc329c41c2
+  data.tar.gz: ad53e3a25cb8a9c817eb14fb0a0f0a8d815fd8dd87b54dfdf0653f920dd6e8f963014d2efdb9fd56405b8ec67d40f5df36930752c6d7794bdce41d61df8c2556

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.7.1 / 2014-08-29
+
+* Total refactor (TM).
+
+* Fix bug in Heroku binstub.
+
+  It checked for group 'default,production' instead of 'default' and 'production'.
+
 # 0.7.0 / 2014-08-24
 
 * Add init:rails-task for setup in Rails applications.

data/README.md

@@ -2,7 +2,7 @@
 
 ### TL;DR ensure presence and type of your app's ENV-variables.
 
-Features:
+## Features:
 
 * check for presence and correctness of ENV-variables
 * access to typed ENV-variables (integers, booleans etc. instead of just strings)
@@ -16,6 +16,7 @@ Features:
   * [Types](#types)
   * [Groups](#groups)
   * [Defaults](#defaults)
+  * [More examples](#more-examples)
 * [Rails](#rails)
 * [Command-line interface](#command-line-interface)
 * [Testing](#testing)
@@ -135,56 +136,10 @@ As a rule of thumb you should only use defaults:
 * for local development
 * for ENV-variables that your application introduces (i.e. for `ENV['STAFF_EMAILS']` not for `ENV['REDIS_URL']`)
 
-### A more extensive example
+### More examples
 
-```ruby
-# Envfile
-# We allow defaults for local development (and local tests), but want our CI
-# to mimic our production as much as possible.
-# New developers that don't have RACK_ENV set, will in this way not be presented with a huge
-# list of missing variables, as defaults are still enabled.
-not_production_nor_ci = ->{ !(ENV['RACK_ENV'] == 'production' || ENV['CI']) }
-enable_defaults!(&not_production_nor_ci)
-
-# Your code will likely not use ENVied.RACK_ENV (better use Rails.env),
-# we want it to be present though; heck, we're using it in this file!
-variable :RACK_ENV
-
-variable :FORCE_SSL, :Boolean, default: false
-variable :PORT, :Integer, default: 3000
-# generate the default value using the value of PORT:
-variable :PUBLIC_HOST_WITH_PORT, :String, default: proc {|envied| "localhost:#{envied.PORT}" }
-
-group :production do
-  variable :MAIL_PAAS_USERNAME
-  variable :DATABASE_URL
-end
-
-group :ci do
-  # ci-only stuff
-end
-
-group :not_ci do
-  # CI needs no puma-threads, and sidekiq-stuff etc.
-  # Define that here:
-  variable :MIN_THREADS, :Integer, default: 1
-  # more...
-end
-
-# Depending on our situation, we can now require the groups needed:
-# At local machines:
-ENVied.require(:default, :development, :not_ci) or
-ENVied.require(:default, :test, :not_ci)
-
-# At the server:
-ENVied.require(:default, :production, :not_ci)
-
-# At CI:
-ENVied.require(:default, :test, :ci)
-
-# All in one line:
-ENVied.require(:default, ENV['RACK_ENV'], (ENV['CI'] ? :ci : :not_ci))
-```
+* See the [examples](/examples)-folder for a more extensive Envfile
+* See [the Envfile](https://github.com/eval/bunny_drain/blob/c54d7d977afb5e23a92da7a2fd0d39f6a7e29bf1/Envfile) for the bunndy_drain application
 
 ## Rails
 

data/envied.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 1.9.3'
-  spec.add_dependency "virtus", '~> 1.0'
+  spec.add_dependency "coercible", '~> 1.0'
   spec.add_dependency "rack", "~> 1.4"
   spec.add_dependency "thor", "~> 0.15"
   spec.add_development_dependency "bundler", "~> 1.5"

data/examples/extensive_envfile

@@ -0,0 +1,46 @@
+# -*- mode: ruby -*-¬
+# We allow defaults for local development (and local tests), but want our CI
+# to mimic our production as much as possible.
+# New developers that don't have RACK_ENV set, will in this way not be presented with a huge
+# list of missing variables, as defaults are still enabled.
+not_production_nor_ci = ->{ !(ENV['RACK_ENV'] == 'production' || ENV['CI']) }
+enable_defaults!(&not_production_nor_ci)
+
+# Your code will likely not use ENVied.RACK_ENV (better use Rails.env),
+# we want it to be present though; heck, we're using it in this file!
+variable :RACK_ENV
+
+variable :FORCE_SSL, :Boolean, default: false
+variable :PORT, :Integer, default: 3000
+# generate the default value using the value of PORT:
+variable :PUBLIC_HOST_WITH_PORT, :String, default: proc {|envied| "localhost:#{envied.PORT}" }
+
+group :production do
+  variable :MAIL_PAAS_USERNAME
+  variable :DATABASE_URL
+end
+
+group :ci do
+  # ci-only stuff
+end
+
+group :not_ci do
+  # CI needs no puma-threads, and sidekiq-stuff etc.
+  # Define that here:
+  variable :MIN_THREADS, :Integer, default: 1
+  # more...
+end
+
+# Depending on our situation, we can now require the correct groups in our initialization-file:
+# At local machines:
+# ENVied.require(:default, :development, :not_ci) or
+# ENVied.require(:default, :test, :not_ci)
+
+# At the server:
+# ENVied.require(:default, :production, :not_ci)
+
+# At CI:
+# ENVied.require(:default, :test, :ci)
+
+# All in one line:
+# ENVied.require(:default, ENV['RACK_ENV'], (ENV['CI'] ? :ci : :not_ci))

data/lib/envied.rb

@@ -1,238 +1,56 @@
 require 'envied/version'
 require 'envied/cli'
-require 'virtus'
+require 'envied/coercer'
+require 'envied/variable'
+require 'envied/configuration'
 
 class ENVied
-  module Hashable
-    def to_hash
-      require 'rack/utils'
-      ::Rack::Utils.parse_nested_query(self)
-    end
-  end
-
-  module Arrayable
-    def to_a
-      self.split(/(?<!\\), ?/).map{|i| i.gsub(/\\,/,',') }
-    end
-  end
-
-  class Configuration
-    include Virtus.model
-
-    def self.variable(name, type = :String, options = {})
-      options = { default: nil, strict: true, group: self.current_group }.merge(options)
-      type = Array if type == :Array
-      attribute(name, type, options)
-    end
-
-    def self.group(name, &block)
-      self.current_group = name.to_sym
-      yield
-    ensure
-      self.current_group = :default
-    end
-
-    def self.enable_defaults
-      (@enable_defaults ||= false).respond_to?(:call) ?
-        @enable_defaults.call :
-        @enable_defaults
-    end
-
-    def self.enable_defaults!(value = nil, &block)
-      value ||= block if block_given?
-      @enable_defaults = value
-    end
-
-    class << self
-      alias_method :defaults_enabled?, :enable_defaults
-      alias_method :enable_defaults=, :enable_defaults!
-      attr_writer :current_group
-    end
-
-    def self.current_group
-      @current_group ||= :default
-    end
-  end
-
-  def self.configuration(options = {}, &block)
-    if block_given?
-      @configuration = build_configuration(&block).tap do |c|
-        options.each {|k, v| c.public_send("#{k}=", v) }
-      end
-    end
-    @configuration ||= build_configuration
-  end
-
-  def self.configure(options = {}, &block)
-    deprecation_warning "ENVied.configure will be deprecated. Please generate an Envfile instead (see the envied command)."
-    configuration(options, &block)
-  end
-
   class << self
-    attr_accessor :required_groups
-  end
-
-  def self.build_configuration(&block)
-    Class.new(Configuration).tap do |c|
-      c.instance_eval(&block) if block_given?
-    end
+    attr_reader :env, :config
   end
 
   def self.require(*groups)
-    groups.compact!
-    @instance = nil
-    if groups.any?
-      self.required_groups = groups.map(&:to_sym)
-    else
-      self.required_groups = [:default]
-    end
-    ensure_configured!
+    @config ||= Configuration.load
+    @env ||= EnvProxy.new(@config, groups: required_groups(*groups))
+
     error_on_missing_variables!
     error_on_uncoercible_variables!
-
-    _required_variables = required_variables
-    group_configuration = build_configuration do
-      _required_variables.each do |v|
-        @attribute_set << v
-      end
-    end
-    @instance = group_configuration.new(env)
-  end
-
-  def self.springified_require(*args)
-    springify { ENVied.require(*args) }
-  end
-
-  def self.springify(&block)
-    if defined?(Spring) && Spring.respond_to?(:watcher)
-      Spring.after_fork(&block)
-    else
-      block.call
-    end
-  end
-
-  def self.ensure_configured!
-    # Backward compat: load Envfile only when it's present
-    configure_via_envfile if envfile_exist?
-  end
-
-  def self.envfile
-    File.expand_path('Envfile')
-  end
-
-  def self.envfile_exist?
-    File.exist?(envfile)
-  end
-
-  def self.configure_via_envfile
-    configuration { eval(File.read(ENVied.envfile)) }
   end
 
   def self.error_on_missing_variables!
-    if missing_variable_names.any?
-      raise "Please set the following ENV-variables: #{missing_variable_names.sort.join(',')}"
-    end
+    names = env.missing_variables.map(&:name)
+    raise "The following environment variables should be set: #{names * ', '}" if names.any?
   end
 
   def self.error_on_uncoercible_variables!
-    # TODO default values should have defined type
-    if non_coercible_variables.any?
-      single_error = "ENV['%{name}'] ('%{value}' can't be coerced to %{type})"
-      errors = non_coercible_variables.map do |v|
-        var_type = v.type.to_s.split("::").last
-        single_error % { name: v.name, value: env_value_or_default(v), type: var_type }
-      end.join ", "
-
-      raise "Some ENV-variables are not coercible: #{errors}"
+    errors = env.uncoercible_variables.map do |v|
+      "%{name} ('%{value}' can't be coerced to %{type})" % {name: v.name, value: env.value_to_coerce(v), type: v.type }
     end
+    raise "The following environment variables are not coercible: #{errors.join(", ")}" if errors.any?
   end
 
-  def self.env_value(variable)
-    env[variable.name.to_s]
+  def self.required_groups(*groups)
+    result = groups.compact
+    result.any? ? result.map(&:to_sym) : [:default]
   end
 
-  def self.env
-    @env ||= begin
-      Hash[ENV.to_hash.map {|k,v| [k, v.dup.extend(Hashable, Arrayable)] }]
+  def self.springify(&block)
+    if spring_enabled?
+      Spring.after_fork(&block)
+    else
+      block.call
     end
   end
 
-  def self.env_value_or_default(variable)
-    env_value(variable) || default_value(variable)
-  end
-
-  # Yields the assigned default for the variable.
-  # When defaults are disabled, nil is returned.
-  def self.default_value(variable)
-    defaults_enabled? ? variable.default_value.value : nil
-  end
-
-  # A list of all configured variable names.
-  #
-  # @example
-  #   ENVied.required_variable_names
-  #   # => [:DATABASE_URL]
-  #
-  # @return [Array<Symbol>] the list of variable names
-  def self.required_variable_names
-    required_variables.map(&:name).map(&:to_sym)
-  end
-
-  def self.required_variables
-    from_required_group = ->(var){ self.required_groups.include?(var.options[:group]) }
-    configured_variables.to_a.keep_if(&from_required_group)
-  end
-
-  def self.configured_variables
-    configuration.attribute_set.dup#.to_a.keep_if(&var_from_required_group)
-  end
-
-  def self.provided_variable_names
-    ENV.keys.map(&:to_sym)
-  end
-
-  def self.non_coercible_variables
-    required_variables.reject(&method(:variable_coercible?))
-  end
-
-  def self.variable_coercible?(variable)
-    var_value = env_value_or_default(variable)
-    return true if var_value.respond_to?(:call)
-
-    !variable.coerce(var_value).nil?
-  rescue Virtus::CoercionError
-    return false
-  end
-
-  def self.missing_variable_names
-    unprovided = required_variable_names - provided_variable_names
-    unprovided -= names_of_required_variables_with_defaults if defaults_enabled?
-    unprovided
-  end
-
-  def self.names_of_required_variables_with_defaults
-    required_variables_with_defaults.map(&:name).map(&:to_sym)
-  end
-
-  def self.required_variables_with_defaults
-    required_variables.map do |v|
-      v unless v.default_value.value.nil?
-    end.compact
-  end
-
-  def self.defaults_enabled?
-    configuration.enable_defaults
+  def self.spring_enabled?
+    defined?(Spring) && Spring.respond_to?(:watcher)
   end
 
   def self.method_missing(method, *args, &block)
-    respond_to_missing?(method) ? @instance.public_send(method, *args, &block) : super
+    respond_to_missing?(method) ? (env && env[method.to_s]) : super
   end
 
   def self.respond_to_missing?(method, include_private = false)
-    @instance.respond_to?(method) || super
-  end
-
-  def self.deprecation_warning(msg)
-    puts "DEPRECATION WARNING: #{msg}"
+    (env && env.has_key?(method)) || super
   end
 end

data/lib/envied/coercer.rb

@@ -0,0 +1,77 @@
+require 'coercible'
+
+# Responsible for all string to type coercions.
+class ENVied::Coercer
+  module CoercerExts
+    def to_array(str)
+      str.split(/(?<!\\),/).map{|i| i.gsub(/\\,/,',') }
+    end
+
+    def to_hash(str)
+      require 'rack/utils'
+      ::Rack::Utils.parse_query(str)
+    end
+  end
+  Coercible::Coercer::String.send(:include, CoercerExts)
+
+  # Coerce strings to specific type.
+  #
+  # @param string [String] the string to be coerced
+  # @param type [#to_sym] the type to coerce to
+  #
+  # @example
+  #   ENVied::Coercer.new.coerce('1', :Integer)
+  #   # => 1
+  #
+  # @return [type] the coerced string.
+  def coerce(string, type)
+    unless supported_type?(type)
+      raise ArgumentError, "#{type.inspect} is not supported type"
+    end
+    coerce_method_for(type.to_sym)[string]
+  end
+
+  def coerce_method_for(type)
+    return nil unless supported_type?(type)
+    coercer.method("to_#{type.downcase}")
+  end
+
+  def self.supported_types
+    @supported_types ||= begin
+      [:hash, :array, :time, :date, :symbol, :boolean, :integer, :string]
+    end
+  end
+
+  # Whether or not Coercer can coerce strings to the provided type.
+  #
+  # @param type [#to_sym] the type (case insensitive)
+  #
+  # @example
+  #   ENVied::Coercer.supported_type?('string')
+  #   # => true
+  #
+  # @return [Boolean] whether type is supported.
+  def self.supported_type?(type)
+    supported_types.include?(type.to_sym.downcase)
+  end
+
+  def supported_type?(type)
+    self.class.supported_type?(type)
+  end
+
+  def coercer
+    @coercer ||= Coercible::Coercer.new[String]
+  end
+
+  def coerced?(value)
+    !value.kind_of?(String)
+  end
+
+  def coercible?(string, type)
+    return false unless supported_type?(type)
+    coerce(string, type)
+    true
+  rescue Coercible::UnsupportedCoercion
+    false
+  end
+end

data/lib/envied/configuration.rb

@@ -0,0 +1,109 @@
+class ENVied
+  class Configuration
+    attr_reader :current_group, :defaults_enabled
+
+    def initialize(options = {})
+      @defaults_enabled = options.fetch(:enable_defaults, false)
+    end
+
+    def self.load
+      new.tap do |v|
+        v.instance_eval(File.read(File.expand_path('Envfile')))
+      end
+    end
+
+    def enable_defaults!(value = nil, &block)
+      @defaults_enabled = (value.nil? ? block : value)
+    end
+
+    def defaults_enabled?
+      @defaults_enabled.respond_to?(:call) ?
+        @defaults_enabled.call :
+        @defaults_enabled
+    end
+
+    def variable(name, type = :String, options = {})
+      options[:group] = current_group if current_group
+      variables << ENVied::Variable.new(name, type, options)
+    end
+
+    def group(name, &block)
+      @current_group = name.to_sym
+      yield
+    ensure
+      @current_group = nil
+    end
+
+    def variables
+      @variables ||= []
+    end
+  end
+
+  # Responsible for anything related to the ENV.
+  class EnvProxy
+    attr_reader :config, :coercer, :groups
+
+    def initialize(config, options = {})
+      @config = config
+      @coercer = options.fetch(:coercer, ENVied::Coercer.new)
+      @groups = options.fetch(:groups, [])
+    end
+
+    def missing_variables
+      variables.select(&method(:missing?))
+    end
+
+    def uncoercible_variables
+      variables.reject(&method(:coerced?)).reject(&method(:coercible?))
+    end
+
+    def variables
+      @variables ||= begin
+        config.variables.select {|v| groups.include?(v.group) }
+      end
+    end
+
+    def variables_by_name
+      Hash[variables.map {|v| [v.name, v] }]
+    end
+
+    def [](name)
+      coerce(variables_by_name[name.to_sym])
+    end
+
+    def has_key?(name)
+      variables_by_name[name.to_sym]
+    end
+
+    def env_value_of(var)
+      ENV[var.name.to_s]
+    end
+
+    def default_value_of(var)
+      var.default_value(ENVied, var)
+    end
+
+    def value_to_coerce(var)
+      return env_value_of(var) unless env_value_of(var).nil?
+      config.defaults_enabled? ? default_value_of(var) : nil
+    end
+
+    def coerce(var)
+      coerced?(var) ?
+        value_to_coerce(var) :
+        coercer.coerce(value_to_coerce(var), var.type)
+    end
+
+    def coercible?(var)
+      coercer.coercible?(value_to_coerce(var), var.type)
+    end
+
+    def missing?(var)
+      value_to_coerce(var).nil?
+    end
+
+    def coerced?(var)
+      coercer.coerced?(value_to_coerce(var))
+    end
+  end
+end

data/lib/envied/templates/heroku-env-check.tt

@@ -3,7 +3,7 @@
 # Check the config of a Heroku app against the defined variables in `Envfile`
 
 <%- if @app %>
-HEROKU_APP=<%= @app %> exec heroku config | bundle exec envied check:heroku --groups <%= @groups.join(",") %>
+HEROKU_APP=<%= @app %> exec heroku config | bundle exec envied check:heroku --groups <%= @groups.join(" ") %>
 <%- else %>
-exec heroku config | bundle exec envied check:heroku --groups <%= @groups.join(",") %>
+exec heroku config | bundle exec envied check:heroku --groups <%= @groups.join(" ") %>
 <%- end %>

data/lib/envied/variable.rb

@@ -0,0 +1,18 @@
+class ENVied::Variable
+  attr_reader :name, :type, :group, :default
+
+  def initialize(name, type, options = {})
+    @name = name.to_sym
+    @type = type.to_sym
+    @group = options.fetch(:group, :default).to_sym
+    @default = options[:default]
+
+    #if !@default.is_a? String
+    #  raise ArgumentError, "Default values should be strings (variable #{@name})"
+    #end
+  end
+
+  def default_value(*args)
+    default.respond_to?(:call) ? default[*args] : default
+  end
+end

data/lib/envied/version.rb

@@ -1,3 +1,3 @@
 class ENVied
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/spec/coercer_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe ENVied::Coercer do
+  it { is_expected.to respond_to :coerce }
+
+  describe '#coerce' do
+    let(:coercer){ described_class.new }
+
+    def coerce_to(type)
+      ->(str){ coercer.coerce(str, type) }
+    end
+
+    describe 'string coercion' do
+      let(:coerce){ coerce_to(:String) }
+
+      it 'yields the input untouched' do
+        expect(coerce['1']).to eq '1'
+        expect(coerce[' 1']).to eq ' 1'
+      end
+    end
+
+    describe 'integer coercion' do
+      let(:coerce){ coerce_to(:Integer) }
+
+      it 'converts strings to integers' do
+        expect(coerce['1']).to eq 1
+        expect(coerce['-1']).to eq(-1)
+      end
+    end
+
+    describe 'boolean coercion' do
+      let(:coerce){ coerce_to(:Boolean) }
+
+      it "converts 'true' and 'false'" do
+        expect(coerce['true']).to eq true
+        expect(coerce['false']).to eq false
+      end
+
+      it "converts '1' and '0'" do
+        expect(coerce['1']).to eq true
+        expect(coerce['0']).to eq false
+      end
+    end
+
+    describe 'symbol coercion' do
+      let(:coerce){ coerce_to(:Symbol) }
+
+      it 'converts strings to symbols' do
+        expect(coerce['a']).to eq :a
+        expect(coerce['nice_symbol']).to eq :nice_symbol
+      end
+    end
+
+    describe 'date coercion' do
+      let(:coerce){ coerce_to(:Date) }
+
+      it 'converts strings to date' do
+        expect(coerce['2014-12-25']).to eq Date.parse('2014-12-25')
+      end
+    end
+
+    describe 'time coercion' do
+      let(:coerce){ coerce_to(:Time) }
+
+      it 'converts strings to time' do
+        expect(coerce['4:00']).to eq Time.parse('4:00')
+      end
+    end
+
+    describe 'array coercion' do
+      let(:coerce){ coerce_to(:Array) }
+
+      it 'converts strings to array' do
+        {
+          'a,b' => ['a','b'],
+          ' a, b' => [' a',' b'],
+          'apples,and\, of course\, pears' => ['apples','and, of course, pears'],
+        }.each do |i, o|
+          expect(coerce[i]).to eq o
+        end
+      end
+    end
+
+    describe 'hash coercion' do
+      let(:coerce){ coerce_to(:Hash) }
+
+      it 'converts strings to hashes' do
+        {
+          'a=1' => {'a' => '1'},
+          'a=1&b=2' => {'a' => '1', 'b' => '2'},
+          'a=&b=2' => {'a' => '', 'b' => '2'},
+          'a&b=2' => {'a' => nil, 'b' => '2'},
+        }.each do |i, o|
+          expect(coerce[i]).to eq o
+        end
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ENVied::Configuration do
+  it { is_expected.to respond_to :variable }
+  it { is_expected.to respond_to :enable_defaults! }
+  it { is_expected.to respond_to :defaults_enabled? }
+
+  describe '#variable' do
+    it 'results in an added variable' do
+
+    end
+  end
+
+  describe 'defaults' do
+    it 'is disabled by default' do
+      expect(subject.defaults_enabled?).to_not be
+    end
+
+    describe '#enable_defaults!' do
+      it 'can be passed a value' do
+        expect {
+          subject.enable_defaults!(true)
+        }.to change { subject.defaults_enabled? }
+      end
+
+      it 'can be passed a block' do
+        expect {
+          subject.enable_defaults! { true }
+        }.to change { subject.defaults_enabled? }.to(true)
+      end
+    end
+  end
+end

data/spec/envied_spec.rb

@@ -1,10 +1,14 @@
 require 'spec_helper'
 
 describe ENVied do
-  subject { described_class }
+  describe 'class' do
+    subject { described_class }
 
-  it { should respond_to :require }
-  it { should respond_to :configure }
+    it { is_expected.to respond_to :require }
+  end
+
+  describe 'responding to methods that are variables' do
+  end
 
   before do
     reset_env
@@ -12,7 +16,7 @@ describe ENVied do
   end
 
   def reset_configuration
-    ENVied.instance_eval { @configuration = nil }
+    ENVied.instance_eval { @config = nil }
   end
 
   def reset_env
@@ -27,16 +31,19 @@ describe ENVied do
     end
 
     def configure(options = {}, &block)
-      described_class.configuration(options, &block)
+      ENVied.instance_eval do
+        @config = ENVied::Configuration.new(options).tap{|c| c.instance_eval(&block)}
+      end
       self
     end
 
     def configured_with(hash = {})
-      described_class.configuration do
+      config = ENVied::Configuration.new.tap do |c|
         hash.each do |name, type|
-          variable(name, *type)
+          c.variable(name, *type)
         end
       end
+      ENVied.instance_eval{ @config = config }
       self
     end
 
@@ -53,14 +60,14 @@ describe ENVied do
       configured_with(a: :Integer).and_ENV({'a' => '1'})
       described_class.require
 
-      is_expected.to respond_to :a
+      expect(described_class).to respond_to :a
     end
 
     it 'responds not to unconfigured variables' do
       unconfigured.and_ENV({'A' => '1'})
       described_class.require
 
-      is_expected.to_not respond_to :B
+      expect(described_class).to_not respond_to :B
     end
 
     context 'ENV contains not all configured variables' do
@@ -69,7 +76,7 @@ describe ENVied do
       specify do
         expect {
           ENVied.require
-        }.to raise_error(/set the following ENV-variables: a/)
+        }.to raise_error(/The following environment variables should be set: a/)
       end
     end
 
@@ -79,14 +86,14 @@ describe ENVied do
       specify do
         expect {
           ENVied.require
-        }.to raise_error(/ENV\['A'\] \('NaN' can't be coerced to Integer/)
+        }.to raise_error(/A \('NaN' can't be coerced to Integer/)
       end
     end
 
     context 'bug: default value "false" is not coercible' do
       before {
         configure(enable_defaults: true) do
-          variable :FORCE_SSL, :Boolean, default: false
+          variable :FORCE_SSL, :Boolean, default: true
         end
       }
 
@@ -99,35 +106,36 @@ describe ENVied do
 
     describe 'defaults' do
       describe 'setting' do
-        subject { described_class.configuration }
+        subject { described_class.config }
+        #subject { ENVied::Configuration.new }
 
-        it 'is disabled by default' do
-          expect(subject.enable_defaults).to_not be
-        end
+        #it 'is disabled by default' do
+        #  expect(subject.defaults_enabled?).to_not be
+        #end
 
         it 'can be enabled via #configure' do
           configure(enable_defaults: true){ }
 
-          expect(subject.enable_defaults).to be
+          expect(subject.defaults_enabled?).to be
         end
 
         it 'can be enabled via a configure-block' do
-          configure { self.enable_defaults = true }
+          configure { self.enable_defaults!(true) }
 
-          expect(subject.enable_defaults).to be
+          expect(subject.defaults_enabled?).to be
         end
 
         it 'can be assigned a Proc' do
-          configure { self.enable_defaults = -> { true } }
+          configure { self.enable_defaults! { true } }
 
-          expect(subject.enable_defaults).to be
+          expect(subject.defaults_enabled?).to be
         end
       end
 
       describe 'assigning' do
         it 'can be a value' do
           configure(enable_defaults: true) do
-            variable :A, :Integer, default: 1
+            variable :A, :Integer, default: '1'
           end
           described_class.require
 
@@ -136,7 +144,7 @@ describe ENVied do
 
         it 'can be a Proc' do
           configure(enable_defaults: true) do
-            variable :A, :Integer, default: proc { 1 }
+            variable :A, :Integer, default: proc { "1" }
           end
           described_class.require
 
@@ -145,7 +153,7 @@ describe ENVied do
 
         it 'is ignored if defaults are disabled' do
           configure(enable_defaults: false) do
-            variable :A, :Integer, default: 1
+            variable :A, :Integer, default: "1"
           end.and_no_ENV
 
           expect {
@@ -153,9 +161,9 @@ describe ENVied do
           }.to raise_error
         end
 
-        it 'is is ignored if ENV is provided' do
+        it 'is ignored if ENV is provided' do
           configure(enable_defaults: true) do
-            variable :A, :Integer, default: 1
+            variable :A, :Integer, default: "1"
           end.and_ENV('A' => '2')
           described_class.require
 
@@ -257,7 +265,7 @@ describe ENVied do
         end
 
         it 'yields array from string' do
-          expect(ENVied.moar).to eq ['a','b','and, c']
+          expect(ENVied.moar).to eq ['a',' b',' and, c']
         end
       end
     end

data/spec/variable_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ENVied::Variable do
+  def variable(*args)
+    described_class.new(*args)
+  end
+
+  def set_env(env)
+    stub_const("ENV", env)
+  end
+
+  describe 'an instance' do
+    subject { variable(:A, :String) }
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: envied
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Gert Goet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: virtus
+  name: coercible
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -112,14 +112,21 @@ files:
 - Rakefile
 - bin/envied
 - envied.gemspec
+- examples/extensive_envfile
 - lib/envied.rb
 - lib/envied/cli.rb
+- lib/envied/coercer.rb
+- lib/envied/configuration.rb
 - lib/envied/templates/Envfile.tt
 - lib/envied/templates/heroku-env-check.tt
 - lib/envied/templates/rails-initializer.tt
+- lib/envied/variable.rb
 - lib/envied/version.rb
+- spec/coercer_spec.rb
+- spec/configuration_spec.rb
 - spec/envied_spec.rb
 - spec/spec_helper.rb
+- spec/variable_spec.rb
 homepage: https://github.com/eval/envied
 licenses:
 - MIT
@@ -145,5 +152,8 @@ signing_key:
 specification_version: 4
 summary: Ensure presence and type of ENV-variables
 test_files:
+- spec/coercer_spec.rb
+- spec/configuration_spec.rb
 - spec/envied_spec.rb
 - spec/spec_helper.rb
+- spec/variable_spec.rb