nenv 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d06558bd1f60f7df4ca005879f7edf5766d39f43
-  data.tar.gz: b799514f85b409d39b5cc00ed89a75ac40128a2e
+  metadata.gz: 206715ae7f773db5e3f4f38a3883e452d9663023
+  data.tar.gz: 8222926939dc0d449a98b13d394a997c2910663b
 SHA512:
-  metadata.gz: 34f8b3b1ba84e8cefded199b13f7aa36bba820455191dcedbb2a6811e2f06f49c39ccaccc8b6e25b20cb10c26bf594db4ccb76a7530cb53d70d27b2fe51e389e
-  data.tar.gz: 541451121f650f2d099632b0c8d900d5f8d630a78c19aa9245127606f71fb20986f77883532a3d14882b1195d4651fd666e93cb6170b056f5a08eddb700488ba
+  metadata.gz: 765ddaad9d2a4ecb29150945fd016c9314d79e472dd49032b47cda912f47c166faa7710d43eaf46feab31586e3b09e982392ffa9708b65eace8cae231316b5a2
+  data.tar.gz: d014fd2ca1203dc5c1a9537de121d7603e06a42912626abd3eb7d6c33258916ff1e5c377aa0f7f6d746441abfa069e16de017331f12ec57eeeeb54d8fc29e5be

data/README.md

@@ -32,7 +32,7 @@ Other benefits (and compared to other solutions):
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'nenv'
+gem 'nenv', '~> 0.1'
 ```
 
 And then execute:
@@ -85,6 +85,16 @@ puts git.pager
 puts git.editor
 ```
 
+Or in block form
+
+```ruby
+Nenv :git do |git|
+  puts git.browser
+  puts git.pager
+  puts git.editor
+end
+```
+
 ### Custom type handling
 
 ```ruby
@@ -231,6 +241,14 @@ 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.
 
 
+## Documentation / SemVer / API
+
+Any behavior not mentioned here (in this README) is subject to change. This
+includes module names, class names, file names, method names, etc.
+
+If you are relying on behavior not documented here, please open a ticket.
+
+
 ## What's wrong with ENV?
 
 Well sure, having ENV act like a Hash is much better than calling "getenv".
@@ -242,27 +260,56 @@ Unfortunately, the advantages of using ENV make no sense:
 - it's globally available ... but you can't isolate it in tests (you need to reset it every time)
 - you can use it to set variables ... but it's named like a const
 - 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)
-- it's supposed to look ugly to discourage use ... but often your app/gem is forced to use them anyway
-- 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 (yuck!)
+- it's supposed to look ugly to discourage use ... but often your app/gem is forced to use 3rd party environment variables anyway
+- it's a simple Hash-like class ... but either you encapsulate it in your own classes - or all the value mapping/validation happens everywhere you want the data (yuck!)
 
 
 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")
+allow(ENV).to receive(:[]).with('MY_VARIABLE').and_return("foo")
+allow(ENV).to receive(:[]=).with('MY_VARIABLE', "foo bar")
+# (and if you get the above wrong, you may be debugging for a long, long time...)
 ```
 
-which could instead be completely isolated as:
+which could instead be completely isolated as (and without side effects):
 
 ```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")
+allow(env).to receive(:variable).and_return("foo")
+expect(env).to receive(:variable=).with("foo bar")
+# (with verifying doubles it's hard to get it wrong and get stuck)
 ```
 
+Here's a full example:
+
+```ruby
+# In your implementation
+MyEnv = Nenv::Builder.build do
+  create_method(:variable)
+  create_method(:variable=)
+end
+
+class Foo
+  def foo
+    MyEnv.new(:my).variable += "bar"
+  end
+end
+
+# Stubbing the class in your specs
+RSpec.describe Foo do
+  let(:env) { instance_double(MyEnv) }
+  before { allow(MyEnv).to receive(:new).with(:my).and_return(env) }
+
+  describe "#foo" do
+    before { allow(env).to receive(:variable).and_return("foo") }
+
+    it "appends a value" do
+      expect(env).to receive(:variable=).with("foo bar")
+      subject.foo
+    end
+  end
+end
+```
 
 ## Contributing
 

data/lib/nenv.rb

@@ -4,7 +4,9 @@ require 'nenv/autoenvironment'
 require 'nenv/builder'
 
 def Nenv(namespace = nil)
-  Nenv::AutoEnvironment.new(namespace)
+  Nenv::AutoEnvironment.new(namespace).tap do |env|
+    yield env if block_given?
+  end
 end
 
 module Nenv

data/lib/nenv/version.rb

@@ -1,3 +1,3 @@
 module Nenv
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nenv
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Cezary Baginski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-14 00:00:00.000000000 Z
+date: 2015-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Convenience wrapper for Ruby's ENV