ecology 0.0.1 → 0.0.11

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in your gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    ecology (0.0.11)
+      multi_json
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    minitest (2.3.0)
+    mocha (0.9.12)
+    multi_json (1.0.3)
+    rake (0.9.2)
+    scope (0.2.1)
+      minitest
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.10)
+  ecology!
+  mocha
+  rake
+  scope (~> 0.2.1)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Ooyala, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+Ecology
+=======
+
+Ecology is a gem to handle configuration variables.  At Ooyala, we use
+it for setting application metadata about logging, monitoring,
+testing, deployment and other "outside the application"
+infrastructure.  So it's the application's ecology, right?
+
+Installing
+==========
+
+"gem install ecology" works pretty well.  You can also specify Ecology
+from a Gemfile if you're using Bundler.
+
+Ooyalans should make sure that "gems.sv2" is listed as a gem source in
+your Gemfile or on your gem command line.
+
+Finding Your Ecology
+====================
+
+By default an application called "bob.sh" will have an ecology file in
+the same directory called "bob.ecology".  Ecology just strips off the
+final file extension, replaces it with ".ecology", and looks there.
+
+You can also specify a different location in your Ecology.read call,
+or set the ECOLOGY_SPEC environment variable to a different location.
+
+An Ecology is a JSON file of roughly this structure:
+
+{
+  "application": "MyApp",
+  "environment-from": "RACK_ENV",
+  "logging": {
+    "default_component": "SplodgingLib",
+    "extra_json_fields": {
+      "app_group": "SuperSpiffyGroup",
+      "precedence": 7
+    },
+    "console_print": "off",
+    "filename": "/tmp/bobo.txt",
+    "stderr_level": "fatal"
+  },
+  "monitoring": {
+    "zookeeper-host": "zookeeper-dev.sv2"
+  }
+}
+
+Absolutely every part of it is optional, including the presence of the file at all.
+
+You can override the application name, as shown above.
+
+Paths
+=====
+
+If you have a configurable per-environment path, you probably want it in the "paths"
+section of your ecology.  For instance:
+
+{
+  "application": "SomeApp",
+  "paths": {
+    "pid_location": "/pid_dir/",
+    "app1_location": "$app/../dir1",
+    "app1_log_path": "$cwd/logs"
+  }
+}
+
+You can then access these paths with Ecology.path("app1_location") and
+similar.  In the paths, "$app" will be replaced by the directory the
+application is run from, "$cwd" will be replaced by the current
+working directory, "$env" will be replaced by the current environment,
+and "$pid" will be replaced by the current process ID.
+
+Reading Data
+============
+
+If your library is configured via Ecology, you'll likely want to read data
+from it.  For instance, let's look at the Termite logging library's method
+of configuration:
+
+{
+  "application": "SomeApp",
+  "logging": {
+    "level": "info",
+    "stderr_level": "warn",
+    "stdout_level": 4,
+    "file_path": "$app/../log_to",
+    "extra_json_fields": {
+      "app_tag": "splodging_apps",
+      "precedence": 9
+    }
+  }
+}
+
+Termite can read the level via Ecology.property("logging:level"), which will
+give it in whatever form it appears in the JSON.
+
+Ecology.property("logging:extra_json_fields") would be returned as a Hash.
+You can return it as a String, Symbol, Array, Fixnum or Hash by supplying
+the :as option:
+
+  Ecology.property("logging:info", :as => Symbol)  # :info
+  Ecology.property("logging:stdout_level", :as => String) # "4"
+  Ecology.property("logging:extra_json_fields", :as => Symbol) # error!
+  Ecology.property("logging:file_path", :as => :path) # "/home/theuser/sub/log_to"
+
+Environment-Specific Data
+=========================
+
+Often you'll want to supply a different path, hostname or other
+configuration variable depending on what environment you're
+currently deployed to - staging may want a different MemCacheD
+server than development, say.
+
+Here's another logging example:
+
+{
+  "application": "Ooyala Rails",
+  "environment-from": ["RAILS_ENV", "RACK_ENV"],
+  "logging": {
+    "console_out": {
+      "env:development": true,
+      "env:*": false
+    },
+    "stderr_level": {
+      "env:development": "fatal",
+      "env:production": "warn"
+    },
+    "stdout_level": "info"
+  }
+}
+
+In this case, data can be converted from a Hash into a Fixnum
+or String automatically:
+
+  Ecology.property("logging:stderr_level", :as => String)
+
+Ecology returns "fatal" or "warn" here, depending on the value
+of RAILS_ENV or RACK_ENV.
+
+Using Other Ecologies
+=====================
+
+The data in a given Ecology file can build on one or more
+other Ecology files.
+
+{
+  "application": "SomeApp",
+  "environment-from": [ "APP_ENV", "RACK_ENV" ],
+  "uses": [ "ecologies/logging.ecology", "ecologies/monitoring.ecology" ]
+}
+
+Each field will be overridden by the "latest" value -- the top-level
+Ecology overrides the Ecologies that it uses, and so on.  If multiple
+Ecologies are used, the earlier Ecologies in the list override the
+later Ecologies.
+
+This can be used to set up Ecology "modules" for common functionality,
+or to override certain settings in certain environments from a common
+base template.
+
+Events
+======
+
+You often want to set your ecology-related properties when the ecology
+is initialized, but no earlier.  You may not know exactly when the
+earliest call to Ecology.read will be.  In that case, you want to use
+the on_initialize event hook:
+
+Ecology.on_initialize do
+  @my_property = Ecology.property("my:property")
+end
+
+If the ecology was already initialized before you set the
+on_initialize hook, then the hook will run immediately.
+
+There is also an on_reset hook.  Read "Testing with an Ecology" to
+find out why you'd ever care about that.
+
+Testing with an Ecology
+=======================
+
+In production use, you'll probably never reset the ecology.  However,
+in testing you may frequently want to, especially if you're testing a
+library that ties closely into the ecology.
+
+There are two basic approaches your library can take, and they affect
+testing.
+
+Termite, our logging library, copies settings from the ecology into
+its instance.  Then, when you reset the ecology, you can also discard
+old logger objects with old settings.
+
+Glowworm, our feature flags library, is basically a big singleton and
+uses ecology data, so it needs to reset its internal state when the
+ecology is reset, and then re-read that state when the ecology is next
+initialized.
+
+Code for that for your library might look something like:
+
+MyLib.on_reset do
+  @myvar1 = nil
+  @myvar2 = nil
+end
+
+MyLib.on_initialize do
+  @myvar1 = Ecology.property("mylib:property1", :as => :string)
+  @myvar2 = Ecology.property("mylib:property2", :as => :path)
+end
+
+Hooks persist across resets.  That is, your on_reset hook will be
+called on every reset until you explicitly remove it.
+
+Releasing within Ooyala
+=======================
+
+Ooyalans, to release Ecology to gems.sv2, use the following:
+
+  gem build
+  rake _0.8.7_ -f ../ooyala_gems.rake gem:push ecology-0.0.1.gem
+
+Change the version to the actual version you'd like to push.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler"
+require "rake/testtask"
+
+require File.join(File.dirname(__FILE__), "lib", "ecology", "version")
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/**/*test.rb")
+  t.verbose = true
+end
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build ecology.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install ecology-#{Ecology::VERSION}"
+end

