greased-rails 0.0.8 → 0.0.9

data/README.md

@@ -20,12 +20,25 @@ Or install it yourself as:
 
 ## Usage
 
-There are two configuration files you can create (optional):
+There are four OPTIONAL configuration files you can create:
 
+ * greased.yml (options for applying settings to environment)
  * greased_settings.yml (serialized application settings)
+ * greased_partial.yml (serialized application settings that override greased_settings.yml)
  * greased_variables.yml (serialized ENV variables)
 
-You can see what they look like in the "templates" folder.
+All YAML files support ERB. You can see what they look like in the "templates" folder.
+
+### Options - greased.yml
+
+This is a YAML serialization of options defining environment and where files are located.
+
+If you don't create your own file, Greased will use the file in the "templates" folder of this gem. To specify your own settings, save your file to one of the following locations:
+
+    * greased.yml (in the root of your Rails application)
+    * greased/greased.yml
+    * config/greased.yml
+    * config/greased/greased.yml
 
 ### Application Settings - greased_settings.yml
 

data/lib/greased/applicator.rb

@@ -5,68 +5,11 @@ require 'active_support/core_ext/hash/deep_merge'
 module Greased
   class Applicator
     
-    # settings applied to application environment
-    APP_SETTINGS_FILENAME_BASE  = "settings.yml"
-    APP_SETTINGS_FILENAME       = "greased_#{APP_SETTINGS_FILENAME_BASE}"
-    # additional settings applied to application environment 
-    # after default Greased (template) settings are applied 
-    # or custom settings file is applied.
-    APP_PATCH_FILENAME_BASE     = "partial.yml"
-    APP_PATCH_FILENAME          = "greased_#{APP_PATCH_FILENAME_BASE}"
-    # environment variables to load into ENV
-    ENV_VARS_FILENAME_BASE      = "variables.yml"
-    ENV_VARS_FILENAME           = "greased_#{ENV_VARS_FILENAME_BASE}"
-    # default Greased template with application settings
-    DEFAULT_SETTINGS_FILE       = Pathname.new(File.join(File.dirname(__FILE__), '..', '..', 'templates', APP_SETTINGS_FILENAME)).realpath
-    DEFAULT_ENV                 = "development"
-    
-    def self.default_options
-      {
-        :app => nil,
-        :env => ENV['RAILS_ENV'] || ENV['RACK_ENV'] || DEFAULT_ENV,
-        :groups => ["application"],
-        :app_filename => DEFAULT_SETTINGS_FILE,
-        #:env_filename => [],
-        :skip_erb => false
-      }
-    end
-    
-    def self.rails_options
-      if defined? ::Rails
-        default_options.merge(
-          :app => ::Rails.application,
-          #:env => ::Rails.env || DEFAULT_ENV,
-          #:groups => ["application"],
-          :app_filename => [
-            File.join(::Rails.root, APP_SETTINGS_FILENAME), 
-            File.join(::Rails.root, "greased", APP_SETTINGS_FILENAME_BASE),
-            File.join(::Rails.root, "config", APP_SETTINGS_FILENAME), 
-            File.join(::Rails.root, "config", "greased", APP_SETTINGS_FILENAME_BASE),
-            DEFAULT_SETTINGS_FILE
-          ],
-          :partial_filename => [
-            File.join(::Rails.root, APP_PATCH_FILENAME), 
-            File.join(::Rails.root, "greased", APP_PATCH_FILENAME_BASE),
-            File.join(::Rails.root, "config", APP_PATCH_FILENAME), 
-            File.join(::Rails.root, "config", "greased", APP_PATCH_FILENAME_BASE)
-          ],
-          :env_filename => [
-            File.join(::Rails.root, ENV_VARS_FILENAME),
-            File.join(::Rails.root, "greased", ENV_VARS_FILENAME_BASE),
-            File.join(::Rails.root, "config", ENV_VARS_FILENAME),
-            File.join(::Rails.root, "config", "greased", ENV_VARS_FILENAME_BASE)
-          ]
-        )
-      else
-        default_options
-      end
-    end
-    
     attr_accessor :app, :env, :groups
     
