foundry 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0e5844ff236192bbd134f6044eeecd46b97a96f
-  data.tar.gz: f54d2a1d4f15b500e121f663b5cdf84fa3eb0d80
+  metadata.gz: b28681a81e233360028348be15505ab62d698a9c
+  data.tar.gz: 060e3a8c45400254f9fb8e926b75683f82a4fed9
 SHA512:
-  metadata.gz: 337e51d286fb9e574bb4f446a0dfdd9d3b689051b4315a0a6d4d269fbccb8075497bda0d751e37bce8f1010cb9c0bd1df3f659484394f1c83ab11dec046598b9
-  data.tar.gz: d808c17433690c4b4375b4a7c2559171844f350005c42e49d3cc150a0eae3c56b95e65c743abfdff735fb132613b5159400ccaf3bc83b58146b5374c99abbade
+  metadata.gz: 52e33f3b602ff5a8dd9fdc6728a8898e42d3572bc4c147f4755cab966d4ceece89ce46639619302677882028620084aaf60c93cebf92e8490515fdfb8fb13a7d
+  data.tar.gz: 3bf3b2b64289087f2abd06816434e51590fd59add1fb82b0aee96522d1a5571d58a0496fc993d420e97b78191219324bd183a78b55e62a0de7bf4a50f508e8fe

data/.travis.yml

@@ -6,10 +6,13 @@ matrix:
     - rvm: rbx-2
 
 rvm:
+  - 1.8.7
+  - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1.0
   - 2.1.1
   - 2.1.2
+  - 2.1.3
   - jruby-19mode
   - rbx-2

data/README.md

@@ -36,40 +36,94 @@ Or install it yourself as:
 Loading from a local-file:
 
 ```ruby
-config = Foundry::Configurator.configure(:file_name => 'path-to-local-file')
+config = Foundry::Configurator.configure(
+  :root_path => 'local-root-path',
+  :relative_path => 'relative-path-to-file',
+  :source_type => Foundry::Sources::File
+)
 ```
 
 Loading from a HTTP/HTTPS endpoint:
 
 ```ruby
-config = Foundry::Configurator.configure(:uri => 'http-or-https-endpoint')
+config = Foundry::Configurator.configure(
+  :root_path => 'http-or-https-root-url',
+  :relative_path => 'relative-path-to-file',
+  :source_type => Foundry::Sources::URI
+)
 ```
 
 Loading from a HTTP/HTTPS endpoint using "Basic Authentication":
 
 ```ruby
 config = Foundry::Configurator.configure(
-  :uri => 'http-or-https-endpoint',
+  :root_path => 'http-or-https-root-url',
+  :relative_path => 'relative-path-to-file',
+  :source_type => Foundry::Sources::URI,
   :username => 'basic-auth-username',
   :password => 'basic-auth-password'
 )
 ```
 
-Using the "config" object (defined above):
+Fetching top-level and nested values:
 
 ```ruby
-# The examples below assume that the following YAML was loaded by a call to
-# "Foundry::Configurator.configure" and into a variable named "config"
+# The examples below assume that a file containing the following has already
+# been loaded and processed by a call to `Foundry::Configurator.configure` (into
+# a variable named `config`).
 #
 # ---
-# some_key:
-#   some_nested_key: value
+# value1: value
+# value2:
+#   nested_value1: value
+
+# Fetching a top-level value using dot-notation
+value1 = config.value1
+
+# Fetching a nested value using dot-notation
+nested_value1 = config.value2.nested_value1
+
+# Fetching a top-level value by key
+value1 = config['value1']
+
+# Fetching a nested value by key
+nested_value1 = config['value2']['nested_value1']
+```
+
+Inheritance support:
+
+```ruby
+# The examples below assume that there are two files available, relative to the
+# `root_path`, named "file1.yml" and "file2.yml" (and that "file2.yml" inherits
+# from "file1.yml").
+#
+# The file contents are as follows:
+#
+# === file1.yml ===
+#
+# ---
+# value1: value
+#
+# === file2.yml ===
+#
+# ---
+# value2: value
+# inherit: file1.yml
+#
+# It is also assumed that the files have already been loaded and processed by a
+# call to `Foundry::Configurator.configure` (into a variable named `config`).
+#
+# The result now contains values for both `value1` and `value2` and can be used
+# as follows (it is worth noting that the `inherit` key is removed during the
+# configuration process):
 
-# Fetch a value using dot-notation
-value = config.some_key.some_nested_key
+# Fetching `value1` and `value2` using dot-notation
+value1 = config.value1
+value2 = config.value2
 
-# Fetch a value by key
-value = config['some_key']['some_nested_key']
+# Fetching `value1` and `value2` by key
+value1 = config['value1']
+value2 = config['value2']
 ```
 
 ## Contributing