data/TODO

@@ -0,0 +1,5 @@
+* Use Erubis before evaluating
+
+* On Ecology.read calls, make sure ecology filename hasn't changed (and warn if it has)
+
+* Have Ecology.read try to do a read relative to the executable's directory first rather than relative to cwd.

data/ecology.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "ecology/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ecology"
+  s.version     = Ecology::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Noah Gibbs"]
+  s.email       = ["noah@ooyala.com"]
+  s.homepage    = "http://www.ooyala.com"
+  s.summary     = %q{Ruby config variable management}
+  s.description = <<EOS
+Ecology sets configuration data for an application based
+on environment variables and other factors.  It is meant
+to unify configuration data for logging, testing, monitoring
+and deployment.
+EOS
+
+  s.rubyforge_project = "ecology"
+
+  ignores = File.readlines(".gitignore").grep(/\S+/).map {|pattern| pattern.chomp }
+  dotfiles = Dir[".*"]
+  s.files = Dir["**/*"].reject {|f| File.directory?(f) || ignores.any? {|i| File.fnmatch(i, f) } } + dotfiles
+  s.test_files = s.files.grep(/^test\//)
+
+  s.require_paths = ["lib"]
+
+  s.add_dependency "multi_json"
+
+  s.add_development_dependency "bundler", "~> 1.0.10"
+  s.add_development_dependency "scope", "~> 0.2.1"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+end

data/ecology.gemspec~

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "ecology/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ecology"
+  s.version     = Ecology::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Noah Gibbs"]
+  s.email       = ["noah@ooyala.com"]
+  s.homepage    = "http://www.ooyala.com"
+  s.summary     = %q{Ruby config variable management}
+  s.description = <<EOS
+Ecology sets configuration data for an application based
+on environment variables and other factors.  It is meant
+to unify configuration data for logging, testing, monitoring
+and deployment.
+EOS
+
+  s.rubyforge_project = "ecology"
+
+  ignores = File.readlines(".gitignore").grep(/\S+/).map {|pattern| pattern.chomp }
+  dotfiles = [".gemtest", ".gitignore", ".rspec", ".yardopts"]
+  s.files = Dir["**/*"].reject {|f| File.directory?(f) || ignores.any? {|i| File.fnmatch(i, f) } } + dotfiles
+  s.test_files = s.files.grep(/^spec\//)
+
+  s.require_paths = ["lib"]
+
+  s.add_dependency "multi_json"
+
+  s.add_development_dependency "bundler", "~> 1.0.10"
+  s.add_development_dependency "scope", "~> 0.2.1"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+end

data/lib/ecology/version.rb

@@ -0,0 +1,3 @@
+module Ecology
+  VERSION = "0.0.11"
+end

data/lib/ecology/version.rb~

@@ -0,0 +1,3 @@
+module Ecology
+  VERSION = "0.0.10"
+end

data/lib/ecology.rb

@@ -0,0 +1,264 @@
+require "multi_json"
+require "thread"
+
+module Ecology
+  class << self
+    attr_reader :application
+    attr_reader :data
+    attr_reader :environment
+    attr_accessor :mutex
+  end
+
+  ECOLOGY_EXTENSION = ".ecology"
+
+  Ecology.mutex = Mutex.new
+
+  class << self
+    # Normally this is only for testing.
+    def reset
+      # Preserve triggers across resets by default
+      @triggers ||= {}
+
+      @application = nil
+      @environment = nil
+      @data = nil
+      @ecology_initialized = nil
+
+      publish_event :reset
+    end
+
+    def clear_triggers
+      @triggers = {}
+    end
+
+    def read(ecology_pathname = nil)
+      return if @ecology_initialized
+
+      should_publish_event = false
+
+      mutex.synchronize do
+        return if @ecology_initialized
+
+        file_path = ENV['ECOLOGY_SPEC'] || ecology_pathname || default_ecology_name
+        if File.exist?(file_path)
+          @data = {}
+          contents = merge_with_overrides(file_path)
+        end
+
+        @application ||= File.basename($0)
+        @environment ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development"
+
+        should_publish_event = true
+
+        @ecology_initialized = true
+      end
+
+      # Do this outside the mutex to reduce the likelihood
+      # of deadlocks.
+      publish_event(:initialize) if should_publish_event
+    end
+
+    def on_initialize(token = nil, &block)
+      on_event(:initialize, token, &block)
+    end
+
+    def on_reset(token = nil, &block)
+      on_event(:reset, token, &block)
+    end
+
+    def remove_trigger(token)
+      @triggers ||= {}
+      @triggers.each do |event, trigger_list|
+        @triggers[event].delete(token)
+      end
+    end
+
+    private
+
+    def on_event(event, token = nil, &block)
+      mutex.synchronize do
+        @token_offset ||= 0
+        token ||= "token#{@token_offset}"
+
+        @triggers ||= {}
+        @triggers[event] ||= {}
+        @triggers[event][token] = block
+
+        if event == :initialize && @ecology_initialized
+          block.call
+        end
+      end
+    end
+
+    def publish_event(event)
+      @triggers ||= {}
+
+      # This doesn't lock the mutex, because there's too high
+      # a chance of somebody calling Ecology.read or on_event
+      # or something while we're doing this.  That would
+      # deadlock, which is no good.
+      (@triggers[event] || {}).each do |token, event_block|
+        event_block.call
+      end
+    end
+
+    def merge_with_overrides(file_path)
+      contents = File.read(file_path)
+      file_data = MultiJson.decode(contents);
+
+      return unless file_data
+
+      # First, try to set @application and @environment from the file data
+
+      @application ||= file_data["application"]
+      @environment ||= file_data["environment"]
+
+      if !@environment && file_data["environment-from"]
+        from = file_data["environment-from"]
+        if from.respond_to?(:map)
+          @environment ||= from.map {|v| ENV[v]}.compact.first
+        else
+          @environment = ENV[from] ? ENV[from].to_s : nil
+        end
+      end
+
+      # Next, filter the data by the current environment
+      file_data = environmentize_data(file_data)
+
+      # Merge the file data into @data
+      @data = deep_merge(@data, file_data)
+
+      # Finally, process any inheritance/overrides
+      if file_data["uses"]
+        if file_data["uses"].respond_to?(:map)
+          file_data["uses"].map { |file| merge_with_overrides(file) }
+        else
+          merge_with_overrides(file_data["uses"])
+        end
+      end
+    end
+
+    def deep_merge(hash1, hash2)
+      all_keys = hash1.keys | hash2.keys
+      ret = {}
+
+      all_keys.each do |key|
+        if hash1.has_key?(key) && hash2.has_key?(key)
+          if hash1[key].is_a?(Hash) && hash2[key].is_a?(Hash)
+            ret[key] = deep_merge(hash1[key], hash2[key])
+          else
+            ret[key] = hash1[key]
+          end
+        elsif hash1.has_key?(key)
+          ret[key] = hash1[key]
+        else
+          ret[key] = hash2[key]
+        end
+      end
+
+      ret
+    end
+
+    def environmentize_data(data_in)
+      if data_in.is_a?(Array)
+        data_in.map { |subdata| environmentize_data(subdata) }
+      elsif data_in.is_a?(Hash)
+        if data_in.keys.any? { |k| k =~ /^env:/ }
+          value = data_in["env:#{@environment}"] || data_in["env:*"]
+          return nil unless value
+          environmentize_data(value)
+        else
+          data_out = {}
+          data_in.each { |k, v| data_out[k] = environmentize_data(v) }
+          data_out
+        end
+      else
+        data_in
+      end
+    end
+
+    public
+
+    def property(param, options = {})
+      components = param.split(":").compact.select {|s| s != ""}
+
+      value = components.inject(@data) do |data, component|
+        if data
+          data[component]
+        else
+          nil
+        end
+      end
+
+      return nil unless value
+      return value unless options[:as]
+
+      unless value.is_a?(Hash)
+        if [String, :string].include?(options[:as])
+          return value.to_s
+        elsif [Symbol, :symbol].include?(options[:as])
+          return value.to_s.to_sym
+        elsif [Fixnum, :int, :integer, :fixnum].include?(options[:as])
+          return value.to_i
+        elsif [Hash, :hash].include?(options[:as])
+          raise "Cannot convert scalar value to Hash!"
+        elsif [:path].include?(options[:as])
+          return string_to_path(value.to_s)
+        elsif [:json].include?(options[:as])
+          raise "JSON return type not yet supported!"
+        else
+          raise "Unknown type #{options[:as].inspect} passed to Ecology.data(:as) for property #{property}!"
+        end
+      end
+
+      return value if options[:as] == Hash
+      raise "Couldn't convert JSON fields to #{options[:as].inspect} for property #{property}!"
+    end
+
+    PATH_SUBSTITUTIONS = {
+      "$env" => proc { Ecology.environment },
+      "$cwd" => proc { Dir.getwd },
+      "$app" => proc { File.dirname($0) },
+      "$pid" => proc { Process.pid.to_s },
+    }
+
+    def path(path_name)
+      path_data = @data ? @data["paths"] : nil
+      return nil unless path_data && path_data[path_name]
+
+      string_to_path path_data[path_name]
+    end
+
+    private
+
+    def string_to_path(path)
+      PATH_SUBSTITUTIONS.each do |key, value|
+        path.gsub! key, value.call
+      end
+
+      path
+    end
+
+    public
+
+    def default_ecology_name(executable = $0)
+      suffix = File.extname(executable)
+      executable[0..(executable.length - 1 - suffix.size)] +
+        ECOLOGY_EXTENSION
+    end
+
+    # This is a convenience function because the Ruby
+    # thread API has no accessor for the thread ID,
+    # but includes it in "to_s" (buh?)
+    def thread_id(thread)
+      return "main" if thread == Thread.main
+
+      str = thread.to_s
+
+      match = nil
+      match  = str.match /(0x\d+)/
+      return nil unless match
+      match[1]
+    end
+  end
+end

data/test/ecology_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+require "thread"
+
+class EcologyTest < Scope::TestCase
+  context "with ecology" do
+    setup do
+      Ecology.reset
+    end
+
+    should "correctly determine default ecology names" do
+      assert_equal "/path/to/bob.txt.ecology", Ecology.default_ecology_name("/path/to/bob.txt.rb")
+      assert_equal "relative/path/to/app.ecology", Ecology.default_ecology_name("relative/path/to/app.rb")
+      assert_equal "/path/to/bob.ecology", Ecology.default_ecology_name("/path/to/bob.sh")
+      assert_equal "\\path\\to\\bob.ecology", Ecology.default_ecology_name("\\path\\to\\bob.EXE")
+    end
+
+    should "respect the ECOLOGY_SPEC environment variable" do
+      ENV['ECOLOGY_SPEC'] = '/tmp/bobo.txt'
+      File.expects(:exist?).with('/tmp/bobo.txt').returns(true)
+      File.expects(:read).with('/tmp/bobo.txt').returns('{ "application": "foo_app" }')
+      Ecology.read
+
+      assert_equal "foo_app", Ecology.application
+    end
+
+    should "recognize that this is the main thread" do
+      assert_equal "main", Ecology.thread_id(Thread.current)
+    end
+
+    should "work without an ECOLOGY_SPEC" do
+      $0 = "whatever_app.rb"
+
+      ENV['ECOLOGY_SPEC'] = nil
+      File.expects(:exist?).with("whatever_app.ecology").returns(false)
+
+      Ecology.read
+
+      assert_equal "whatever_app.rb", Ecology.application
+    end
+  end
+end

data/test/environment_test.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class EnvironmentTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  context "with environment-from in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "environment-from": ["SOME_ENV_VAR", "VAR2"]
+}
+ECOLOGY_CONTENTS
+
+      ENV["SOME_ENV_VAR"] = ENV["VAR2"] = nil
+    end
+
+    should "default to the development environment" do
+      Ecology.read
+      assert_equal "development", Ecology.environment
+    end
+
+    should "use the environment variables to determine environment" do
+      ENV["SOME_ENV_VAR"] = "staging"
+      Ecology.read
+      assert_equal "staging", Ecology.environment
+    end
+
+    should "use secondary environment variables when the primary isn't set" do
+      ENV["VAR2"] = "daily-staging"
+      Ecology.read
+      assert_equal "daily-staging", Ecology.environment
+    end
+
+    should "use primary environment variables in preference to secondary" do
+      ENV["SOME_ENV_VAR"] = "theatrical staging"
+      ENV["VAR2"] = "daily-staging"
+      Ecology.read
+      assert_equal "theatrical staging", Ecology.environment
+    end
+  end
+
+  context "with an environment override in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "environment": "not really staging",
+  "environment-from": "SOME_ENV_VAR"
+}
+ECOLOGY_CONTENTS
+    end
+
+    should "use the environment override" do
+      Ecology.read
+      assert_equal "not really staging", Ecology.environment
+    end
+  end
+
+  context "with a single environment-from in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "environment-from": "SOME_ENV_VAR"
+}
+ECOLOGY_CONTENTS
+    end
+
+    should "use the environment override" do
+      ENV['SOME_ENV_VAR'] = "bob's pants"
+      Ecology.read
+      assert_equal "bob's pants", Ecology.environment
+    end
+  end
+end

