coconut 0.0.1 → 0.1.0

data/README.md

@@ -19,16 +19,16 @@ Or install it yourself as:
     $ gem install coconut
 
 
-## What is coconut?
+## Overview
 Coconut provides **a simple DSL that allows you to configure your application's
-assets on different environments**
+assets on different environments**.
 
 ```ruby
 require 'coconut'
 
 Coconut.configure MyApp do
   twitter do
-    environment :development do
+    environments :development, :test do
       consumer_key     'development_key'
       consumer_secret  'development_secret'
     end
@@ -41,11 +41,8 @@ Coconut.configure MyApp do
 end
 ```
 
-You only need to require file from your app. Coconut will define a
+You only need to require the config file from your app. Coconut will define a
 `config` method on your application's namespace that you can use to query it.
-**You don't have to specify the environment when querying for configuration
-values**. Coconut will only run the configuration for the environment it's
-running on.
 
 ```ruby
 ENV['RACK_ENV'] = :development
@@ -55,28 +52,244 @@ ENV['RACK_ENV'] = :production
 MyApp.config.twitter.consumer_key       # => production_key
 ```
 
-## Why coconut?
-TODO
+**You don't have to specify the environment when querying for configuration
+values. Coconut will only run the configuration for the environment it's
+running on.**
 
 
-## Coconut flavours
-TODO
-### Single file
-TODO
+## How is the environment detected?
+Coconut uses the `RACK_ENV` environment variable by default to detect the
+environment the app is running on. If this variable is not set or is empty it
+will default to `:development`.
 
-### Folder
-TODO
+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
+(See the *Specifying how the environment should be found* section on
+*Application* under *Coconut Anatomy*).
 
-### List of files
-TODO
 
+## Coconut Anatomy
+Coconut is composed of **3 different parts**:
 
-## How is the environment detected?
-Right now coconut uses the environment variable `RACK_ENV` to detect the
-environment the app is running on. If `RACK_ENV` is not set or is empty it
-defaults to `:development`.
+### 1) Application
+*Application is the top level block* of Coconut. It's composed of the configuration
+of the *Assets* your application has. It may also contain information about
+where Coconut should look for *Asset* configuration files and how it should
+find out which environment the application is running on.
+
+You will enter this block when you call the `Coconut.configure` method passing
+in your application's namespace.
+
+```ruby
+require 'coconut'
+
+Coconut.configure MyApp do
+  # your application configuration
+end
+```
+
+Coconut will then detect the environment,
+run the configuration and create a `Coconut::Config` object with the assets
+and it's properties for the current environment. A `config` method will be
+defined in the namespace passed to `configure`. That method will return the
+`Coconut::Config` object with your application's configuration.
+
+That means:
+* You only need to make sure that you require the config file that includes the
+  *Application* block for your configuration to be run.
+* Your configuration will be run just once (unless you use `Kernel::load`)
+* If there is a `config` method on your namespace it will be overriden.
+* You will be able to access the configuration from anywhere by calling
+  `Namespace::config`.
+
+#### Specifying how the environment should be found
+If your application should not use the RACK_ENV environment variable to
+determine which configuration to use you can tell Coconut how to find out:
+
+```ruby
+Coconut.configure MyApp do
+  environment { MyApp::find_out_environment }
+  # ...
+end
+```
+
+Coconut will call the block passed to the `environment` method to find out
+what environment the application is running on. Therefore **the environment
+will be the return value of that block**.
+
+
+#### Coconut flavours (a.k.a. how to structure your configuration).
+You can structure the configuration the way that suits you best. Maybe it fits
+in a single file best. Maybe you want to split it and have several configuration
+files. Coconut offers you three different alternatives.
+
+#####a) Single file
+If your configuration is small this is probably the best choice. In this case
+your application section will only be composed of *Assets*. You will need
+nothing more. The first example of this README uses this Coconut flavour.
+
+#####b) Folder
+If you want to split your configuration in several files and put them in the
+same folder you will be able to tell Coconut how to find them. Coconut will
+load **every file in that folder and run them as if they were Coconut scripts**.
+
+If the file that has the *Application* level configuration is in that folder
+too it will be run and will cause an error. You have two options to avoid this:
+
+1. Name that file `config.rb`. By convention Coconut won't run a file in an
+asset folder if it is called like that.
+2. Put the configuration file that has the *Application* level configuration
+in a different folder. In this case the files in the given folder will only
+have *Asset* configuration.
+
+```ruby
+Coconut.configure MyApp do
+  asset_folder 'path/to/folder'
+end
+```
+
+This allows you to write your files focusing only on *Assets*, given that
+when Coconut will run then within the *Application* block. So you could
+have the following project structure:
+
+    .
+    ..
+    /config
+      config.rb
+      database.rb
+      oauth.rb
+      s3.rb
+    /lib
+    /spec
+
+You could have the *Application* block on the `config.rb` file like this
+(assuming that you run the application from the root of the project):
+
+```ruby
+Coconut.configure MyApp do
+  asset_folder 'config'
+end
+```
+
+And each of the asset files would only include asset configuration:
 