-    def initialize(options)
-      @options  = self.class.default_options.merge(options)
-      @app      = @options[:app]
+    def initialize(application, options = {})
+      @options  = Options.defaults.merge(options)
+      @app      = application#@options[:app]
       @env      = @options[:env]
       @groups   = @options[:groups]
     end
@@ -82,16 +25,12 @@ module Greased
       self
     end
     
-    def puts_env(options = {})
-      puts(*list_env(options))
-    end
-    
     def list_env(options = {})
       variables(options).collect{|key, value| "#{key}=#{value}"}
     end
     
-    def save_env_file(environment, filename = nil)
-      filename ||= File.join(::Rails.root, "#{environment}.env")
+    def save_env_file(path, environment, filename = nil)
+      filename ||= Greased.file_path(path, "#{environment}.env")
       
       File.open(filename, 'w') do |file|
         list_env(:env => environment).each{|line| file.puts line }
@@ -123,21 +62,12 @@ module Greased
     protected
     
     def load_settings(filename, options = {})
-      # allow multiple filenames and use the first one that exists
-      filename = Array.wrap(filename).find{|path| File.exists?(path)}
+      all       = Greased.load_yaml(filename, options)
+      defaults  = all.delete('defaults') || {}
       
-      unless filename.nil?
-        source  = File.read(filename)
-        source  = ERB.new(source).result unless options[:skip_erb]
-        all     = YAML.load(source)
-        defaults = all.delete('defaults') || {}
-        
-        all.each do |environment, settings|
-          all[environment] = defaults.deep_merge(settings)
-        end
+      all.each do |environment, settings|
+        all[environment] = defaults.deep_merge(settings)
       end
-      
-      all || {}
     end
     
   end

data/lib/greased/loggable.rb

@@ -0,0 +1,72 @@
+# 
+# Taken from Mongoid 4/2/2013
+# https://github.com/mongoid/mongoid/blob/master/lib/mongoid/loggable.rb
+# 
+
+module Greased
+  # Contains logging behaviour.
+  module Loggable
+
+    # Get the logger.
+    #
+    # @note Will try to grab Rails' logger first before creating a new logger
+    #   with stdout.
+    #
+    # @example Get the logger.
+    #   Loggable.logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 3.0.0
+    def logger
+      return @logger if defined?(@logger)
+      @logger = rails_logger || default_logger
+    end
+
+    # Set the logger.
+    #
+    # @example Set the logger.
+    #   Loggable.logger = Logger.new($stdout)
+    #
+    # @param [ Logger ] The logger to set.
+    #
+    # @return [ Logger ] The new logger.
+    #
+    # @since 3.0.0
+    def logger=(logger)
+      @logger = logger
+    end
+
+    private
+
+    # Gets the default Mongoid logger - stdout.
+    #
+    # @api private
+    #
+    # @example Get the default logger.
+    #   Loggable.default_logger
+    #
+    # @return [ Logger ] The default logger.
+    #
+    # @since 3.0.0
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    # Get the Rails logger if it's defined.
+    #
+    # @api private
+    #
+    # @example Get Rails' logger.
+    #   Loggable.rails_logger
+    #
+    # @return [ Logger ] The Rails logger.
+    #
+    # @since 3.0.0
+    def rails_logger
+      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+  end
+end

data/lib/greased/method_caller.rb

@@ -0,0 +1,43 @@
+module Greased
+  class MethodCaller
+    
+    def initialize(operator = nil, options = {})
+      @operator = operator
+      @evaluations = []
+      
+      if @operator.nil?
+        @evaluations << :default              
+      elsif @operator == "="
+        @evaluations << :assign
+      else
+        @evaluations << :evaluate
+      end
+      
+      if options[:reassign]
+        @evaluations << :assign
+      end
+    end
+    
+    def call(target, name, value)
+      @evaluations.inject(value) do |result, evaluator|
+        send(evaluator, target, name, result)
+      end
+    end
+    
+    protected
+    
+    def evaluate(target, name, value)
+      target.send(name.to_sym).send(@operator.to_sym, value)
+    end
+    
+    def assign(target, name, value)
+      target.send(:"#{name}=", value)
+    end
+    
+    def default(target, name, value)
+      value = [value] unless value.is_a? Array
+      target.send(name.to_sym, *value)
+    end
+    
+  end
+end