data/test/environment_var_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class EnvironmentVarTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  context "with environments in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "environment-from": ["RACK_ENV"],
+  "domain": {
+    "property1" : {
+      "env:staging": "value1",
+      "env:development": "value2",
+      "env:*": "value3"
+    }
+  }
+}
+ECOLOGY_CONTENTS
+
+      ENV["RACK_ENV"] = nil
+    end
+
+    should "select the right environment value for a property" do
+      ENV["RACK_ENV"] = "staging"
+      Ecology.read
+      assert_equal "value1", Ecology.property("domain::property1", :as => String)
+    end
+
+  end
+end

data/test/override_properties_test.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class OverridePropertiesTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  context "with environment-from in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_GRANDPARENT1_CONTENTS, "grandparent1.ecology"
+{
+  "testing": {
+    "capabilities": [ "rails", "rvm" ],
+    "othertag": 9
+  },
+  "monitoring": {
+    "property9": 71
+  }
+}
+ECOLOGY_GRANDPARENT1_CONTENTS
+
+      set_up_ecology <<ECOLOGY_GRANDPARENT2_CONTENTS, "grandparent2.ecology"
+{
+  "monitoring": {
+    "property3": 7,
+    "property9": 134
+  }
+}
+ECOLOGY_GRANDPARENT2_CONTENTS
+
+      set_up_ecology <<ECOLOGY_PARENT_CONTENTS, "parent.ecology"
+{
+  "uses": ["grandparent1.ecology", "grandparent2.ecology"],
+  "logging": {
+    "property1": "foo"
+  },
+  "monitoring": {
+    "property1": "burgers",
+    "property2": "bar",
+    "property3": "quux"
+  }
+}
+ECOLOGY_PARENT_CONTENTS
+
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "uses": "parent.ecology",
+  "monitoring": {
+    "property2": "baz"
+  }
+}
+ECOLOGY_CONTENTS
+      Ecology.read
+    end
+
+    should "get overridden properties correctly" do
+      assert_equal "baz", Ecology.property("monitoring::property2")
+    end
+
+    should "get inherited properties correctly" do
+      assert_equal "foo", Ecology.property("logging::property1")
+    end
+
+    should "get properties in an overridden hash" do
+      assert_equal "burgers", Ecology.property("monitoring::property1")
+    end
+
+    should "get grandparent properties" do
+      assert_equal 9, Ecology.property("testing::othertag")
+    end
+
+    should "have first parent override second parent properties" do
+      assert_equal 71, Ecology.property("monitoring::property9")
+    end
+  end
+end