data/foundry.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'pry', '~> 0.10'
   gem.add_development_dependency 'rake', '~> 10.3'
   gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'webmock', '~> 1.20'
 end

data/lib/foundry.rb

@@ -5,7 +5,9 @@ require 'ostruct'
 require 'uri'
 require 'yaml'
 
+require 'foundry/refinements/hash'
+
 require 'foundry/configurator'
-require 'foundry/loaders/file'
-require 'foundry/loaders/uri'
+require 'foundry/sources/file'
+require 'foundry/sources/uri'
 require 'foundry/version'

data/lib/foundry/configurator.rb

@@ -1,52 +1,81 @@
 module Foundry
   class Configurator
-    class << self
-      def configure(opts={})
-        structify(
-          load_yaml(
-            evaluate_erb(
-              load_by_filename_or_uri(opts)
-            )
-          )
-        )
+    def self.configure(opts)
+      Configurator.new.configure(opts)
+    end
+
+    def configure(opts)
+      with_opts(opts) do
+        transmorgs = transmorgify(opts.fetch(:relative_path))
+        merged = mergify(transmorgs)
+        structify(merged)
       end
+    end
 
-      private
+    private
 
-      def evaluate_erb(str)
-        ERB.new(str).result
-      end
+    attr_reader :opts
 
-      def load_by_filename_or_uri(opts)
-        if file_name = opts.delete(:file_name)
-          Foundry::Loaders::File.load(file_name, opts)
-        elsif uri = opts.delete(:uri)
-          Foundry::Loaders::Uri.load(uri, opts)
-        else
-          raise NotImplementedError
-        end
-      end
+    def erbify(str)
+      ERB.new(str).result
+    end
 
-      def load_yaml(str)
-        YAML.load(str)
-      end
+    def loadify(relative_path)
+      source.load(
+        root_path,
+        relative_path,
+        opts
+      )
+    end
 
-      def structify(object)
-        case object
-        when Array
-          object.map do |value|
-            structify(value)
-          end
-        when Hash
-          OpenStruct.new.tap do |open_struct|
-            object.each do |key, value|
-              open_struct.public_send("#{key}=", structify(value))
-            end
+    def mergify(transmorgs)
+      transmorgs.reduce({}) { |memo, transmorg| memo.deep_merge(transmorg) }
+    end
+
+    def parsify(str)
+      YAML.load(str) || {}
+    end
+
+    def root_path
+      opts.fetch(:root_path)
+    end
+
+    def source
+      source_type.new
+    end
+
+    def source_type
+      opts.fetch(:source_type)
+    end
+
+    def structify(object)
+      case object
+      when Array
+        object.map do |value|
+          structify(value)
+        end
+      when Hash
+        OpenStruct.new.tap do |open_struct|
+          object.each do |key, value|
+            open_struct.send("#{key}=", structify(value))
           end
-        else
-          object
         end
+      else
+        object
       end
     end
+
+    def transmorgify(relative_path)
+      parsed = parsify(erbify(loadify(relative_path)))
+      inherit = parsed.delete('inherit')
+      Array(inherit && transmorgify(inherit)) << parsed
+    end
+
+    def with_opts(opts)
+      @opts = opts
+      yield
+    ensure
+      @opts = nil
+    end
   end
 end

data/lib/foundry/refinements/hash.rb

@@ -0,0 +1,25 @@
+class Hash
+  def deep_merge(other)
+    dup.deep_merge!(other)
+  end
+
+  def deep_merge!(other)
+    other.each_pair do |other_key, other_value|
+      this_value = self[other_key]
+      if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        self[other_key] = this_value.deep_merge(other_value)
+      else
+        self[other_key] = other_value
+      end
+    end
+    self
+  end
+
+  def without(*keys)
+    dup.without!(*keys)
+  end
+
+  def without!(*keys)
+    self.reject! { |key, _| keys.include?(key) }; self
+  end
+end

data/lib/foundry/sources/file.rb

@@ -0,0 +1,11 @@
+module Foundry
+  module Sources
+    class File
+      def load(root_path, relative_path, opts)
+        file_path = ::File.join(root_path, relative_path)
+        raise "Unknown configuration file: #{file_path}" unless ::File.exists?(file_path)
+        ::File.read(file_path)
+      end
+    end
+  end
+end

data/lib/foundry/sources/uri.rb