-### Changing the environment
+```ruby
+database do
+  environment :development do
+    #...
+  end
+
+  environment :staging, :production do
+    #...
+  end
+end
+```
+
+You would only need to require the `config/config.rb` file to access the
+configuration.
+
+#####c) List of files
+
+*NOT DEVELOPED YET: will be available on next version (0.1.1)*
+
+This flavour is exactly like the *folder* one with the difference that instead
+of providing the path to the folder to the asset configuration files you provide
+the path to every one of them:
+
+```ruby
+Coconut.configure MyApp do
+  asset_files 'database.rb', 'oauth.rb', 's3.rb'
+end
+```
+
+Notice that the paths are relative to where the `config.rb` file is located.
+
+### 2) Asset
+Each of this blocks represent one of the assets of your application. Inside
+each one of them you will include the *Asset* properties on each of the
+environments your application will run on.
+
+An *Asset* block consist of the asset name and a Ruby block containing it's
+configuration in each of the environments:
+
+```ruby
+asset_name do
+  environment(:production)         { property 'value on production' }
+  environment(:development, :test) { property 'value on test and development' }
+end
+```
+
+You can specify one or more environments at the same time. You can also use any
+of the aliases the `environment` method has:
+
+```ruby
+env(:development, :test)          { property 'value' }
+envs(:development, :test)         { property 'value' }
+environment(:development, :test)  { property 'value' }
+environments(:development, :test) { property 'value' }
+```
+
+An *Asset* can have *almost* any name. There are some restrictions that apply to
+the names. This restrictions apply to both asset names and property names
+and are explained in the *Environment* section of this README.
+
+### 3) Environment
+Environments are the lowest level of a Coconut configuration. Its composed of
+the configuration properties an asset will have on that environment. So,
+essentially, it's a series of key-value pairs.
+
+Properties can have almost any name you can think of. It only has to be a valid
+Ruby method name and you have to avoid those that will collide with calls on
+the `Config` object. Coconut will raise an error if you use one of the reserved
+names:
+
+```ruby
+environment(:development) { object_id 11 }
+# => Coconut::Dsl::InvalidName: object_id can't be used as property name: it will collide with Coconut::Config methods
+```
+
+You can find out the forbidden property (and asset) names by calling the method:
+```ruby
+Coconut::Dsl::BlankSlate.__forbidden_names
+# => [:respond_to?, :to_hash, :nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone, :dup,
+#     :initialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze,
+#     :frozen?, :to_s, :inspect, :methods, :singleton_methods, :protected_methods, :private_methods,
+#     :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set,
+#     :instance_variable_defined?, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send,
+#     :respond_to_missing?, :extend, :display, :method, :public_method, :define_singleton_method, :object_id,
+#     :to_enum, :enum_for, :==, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__,
+#     :instance_eval, :__send__, :object_id, :__taken?, :__taken_error_message]
+```
+
+If you want to use the methods from `Kernel` that are widely available
+on Ruby objects you will need to prepend the module to the method call:
+
+```ruby
+environment(:development) do
+  puts 'here'         # declaring a property named "puts"
+  Kernel::puts 'here' # printing "here" to STDOUT
+end
+```
+
+Values can be any Ruby object, from a simple integer or string to a lambda.
+You can even use constant or expressions. Keep in mind that the block passed
+to environment will be evaluated in a different context:
+you won't be able to call methods without specifying their receiver.
+
+```ruby
+environment :development do
+  four      2 + 2
+  arguments ARGV
+  encodings Encoding.list
+  setup -> do
+    enable  :sessions, :logging
+    disable :dump_errors, :some_custom_option
+  end
+end
+```
+
+## Why coconut?
 TODO
 
 ## Contributing

