smart_env 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in env.gemspec
+gemspec
+
+gem 'ruby-debug19'
+gem 'rspec'

data/README.md

@@ -0,0 +1,17 @@
+# SmartEnv
+
+## Purpose
+Attach hooks to your ENV vars and wrap them in Proxy Objects.
+
+## Example
+    ENV['SERVICE'] = 'http://username:password@example.com:3000/"
+
+    ENV['SERVICE']             #=> 'http://username:password@example.com:3000/"
+    ENV['SERVICE'].base_uri    #=> 'http://example.com/"
+    ENV['SERVICE'].url         #=> 'http://example.com/"
+    ENV['SERVICE'].user        #=> 'username'
+    ENV['SERVICE'].password    #=> 'password'
+    ENV['SERVICE'].host        #=> 'example.com'
+    ENV['SERVICE'].scheme      #=> 'http'
+    ENV['SERVICE'].port        #=> 3000
+

data/Rakefile

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

data/lib/smart_env/uri_proxy.rb

@@ -0,0 +1,24 @@
+require 'uri'
+require 'forwardable'
+
+module SmartEnv
+  class UriProxy < BasicObject
+    extend ::Forwardable
+    def_delegators :@uri, *(::URI::Generic::COMPONENT + [:user, :password])
+
+    def initialize(uri)
+      @original = uri
+      @uri = ::URI.parse(uri)
+    end
+
+    def base_uri
+      base = "#{@uri.scheme}://#{@uri.host}"
+      (@uri.port ? "#{base}:#{@uri.port}" : base) + '/'
+    end
+    alias url base_uri
+
+    def method_missing(method, *args, &block)
+      @original.send(method, *args, &block) 
+    end
+  end
+end

data/lib/smart_env/version.rb

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

data/lib/smart_env.rb

@@ -0,0 +1,58 @@
+require "smart_env/version"
+require "smart_env/uri_proxy"
+
+module SmartEnv
+  extend self
+
+  @@loaded   = false
+  @@registry = []
+
+  def reset_registry
+    @@registry = [
+      [lambda{ |k,v| v.match(/^\w+:\/\//) }, UriProxy]
+    ]
+  end
+
+  def use(klass)
+    @class = klass
+    self
+  end
+
+  def when(&block)
+    raise "Block must take 0 or 2 arguments" unless ( block.arity == 0 || block.arity == 2)
+    @@registry << [block, @class]
+    self
+  end
+
+  def [](key)
+    value = ENV.get(key)
+    @@registry.each do |condition, klass|
+      result = condition.call(key, value) rescue false
+      return klass.new(value) if result
+    end
+    value
+  end
+
+  def unload!
+    class << ENV
+      alias_method :[], :get  
+      alias_method :[]=, :set
+    end
+    @@loaded = false
+  end
+
+  def load!
+    reset_registry
+    return if @@loaded
+    class << ENV
+      alias_method :get, :[]  
+
+      def [](key)
+        SmartEnv[key]
+      end
+    end
+    @@loaded = true
+  end
+end
+
+SmartEnv.load!

data/smart_env.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "smart_env/version"
+
+Gem::Specification.new do |s|
+  s.name        = "smart_env"
+  s.version     = SmartEnv::VERSION
+  s.authors     = ["Chris Continanza"]
+  s.email       = ["christopher.continanza@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Lazily proxy ENV values}
+  s.description = %q{Allows you to register Proxy classes for ENV vars by using blocks to match keys and values}
+
+  s.rubyforge_project = "smart_env"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/registry_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe SmartEnv, 'registering your own Proxies' do
+  before do
+    class TestProxy
+      def initialize(value)
+      end
+    end
+    SmartEnv.use(TestProxy).when { |key, value| key == 'FOO' }
+  end
+
+  it "should use the specified proxy when the block returns true" do
+    ENV['FOO'] = 'bar'
+    ENV['FOO'].should be_a(TestProxy)
+    ENV['BAR'] = 'bar'
+    ENV['BAR'].should == 'bar'
+    ENV['BAR'].should be_a(String)
+  end
+
+  it "raises error if the block doens't have two args" do
+    lambda { SmartEnv.use(TestProxy).when { |k,v,x| name == 'FOO' } }.should raise_error
+    lambda { SmartEnv.use(TestProxy).when { |value| name == 'FOO' } }.should raise_error
+    lambda { SmartEnv.use(TestProxy).when { false } }.should_not raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/smart_env'
+
+RSpec.configure do |config|
+  config.after(:each) { SmartEnv.reset_registry }
+end

data/spec/uri_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe SmartEnv, 'uri support' do
+  context "with a value FOO that is not a URI" do
+    before do
+      ENV['FOO'] = 'bar'
+    end
+
+    it "should not wrap it" do
+      lambda { ENV['FOO'].scheme }.should raise_error(::NoMethodError)
+    end
+  end
+
+  context "with a value FOO that is a URI" do
+
+    before do
+      @url = 'http://username:password@this.domain.example.com:3000/path?var=val'
+      ENV['FOO'] = @url
+    end
+
+    it "should leave the original value unchanged" do
+      ENV['FOO'].should == @url
+    end
+
+    it "should return scheme://host for #base_uri and #url" do
+      ENV['FOO'].base_uri.should == 'http://this.domain.example.com:3000/'
+      ENV['FOO'].url.should == 'http://this.domain.example.com:3000/'
+    end
+
+    it "should respond to #scheme with the scheme" do
+      ENV['FOO'].scheme.should == 'http'
+    end
+
+    it "should respond to #host with the host" do
+      ENV['FOO'].host.should == 'this.domain.example.com'
+    end
+
+    it "should respond to #password with the password" do
+      ENV['FOO'].password.should == 'password'
+    end
+
+    it "should respond to #user with the user" do
+      ENV['FOO'].user.should == 'username'
+    end
+
+    it "should respond to #port with the port" do
+      ENV['FOO'].port.should == 3000
+    end
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: smart_env
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Continanza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-19 00:00:00.000000000 -07:00
+default_executable: 
+dependencies: []
+description: Allows you to register Proxy classes for ENV vars by using blocks to
+  match keys and values
+email:
+- christopher.continanza@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/smart_env.rb
+- lib/smart_env/uri_proxy.rb
+- lib/smart_env/version.rb
+- smart_env.gemspec
+- spec/registry_spec.rb
+- spec/spec_helper.rb
+- spec/uri_spec.rb
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: smart_env
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Lazily proxy ENV values
+test_files:
+- spec/registry_spec.rb
+- spec/spec_helper.rb
+- spec/uri_spec.rb