data/test/path_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class PathTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  context "with paths in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "paths": {
+    "pid_location": "/pid_dir/",
+    "whozit_location": "$app/../dir1",
+    "whatsit_path": "$cwd/logs",
+    "some_other_location": "dir/to/there.$pid"
+  }
+}
+ECOLOGY_CONTENTS
+      Ecology.read
+    end
+
+    should "find an absolute path" do
+      assert_equal "/pid_dir/", Ecology.path("pid_location")
+    end
+
+    should "find an application-relative path" do
+      $0 = "some/path/my_app.rb"
+      assert_equal "some/path/../dir1", Ecology.path("whozit_location")
+    end
+
+    should "find a cwd-relative path" do
+      Dir.expects(:getwd).returns("some/path")
+      assert_equal "some/path/logs", Ecology.path("whatsit_path")
+    end
+
+    should "substitute correctly for a PID path" do
+      Process.expects(:pid).returns(379)
+      assert_equal "dir/to/there.379", Ecology.path("some_other_location")
+    end
+  end
+
+end

data/test/property_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class PropertyTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  context "with environments in your ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp",
+  "environment-from": ["RACK_ENV"],
+  "domain": {
+    "property1" : "strval1",
+    "property2" : "374",
+    "property3" : 1987
+  }
+}
+ECOLOGY_CONTENTS
+      Ecology.read
+    end
+
+    should "get a top-level property" do
+      assert_equal "SomeApp", Ecology.property("application")
+    end
+
+    should "get a string property without a typecast" do
+      assert_equal "strval1", Ecology.property("domain::property1")
+    end
+
+    should "get a string property with a typecast" do
+      assert_equal "strval1", Ecology.property("domain::property1", :as => String)
+    end
+
+    should "get a string-number property with a String typecast" do
+      assert_equal "374", Ecology.property("domain::property2", :as => String)
+    end
+
+    should "get a string-number property with a Fixnum typecast" do
+      assert_equal 374, Ecology.property("domain::property2", :as => Fixnum)
+    end
+
+    should "get a string-number property with no typecast" do
+      assert_equal "374", Ecology.property("domain::property2")
+    end
+
+    should "get an integer property with a String typecast" do
+      assert_equal "1987", Ecology.property("domain::property3", :as => String)
+    end
+
+    should "get an integer property with a Fixnum typecast" do
+      assert_equal 1987, Ecology.property("domain::property3", :as => Fixnum)
+    end
+
+    should "get an integer property with no typecast" do
+      assert_equal 1987, Ecology.property("domain::property3")
+    end
+
+    should "be able to use :integer for a Fixnum typecast" do
+      assert_equal 374, Ecology.property("domain::property2", :as => :integer)
+    end
+
+    should "be able to use :int for a Fixnum typecast" do
+      assert_equal 374, Ecology.property("domain::property2", :as => :int)
+    end
+
+    should "be able to use :string for a String typecast" do
+      assert_equal "1987", Ecology.property("domain::property3", :as => :string)
+    end
+
+    should "be able to use :symbol for a Symbol typecast" do
+      assert_equal "1987".to_sym, Ecology.property("domain::property3", :as => :symbol)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :development)
+require "minitest/autorun"
+
+# For testing Ecology itself, use the local version *first*.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "ecology"
+
+class Scope::TestCase
+  def set_up_ecology(file_contents, filename = "some.ecology")
+    ENV["ECOLOGY_SPEC"] = filename
+    File.stubs(:exist?).with(filename).returns(true)
+    File.expects(:read).with(filename).returns(file_contents).at_least_once
+  end
+
+end

