coconut 0.1.1 → 0.2.0

data/README.md

@@ -63,8 +63,8 @@ environment the app is running on. If this variable is not set or is empty it
 will default to `:development`.
 
 If your ecosystem uses something that is not RACK based you can specify how
-Coconut should find out the environment with the `environment` method on the
-**Application** level
+Coconut should find out the environment with the `take_environment_from` method 
+on the **Application** level
 (See the *Specifying how the environment should be found* section on
 *Application* under *Coconut Anatomy*).
 
@@ -109,7 +109,7 @@ determine which configuration to use you can tell Coconut how to find out:
 
 ```ruby
 Coconut.configure MyApp do
-  environment { MyApp::find_out_environment }
+  take_environment_from { MyApp::find_out_environment }
   # ...
 end
 ```

data/changelog.md

@@ -1,11 +1,19 @@
 # Coconut release changes
 
-## Version 0.0.1
-- Single file configuration preview.
+## Version 0.2.0
+- Including `Coconut` as a module to define the `configure` method.
+- Querying the configuration using constants.
+- Asset setup hook.
+- Improved error messages and warnings.
+- Improved constant resolution.
+
+## Version 0.1.1
+- Add *file list flavour* support.
 
 ## Version 0.1.0
 - Remove Hashie dependency.
 - Add *folder flavour* support.
 
-## Version 0.1.1
-- Add *file list flavour* support.
+## Version 0.0.1
+- Single file configuration preview.
+

data/features/setup.feature

@@ -0,0 +1,25 @@
+Feature: Setting up an asset in the configuration
+
+  Many times you use your configuration values to setup a gem or external
+  library. Coconut will allow you to put this code where it belongs: your
+  configuration files.
+
+  Scenario: Setting up an asset
+    Given I have my application config in "/tmp/coconut_config/config.rb" with content:
+      """
+      Coconut.configure(MyApp) do
+        ftp do
+          environment(:development) do
+            user 'root'
+            pass '1234'
+          end
+          setup do
+            DummyFtp.user = user
+            DummyFtp.pass = pass
+          end
+        end
+      end
+      """
+    When I run my application on the "development" environment
+    Then my setup block should have been called with the correct values
+

data/features/step_definitions/configuration_steps.rb

@@ -19,3 +19,8 @@ end
 Then /^the configured value should be "(.*?)"$/ do |expected_result|
   eval(@query).should eq expected_result
 end
+
+Then /^my setup block should have been called with the correct values$/ do
+  DummyFtp.user.should eq 'root'
+  DummyFtp.pass.should eq '1234'
+end

data/features/support/dummy_ftp.rb

@@ -0,0 +1,5 @@
+class DummyFtp
+  class << self
+    attr_accessor :user, :pass
+  end
+end

data/lib/coconut.rb

@@ -4,24 +4,48 @@ require_relative 'coconut/dsl/application'
 module Coconut
   include Dsl
 
+  def self.included(base)
+    configure_method = method(:configure)
+    base.singleton_class.instance_eval do
+      define_method(:configure) { |*args, &block| configure_method.(base, &block) }
+    end
+  end
+
   def self.configure(namespace, &config)
-    define_config_method namespace, Application.configure(environment, &config)
+    config = Application.configure(environment, &config)
+    check_for_unconfigured_assets(config)
+        define_config_method(namespace, config)
+    define_config_constant(namespace, config)
   end
 
   def self.environment
-    return @__coconut_environment.() unless @__coconut_environment.nil?
+    return @_coconut_environment.() unless @_coconut_environment.nil?
     ENV['RACK_ENV'] || :development
   end
 
   def self.take_environment_from(&block)
-    @__coconut_environment = block
+    @_coconut_environment = block
   end
 
   private
 
   def self.define_config_method(namespace, configuration)
     namespace.singleton_class.instance_eval do
-      define_method(:config) { @__coconut_configuration ||= configuration }
+      define_method(:config) { @_coconut_configuration ||= configuration }
+    end
+  end
+
+  def self.define_config_constant(namespace, configuration)
+    namespace.instance_eval do
+      remove_const(:CONFIG) if const_defined?(:CONFIG, false)
+      const_set(:CONFIG, configuration)
+    end
+  end
+
+  def self.check_for_unconfigured_assets(config)
+    config.to_hash.each do |asset, properties|
+      Kernel.warn "WARNING: \"#{asset}\" asset has no properties set up for \
+                   current environment (#{environment})" if properties.empty?
     end
   end
 end