data/lib/greased/options.rb

@@ -0,0 +1,106 @@
+require 'delegate'
+require 'pathname'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/keys'
+
+module Greased
+  class Options
+    
+    # settings applied to application environment
+    APP_SETTINGS_FILENAME_BASE  = "settings.yml"
+    APP_SETTINGS_FILENAME       = "greased_#{APP_SETTINGS_FILENAME_BASE}"
+    # additional settings applied to application environment 
+    # after default Greased (template) settings are applied 
+    # or custom settings file is applied.
+    APP_PATCH_FILENAME_BASE     = "partial.yml"
+    APP_PATCH_FILENAME          = "greased_#{APP_PATCH_FILENAME_BASE}"
+    # environment variables to load into ENV
+    ENV_VARS_FILENAME_BASE      = "variables.yml"
+    ENV_VARS_FILENAME           = "greased_#{ENV_VARS_FILENAME_BASE}"
+    # options to load from YAML
+    OPTIONS_FILENAME            = "greased.yml"
+    DEFAULT_OPTIONS_FILE        = Greased.file_path(File.dirname(__FILE__), '..', '..', 'templates', OPTIONS_FILENAME)
+    # default Greased template with application settings
+    DEFAULT_SETTINGS_FILE       = Greased.file_path(File.dirname(__FILE__), '..', '..', 'templates', APP_SETTINGS_FILENAME)
+    DEFAULT_ENV                 = "development"
+    
+    class << self
+      
+      def defaults
+        load_options(DEFAULT_OPTIONS_FILE).deep_merge!(:app_filename => DEFAULT_SETTINGS_FILE)
+      end
+      
+      def find(path)
+        #Greased.logger.debug "Find application options in: #{path}"
+        
+        options = defaults
+        
+        if Dir.exists? path
+          # load rails defaults
+          options = merge_options options, {
+            #:env => ::Rails.env || DEFAULT_ENV,
+            #:groups => ["application"],
+            :app_filename => [
+              Greased.file_path(path, APP_SETTINGS_FILENAME), 
+              Greased.file_path(path, "greased", APP_SETTINGS_FILENAME_BASE),
+              Greased.file_path(path, "config", APP_SETTINGS_FILENAME), 
+              Greased.file_path(path, "config", "greased", APP_SETTINGS_FILENAME_BASE),
+              DEFAULT_SETTINGS_FILE
+            ],
+            :partial_filename => [
+              Greased.file_path(path, APP_PATCH_FILENAME), 
+              Greased.file_path(path, "greased", APP_PATCH_FILENAME_BASE),
+              Greased.file_path(path, "config", APP_PATCH_FILENAME), 
+              Greased.file_path(path, "config", "greased", APP_PATCH_FILENAME_BASE)
+            ],
+            :env_filename => [
+              Greased.file_path(path, ENV_VARS_FILENAME),
+              Greased.file_path(path, "greased", ENV_VARS_FILENAME_BASE),
+              Greased.file_path(path, "config", ENV_VARS_FILENAME),
+              Greased.file_path(path, "config", "greased", ENV_VARS_FILENAME_BASE)
+            ]
+          },
+          # load custom options
+          load_options([
+            Greased.file_path(path, OPTIONS_FILENAME), 
+            Greased.file_path(path, "greased", OPTIONS_FILENAME),
+            Greased.file_path(path, "config", OPTIONS_FILENAME), 
+            Greased.file_path(path, "config", "greased", OPTIONS_FILENAME)
+          ])
+        end
+        
+        options
+      end
+      
+      protected
+      
+      def load_options(filename)
+        #Greased.logger.debug "Loading options from: #{filename}"
+        
+        merge_options Greased.load_yaml(filename)
+      end
+      
+      def merge_options(*options)
+        options.inject({}) do |all, one|
+          all.deep_merge deep_symbolize_keys(one)
+        end
+      end
+      
+      private
+      
+      def deep_symbolize_keys(object)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = deep_symbolize_keys(value)
+          end
+        when Array
+          object.map {|e| deep_symbolize_keys(e) }
+        else
+          object
+        end
+      end
+      
+    end
+  end
+end

data/lib/greased/rails/engine.rb