data/test/trigger_test.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class EnvironmentTest < Scope::TestCase
+  setup do
+    Ecology.reset
+  end
+
+  teardown do
+    Ecology.clear_triggers
+  end
+
+  context "without an ecology" do
+    should "call on_initialize events at initialize" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method)
+
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+      Ecology.read
+    end
+
+    should "call on_initialize events when called after initialize" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method)
+
+      Ecology.read
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+    end
+
+    should "call on_initialize events with no token" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method)
+
+      Ecology.read
+      Ecology.on_initialize { callee_mock.method }      
+    end
+  end
+
+  context "with an ecology" do
+    setup do
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "SomeApp"
+}
+ECOLOGY_CONTENTS
+    end
+
+    should "call on_initialize events at initialize" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method)
+
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+      Ecology.read
+    end
+
+    should "call on_initialize events when called after initialize" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method)
+
+      Ecology.read
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+    end
+
+    should "call on_initialize events again after reset" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).twice
+
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+      Ecology.read
+      Ecology.reset
+      Ecology.read
+    end
+
+    should "call tokenless on_initialize events again after reset" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).twice
+
+      Ecology.on_initialize { callee_mock.method }
+      Ecology.read
+      Ecology.reset
+      Ecology.read
+    end
+
+    should "call on_reset events across multiple resets" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).twice
+
+      Ecology.read
+      Ecology.on_reset("test_on_reset") { callee_mock.method }
+      Ecology.reset
+      Ecology.reset
+    end
+
+    should "call on_reset events with no token across multiple resets" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).twice
+
+      Ecology.read
+      Ecology.on_reset { callee_mock.method }
+      Ecology.reset
+      Ecology.reset
+    end
+
+    should "remove on_reset events after remove_trigger" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).once  # Not three times...
+
+      Ecology.read
+      Ecology.on_reset("on_reset_remove") { callee_mock.method }
+      Ecology.reset
+      Ecology.remove_trigger("on_reset_remove")
+      Ecology.reset
+      Ecology.reset
+    end
+
+    should "repeat on_initialize events even when called after initialize" do
+      callee_mock = mock("object that gets called")
+      callee_mock.expects(:method).twice
+
+      Ecology.read
+      Ecology.on_initialize("test_on_init") { callee_mock.method }
+      Ecology.reset
+      Ecology.read
+    end
+
+  end
+
+end