data/lib/coconut/config.rb

@@ -1,8 +1,10 @@
 module Coconut
   class Config
-    def initialize(properties)
-      @properties = properties
-      @config = config_from(properties)
+    def self.with(properties)
+      dup.tap do |new_config|
+        new_config.instance_variable_set('@properties', properties)
+        new_config.instance_variable_set('@config', config_from(properties))
+      end
     end
 
     # Coconut::Config objects will respond to methods if its name is
@@ -10,29 +12,27 @@ module Coconut
     # make its behaviour consistent with Coconut::Config#method_missing
     #
     # @return [Boolean] whether a config object knows how to respond to method "name"
-    def respond_to?(name)
+    def self.respond_to?(name)
       property?(name) or super
     end
 
     # @return [Hash] a Hash representation of the configuration object
-    def to_hash
+    def self.to_hash
       @properties.dup
     end
 
-    private
-
-    def config_from(properties)
+    def self.config_from(properties)
       properties.each_with_object({}) do |(property, value), config|
         config[property]= config_value_for(value)
       end
     end
 
-    def config_value_for(value)
-      return Config.new(value) if value.is_a? Hash
+    def self.config_value_for(value)
+      return Config.with(value) if value.is_a? Hash
       value
     end
 
-    def method_missing(name, *args, &block)
+    def self.method_missing(name, *args, &block)
       if property?(name)
         define_property_accessor(name)
         return @config[name]
@@ -40,14 +40,34 @@ module Coconut
       super
     end
 
-    def property?(name)
+    def self.const_missing(name)
+      if property?(name.downcase)
+        define_constant(name)
+        return @config[name.downcase]
+      end
+      super
+    end
+
+    def self.property?(name)
+      return false if @config.nil?
       @config.has_key?(name)
     end
 
-    def define_property_accessor(name)
+    def self.define_property_accessor(name)
       singleton_class.instance_eval do
         define_method(name) { @config[name] }
       end
     end
+
+    def self.define_constant(name)
+      self.const_set(name, @config[name.downcase])
+    end
+
+    private_class_method :config_from,
+                         :config_value_for,
+                         :define_constant,
+                         :define_property_accessor,
+                         :method_missing,
+                         :property?
   end
 end

data/lib/coconut/dsl/application.rb

@@ -1,5 +1,6 @@
 require_relative 'asset'
 require_relative 'asset_folder'
+require_relative 'asset_file_list'
 
 module Coconut
   module Dsl
@@ -15,21 +16,25 @@ module Coconut
       def run(&config)
         @assets_config = {}
         instance_eval &config
-        Config.new(@assets_config)
+        Config.with(@assets_config)
       end
 
       private
 
       def asset_folder(path)
-        instance_eval AssetFolder.config_from(path, IGNORED_FILES)
+        AssetFolder.new(path, IGNORED_FILES).each do |asset_config, path|
+          instance_eval(asset_config, path)
+        end
       end
 
       def asset_files(*files)
-        instance_eval AssetFileList.config_from(*files)
+        AssetFileList.new(*files).each do |asset_config, path|
+          instance_eval(asset_config, path)
+        end
       end
 
       def method_missing(asset, *args, &config)
-        ::Kernel::raise InvalidName, __taken_error_message(asset, 'asset name') if __taken?(asset)
+        ::Kernel::raise InvalidName, "#{asset} can't be used as asset name" if _taken?(asset)
         @assets_config[asset] = Asset.configure(@current_environment, &config)
       end
 

data/lib/coconut/dsl/asset.rb

@@ -1,5 +1,5 @@
-require_relative '../config'
 require_relative './environment'
+require_relative './asset_setup'
 
 module Coconut
   module Dsl
@@ -20,19 +20,23 @@ module Coconut
 
       private
 
+      def setup(&code)
+        AssetSetup.new(@properties).instance_eval(&code)
+      end
+
       def environment(*environments, &config)
-        environments.each { |environment| __configure(environment, config) }
+        environments.each { |environment| _configure(environment, config) }
       end
 
       alias :env          :environment
       alias :envs         :environment
       alias :environments :environment
 
-      def __configure(environment, config)
-        @properties.merge! Environment.configure(&config) if __current?(environment)
+      def _configure(environment, config)
+        @properties.merge! Environment.configure(&config) if _current?(environment)
       end
 
