nenv 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4aa66c0bda93185b1177fda8e93484e004f4e802
+  data.tar.gz: 8b360b9cb96f49e49ade892326f1ab979ab4ab64
+SHA512:
+  metadata.gz: 872463708e4ba5ea45e565f5cf2de586900e702abd3996037388947f3e9e69da949e62d1a60dfa41550400427ee27e6cc8c736516f17278dc2a606903d7f81bb
+  data.tar.gz: b793da1678ae9e09d164f0121286f6f35874c8721da2351aab457918188d086c318dcd84a75deaa67c9f7c1f270057275d26d5f02fabdf1929e1fe336c202882

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nenv.gemspec
+gemspec development_group: :test
+
+group :development do
+  gem 'guard-rspec', '~> 4.5.0'
+end

data/Guardfile

@@ -0,0 +1,34 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+directories(%w(lib spec))
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Cezary Baginski
+
+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,232 @@
+# Nenv
+
+Using ENV in Ruby is like using raw SQL statements - it feels wrong, because it is.
+
+If you agree, this gem is for you.
+
+## The benefits over using ENV directly:
+
+- much friendlier stubbing in tests
+- you no longer have to care whether false is "0" or "false" or whatever
+- NO MORE ALL CAPS EVERYWHERE!
+- keys become methods
+- namespaces which can be passed around as objects
+- you can subclass!
+- you can marshal/unmarshal your own types automatically!
+- strict mode saves you from doing validation yourself
+- and there's more to come...
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nenv'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nenv
+
+
+## Examples !!!
+
+
+### Automatic booleans
+
+You no longer have to care whether the value is "0" or "false" or "no" or "FALSE" or ... whatever
+
+```ruby
+t.verbose = (ENV['CI'] == 'true')
+ok = ENV['RUBYGEMS_GEMDEPS'] == "1" || ENV.key?('BUNDLE_GEMFILE']
+ENV['DEBUG'] = "true"
+
+```
+
+now becomes:
+
+```ruby
+t.verbose = Nenv.ci?
+gemdeps = Nenv.rubygems_gemdeps? || Nenv.bundle_gemfile?
+Nenv.debug = true
+```
+
+### "Namespaces"
+
+```ruby
+puts ENV['GIT_BROWSER`]
+puts ENV['GIT_PAGER`]
+puts ENV['GIT_EDITOR`]
+```
+
+now becomes:
+
+```ruby
+git = Nenv :git
+puts git.browser
+puts git.pager
+puts git.editor
+```
+
+### Custom type handling
+
+```ruby
+paths = [ENV['GEM_HOME`]] + ENV['GEM_PATH'].split(':')
+enable_logging if Integer(ENV['WEB_CONCURRENCY']) > 1
+mydata = YAML.load(ENV['MY_DATA'])
+ENV['VERBOSE'] = debug ? "1" : nil
+```
+
+can become:
+
+```ruby
+# setup
+gem = Nenv :gem
+gem.instance.create_method(:path) { |p| p.split(':') }
+
+web = Nenv :web
+web.instance.create_method(:concurrency) { |c| Integer(c) }
+
+my = Nenv :my
+my.instance.create_method(:data) { |d| YAML.load(d) }
+
+Nenv.instance.create_method(:verbose=) { |v| v ? 1 : nil }
+
+# and then you can simply do:
+
+paths = [gem.home] + gem.path
+enable_logging if web.concurrency > 1
+mydata = my.data
+Nenv.verbose = debug
+```
+
+### Automatic conversion to string
+
+```ruby
+ENV['RUBYGEMS_GEMDEPS'] = 1  # TypeError: no implicit conversion of Fixnum into String
+```
+
+No automatically uses `to_s`:
+
+```ruby
+Nenv.rubygems_gemdeps = 1  # no problem here
+```
+
+
+### Custom assignment
+
+```ruby
+data = YAML.load(ENV['MY_DATA'])
+data[:foo] = :bar
+ENV['MY_DATA'] = YAML.dump(data)
+```
+
+can now become:
+
+```ruby
+my = Nenv(:my)
+my.instance.create_method(:data) { |d| YAML.load(d) }
+my.instance.create_method(:data=) { |d| YAML.dump(d) }
+
+data = my.data
+data[:foo] = :bar
+my.data = data
+```
+
+### Strict mode
+
+```ruby
+fail 'home not allowed' if ENV['HOME'] = Dir.pwd  # BUG! Assignment instead of comparing!
+puts ENV['HOME'] # Now contains clobbered value
+```
+
+Now, clobbering can be prevented:
+
+```ruby
+env = Nenv::Environment.new
+env.create_method(:home)
+
+fail 'home not allowed' if env.home = Dir.pwd  # Fails with NoMethodError
+puts env.home # works
+```
+
+### Mashup mode
+
+You can first define all the load/dump logic globally in one place
+
+```ruby
+Nenv.instance.create_method(:web_concurrency) { |d| Integer(d) }
+Nenv.instance.create_method(:web_concurrency=)
+Nenv.instance.create_method(:path) { |p| Pathname(p.split(File::PATH_SEPARATOR)) }
+Nenv.instance.create_method(:path=) { |array| array.map(&:to_s).join(File::PATH_SEPARATOR) }
+
+# And now, anywhere in your app:
+
+Nenv.web_concurrency += 3
+Nenv.path += Pathname.pwd + "foo"
+
+```
+
+## NOTES
+
+Still, avoid using environment variables if you can.
+
+At least, avoid actually setting them - especially in multithreaded apps.
+
+As for Nenv, while you can access the same variable with or without namespaces,
+filters are tied to instances, e.g.:
+
+```ruby
+Nenv.instance.create_method(:foo_bar) { |d| Integer(d) }
+Nenv('foo').instance.create_method(:bar) { |d| Float(d) }
+env = Nenv::Environment.new(:foo).tap { |e| e.create_method(:bar) }
+```
+
+all work on the same variable, but each uses a different filter for reading the value.
+
+
+## What's wrong with ENV?
+
+Well sure, having ENV act like a Hash is much better than calling "getenv".
+
+Unfortunately, the advantages of using ENV make no sense:
+
+1) it's faster but ... environment variables are rarely used thousands of times in tight loops
+2) it's already an object ... but there's not much you can do with it
+3) it's globally available ... but you can't isolate it in tests (you need to reset it every time)
+4) you can use it to set variables ... but it's named like a const
+5) it allows you to use keys regardless of case ... but by convention lowercase shouldn't be used except for local variables (which are only really used by shell scripts)
+6) it's supposed to look ugly to discourage use ... but often your app/gem is forced to use them anyway
+7) it's a simple class ... but either you encapsulate it in your own classes - or all the value mapping/validation happens everywhere you want the data
+
+
+But the BIGGEST disadvantage is in specs, e.g.:
+
+```ruby
+allow(ENV).to receive(:[]).with('MY_VARIABLE').and_return("old data")
+allow(ENV).to receive(:[]=).with('MY_VARIABLE', "new data")
+```
+
+which could instead be completely isolated as:
+
+```ruby
+let(:env) { instance_double(Nenv::Environment) }
+before { allow(Nenv::Environment).to receive(:new).with(:my).and_return(env) }
+
+allow(env).to receive(:variable).and_return("old data")
+allow(env).to receive(:variable=).with("new data")
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/nenv/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+default_tasks = []
+
+require "rspec/core/rake_task"
+default_tasks  << RSpec::Core::RakeTask.new(:spec)
+
+task default: default_tasks.map(&:name)

data/lib/nenv.rb

@@ -0,0 +1,27 @@
+require "nenv/version"
+
+require "nenv/autoenvironment"
+
+def Nenv(namespace=nil)
+  Nenv::AutoEnvironment.new(namespace)
+end
+
+module Nenv
+  class << self
+    def respond_to?(meth)
+      instance.respond_to?(meth)
+    end
+
+    def method_missing(meth, *args)
+      instance.send(meth, *args)
+    end
+
+    def reset
+      @instance = nil
+    end
+
+    def instance
+      @instance ||= Nenv::AutoEnvironment.new
+    end
+  end
+end

data/lib/nenv/autoenvironment.rb

@@ -0,0 +1,9 @@
+require "nenv/environment"
+module Nenv
+  class AutoEnvironment < Nenv::Environment
+    def method_missing(meth, *args)
+      create_method(meth) unless respond_to?(meth)
+      self.send(meth, *args)
+    end
+  end
+end

data/lib/nenv/environment.rb

@@ -0,0 +1,47 @@
+require "nenv/environment/dumper"
+require "nenv/environment/loader"
+
+module Nenv
+  class Environment
+    class Error < ArgumentError
+    end
+
+    class MethodError < Error
+      def initialize(meth)
+        @meth = meth
+      end
+    end
+
+    class AlreadyExistsError < MethodError
+      def message
+        format("Method %s already exists", @meth.inspect)
+      end
+    end
+
+    def initialize(namespace = nil)
+      @namespace = (namespace ? namespace.upcase : nil)
+    end
+
+    def create_method(meth, &block)
+      fail(AlreadyExistsError, meth) if respond_to?(meth)
+
+      (class << self; self; end).send(:define_method, meth) do |*args|
+        raw_value = args.first
+        env_name = [@namespace, _sanitize(meth)].compact.join('_')
+
+        callback = block
+        if args.size == 1
+          ENV[env_name] = Dumper.new.dump(raw_value, &callback)
+        else
+          Loader.new(meth).load(ENV[env_name], &callback)
+        end
+      end
+    end
+
+    private
+
+    def _sanitize(meth)
+      meth[/^([^=?]*)[=?]?$/, 1].upcase
+    end
+  end
+end

data/lib/nenv/environment/dumper.rb

@@ -0,0 +1,10 @@
+module Nenv
+  class Environment
+    class Dumper
+      def dump(raw_value, &callback)
+        return callback.call(raw_value) if callback
+        raw_value.nil? ? nil : raw_value.to_s
+      end
+    end
+  end
+end

data/lib/nenv/environment/loader.rb

@@ -0,0 +1,29 @@
+module Nenv
+  class Environment
+    class Loader
+      def initialize(meth)
+        @bool = meth.to_s.end_with?("?")
+      end
+
+      def load(raw_value, &callback)
+        return callback.call(raw_value) if callback
+        @bool ? _to_bool(raw_value) : raw_value
+      end
+
+      private
+
+      def _to_bool(raw_value)
+        case raw_value
+        when nil
+          nil
+        when ""
+          fail ArgumentError, "Can't convert empty string into Bool"
+        when "0", "false", "n", "no", "NO", "FALSE"
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/nenv/version.rb

@@ -0,0 +1,3 @@
+module Nenv
+  VERSION = "0.0.2"
+end

data/nenv.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nenv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nenv"
+  spec.version       = Nenv::VERSION
+  spec.authors       = ["Cezary Baginski"]
+  spec.email         = ["cezary@chronomantic.net"]
+  spec.summary       = %q{Convenience wrapper for Ruby's ENV}
+  spec.description   = %q{Using ENV is like using raw SQL statements in your code. Well all know how that ends...}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/lib/nenv/environment/dumper_spec.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+require "nenv/environment/dumper"
+
+RSpec.describe Nenv::Environment::Dumper do
+  subject { described_class.new.dump(value) }
+
+  context "with \"abc\"" do
+    let(:value) { "abc" }
+    it { is_expected.to eq("abc") }
+  end
+
+  context "with 123" do
+    let(:value) { 123 }
+    it { is_expected.to eq("123") }
+  end
+
+  context "with nil" do
+    let(:value) { nil }
+    it { is_expected.to eq(nil) }
+  end
+
+  context "with a block" do
+    subject do
+      described_class.new.dump(value) { |data| YAML::dump(data) }
+    end
+
+    context "with a yaml string" do
+      let(:value) { { foo: 3 } }
+      let(:yaml) { "---\n:foo: 3\n" }
+      it { is_expected.to eq(yaml) }
+    end
+  end
+end

data/spec/lib/nenv/environment/loader_spec.rb

@@ -0,0 +1,59 @@
+require 'yaml'
+require "nenv/environment/loader"
+
+RSpec.describe Nenv::Environment::Loader do
+  context "with no block" do
+    subject { described_class.new(meth).load(value) }
+
+    context "with a normal method" do
+      let(:meth) { :foo }
+
+      context "with \"abc\"" do
+        let(:value) { "abc" }
+        it { is_expected.to eq("abc") }
+      end
+    end
+
+    context "with a bool method" do
+      let(:meth) { :foo? }
+
+      %w(1 true y yes TRUE YES foobar).each do |data|
+        context "with #{data.inspect}" do
+          let(:value) { data }
+          it { is_expected.to eq(true) }
+        end
+      end
+
+      %w(0 false n no FALSE NO).each do |data|
+        context "with #{data.inspect}" do
+          let(:value) { data }
+          it { is_expected.to eq(false) }
+        end
+      end
+
+      context "with nil" do
+        let(:value) { nil }
+        it { is_expected.to eq(nil) }
+      end
+
+      context "when empty string" do
+        let(:value) { "" }
+        it do
+          expect { subject }.to raise_error(
+            ArgumentError, /Can't convert empty string into Bool/
+          )
+        end
+      end
+    end
+  end
+
+  context "with a block" do
+    subject do
+      described_class.new(:foo).load(value) { |data| YAML::load(data) }
+    end
+    context "with a yaml string" do
+      let(:value) { "--- foo\n...\n" }
+      it { is_expected.to eq("foo") }
+    end
+  end
+end

data/spec/lib/nenv/environment_spec.rb

@@ -0,0 +1,223 @@
+require "yaml"
+
+require "nenv/environment"
+
+RSpec.describe Nenv::Environment do
+  let(:env) { instance_double(Hash) } # a hash is close enough
+  before(:each) { stub_const("ENV", env) }
+
+  context "without integration" do
+
+    let(:dumper) { instance_double(described_class::Dumper) }
+    let(:loader) { instance_double(described_class::Loader) }
+
+    before do
+      allow(described_class::Dumper).to receive(:new).and_return(dumper)
+      allow(described_class::Loader).to receive(:new).and_return(loader)
+    end
+
+    context "with no namespace" do
+      let(:instance) { described_class.new }
+
+      context "with an existing method" do
+        before do
+          subject.create_method(:foo?)
+        end
+
+        it "uses the name as full key" do
+          expect(ENV).to receive(:[]).with("FOO").and_return("true")
+          expect(loader).to receive(:load).with("true").and_return(true)
+          expect(subject.foo?).to eq(true)
+        end
+      end
+    end
+
+    context "with any namespace" do
+      let(:namespace) { "bar" }
+      let(:instance) { described_class.new(namespace) }
+
+      describe "creating a method" do
+        subject { instance }
+
+        before do
+          subject.create_method(:foo)
+        end
+
+        it { is_expected.to respond_to(:foo) }
+
+        context "when the method already exists" do
+          let(:error) { described_class::AlreadyExistsError }
+          let(:message) { "Method :foo already exists" }
+          specify do
+            expect do
+              subject.create_method(:foo)
+            end.to raise_error(error, message)
+          end
+        end
+      end
+
+      describe "calling" do
+        subject { instance }
+
+        context "when method does not exist" do
+          let(:error) { NoMethodError }
+          let(:message) { /undefined method `foo' for/ }
+          it { expect { subject.foo }.to raise_error(error, message) }
+        end
+
+        context "with a reader method" do
+
+          context "with no block" do
+            before { instance.create_method(meth) }
+
+            context "with a normal method" do
+              let(:meth) { :foo }
+              before do
+                allow(loader).to receive(:load).with("123").and_return(123)
+              end
+
+              it "returns unmarshalled stored value" do
+                expect(ENV).to receive(:[]).with("BAR_FOO").and_return("123")
+                expect(subject.foo).to eq 123
+              end
+            end
+
+            context "with a bool method" do
+              let(:meth) { :foo? }
+
+              it "references the proper ENV variable" do
+                allow(loader).to receive(:load).with("false").and_return(false)
+                expect(ENV).to receive(:[]).with("BAR_FOO").and_return("false")
+                expect(subject.foo?).to eq false
+              end
+            end
+          end
+
+          context "with a block" do
+            before do
+              instance.create_method(:foo) { |data| YAML::load(data) }
+            end
+
+            let(:value) { "---\n:foo: 5\n" }
+
+            it "unmarshals using the block" do
+              allow(ENV).to receive(:[]).with("BAR_FOO").
+                and_return(value)
+
+              allow(loader).to receive(:load).with(value) do |arg, &block|
+                expect(block).to be
+                block.call(arg)
+              end
+
+              expect(subject.foo).to eq(foo: 5)
+            end
+          end
+
+        end
+
+        context "with a writer method" do
+          before { instance.create_method(:foo=) }
+
+          it "set the environment variable" do
+            expect(ENV).to receive(:[]=).with("BAR_FOO", "123")
+            allow(dumper).to receive(:dump).with(123).and_return("123")
+            subject.foo = 123
+          end
+
+          it "marshals and stores the value" do
+            expect(ENV).to receive(:[]=).with("BAR_FOO", "123")
+            allow(dumper).to receive(:dump).with(123).and_return("123")
+            subject.foo = 123
+          end
+        end
+
+        context "with a method containing underscores" do
+          before { instance.create_method(:foo_baz) }
+          it "reads the correct variable" do
+            expect(ENV).to receive(:[]).with("BAR_FOO_BAZ").and_return("123")
+            allow(loader).to receive(:load).with("123").and_return(123)
+            subject.foo_baz
+          end
+        end
+
+        context "with a block" do
+          before do
+            instance.create_method(:foo=) { |data| YAML::dump(data) }
+          end
+
+          let(:result) { "---\n:foo: 5\n" }
+
+          it "marshals using the block" do
+            allow(ENV).to receive(:[]=).with("BAR_FOO", result)
+
+            allow(dumper).to receive(:dump).with(foo: 5) do |arg, &block|
+              expect(block).to be
+              block.call(arg)
+            end
+
+            subject.foo = { foo: 5 }
+          end
+        end
+
+        context "with an unsanitized name" do
+          pending
+        end
+      end
+    end
+  end
+
+  describe "with integration" do
+    context "with any namespace" do
+      let(:namespace) { "baz" }
+      let(:instance) { described_class.new(namespace) }
+      subject { instance }
+
+      context "with a reader method" do
+        context "with no block" do
+          before { instance.create_method(:foo) }
+
+          it "returns the stored value" do
+            allow(ENV).to receive(:[]).with("BAZ_FOO").and_return("123")
+            expect(subject.foo).to eq "123"
+          end
+        end
+
+        context "with a block" do
+          before do
+            instance.create_method(:foo) { |data| YAML::load(data) }
+          end
+
+          it "unmarshals the value" do
+            expect(ENV).to receive(:[]).with("BAZ_FOO").
+              and_return("---\n:foo: 5\n")
+
+            expect(subject.foo).to eq(foo: 5)
+          end
+        end
+      end
+
+      context "with a writer method" do
+        context "with no block" do
+          before { instance.create_method(:foo=) }
+
+          it "marshals and stores the value" do
+            expect(ENV).to receive(:[]=).with("BAZ_FOO", "123")
+            subject.foo = 123
+          end
+        end
+
+        context "with a block" do
+          before do
+            instance.create_method(:foo=) { |data| YAML::dump(data) }
+          end
+
+          it "nmarshals the value" do
+            expect(ENV).to receive(:[]=).with("BAZ_FOO", "---\n:foo: 5\n")
+
+            subject.foo = { foo: 5 }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/nenv_spec.rb

@@ -0,0 +1,53 @@
+require "nenv"
+
+RSpec.describe Nenv do
+  let(:env) { instance_double(Hash) } # Hash is close enough
+  before { stub_const("ENV", env) }
+
+  describe "Nenv() helper method" do
+    it "reads from env" do
+      expect(ENV).to receive(:[]).with('GIT_BROWSER').and_return('chrome')
+      Nenv('git').browser
+    end
+
+    it "return the value from env" do
+      allow(ENV).to receive(:[]).with('GIT_BROWSER').and_return('firefox')
+      expect(Nenv('git').browser).to eq('firefox')
+    end
+  end
+
+  describe "Nenv() module" do
+    it "reads from env" do
+      expect(ENV).to receive(:[]).with('CI').and_return('true')
+      Nenv.ci?
+    end
+
+    it "return the value from env" do
+      allow(ENV).to receive(:[]).with('CI').and_return('false')
+      expect(Nenv.ci?).to be(false)
+    end
+
+    context "with no method" do
+      it "automatically creates the method" do
+        expect(ENV).to receive(:[]).with('FOO').and_return('true')
+        Nenv.foo?
+      end
+    end
+
+    context "with existing method" do
+      before do
+        Nenv.instance.create_method(:foo?)
+      end
+
+      it "reads from env" do
+        expect(ENV).to receive(:[]).with('FOO').and_return("true")
+        Nenv.foo?
+      end
+
+      it "return the value from env" do
+        expect(ENV).to receive(:[]).with('FOO').and_return("true")
+        expect(Nenv.foo?).to be(true)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  # config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  # config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.before do
+    allow(ENV).to receive(:[]) do |key|
+      fail "stub me: ENV[#{key.inspect}]"
+    end
+
+    allow(ENV).to receive(:[]=) do |key, value|
+      fail "stub me: ENV[#{key.inspect}] = #{value.inspect}"
+    end
+  end
+
+  config.after do
+    begin
+      Nenv.method(:reset).call
+    rescue NameError
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: nenv
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Cezary Baginski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Using ENV is like using raw SQL statements in your code. Well all know
+  how that ends...
+email:
+- cezary@chronomantic.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nenv.rb
+- lib/nenv/autoenvironment.rb
+- lib/nenv/environment.rb
+- lib/nenv/environment/dumper.rb
+- lib/nenv/environment/loader.rb
+- lib/nenv/version.rb
+- nenv.gemspec
+- spec/lib/nenv/environment/dumper_spec.rb
+- spec/lib/nenv/environment/loader_spec.rb
+- spec/lib/nenv/environment_spec.rb
+- spec/lib/nenv_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: Convenience wrapper for Ruby's ENV
+test_files:
+- spec/lib/nenv/environment/dumper_spec.rb
+- spec/lib/nenv/environment/loader_spec.rb
+- spec/lib/nenv/environment_spec.rb
+- spec/lib/nenv_spec.rb
+- spec/spec_helper.rb