metadata

@@ -1,45 +1,140 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: ecology
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.11
 platform: ruby
-authors:
-- Caleb Spare
+authors: 
+- Noah Gibbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-23 00:00:00.000000000Z
-dependencies: []
-description: ecology
-email:
-- caleb@ooyala.com
+
+date: 2011-10-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.10
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: scope
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: |
+  Ecology sets configuration data for an application based
+  on environment variables and other factors.  It is meant
+  to unify configuration data for logging, testing, monitoring
+  and deployment.
+
+email: 
+- noah@ooyala.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files: []
-homepage: ''
+
+files: 
+- ecology.gemspec
+- ecology.gemspec~
+- Gemfile
+- Gemfile.lock
+- lib/ecology/version.rb
+- lib/ecology/version.rb~
+- lib/ecology.rb
+- LICENSE
+- Rakefile
+- README.md
+- test/ecology_test.rb
+- test/environment_test.rb
+- test/environment_var_test.rb
+- test/override_properties_test.rb
+- test/path_test.rb
+- test/property_test.rb
+- test/test_helper.rb
+- test/trigger_test.rb
+- TODO
+- .gitignore
+homepage: http://www.ooyala.com
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: ecology
-rubygems_version: 1.8.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: ecology
-test_files: []
+summary: Ruby config variable management
+test_files: 
+- test/ecology_test.rb
+- test/environment_test.rb
+- test/environment_var_test.rb
+- test/override_properties_test.rb
+- test/path_test.rb
+- test/property_test.rb
+- test/test_helper.rb
+- test/trigger_test.rb