-      def __current?(environment)
+      def _current?(environment)
         @current_environment.to_sym == environment.to_sym
       end
     end

data/lib/coconut/dsl/asset_file_list.rb

@@ -1,18 +1,12 @@
-require_relative 'asset_file'
-
 module Coconut
   module Dsl
     class AssetFileList
-      def self.config_from(*file_paths)
-        new(*file_paths).assets_config
-      end
-
       def initialize(*file_paths)
-        @files = file_paths.map { |file| AssetFile.new(file) }
+        @paths = file_paths
       end
 
-      def assets_config
-        @files.map { |file| file.asset_config }.join("\n")
+      def each(&block)
+        @paths.each { |path| yield File.read(path), path }
       end
     end
   end

data/lib/coconut/dsl/asset_folder.rb

@@ -3,17 +3,13 @@ require_relative 'asset_file_list'
 module Coconut
   module Dsl
     class AssetFolder
-      def self.config_from(path, ignored_files)
-        new(path, ignored_files).assets_config
-      end
-
       def initialize(path, ignored_files)
         @path = path
         @ignored_files = ignored_files.map(&method(:path_to))
       end
 
-      def assets_config
-        AssetFileList.new(*asset_files_in_folder).assets_config
+      def each(&block)
+        AssetFileList.new(*asset_files_in_folder).each(&block)
       end
 
       private
@@ -38,6 +34,5 @@ module Coconut
         File.expand_path(File.join(@path, file))
       end
     end
-
-      end
+  end
 end

data/lib/coconut/dsl/asset_setup.rb

@@ -0,0 +1,16 @@
+require_relative 'blank_slate'
+
+module Coconut
+  module Dsl
+    class AssetSetup < BlankSlate
+      def initialize(properties)
+        @properties = properties
+      end
+
+      def method_missing(name, *args, &block)
+        return @properties[name] if @properties.has_key? name
+        super
+      end
+    end
+  end
+end

data/lib/coconut/dsl/blank_slate.rb

@@ -2,32 +2,33 @@ require_relative '../config'
 
 module Coconut
   module Dsl
-    class InvalidName < Exception; end
+    class InvalidName < RuntimeError; end
 
     class BlankSlate < BasicObject
       def self.__forbidden_names
-        Config.instance_methods + PERMANENT_METHODS
+        Config.instance_methods + PERMANENT_PUBLIC_METHODS
       end
 
       private
 
-      def __taken?(name)
+      def _taken?(name)
         Config.instance_methods.include? name
       end
 
-      def __taken_error_message(name, usage)
-        "#{name} can't be used as #{usage}: it will collide with Coconut::Config methods"
+      def self.const_missing(name)
+        super unless self.class.const_defined?(name)
+        self.class.const_get(name)
       end
 
       def self.inherited(subclass)
-        __eraseable_methods.each{ |method_name| undef_method method_name }
+        _eraseable_methods.each{ |method_name| undef_method method_name }
       end
 
-      def self.__eraseable_methods
-        instance_methods - PERMANENT_METHODS
+      def self._eraseable_methods
+        instance_methods - PERMANENT_PUBLIC_METHODS
       end
 
-      PERMANENT_METHODS = [:instance_eval, :__send__, :object_id, :__taken?, :__taken_error_message, :asset_folder]
+      PERMANENT_PUBLIC_METHODS = [:instance_eval, :__send__, :object_id, :__forbidden_names]
     end
   end
 end

data/lib/coconut/dsl/environment.rb

@@ -20,7 +20,7 @@ module Coconut
       private
 
       def method_missing(name, *args, &block)
-        ::Kernel::raise InvalidName, __taken_error_message(name, 'property name') if __taken?(name)
+        ::Kernel::raise InvalidName, "#{name} can't be used as property name" if _taken?(name)
         @properties[name] = args.first
       end
     end

data/lib/coconut/version.rb

@@ -1,3 +1,3 @@
 module Coconut
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/coconut/coconut_spec.rb

@@ -1,9 +1,19 @@
 require 'coconut'
 
-class  MyClass; end
-module MyModule; end
 
 describe Coconut do
+  before do
+    class  MyClass; end
+    module MyModule; end
+  end
+
+  after do
+    Object.instance_eval do
+      remove_const(:MyClass)
+      remove_const(:MyModule)
+    end
+  end
+
   it 'defines a config method in the provided namespace' do
     Coconut.configure(MyClass){}
     MyClass.should respond_to(:config)