@@ -5,6 +5,8 @@ module Greased
   module Rails
     class Engine < ::Rails::Engine
       
+      Greased.logger.level = Logger::DEBUG if ::Rails.env.development?
+      
       rake_tasks do
         path = Pathname.new(File.join(File.dirname(__FILE__), '../../../tasks/')).realpath
         
@@ -24,8 +26,8 @@ module Greased
       #:load_environment_hook
       config.before_configuration do |application|
         
-        options     = Applicator.rails_options.merge(:app => application)
-        applicator  = Applicator.new(options)
+        options     = Options.find(::Rails.root)
+        applicator  = Applicator.new(application, options)
         variables   = applicator.variables.except("RACK_ENV", "RAILS_ENV")
         
         variables.each do |key, value|
@@ -33,34 +35,51 @@ module Greased
         end
         
         if ::Rails.env.development?
-          puts ""
-          puts "############################## GREASED ##############################"
-          puts "#                                                                   #"
-          puts "#               ... loading application settings ...                #"
-          puts "#                                                                   #"
-          puts "#####################################################################"
-          puts ""
+          
+          Greased.logger.debug " "
+          Greased.logger.debug "## GREASED [#{applicator.env.upcase}] #{'#' * (55 - applicator.env.size)}"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#                      ... loaded options ...                       #"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
+          
+          pp options
+          
+          Greased.logger.debug " "
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
+          
+          ##########################
+          
+          Greased.logger.debug " "
+          Greased.logger.debug "## GREASED [#{applicator.env.upcase}] #{'#' * (55 - applicator.env.size)}"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#              ... loading environment variables ...                #"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
           
           applicator.list_env.map.collect do |var|
-            puts "   #{var}"
+            Greased.logger.debug "   #{var}"
           end
           
-          puts ""
-          puts "#####################################################################"
-          puts ""
+          Greased.logger.debug " "
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
         end
         
       end
       
-      # config.before_configuration {|app| puts "BEFORE CONFIGURATION"}
+      # config.before_configuration {|app| Greased.logger.debug "BEFORE CONFIGURATION"}
 #       
-      # config.before_initialize {|app| puts "BEFORE INITIALIZE"}
+      # config.before_initialize {|app| Greased.logger.debug "BEFORE INITIALIZE"}
 #       
-      # config.to_prepare {|app| puts "TO PREPARE"}
+      # config.to_prepare {|app| Greased.logger.debug "TO PREPARE"}
 #       
-      # config.before_eager_load {|app| puts "BEFORE EAGER LOAD"}
+      # config.before_eager_load {|app| Greased.logger.debug "BEFORE EAGER LOAD"}
 #       
-      # config.after_initialize {|app| puts "AFTER INITIALIZE"}
+      # config.after_initialize {|app| Greased.logger.debug "AFTER INITIALIZE"}
 #       
       # hooks = [
         # :load_environment_hook, :load_active_support, :preload_frameworks, :initialize_logger, :initialize_cache, :set_clear_dependencies_hook,
@@ -71,34 +90,34 @@ module Greased
       # ]
 #       
       # hooks.each do |hook_name|
-        # initializer("greased.before.#{hook_name}", :before => hook_name, :group => :all) {|a| puts "BEFORE #{hook_name}".upcase}
+        # initializer("greased.before.#{hook_name}", :before => hook_name, :group => :all) {|a| Greased.logger.debug "BEFORE #{hook_name}".upcase}
       # end
       
       # RUNS BEFORE ENVIRONMENT CONFIGS ARE LOADED!
       #app.config.before_initialize
       config.before_configuration do |application|
         
-        options     = Applicator.rails_options.merge(:app => application)
-        applicator  = Applicator.new(options)
+        options     = Options.find(::Rails.root)
+        applicator  = Applicator.new(application, options)
         
         applicator.settings.apply!
         
         if ::Rails.env.development?
-          puts ""
-          puts "############################## GREASED ##############################"
-          puts "#                                                                   #"
-          puts "#               ... loading application settings ...                #"
-          puts "#                                                                   #"
-          puts "#####################################################################"
-          puts ""
+          Greased.logger.debug " "
+          Greased.logger.debug "## GREASED [#{applicator.env.upcase}] #{'#' * (55 - applicator.env.size)}"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#               ... loading application settings ...                #"
+          Greased.logger.debug "#                                                                   #"
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
           
           applicator.settings.list.map(&:strip).map{|setting| setting.split("\n")}.flatten.each do |line|