@@ -0,0 +1,21 @@
+module Foundry
+  module Sources
+    class URI
+      def load(root_path, relative_path, opts)
+        uri = ::URI.join(root_path, relative_path)
+        client = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          client.use_ssl = true
+          client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        request = Net::HTTP::Get.new(uri.request_uri)
+        if (username = opts[:username]) && (password = opts[:password])
+          request.basic_auth(username, password)
+        end
+        response = client.request(request)
+        raise "Unknown configuration file: #{uri}" unless response.is_a?(Net::HTTPSuccess)
+        response.body
+      end
+    end
+  end
+end

data/lib/foundry/version.rb

@@ -1,3 +1,3 @@
 module Foundry
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/spec/configurator_spec.rb

@@ -1,36 +1,45 @@
 require 'spec_helper'
-require 'foundry/configurator'
 
 describe Foundry::Configurator do
-  subject { Foundry::Configurator }
+  REQUIRED_OPTS = [
+    :root_path,
+    :relative_path,
+    :source_type,
+  ]
 
-  it 'must be passed either a "file_name" or "uri"' do
-    expect { subject.configure }.to raise_error
-  end
+  subject { Foundry::Configurator.new }
+  let(:opts) { REQUIRED_OPTS.reduce({}) { |memo, opt| memo[opt] = nil; memo } }
 
-  it 'will attempt to load from a file' do
-    expect(Foundry::Loaders::File).to receive(:load) { '' }
-    subject.configure(:file_name => '')
+  REQUIRED_OPTS.each do |key|
+    it %{must be passed a "#{key}"} do
+      expect { subject.configure(opts.without(key)) }.to raise_error
+    end
   end
 
-  it 'will attempt to load from a uri' do
-    expect(Foundry::Loaders::Uri).to receive(:load) { '' }
-    subject.configure(:uri => '')
+  it 'will load from a source' do
+    with_source do |source|
+      expect(source).to receive(:load) { '' }
+      expect { subject.configure(opts) }.not_to raise_error
+    end
   end
 
   it 'will fail-fast if the YAML is invalid' do
-    expect(Foundry::Loaders::File).to receive(:load)
-    expect { subject.configure(:file_name => '') }.to raise_error
+    with_source do |source|
+      expect(source).to receive(:load)
+      expect { subject.configure(opts) }.to raise_error
+    end
   end
 
   it 'will fail-fast if the ERB raises an error' do
-    expect(Foundry::Loaders::File).to receive(:load) { 'foo: <%= 1/0 %>' }
-    expect { subject.configure(:file_name => '') }.to raise_error
+    with_source do |source|
+      expect(source).to receive(:load) { 'foo: <%= 1/0 %>' }
+      expect { subject.configure(opts) }.to raise_error
+    end
   end
 