@@ -11,14 +21,35 @@ describe Coconut do
     MyModule.should respond_to(:config)
   end
 
+  it 'defines a config constant in the provided namespace' do
+    Coconut.configure(MyClass){}
+    MyClass::CONFIG.should_not be_nil
+    Coconut.configure(MyModule){}
+    MyModule::CONFIG.should_not be_nil
+  end
+
   it "allows the app's configuration to be run twice" do
     Coconut.configure(MyClass) { asset { env(:development){ property 'initial value' } } }
     Coconut.configure(MyClass) { asset { env(:development){ property 'latest value'  } } }
     MyClass::config.asset.property.should eq 'latest value'
   end
 
+  it 'checks the configuration for assets without properties' do
+    Kernel.should_receive(:warn).with(/asset|current environment|development/)
+    Coconut.configure MyClass do
+      asset {}
+    end
+  end
+
+  context 'when included' do
+    it 'defines a configure method' do
+      module MyModule; include Coconut; end
+      expect { module MyModule; configure{}; end }.not_to raise_error
+    end
+  end
+
   context 'finding out the environment' do
-    before { Coconut.instance_variable_set(:@__coconut_environment, nil) }
+    before { Coconut.instance_variable_set(:@_coconut_environment, nil) }
 
     it 'uses the expression provided by the user if any' do
       Coconut.take_environment_from { :somewhere }

data/spec/coconut/config_spec.rb

@@ -1,34 +1,47 @@
 require 'coconut/config'
 
 describe Coconut::Config do
-  subject           { described_class.new(application) }
-  let(:application) { Hash[twitter: properties] }
-  let(:properties)  { Hash[property: 'value', other: 'other'] }
+  subject          { described_class.with(assets) }
+  let(:assets)     { Hash[twitter: properties] }
+  let(:properties) { Hash[property: 'value', other: 'other'] }
 
   context 'newly created' do
     it 'has no property methods' do
-      (subject.methods - Object.instance_methods).should eq [:to_hash]
+      (subject.public_methods - Class.public_methods).should eq [:with, :to_hash]
     end
 
-    it 'responds to every property' do
+   it 'responds to every property' do
       subject.should respond_to :twitter
     end
   end
 
-  context 'when a property is queried' do
-    it 'returns the property value' do
+  context 'when a property is queried as a method' do
+   it 'returns the property value' do
       subject.twitter.property.should eq 'value'
       subject.twitter.other.should eq 'other'
     end
 
-    it 'defines a new method to access the property' do
+   it 'defines a new method to access the property' do
       subject.methods.should_not include(:twitter)
       subject.twitter
       subject.methods.should include(:twitter)
     end
   end
 
-  it 'can be transformed to a hash' do
-    subject.to_hash.should eq application
+  context 'when a property is queried as a constant' do
+    it 'returns the property value' do
+      subject::TWITTER::PROPERTY.should eq 'value'
+      subject::TWITTER::OTHER.should eq 'other'
+    end
+
+    it 'defines a new constant to access the property' do
+      subject.constants.should_not include(:TWITTER)
+      subject::TWITTER
+      subject.constants.should include(:TWITTER)
+    end
+  end
+
+ it 'can be transformed to a hash' do
+    subject.to_hash.should eq assets
   end
 end

data/spec/coconut/dsl/application_spec.rb

@@ -15,17 +15,26 @@ describe Coconut::Dsl::Application do
   end
 
   it 'can load the asset configuration from a folder' do
-    path = '.'
-    Coconut::Dsl::AssetFolder.stub(:config_from).with(path, ['config.rb']).
-      and_return("asset { environment(:current) { property 'value' } }")
-    config = described_class.configure(:current) { asset_folder path }
+    asset_path = '/file/path.rb'
+    asset_config = "asset { environment(:current) { property 'value' } }"
+
+    asset_folder = stub(:asset_folder)
+    Coconut::Dsl::AssetFolder.stub(:new).and_return(asset_folder)
+    asset_folder.stub(:each).and_yield(asset_config, asset_path)
+
+    config = described_class.configure(:current) { asset_folder '.' }
     config.asset.property.should eq 'value'
   end
 