-            puts "   #{line}"
+            Greased.logger.debug "   #{line}"
           end
           
-          puts ""
-          puts "#####################################################################"
-          puts ""
+          Greased.logger.debug " "
+          Greased.logger.debug "#####################################################################"
+          Greased.logger.debug " "
         end
         
       end

data/lib/greased/rails/version.rb

@@ -1,5 +1,5 @@
 module Greased
   module Rails
-    VERSION = "0.0.8"
+    VERSION = "0.0.9"
   end
 end

data/lib/greased/setting.rb

@@ -1,18 +1,15 @@
 
 module Greased
   class Setting
-    
     DEFAULT_OPERATOR = "="
     OPERATIONS = {
-      "<<"    => lambda{ |target, name, value| target.send(:"#{name}<<", value) },
-      "+="    => lambda{ |target, name, value| target.send(:"#{name}=", target.send(:"#{name}") + value) },
-      "-="    => lambda{ |target, name, value| target.send(:"#{name}=", target.send(:"#{name}") - value) },
-      "*="    => lambda{ |target, name, value| target.send(:"#{name}=", target.send(:"#{name}") * value) },
-      "="     => lambda{ |target, name, value| target.send(:"#{name}=", value) },
-      "send"  => lambda{ |target, name, value| target.send(name.to_sym, *value) }
-    }
-    OPERATION_VALIDATORS = {
-      "send" => lambda{|target, name, value| raise "Value for the 'send' operator must be an array of method parameters" unless value.is_a? Array }
+      "<<"    => MethodCaller.new("<<"),
+      "+="    => MethodCaller.new("+", :reassign => true),
+      "-="    => MethodCaller.new("-", :reassign => true),
+      "*="    => MethodCaller.new("*", :reassign => true),
+      "="     => MethodCaller.new("="),
+      "call"  => MethodCaller.new,
+      "send"  => MethodCaller.new
     }
     
     attr_reader :name, :value, :operator, :app, :env
@@ -33,8 +30,7 @@ module Greased
     end
     
     def apply!
-      raise "Unknown operator (#{operator}) for setting option: #{name}"  unless OPERATIONS.keys.include? operator
-      OPERATION_VALIDATORS[operator].call(@target, name, value)           if OPERATION_VALIDATORS.keys.include? operator
+      raise "Unknown operator (#{operator}) for setting option: #{name}" unless OPERATIONS.keys.include? operator
       OPERATIONS[operator].call(@target, name, value)
       
       self

data/lib/greased/settings.rb

@@ -12,21 +12,16 @@ module Greased
       refresh_settings!
     end
     
-    def serialize
-      @settings.collect(&:serialize).join("\n")
-    end
-    
     def apply!
-      @settings.each(&:apply!)
-      self
+      each(&:apply!)
     end
     
-    def puts!
-      puts(*list)
+    def list
+      @settings.map(&:serialize)
     end
     
-    def list
-      @settings.collect(&:serialize)
+    def serialize
+      list.join("\n")
     end
     
     def each(&block)
@@ -37,7 +32,7 @@ module Greased
     protected
     
     def refresh_settings!
-      @settings = @config.collect{ |key, value| Setting.from_config(@application, key, value, @environment) }.flatten
+      @settings = @config.map{|key, value| Setting.from_config(@application, key, value, @environment)}.flatten
     end
   end
 end

data/lib/greased-rails.rb

@@ -1,4 +1 @@
-require_relative "greased/rails"
-require_relative "greased/applicator"
-require_relative "greased/setting"
-require_relative "greased/settings"
+require_relative "greased"

data/lib/greased.rb