data/Rakefile

@@ -1 +1,30 @@
 require "bundler/gem_tasks"
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:ok,  'Run features that should pass') do |t|
+    t.cucumber_opts = ['--strict', '--tags ~@wip', '--format progress']
+  end
+
+  Cucumber::Rake::Task.new(:wip, 'Run features that are being worked on') do |t|
+    t.cucumber_opts = ['--wip', '--tags @wip']
+  end
+
+  Cucumber::Rake::Task.new(:all, 'Run all features')
+end
+
+namespace :rspec do
+  desc 'Run specs with progress output'
+  RSpec::Core::RakeTask.new(:progress) do |t|
+    t.rspec_opts = '--format progress'
+  end
+
+  desc 'Run all specs'
+  RSpec::Core::RakeTask.new(:spec)
+end
+
+task spec:     'rspec:spec'
+task cucumber: 'cucumber:ok'
+task test:     ['rspec:progress', 'cucumber:ok']
+task default:  'test'

data/changelog.md

@@ -0,0 +1,8 @@
+# Coconut release changes
+
+## Version 0.0.1
+- Single file configuration preview.
+
+## Version 0.1.0
+- Remove Hashie dependency.
+- Add *folder flavour* support.

data/coconut.gemspec

@@ -17,9 +17,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_runtime_dependency 'hashie'
-
   gem.add_development_dependency 'cucumber'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'yard'
 end

data/features/folder_configuration.feature

@@ -0,0 +1,52 @@
+Feature: Load configuration from folder
+
+  You can split your configuration into asset files, put those files into a
+  folder and tell Coconut to load the configuration from there. That
+  folder should only include asset files. If it includes some other Ruby file
+  Coconut will try to execute it as such and you will get an error.
+
+  In order to be able to have all the configuration related files in a single
+  folder you can adhere to the convention and put your application configuration
+  in a file called 'config.rb' inside that folder.
+
+  If Coconut will ignore that file and it won't be executed as if it was an
+  asset file.
+
+  You can also have your application related configuration in other folder and
+  use the file name that you want.
+
+  Scenario: Application file and assets file under the same folder
+    Given I have my application config in "/tmp/coconut_config/config.rb" with content:
+      """
+      Coconut.configure MyApp do
+        asset_folder '/tmp/coconut_config'
+      end
+      """
+      And I have a "s3.rb" asset file on /tmp/coconut_config with content:
+      """
+      s3 do
+        env(:development) { key 'xxx' }
+        env(:production)  { key 'yyy' }
+      end
+      """
+     When I run my application on the "development" environment
+      And I query the configuration for "s3.key"
+     Then the configured value should be "xxx"
+
+  Scenario: Application file and assets file in different folders
+    Given I have my application config in "/tmp/coconut.rb" with content:
+      """
+      Coconut.configure MyApp do
+        asset_folder '/tmp/coconut_config'
+      end
+      """
+      And I have a "s3.rb" asset file on /tmp/coconut_config with content:
+      """
+      facebook do
+        env(:development) { key 'xxx' }
+        env(:production)  { key 'yyy' }
+      end
+      """
+     When I run my application on the "development" environment
+      And I query the configuration for "facebook.key"
+     Then the configured value should be "xxx"

data/features/single_file_configuration.feature

@@ -1,7 +1,7 @@
 Feature: Single file configuration
 
   Scenario: One environment configuration