-  it 'can parse [nested] YAML/ERB' do
-    expect(Foundry::Loaders::File).to receive(:load) { <<-YAML
-      root:
+  it 'can parse YAML/ERB' do
+    with_source do |source|
+      expect(source).to receive(:load) { <<-YAML
         erb: <%= 1 * 2 * 3 %>
         float: 123.0
         integer: 42
@@ -39,11 +48,10 @@ describe Foundry::Configurator do
           - dos
           - tres
         string: hello world
-    YAML
-    }
-    expect(subject.configure(:file_name => '')).to eq(
-      OpenStruct.new(
-        'root' => OpenStruct.new(
+      YAML
+      }
+      expect(subject.configure(opts)).to eq(
+        OpenStruct.new(
           'erb' => 6,
           'float' => 123.0,
           'integer' =>  42,
@@ -51,6 +59,37 @@ describe Foundry::Configurator do
           'string' => 'hello world'
         )
       )
-    )
+    end
+  end
+
+  it 'supports inheritance' do
+    with_source(:exactly => :twice) do |source|
+      expect(source).to receive(:load).and_return(
+        "foo: foo\ninherit: bar",
+        "bar: bar"
+      )
+      expect(subject.configure(opts)).to eq(
+        OpenStruct.new(
+          'foo' => 'foo',
+          'bar' => 'bar'
+        )
+      )
+    end
+  end
+
+  private
+
+  def default_opts
+    {
+      :exactly => :once,
+      :type => Foundry::Sources::File,
+    }
+  end
+
+  def with_source(opts={})
+    merged_opts = default_opts.merge(opts)
+    source = merged_opts[:type].new
+    expect(subject).to receive(:source).exactly(merged_opts[:exactly]) { source }
+    yield source
   end
 end

data/spec/refinements/hash_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Hash do
+  subject do
+    {
+      :A => nil,
+      :B => nil,
+      :C => nil,
+      :D => nil,
+    }
+  end
+  let(:keys) do
+    [
+      :A,
+      :B,
+      :C,
+      :D,
+    ]
+  end
+
+  let(:other) do
+    {
+      :E => nil,
+      :F => nil,
+      :G => nil,
+      :H => nil,
+    }
+  end
+  let(:other_keys) do
+    [
+      :E,
+      :F,
+      :G,
+      :H,
+    ]
+  end
+
+  let(:nested) do
+    {
+      :I => nil,
+      :J => nil,
+      :K => {
+        :L => nil,
+      },
+    }
+  end
+
+  describe 'destructive' do
+    describe 'deep_merge!' do
+      it 'can merge two hashes' do
+        expect(subject.deep_merge!(other)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+          :E => nil,
+          :F => nil,
+          :G => nil,
+          :H => nil,
+        })
+        expect(subject.size).to eq(keys.size + other_keys.size)
+      end
+
+      it 'can merge nested hashes' do
+        expect(subject.deep_merge!(nested)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+          :I => nil,
+          :J => nil,
+          :K => {
+            :L => nil,
+          },
+        })
+      end
+    end
+
+    describe 'without!' do
+      it 'can filter one key' do
+        expect(subject.without!(:A)).to eq({
+          :B => nil,
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size - 1)
+      end
+
+      it 'can filter multiple keys' do
+        expect(subject.without!(:A, :B)).to eq({
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size - 2)
+      end
+
+      it 'skips keys that do not exist' do
+        expect(subject.without!(:E)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+    end
+  end
+
+  describe 'non-destructive' do
+    describe 'deep_merge' do
+      it 'can merge two hashes' do
+        expect(subject.deep_merge(other)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+          :E => nil,
+          :F => nil,
+          :G => nil,
+          :H => nil,
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+
+      it 'can merge nested hashes' do
+        expect(subject.deep_merge(nested)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+          :I => nil,
+          :J => nil,
+          :K => {
+            :L => nil,
+          },
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+    end
+
+    describe 'without' do
+      it 'can filter one key' do
+        expect(subject.without(:A)).to eq({
+          :B => nil,
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+
+      it 'can filter multiple keys' do
+        expect(subject.without(:A, :B)).to eq({
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+
+      it 'skips keys that do not exist' do
+        expect(subject.without(:E)).to eq({
+          :A => nil,
+          :B => nil,
+          :C => nil,
+          :D => nil,
+        })
+        expect(subject.size).to eq(keys.size)
+      end
+    end
+  end
+end

data/spec/sources/file_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Foundry::Sources::File do
+  subject { Foundry::Sources::File.new }
+
+  it 'can load a file' do
+    expect(File).to receive(:read)
+    subject.load('', '', {})
+  end
+
+  it 'will raise an error if the file does not exist' do
+    expect { subject.load('', '', {}) }.to raise_error
+  end
+end

data/spec/sources/uri_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Foundry::Sources::URI do
+  subject { Foundry::Sources::URI.new }
+  let(:domain) { 'foo.bar.com' }
+  let(:relative_path) { 'config.yml' }
+
+  let(:http_uri) { "#{http_root_path}/#{relative_path}" }
+  let(:http_root_path) { "http://#{domain}" }
+  let(:http_response_body) { 'http_response_body' }
+  let(:http_opts) { {} }
+
+  let(:https_uri) { "#{https_root_path}/#{relative_path}" }
+  let(:https_root_path) { "https://#{domain}" }
+  let(:https_response_body) { 'https_response_body' }
+  let(:https_opts) { {} }
+
+  let(:basic_auth_uri) { "http://#{basic_auth_username}:#{basic_auth_password}@#{domain}/#{relative_path}" }
+  let(:basic_auth_root_path) { http_root_path }
+  let(:basic_auth_response_body) { 'basic_auth_response_body' }
+  let(:basic_auth_username) { 'basic_auth_username' }
+  let(:basic_auth_password) { 'basic_auth_password' }
+  let(:basic_auth_opts) { { :username => basic_auth_username, :password => basic_auth_password } }
+
+  before do
+  end
+
+  it 'can load from a HTTP endpoint' do
+    stub_request(:get, http_uri).to_return(:body => http_response_body)
+
+    expect(
+      subject.load(
+        http_root_path,
+        relative_path,
+        http_opts
+      )
+    ).to eq(http_response_body)
+  end
+
+  it 'can load from a HTTPS endpoint' do
+    stub_request(:get, https_uri).to_return(:body => https_response_body)
+
+    expect(
+      subject.load(
+        https_root_path,
+        relative_path,
+        https_opts
+      )
+    ).to eq(https_response_body)
+  end
+
+  it 'can load from a endpoint using basic-auth' do
+    stub_request(:get, basic_auth_uri).to_return(:body => basic_auth_response_body)
+
+    expect(
+      subject.load(
+        basic_auth_root_path,
+        relative_path,
+        basic_auth_opts
+       )
+    ).to eq(basic_auth_response_body)
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,3 @@
 require 'rspec'
+require 'webmock/rspec'
 require File.expand_path('../../lib/foundry.rb', __FILE__)
-
-RSpec.configure do |config|
-  config.color_enabled = true if config.respond_to?(:color_enabled)
-end

metadata

@@ -1,71 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: foundry
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonathan W. Zaleski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-25 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.20'
 description: |2
     Let's face it, there are a number of problems when application/environment
     configuration logic is too tightly coupled with the configuration-data itself.
@@ -76,8 +90,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -86,12 +100,14 @@ files:
 - foundry.gemspec
 - lib/foundry.rb
 - lib/foundry/configurator.rb
-- lib/foundry/loaders/file.rb
-- lib/foundry/loaders/uri.rb
+- lib/foundry/refinements/hash.rb
+- lib/foundry/sources/file.rb
+- lib/foundry/sources/uri.rb
 - lib/foundry/version.rb
 - spec/configurator_spec.rb
-- spec/loaders/file_spec.rb
-- spec/loaders/uri_spec.rb
+- spec/refinements/hash_spec.rb
+- spec/sources/file_spec.rb
+- spec/sources/uri_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jzaleski/foundry
 licenses:
@@ -103,22 +119,23 @@ 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.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: An application configuration gem that aims to keep it simple
 test_files:
 - spec/configurator_spec.rb
-- spec/loaders/file_spec.rb
-- spec/loaders/uri_spec.rb
+- spec/refinements/hash_spec.rb
+- spec/sources/file_spec.rb
+- spec/sources/uri_spec.rb
 - spec/spec_helper.rb

data/lib/foundry/loaders/file.rb

@@ -1,9 +0,0 @@
-module Foundry
-  module Loaders
-    class File
-      def self.load(file_name, opts)
-        ::File.read(file_name)
-      end
-    end
-  end
-end

data/lib/foundry/loaders/uri.rb

@@ -1,19 +0,0 @@
-module Foundry
-  module Loaders
-    class Uri
-      def self.load(uri, opts)
-        parsed_uri = URI.parse(uri)
-        http = Net::HTTP.new(parsed_uri.host, parsed_uri.port)
-        if parsed_uri.scheme == 'https'
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-        request = Net::HTTP::Get.new(parsed_uri.request_uri)
-        if username = opts.delete(:username) && password = opts.delete(:password)
-          request.basic_auth(username, password)
-        end
-        http.request(request).body
-      end
-    end
-  end
-end

data/spec/loaders/file_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-require 'foundry/loaders/file'
-
-describe Foundry::Loaders::File do
-  subject { Foundry::Loaders::File }
-
-  it 'can load a file' do
-    expect(File).to receive(:read)
-    subject.load('', {})
-  end
-
-  it 'will raise an error if the file does not exist' do
-    expect { subject.load('', {}) }.to raise_error
-  end
-end

data/spec/loaders/uri_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'foundry/loaders/uri'
-
-describe Foundry::Loaders::Uri do
-  subject { Foundry::Loaders::Uri }
-  let(:request) { double }
-  let(:response_body) { 'response_body' }
-  let(:response) { double(:body => response_body) }
-  let(:http) { double(:request => response) }
-  let(:http_url) { 'http://foo.bar.com' }
-  let(:https_url) { http_url.gsub(/\Ahttp:/, 'https:') }
-
-  before do
-    expect(Net::HTTP).to receive(:new) { http }
-    expect(Net::HTTP::Get).to receive(:new) { request }
-  end
-
-  it 'can load from a HTTP endpoint' do
-    expect(subject.load(http_url, {})).to eq(response_body)
-  end
-
-  it 'can load from a HTTPS endpoint' do
-    expect(http).to receive_messages([:use_ssl=, :verify_mode=])
-    expect(subject.load(https_url, {})).to eq(response_body)
-  end
-
-  it 'can load from a endpoint using basic-auth' do
-    expect(request).to receive(:basic_auth)
-    expect(subject.load(
-      http_url, {
-        :username => 'basic_auth_username',
-        :password => 'basic_auth_password',
-      }
-    )).to eq(response_body)
-  end
-end