@@ -0,0 +1,40 @@
+
+require_relative "greased/loggable"
+
+module Greased
+  extend Loggable
+    
+  def self.load_yaml(filename, options = {})
+    # allow multiple filenames and use the first one that exists
+    filename = Array.wrap(filename).find do |path|
+      File.exists?(path).tap do |found|
+        #logger.debug "#{self.class}.#{__method__} exists [#{found}]: #{path}"
+      end
+    end
+    
+    unless filename.nil?
+      source  = File.read(filename)
+      source  = ERB.new(source).result unless options[:skip_erb]
+      all     = YAML.load(source)
+    end
+    
+    all || {}
+  end
+  
+  def self.file_path(*args)
+    path = File.expand_path File.join(*args)
+    path = File.realpath(path) if File.exists?(path)
+    
+    #logger.debug "#{self.class}.#{__method__} path: #{path}"
+    
+    path
+  end
+end
+
+require_relative "greased/applicator"
+require_relative "greased/options"
+require_relative "greased/method_caller"
+require_relative "greased/setting"
+require_relative "greased/settings"
+
+require_relative "greased/rails" if defined? ::Rails

data/tasks/greased.rake

@@ -3,30 +3,30 @@ require 'greased-rails'
 namespace :greased do
   namespace :env do
     task :dump => :environment do
-      options   = Greased::Applicator.rails_options
-      settings  = Greased::Applicator.new(options)
+      options   = Greased::Options.find(Rails.root)
+      applicator  = Greased::Applicator.new(Rails.application, options)
       
-      puts ""
-      puts "############################## GREASED ##############################"
-      puts "#                                                                   #"
-      puts "#            ... dumping variables to *.env files ...               #"
-      puts "#                                                                   #"
-      puts "#####################################################################"
-      puts ""
+      Greased.logger.debug ""
+      Greased.logger.debug "## GREASED [#{applicator.env.upcase}] #{'#' * (55 - applicator.env.size)}"
+      Greased.logger.debug "#                                                                   #"
+      Greased.logger.debug "#            ... dumping variables to *.env files ...               #"
+      Greased.logger.debug "#                                                                   #"
+      Greased.logger.debug "#####################################################################"
+      Greased.logger.debug ""
       
       environments  = ["development", "staging", "production"]
       longest       = environments.map(&:size).max
       
       environments.each do |env|
-        path      = settings.save_env_file(env)
-        filename  = Pathname.new(path).basename
+        path      = applicator.save_env_file(Rails.root, env)
+        filename  = File.basename(path)
         
-        puts "   [#{env}]#{' ' * (longest - env.size)} filename: #{path}"
+        Greased.logger.debug "   [#{env}]#{' ' * (longest - env.size)} filename: #{path}"
       end
       
-      puts ""
-      puts "#####################################################################"
-      puts ""
+      Greased.logger.debug ""
+      Greased.logger.debug "#####################################################################"
+      Greased.logger.debug ""
       
     end
   end

data/templates/greased.yml

@@ -0,0 +1,19 @@
+
+# Where to look for the environment settings file(s).
+# By default, Greased will try several file path permuations to find the file dynamically.
+# app_filename:     <%= File.join(Rails.root, 'greased_settings.yml') %>
+
+# Where to look for the environment settings override file(s).
+# By default, Greased will try several file path permuations to find the file dynamically.
+# partial_filename: <%= File.join(Rails.root, 'greased_partial.yml') %>
+
+# Where to look for the environment variable file(s).
+# By default, Greased will try several file path permuations to find the file dynamically.
+# env_filename:     <%= File.join(Rails.root, 'greased_variables.yml') %>
+
+# Envirionment (e.g. development, staging, production)
+env:              <%= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development" %>
+
+# Groups within the environment variables to load up.
+groups:           ["application"]
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: greased-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-02 00:00:00.000000000 Z
+date: 2013-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,8 +58,12 @@ files:
 - Rakefile
 - greased-rails.gemspec
 - lib/greased-rails.rb
+- lib/greased.rb
 - lib/greased/app_env.rb
 - lib/greased/applicator.rb
+- lib/greased/loggable.rb
+- lib/greased/method_caller.rb
+- lib/greased/options.rb
 - lib/greased/rails.rb
 - lib/greased/rails/engine.rb
 - lib/greased/rails/version.rb
@@ -67,6 +71,7 @@ files:
 - lib/greased/settings.rb
 - release.sh
 - tasks/greased.rake
+- templates/greased.yml
 - templates/greased_partial.yml
 - templates/greased_settings.yml
 - templates/greased_variables.yml