-    Given my application is configured like this:
+    Given I have my application config in "/tmp/coconut_config/config.rb" with content:
       """
       Coconut.configure(MyApp) do
         ftp do
@@ -14,3 +14,18 @@ Feature: Single file configuration
     When I run my application on the "development" environment
      And I query the configuration for "ftp.user"
     Then the configured value should be "root"
+
+  Scenario: Several environments configuration
+    Given I have my application config in "/tmp/coconut_config/config.rb" with content:
+      """
+      Coconut.configure(MyApp) do
+        ssh do
+          environment(:development, :staging, :production) do
+            login 'username'
+          end
+        end
+      end
+      """
+    When I run my application on the "development" environment
+     And I query the configuration for "ssh.login"
+    Then the configured value should be "username"

data/features/step_definitions/configuration_steps.rb

@@ -1,10 +1,15 @@
-Given /^my application is configured like this:$/ do |configuration|
-  @app_config = configuration
+Given /^I have my application config in "(.*?)" with content:$/ do |file, content|
+  @config = file
+  File.open(file, 'w+') { |file| file.write(content) }
+end
+
+Given /^I have a "(.*?)" asset file on (.*?) with content:$/ do |name, folder, content|
+  File.open(File.join(folder, name), 'w+') { |file| file.write(content) }
 end
 
 When /^I run my application on the "(.*?)" environment$/ do |environment|
   ENV['RACK_ENV']= environment
-  eval @app_config
+  eval "load '#{@config}'"
 end
 
 When /^I query the configuration for "(.*?)"$/ do |query|

data/features/support/env.rb

@@ -2,4 +2,32 @@ $: << File.join(File.dirname(__FILE__), '..', '..', 'lib')
 
 require 'coconut'
 
-module MyApp; end
+CONFIG_FOLDER = '/tmp/coconut_config/'
+
+Before do
+  clean_tmp_folder
+  create_folder_for_testing
+  create_namespace_for_testing
+end
+
+After do
+  clean_tmp_folder
+  clean_namespace_for_testing
+end
+
+def create_namespace_for_testing
+  Object.send(:const_set, :MyApp, Module.new) 
+end
+
+def clean_namespace_for_testing
+  Object.send(:remove_const, :MyApp)
+end
+
+def clean_tmp_folder
+  `rm -rf #{CONFIG_FOLDER}` if File.directory?(CONFIG_FOLDER)
+  `rm -f /tmp/coconut.rb` if File.exists?('/tmp/coconut.rb')
+end
+
+def create_folder_for_testing
+  `mkdir #{CONFIG_FOLDER}`
+end

data/lib/coconut.rb

@@ -1,27 +1,27 @@
 require_relative 'coconut/version'
-require_relative 'coconut/config'
+require_relative 'coconut/dsl/application'
 
 module Coconut
-  def self.configure(namespace, &assets)
-    raise "#{namespace} already has a config method" if namespace.respond_to? :config
-    define_config_method namespace, Config.new(current_environment, &assets)
+  include Dsl
+
+  def self.configure(namespace, &config)
+    define_config_method namespace, Application.configure(environment, &config)
   end
 
-  def self.current_environment
+  def self.environment
+    return @__coconut_environment.() unless @__coconut_environment.nil?
     ENV['RACK_ENV'] || :development
   end
 
+  def self.take_environment_from(&block)
+    @__coconut_environment = block
+  end
+
   private
 
   def self.define_config_method(namespace, configuration)
-    singleton_class_of(namespace).instance_eval do
-      define_method :config do
-        @_coconut_configuration ||= configuration
-      end
+    namespace.singleton_class.instance_eval do
+      define_method(:config) { @__coconut_configuration ||= configuration }
     end
   end
-
-  def self.singleton_class_of(class_or_module)
-    class << class_or_module; self; end
-  end
 end

data/lib/coconut/config.rb

@@ -1,23 +1,53 @@
-require 'delegate'
-require 'hashie'
-require_relative 'asset'
-require_relative 'runner'
-
 module Coconut
-  class Config < DelegateClass(Hashie::Mash)
-    def initialize(current_environment, &assets_config)
-      super Hashie::Mash.new
-      run assets_config, current_environment
+  class Config
+    def initialize(properties)
+      @properties = properties
+      @config = config_from(properties)
+    end
+
+    # Coconut::Config objects will respond to methods if its name is
+    # equal to any of the configured properties. This method is redefined to
+    # 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)
+      property?(name) or super
+    end
+
+    # @return [Hash] a Hash representation of the configuration object
+    def to_hash
+      @properties.dup
     end
 
     private
 
-    def run(config, environment)
-      Runner.new run: config, method_missing: configure_asset_on(environment)
+    def 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
+      value
+    end
+
+    def method_missing(name, *args, &block)
+      if property?(name)
+        define_property_accessor(name)
+        return @config[name]
+      end
+      super
+    end
+
+    def property?(name)
+      @config.has_key?(name)
     end
 
-    def configure_asset_on(environment)
-      ->(name, *args, &config){ self[name] = Asset.new(environment, &config) }
+    def define_property_accessor(name)
+      singleton_class.instance_eval do
+        define_method(name) { @config[name] }
+      end
     end
   end
 end

data/lib/coconut/dsl/application.rb

@@ -0,0 +1,35 @@
+require_relative 'asset'
+require_relative 'asset_folder'
+
+module Coconut
+  module Dsl
+    class Application < BlankSlate
+      def self.configure(current_environment, &config)
+        new(current_environment).run(&config)
+      end
+
+      def initialize(current_environment)
+        @current_environment = current_environment
+      end
+
+      def run(&config)
+        @assets_config = {}
+        instance_eval &config
+        Config.new(@assets_config)
+      end
+
+      private
+
+      def asset_folder(path)
+        instance_eval AssetFolder.config_from(path, IGNORED_FILES)
+      end
+
+      def method_missing(asset, *args, &config)
+        ::Kernel::raise InvalidName, __taken_error_message(asset, 'asset name') if __taken?(asset)
+        @assets_config[asset] = Asset.configure(@current_environment, &config)
+      end
+
+      IGNORED_FILES = ['config.rb']
+    end
+  end
+end

data/lib/coconut/dsl/asset.rb

@@ -0,0 +1,40 @@
+require_relative '../config'
+require_relative './environment'
+
+module Coconut
+  module Dsl
+    class Asset
+      def self.configure(environment, &config)
+        new(environment).run(&config)
+      end
+
+      def initialize(current_environment)
+        @current_environment = current_environment
+      end
+
+      def run(&config)
+        @properties = {}
+        instance_eval &config
+        @properties
+      end
+
+      private
+
+      def environment(*environments, &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)
+      end
+
+      def __current?(environment)
+        @current_environment.to_sym == environment.to_sym
+      end
+    end
+  end
+end

data/lib/coconut/dsl/asset_folder.rb

@@ -0,0 +1,44 @@
+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
+        asset_files_in_folder.map { |file| content(file) }.join "\n"
+      end
+
+      private
+
+      def asset_files_in_folder
+        ruby_files_in_folder - @ignored_files
+      end
+
+      def ruby_files_in_folder
+        files_in_folder.select { |file| file.match /\.rb$/ }
+      end
+
+      def files_in_folder
+        folder.entries.map(&method(:path_to)).reject { |path| File.directory? path }
+      end
+
+      def folder
+        Dir.open(@path)
+      end
+
+      def content(file)
+        File.read(file)
+      end
+
+      def path_to(file)
+        File.expand_path(File.join(@path, file))
+      end
+    end
+  end
+end

data/lib/coconut/dsl/blank_slate.rb

@@ -0,0 +1,33 @@
+require_relative '../config'
+
+module Coconut
+  module Dsl
+    class InvalidName < Exception; end
+
+    class BlankSlate < BasicObject
+      def self.__forbidden_names
+        Config.instance_methods + PERMANENT_METHODS
+      end
+
+      private
+
+      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"
+      end
+
+      def self.inherited(subclass)
+        __eraseable_methods.each{ |method_name| undef_method method_name }
+      end
+
+      def self.__eraseable_methods
+        instance_methods - PERMANENT_METHODS
+      end
+
+      PERMANENT_METHODS = [:instance_eval, :__send__, :object_id, :__taken?, :__taken_error_message, :asset_folder]
+    end
+  end
+end

data/lib/coconut/dsl/environment.rb

@@ -0,0 +1,28 @@
+require_relative 'blank_slate'
+require_relative '../config'
+
+module Coconut
+  module Dsl
+    class Environment < BlankSlate
+      def self.configure(&config)
+        new.configure(&config)
+      end
+
+      def initialize
+        @properties = {}
+      end
+
+      def configure(&config)
+        instance_eval &config
+        @properties
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        ::Kernel::raise InvalidName, __taken_error_message(name, 'property name') if __taken?(name)
+        @properties[name] = args.first
+      end
+    end
+  end
+end

data/lib/coconut/version.rb

@@ -1,3 +1,3 @@
 module Coconut
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/coconut/coconut_spec.rb

@@ -2,7 +2,6 @@ require 'coconut'
 
 class  MyClass; end
 module MyModule; end
-module MyConfig; def self.config; end; end;
 
 describe Coconut do
   it 'defines a config method in the provided namespace' do
@@ -12,9 +11,28 @@ describe Coconut do
     MyModule.should respond_to(:config)
   end
 
-  it 'raises an error if the namespace already has a config method' do
-    expect { Coconut.configure(MyConfig, :asset){} }.to raise_error
+  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
-end
 
+  context 'finding out the environment' do
+    before { Coconut.instance_variable_set(:@__coconut_environment, nil) }
+
+    it 'uses the expression provided by the user if any' do
+      Coconut.take_environment_from { :somewhere }
+      Coconut.environment.should eq :somewhere
+    end
+
+    it 'uses the RACK_ENV environment variable by default' do
+      ENV['RACK_ENV'] = 'rack_env'
+      Coconut.environment.should eq 'rack_env'
+    end
 
+    it 'uses :development as environment if RACK_ENV is not defined' do
+      ENV['RACK_ENV'] = nil
+      Coconut.environment.should eq :development
+    end
+  end
+end

data/spec/coconut/config_spec.rb

@@ -1,34 +1,34 @@
 require 'coconut/config'
 
 describe Coconut::Config do
-  let(:asset_config) { Coconut::Asset }
+  subject           { described_class.new(application) }
+  let(:application) { Hash[twitter: properties] }
+  let(:properties)  { Hash[property: 'value', other: 'other'] }
 
-  it 'configures a series of assets' do
-    subject = described_class.new(:current) do
-      ftp {}
-      ssh {}
+  context 'newly created' do
+    it 'has no property methods' do
+      (subject.methods - Object.instance_methods).should eq [:to_hash]
     end
-    subject.should have_key 'ftp'
-    subject.should have_key 'ssh'
-  end
 
-  it 'runs the configuration of each asset' do
-    ftp_config = lambda {}
-    ssh_config = lambda {}
-    asset_config.should_receive(:new).with(:current, &ftp_config)
-    asset_config.should_receive(:new).with(:current, &ssh_config)
-    described_class.new(:current) do
-      ftp &ftp_config
-      ssh &ssh_config
+    it 'responds to every property' do
+      subject.should respond_to :twitter
     end
   end
 
-  it 'assets can have (almost) any name' do
-    subject = described_class.new(:current) do
-      __id__  {}
-      equal?  {}
-      inspect {}
+  context 'when a property is queried' 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
+      subject.methods.should_not include(:twitter)
+      subject.twitter
+      subject.methods.should include(:twitter)
     end
-    ['__id__', 'equal?', 'inspect'].each { |key| subject.should have_key(key) }
+  end
+
+  it 'can be transformed to a hash' do
+    subject.to_hash.should eq application
   end
 end

data/spec/coconut/dsl/application_spec.rb

@@ -0,0 +1,24 @@
+require 'coconut/dsl/application'
+
+describe Coconut::Dsl::Application do
+  it 'creates the config for every asset' do
+    config = described_class.new(:current).run do
+      asset { environment(:current) { property 'value' } }
+    end
+    config.asset.property.should eq 'value'
+  end
+
+  it "doesn't allow assets with colliding names" do
+    expect {
+      described_class.configure(:current) { to_s {} }
+    }.to raise_error Coconut::Dsl::InvalidName, /to_s/
+  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 }
+    config.asset.property.should eq 'value'
+  end
+end

data/spec/coconut/dsl/asset_spec.rb

@@ -0,0 +1,49 @@
+require 'coconut/dsl/asset'
+
+describe Coconut::Dsl::Asset do
+  it 'creates the asset config for the given environment' do
+    asset_config = described_class.configure(:current) do
+      environment(:other)   { property 'value in other' }
+      environment(:current) { property 'value in current' }
+    end
+    asset_config.fetch(:property).should eq 'value in current'
+  end
+
+  it 'can setup different environments at the same time' do
+    asset_config = described_class.configure(:current) do
+      environment(:other, :current) { property 'value in other and current' }
+    end
+    asset_config.fetch(:property).should eq 'value in other and current'
+  end
+
+  it 'can setup environments step by step' do
+    asset_config = described_class.configure(:current) do
+      environment(:other, :current) { property 'value in other and current' }
+      environment(:other)   { thing 'thing in other' }
+      environment(:current) { thing 'thing in current' }
+    end
+    asset_config.fetch(:property).should eq 'value in other and current'
+    asset_config.fetch(:thing).should eq 'thing in current'
+  end
+
+  it 'allows properties to be overriden' do
+    asset_config = described_class.configure(:current) do
+      environment(:other, :current) { property 'value in other and current' }
+      environment(:current) { property 'only in current' }
+    end
+    asset_config.fetch(:property).should eq 'only in current'
+  end
+
+  it 'has alternate ways of configuring an environment' do
+    asset_config = described_class.configure(:current) do
+      env(:current)          { property1 1 }
+      environment(:current)  { property2 2 }
+      environments(:current) { property3 3 }
+      envs(:current)         { property4 4 }
+    end
+    asset_config.fetch(:property1).should eq 1
+    asset_config.fetch(:property2).should eq 2
+    asset_config.fetch(:property3).should eq 3
+    asset_config.fetch(:property4).should eq 4
+  end
+end

data/spec/coconut/dsl/assets_folder_spec.rb

@@ -0,0 +1,36 @@
+require 'coconut/dsl/asset_folder'
+
+describe 'Assets configuration from files in folder', integration: true do
+  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}`
+    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 }
+  end
+
+  it 'evals every asset file in the folder as application config' do
+    configuration_from_folder.should eq "#{db_config}\n#{s3_config}"
+  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' }
+    end
+
+    it 'ignores non Ruby files' do
+      configuration_from_folder.should eq "#{db_config}\n#{s3_config}"
+    end
+  end
+
+  def configuration_from_folder
+    Coconut::Dsl::AssetFolder.config_from(path, ignored)
+  end
+end

data/spec/coconut/dsl/blank_slate_spec.rb

@@ -0,0 +1,9 @@
+require 'coconut/dsl/blank_slate'
+
+describe Coconut::Dsl::BlankSlate do
+  it 'knows the forbidden names' do
+    expected_names =  described_class::PERMANENT_METHODS + [:one]
+    Coconut::Config.stub(:instance_methods).and_return([:one])
+    described_class.__forbidden_names.should include(*expected_names)
+  end
+end

data/spec/coconut/dsl/environment_spec.rb

@@ -0,0 +1,49 @@
+require 'coconut/dsl/environment'
+
+describe Coconut::Dsl::Environment do
+  it 'creates an environment config' do
+    config = described_class.configure do
+      property 'value'
+      other    'other'
+    end
+    config.fetch(:property).should eq 'value'
+    config.fetch(:other).should eq 'other'
+  end
+
+  it "doesn't allow properties with colliding names" do
+    expect {
+      described_class.configure { object_id '11' }
+    }.to raise_error Coconut::Dsl::InvalidName, /object_id/
+  end
+
+  it 'can take procs as property values' do
+    config = described_class.configure do
+      property1 Proc.new { 'value' }
+      property2 -> { 'value' }
+      property3 Kernel::lambda { 'value' }
+    end
+    config.fetch(:property1).should be_a_kind_of Proc
+    config.fetch(:property2).should be_a_kind_of Proc
+    config.fetch(:property3).should be_a_kind_of Proc
+  end
+
+  it 'can take expressions as property values' do
+    config = described_class.configure do
+      property1 2 + 2
+      property2 'aeiou'[0..2]
+      property3 [:a, :e, :i, :o, :u].take(3)
+    end
+    config.fetch(:property1).should eq 4
+    config.fetch(:property2).should eq 'aei'
+    config.fetch(:property3).should eq [:a, :e, :i]
+  end
+
+  it 'can take constants and scoped method calls as property values' do
+    config = described_class.configure do
+      arguments Math::PI
+      encodings Encoding.list
+    end
+    config.fetch(:arguments).should eq Math::PI
+    config.fetch(:encodings).should eq Encoding.list
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coconut
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,17 +9,17 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-24 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -28,7 +28,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -44,7 +44,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -60,7 +60,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -88,20 +88,27 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- changelog.md
 - coconut.gemspec
+- features/folder_configuration.feature
 - features/single_file_configuration.feature
 - features/step_definitions/configuration_steps.rb
 - features/support/env.rb
 - lib/coconut.rb
-- lib/coconut/asset.rb
 - lib/coconut/config.rb
-- lib/coconut/environment.rb
-- lib/coconut/runner.rb
+- lib/coconut/dsl/application.rb
+- lib/coconut/dsl/asset.rb
+- lib/coconut/dsl/asset_folder.rb
+- lib/coconut/dsl/blank_slate.rb
+- lib/coconut/dsl/environment.rb
 - lib/coconut/version.rb
-- spec/coconut/asset_spec.rb
 - spec/coconut/coconut_spec.rb
 - spec/coconut/config_spec.rb
-- spec/coconut/environment_spec.rb
+- spec/coconut/dsl/application_spec.rb
+- spec/coconut/dsl/asset_spec.rb
+- spec/coconut/dsl/assets_folder_spec.rb
+- spec/coconut/dsl/blank_slate_spec.rb
+- spec/coconut/dsl/environment_spec.rb
 homepage: http://github.com/jacegu/coconut
 licenses: []
 post_install_message: 
@@ -116,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3927338585615885072
+      hash: -443559654264598590
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -125,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3927338585615885072
+      hash: -443559654264598590
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -134,10 +141,15 @@ specification_version: 3
 summary: Coconut is a simple DSL that allows you to easily write and query your application's
   configuration with pure Ruby.
 test_files:
+- features/folder_configuration.feature
 - features/single_file_configuration.feature
 - features/step_definitions/configuration_steps.rb
 - features/support/env.rb
-- spec/coconut/asset_spec.rb
 - spec/coconut/coconut_spec.rb
 - spec/coconut/config_spec.rb
-- spec/coconut/environment_spec.rb
+- spec/coconut/dsl/application_spec.rb
+- spec/coconut/dsl/asset_spec.rb
+- spec/coconut/dsl/assets_folder_spec.rb
+- spec/coconut/dsl/blank_slate_spec.rb
+- spec/coconut/dsl/environment_spec.rb
+has_rdoc: 

data/lib/coconut/asset.rb

@@ -1,27 +0,0 @@
-require 'delegate'
-require 'hashie'
-require_relative 'environment'
-
-module Coconut
-  class Asset < DelegateClass(Hashie::Mash)
-    def initialize(current_environment, &config)
-      super Hashie::Mash.new
-      run config, current_environment if block_given?
-    end
-
-    def environment(environment_name, &config)
-      merge! Environment.new(&config) if current? environment_name
-    end
-
-    private
-
-    def run(config, environment)
-      @current_environment = environment
-      instance_eval &config
-    end
-
-    def current?(environment)
-      environment.to_sym == @current_environment.to_sym
-    end
-  end
-end

data/lib/coconut/environment.rb

@@ -1,22 +0,0 @@
-require 'delegate'
-require 'hashie'
-require_relative 'runner'
-
-module Coconut
-  class Environment < DelegateClass(Hashie::Mash)
-    def initialize(&config)
-      super Hashie::Mash.new
-      run config
-    end
-
-    private
-
-    def run(config)
-      Runner.new run: config, method_missing: method(:configure_property)
-    end
-
-    def configure_property(name, values)
-      self[name] = values.first
-    end
-  end
-end

data/lib/coconut/runner.rb

@@ -1,28 +0,0 @@
-module Coconut
-  class BlankSlate < BasicObject
-    private
-
-    def self.inherited(subclass)
-      eraseable_methods.each{ |method_name| undef_method method_name }
-    end
-
-    def self.eraseable_methods
-      instance_methods - PERMANENT_METHODS
-    end
-
-    PERMANENT_METHODS = [:instance_eval, :__send__, :object_id]
-  end
-
-  class Runner < BlankSlate
-    def initialize(options)
-      @callback = options[:method_missing]
-      instance_eval &options[:run]
-    end
-
-    private
-
-    def method_missing(name, *args, &block)
-      @callback.(name, args, &block)
-    end
-  end
-end

data/spec/coconut/asset_spec.rb

@@ -1,12 +0,0 @@
-require 'coconut/asset'
-
-describe Coconut::Asset do
-  it "knows the asset's config on the current environment" do
-    subject = described_class.new(:current) do
-      environment(:other)   { property 'value on other'   }
-      environment(:current) { property 'value on current' }
-    end
-    subject.should have_key 'property'
-    subject.fetch('property').should eq 'value on current'
-  end
-end

data/spec/coconut/environment_spec.rb

@@ -1,21 +0,0 @@
-require 'hashie'
-require 'coconut/environment'
-
-describe Coconut::Environment do
-  it 'collects method calls as configuration values' do
-    config = described_class.new { property 'value' }
-    config.should have_key :property
-    config.property.should eq 'value'
-  end
-
-  it 'can have (almost) any property name' do
-    config = described_class.new do
-      __id__  11
-      equal?  33
-      inspect 'CoconutJuice'
-    end
-    config.fetch('__id__').should eq 11
-    config.fetch('equal?').should eq 33
-    config.fetch('inspect').should eq 'CoconutJuice'
-  end
-end