-  it 'can load asset configuration from a list of files' do
-    Coconut::Dsl::AssetFileList.stub(:config_from).with('/file/path.rb').
-      and_return("asset { environment(:current) { property 'value' } }")
-    config = described_class.configure(:current) { asset_files '/file/path.rb' }
+  it 'can load asset configuration from a list of asset files' do
+    asset_path = '/file/path.rb'
+    asset_config = "asset { environment(:current) { property 'value' } }"
+
+    asset_file_list = stub(:asset_file_list)
+    Coconut::Dsl::AssetFileList.stub(:new).and_return(asset_file_list)
+    asset_file_list.stub(:each).and_yield(asset_config, asset_path)
+
+    config = described_class.configure(:current) { asset_files asset_path }
     config.asset.property.should eq 'value'
   end
 end

data/spec/coconut/dsl/asset_file_list_spec.rb

@@ -1,6 +1,7 @@
 require 'coconut/dsl/asset_file_list'
 
 describe Coconut::Dsl::AssetFileList do
+  subject       { described_class.new(path1, path2) }
   let(:path1)   { '/tmp/asset1.rb' }
   let(:path2)   { '/tmp/asset2.rb' }
   let(:config1) { "asset1 { env(:current) { property 'value for asset1' } }" }
@@ -15,7 +16,10 @@ describe Coconut::Dsl::AssetFileList do
     File.delete('/tmp/asset1.rb', '/tmp/asset2.rb')
   end
 
-  it 'reads the content of the asset file at path' do
-    described_class.config_from(path1, path2).should eq "#{config1}\n#{config2}"
+  it "yields each asset file's config and path in the list" do
+    configs, paths = [], []
+    subject.each { |config, path| paths << path and configs << config }
+    paths.should include(path1, path2)
+    configs.should include(config1, config2)
   end
 end

data/spec/coconut/dsl/asset_folder_spec.rb

@@ -1,36 +1,53 @@
 require 'coconut/dsl/asset_folder'
 
 describe 'Assets configuration from files in folder', integration: true do
+  subject       { Coconut::Dsl::AssetFolder.new(path, ignored) }
   let(:path)    { '/tmp/coconut-testing/' }
   let(:ignored) { ['config.rb'] }
 
-  let(:config)    { "" }
   let(:s3_config) { "s3       { environment(:current) { property 'p1' } }" }
   let(:db_config) { "database { environment(:current) { property 'p2' } }" }
 
-  before :all do
-    `rm -rf #{path}`
+  before do
     Dir::mkdir path
-    File.open(File.join(path, 'config.rb'), 'w+') { |f| f.write '' }
-    File.open(File.join(path, 's3.rb'), 'w+')     { |f| f.write s3_config }
-    File.open(File.join(path, 'db.rb'), 'w+')     { |f| f.write db_config }
+    File.open(File.join(path, 's3.rb'), 'w+') { |f| f.write s3_config }
+    File.open(File.join(path, 'db.rb'), 'w+') { |f| f.write db_config }
   end
 
-  it 'evals every asset file in the folder as application config' do
-    configuration_from_folder.should eq "#{db_config}\n#{s3_config}"
+  after do
+    `rm -rf #{path}`
   end
 
-  context 'with other files that are not Ruby files' do
-    before do
-      File.open(File.join(path, 'readme.md'), 'w+') { |f| f.write 'readme' }
+  shared_examples_for 'a folder with asset files only' do
+    let(:paths)   { [] }
+    let(:configs) { [] }
+
+    it "yields every asset file's config and path" do
+      subject.each { |config, path| paths << path and configs << config }
+      paths.length.should be 2
+      paths.should include('/tmp/coconut-testing/s3.rb', '/tmp/coconut-testing/db.rb')
+      configs.length.should be 2
+      configs.should include(s3_config, db_config)
     end
+  end
+
+  context 'with asset files only' do
+    it_behaves_like 'a folder with asset files only'
+  end
 
-    it 'ignores non Ruby files' do
-      configuration_from_folder.should eq "#{db_config}\n#{s3_config}"
+  context 'with asset files and a config.rb file' do
+    before do
+      File.open(File.join(path, 'config.rb'), 'w+') { |f| f.write '#config' }
     end
+
+    it_behaves_like 'a folder with asset files only'
   end
 
-  def configuration_from_folder
-    Coconut::Dsl::AssetFolder.config_from(path, ignored)
+  context 'with asset files and non Ruby files' do
+    before do
+      File.open(File.join(path, 'readme.md'), 'w+') { |f| f.write 'readme' }
+    end
+
+    it_behaves_like 'a folder with asset files only'
   end
 end

data/spec/coconut/dsl/asset_spec.rb

@@ -46,4 +46,15 @@ describe Coconut::Dsl::Asset do
     asset_config.fetch(:property3).should eq 3
     asset_config.fetch(:property4).should eq 4
   end
+
+  it 'has a setup hook' do
+    setup_value = nil
+    asset_config = described_class.configure(:current) do
+      env(:current) { property 'value' }
+      setup do
+        setup_value = property
+      end
+    end
+    setup_value.should eq 'value'
+  end
 end

data/spec/coconut/dsl/blank_slate_spec.rb

@@ -2,8 +2,14 @@ require 'coconut/dsl/blank_slate'
 
 describe Coconut::Dsl::BlankSlate do
   it 'knows the forbidden names' do
-    expected_names =  described_class::PERMANENT_METHODS + [:one]
+    expected_names =  described_class::PERMANENT_PUBLIC_METHODS + [:one]
     Coconut::Config.stub(:instance_methods).and_return([:one])
     described_class.__forbidden_names.should include(*expected_names)
   end
+
+  it 'can look up for constants on the global namespace' do
+    context = described_class.new
+    expect { context.instance_eval('Kernel') }.not_to raise_error NameError
+  end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coconut
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-26 00:00:00.000000000 Z
+date: 2013-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -92,16 +92,18 @@ files:
 - coconut.gemspec
 - features/folder_configuration.feature
 - features/multiple_file_configuration.feature
+- features/setup.feature
 - features/single_file_configuration.feature
 - features/step_definitions/configuration_steps.rb
+- features/support/dummy_ftp.rb
 - features/support/env.rb
 - lib/coconut.rb
 - lib/coconut/config.rb
 - lib/coconut/dsl/application.rb
 - lib/coconut/dsl/asset.rb
-- lib/coconut/dsl/asset_file.rb
 - lib/coconut/dsl/asset_file_list.rb
 - lib/coconut/dsl/asset_folder.rb
+- lib/coconut/dsl/asset_setup.rb
 - lib/coconut/dsl/blank_slate.rb
 - lib/coconut/dsl/environment.rb
 - lib/coconut/version.rb
@@ -109,7 +111,6 @@ files:
 - spec/coconut/config_spec.rb
 - spec/coconut/dsl/application_spec.rb
 - spec/coconut/dsl/asset_file_list_spec.rb
-- spec/coconut/dsl/asset_file_spec.rb
 - spec/coconut/dsl/asset_folder_spec.rb
 - spec/coconut/dsl/asset_spec.rb
 - spec/coconut/dsl/blank_slate_spec.rb
@@ -128,7 +129,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2312631787946944813
+      hash: 2150013374139596454
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -137,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2312631787946944813
+      hash: 2150013374139596454
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -148,14 +149,15 @@ summary: Coconut is a simple DSL that allows you to easily write and query your
 test_files:
 - features/folder_configuration.feature
 - features/multiple_file_configuration.feature
+- features/setup.feature
 - features/single_file_configuration.feature
 - features/step_definitions/configuration_steps.rb
+- features/support/dummy_ftp.rb
 - features/support/env.rb
 - spec/coconut/coconut_spec.rb
 - spec/coconut/config_spec.rb
 - spec/coconut/dsl/application_spec.rb
 - spec/coconut/dsl/asset_file_list_spec.rb
-- spec/coconut/dsl/asset_file_spec.rb
 - spec/coconut/dsl/asset_folder_spec.rb
 - spec/coconut/dsl/asset_spec.rb
 - spec/coconut/dsl/blank_slate_spec.rb

data/lib/coconut/dsl/asset_file.rb

@@ -1,13 +0,0 @@
-module Coconut
-  module Dsl
-    class AssetFile
-      def initialize(path)
-        @path = path
-      end
-
-      def asset_config
-        ::File.read(@path)
-      end
-    end
-  end
-end

data/spec/coconut/dsl/asset_file_spec.rb

@@ -1,19 +0,0 @@
-require 'coconut/dsl/asset_file'
-
-describe Coconut::Dsl::AssetFile do
-  subject      { described_class.new(path) }
-  let(:path)   { '/tmp/asset.rb' }
-  let(:config) { "asset { env(:current) { property 'value' } }" }
-
-  before do
-    File.open('/tmp/asset.rb', 'w+') { |f| f.write(config) }
-  end
-
-  after do
-    File.delete('/tmp/asset.rb')
-  end
-
-  it 'reads the content of the asset file at path' do
-    subject.asset_config.should eq config
-  end
-end