objectified_environments 1.0.0

data/lib/objectified_environments_generator.rb

@@ -0,0 +1,206 @@
+require File.join(File.dirname(__FILE__), 'objectified_environments/rails_requirer')
+
+require 'rails/generators'
+
+class ObjectifiedEnvironmentsGenerator < Rails::Generators::Base
+  def create_environment_files
+    needed_environments = all_environments.select { |e| (! environment_defined?(e)) }
+
+    needed_environments.each do |environment|
+      create_environment(environment)
+    end
+
+    create_superclasses_for(needed_environments)
+  end
+
+  private
+  def create_environment(environment)
+    target_file = File.join(objenv_dir, "#{environment.underscore}.rb")
+
+    if File.exist?(target_file)
+      puts "skip #{target_file}"
+    else
+      create_file(target_file) do
+        content_for_environment(environment)
+      end
+    end
+  end
+
+  def create_superclasses_for(environments)
+    superclasses = environments.map { |e| superclass_for_environment(e) }.uniq
+    superclasses -= [ "ObjectifiedEnvironments::Base" ]
+    superclasses = superclasses.map do |sc|
+      if sc =~ /::([A-Z0-9_]+)$/i
+        $1
+      else
+        sc
+      end
+    end
+
+    unless superclasses.length == 0
+      superclasses.each { |sc| create_environment(sc) }
+      create_superclasses_for(superclasses)
+    end
+  end
+
+  DEFAULT_ENVIRONMENT_SUPERCLASS = 'Objenv::Environment'
+  ENVIRONMENT_HIERARCHY = {
+    'Environment' => "ObjectifiedEnvironments::Base",
+
+    'LocalEnvironment' => 'Environment',
+    'Development' => 'LocalEnvironment',
+    'Test' => 'LocalEnvironment',
+
+    'ProductionEnvironment' => 'Environment',
+    'Production' => 'ProductionEnvironment'
+  }
+  ENVIRONMENTS_MODULE = "Objenv"
+
+  CLASS_COMMENTS = { }
+  CLASS_COMMENTS['Environment'] = <<-EOS
+# This is the root class of all of your objectified environments -- i.e., all the other
+# classes in config/lib/objenv. As such, it defines the behavior of a "default" environment,
+# with subclasses overriding its methods as needed.
+#
+# You might think that this is useless -- after all, the whole point of environments is to
+# define things that *aren't* common across RAILS_ENV settings, so what could possibly go
+# here? However, you'll find that several things are useful about this class:
+#
+#   - If you define all methods here and simply call #must_implement (defined in
+#     ObjectifiedEnvironments::Base) in them, then you'll have an elegant template that
+#     immediately shows everybody exactly what varies based on environment and what they
+#     need to think about/override when creating a new environment.
+#
+#   - Often, you'll want to define methods on the environment that actually include a
+#     little bit of functionality -- like creating and returning a Memcached client, for
+#     example. This can therefore be a nice place to put the structure of those methods.
+#     (The method that the rest of the code actually calls directly can be defined here,
+#     while subclasses override methods that provide crucial information -- like the name
+#     of the Memcached host, for example -- that this method uses to do its work.)
+#
+#   - You may well have cases where nearly all environments behave identically, but only
+#     one or two vary. It therefore makes a lot of sense to put the default behavior
+#     here, and override as necessary only in those one or two cases.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  CLASS_COMMENTS['LocalEnvironment'] = <<-EOS
+# This class is a descendent of the base Environment class and is inherited by Development
+# and Test, the two environments that typically run locally (i.e., not on a remote server).
+# It's very common that these two environments share a lot of settings in common -- hence
+# the case for this class.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  CLASS_COMMENTS['Development'] = <<-EOS
+# This class defines environment settings when RAILS_ENV == 'development'.
+#
+# If you have settings to define that also apply to Test, please consider placing them
+# in LocalEnvironment, the superclass of this class, instead. You'll keep your code DRYer.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  CLASS_COMMENTS['Test'] = <<-EOS
+# This class defines environment settings when RAILS_ENV == 'test'.
+#
+# If you have settings to define that also apply to Development, please consider placing them
+# in LocalEnvironment, the superclass of this class, instead. You'll keep your code DRYer.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  CLASS_COMMENTS['ProductionEnvironment'] = <<-EOS
+# This class is a descendent of the base Environment class and is inherited by Production.
+# While this may seem a bit silly -- why have an intermediate class between Environment and
+# Production at all? -- there's a good reason for it. It's exceptionally common to create
+# 'production-like' environments, like 'qa', 'beta', and so on. These environments very often
+# share a great number of environment settings, and this class is a perfect place to put
+# that code. If you start from the beginning separating out settings that apply to "any
+# environment that's like production" from "only production itself", adding these environments
+# in the future gets to be a whole lot easier.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  CLASS_COMMENTS['Production'] = <<-EOS
+# This class defines environment settings when RAILS_ENV == 'production'.
+#
+# Please see the comment at the top of ProductionEnvironment, as well. If you have settings
+# that apply to 'any production-like environment' rather than 'only production itself', putting
+# that code in ProductionEnvironment instead of in this class will likely serve you better
+# in the long run.
+#
+# Note that the inheritance hierarchy here is only suggested and part of the
+# objectified_environments generator, but not the core Gem code itself. You can change and
+# rearrange things to your heart's content.
+EOS
+
+  def content_for_environment(environment)
+    %{#{CLASS_COMMENTS[environment.camelize] || ''}
+module #{ENVIRONMENTS_MODULE}
+  class #{environment.camelize} < #{superclass_for_environment(environment)}
+    # Add your own method definitions here!
+  end
+end
+}
+  end
+
+  def superclass_for_environment(environment)
+    ENVIRONMENT_HIERARCHY[environment.camelize] || DEFAULT_ENVIRONMENT_SUPERCLASS
+  end
+
+  def environment_defined?(environment)
+    target_class_name = "#{ENVIRONMENTS_MODULE}::#{environment.camelize}"
+    begin
+      target_class_name.constantize
+      true
+    rescue NameError => ne
+      false
+    end
+  end
+
+  def all_environments
+    config_environments | [ current_environment ]
+  end
+
+  def config_environments
+    return [ ] unless File.directory?(config_environments_dir)
+
+    Dir.entries(config_environments_dir).map do |entry|
+      $1.downcase if entry =~ /^([A-Z0-9_]+)\.rb$/i
+    end.compact
+  end
+
+  def config_dir
+    @config_dir ||= File.expand_path(File.join(Rails.root, 'config'))
+  end
+
+  def config_environments_dir
+    @config_environments_dir ||= File.join(config_dir, 'environments')
+  end
+
+  def config_lib_dir
+    @config_lib_dir ||= File.join(config_dir, 'lib')
+  end
+
+  def objenv_dir
+    @objenv_dir ||= File.join(config_lib_dir, ENVIRONMENTS_MODULE.underscore)
+  end
+
+  def current_environment
+    Rails.env
+  end
+end

data/objectified_environments.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'objectified_environments/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "objectified_environments"
+  spec.version       = ObjectifiedEnvironments::VERSION
+  spec.authors       = ["Andrew Geweke"]
+  spec.email         = ["andrew@geweke.org"]
+  spec.description   = %q{Exposes your Rails.env as an object you can invoke methods on, use inheritance to structure, and otherwise use all modern powerful programming techniques on. In large projects, this can make an enormous difference in maintainability and reliability.}
+  spec.summary       = %q{Vastly improve maintainability of your Rails.env-dependent code by using object-oriented environments.}
+  spec.homepage      = "https://github.com/ageweke/objectified_environments"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14"
+
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    spec.add_development_dependency "activerecord-jdbcsqlite3-adapter"
+  else
+    spec.add_development_dependency "sqlite3"
+  end
+
+  rails_version = ENV['OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION']
+  rails_version = rails_version.strip if rails_version
+
+  version_spec = case rails_version
+  when nil then [ ">= 3.0", "<= 4.99.99" ]
+  when 'master' then nil# { :git => 'git://github.com/rails/rails.git' }
+  else [ "=#{rails_version}" ]
+  end
+
+  if version_spec
+    spec.add_dependency("rails", *version_spec)
+  end
+end

data/spec/objectified_environments/helpers/command_helpers.rb

@@ -0,0 +1,46 @@
+module ObjectifiedEnvironments
+  module Specs
+    module Helpers
+      module CommandHelpers
+        def safe_system(command, options = { })
+          # Ugh. Bundler sets environment variables that causes subprocesses to use the same Bundler Gemfiles, etc.
+          # While I'm sure this is exactly what you want in most circumstances, it breaks our handling of different
+          # Rails versions. So we remove these explicitly when we execute a subprocess.
+          old_env = { }
+          ENV.keys.select { |k| k =~ /^BUNDLE_/ }.each do |key|
+            old_env[key] = ENV[key]
+            ENV.delete(key)
+          end
+
+          output = `#{command} 2>&1`
+
+          old_env.each { |k,v| ENV[k] = v }
+
+          successful = $?.success?
+          successful = false if options[:output_must_match] && (! (output =~ options[:output_must_match]))
+
+          unless successful
+            what_we_were_doing = options[:what_we_were_doing] || "run a command"
+
+            raise <<-EOS
+Unable to #{what_we_were_doing}. In this directory:
+
+  #{Dir.pwd}
+
+...we ran:
+
+  #{command}
+
+...but it returned this result: #{$?.inspect}
+...and gave this output:
+
+#{output}
+EOS
+          end
+
+          output
+        end
+      end
+    end
+  end
+end

data/spec/objectified_environments/helpers/rails_helper.rb

@@ -0,0 +1,299 @@
+require File.join(File.dirname(__FILE__), 'command_helpers')
+require 'fileutils'
+
+module ObjectifiedEnvironments
+  module Specs
+    module Helpers
+      class RailsHelper
+        include ObjectifiedEnvironments::Specs::Helpers::CommandHelpers
+
+        DEFAULT_RAILS_ENV = 'test'
+
+        def initialize(container_dir, options = { })
+          @container_dir = container_dir
+          @options = options
+
+          @root = nil
+          @version = nil
+          @running = false
+          @rails_env = (options[:rails_env] || DEFAULT_RAILS_ENV).to_s.strip
+
+          raise "This is not a valid Rails.env: #{@rails_env.inspect}" if @rails_env.length == 0
+        end
+
+        attr_reader :root, :version, :rails_env
+
+        def run!(&block)
+          begin
+            @running = true
+            preserve_state do
+              new_rails_installation!
+
+              Dir.chdir(root)
+              ENV['RAILS_ENV'] = rails_env
+
+              block.call(self)
+
+              FileUtils.rm_rf(File.dirname(root)) unless options[:always_keep_installation]
+            end
+          ensure
+            @running = false
+          end
+        end
+
+        def major_version
+          Integer($1) if version && version =~ /^(\d+)\./i
+        end
+
+        def major_and_minor_version
+          Float($1) if version && version =~ /^(\d+\.\d+)\./i
+        end
+
+        def run_script_command
+          if major_version <= 2
+            "ruby #{File.join('script', 'runner')}"
+          else
+            "rails runner"
+          end
+        end
+
+        def run_script!(script_path, *args)
+          opts = args.pop if args && args[-1] && args[-1].kind_of?(Hash)
+          opts ||= { }
+
+          must_be_running!
+          Dir.chdir(root) do
+            cmd = "bundle exec #{run_script_command} #{script_path}"
+            if args.length > 0
+              cmd << " "
+              cmd << args.join(" ")
+            end
+            safe_system(cmd, opts)
+          end
+        end
+
+        def run_as_script!(contents, opts = { })
+          script_file = opts[:script_name] || "temp_rails_script_#{rand(1_000_000)}"
+          script_file << ".rb" unless script_file =~ /\.rb$/i
+
+          File.open(script_file, 'w') { |f| f.puts contents }
+
+          run_script!(script_file, opts)
+        end
+
+        def run_generator(*args)
+          cmd = if major_version <= 2
+            "script/generate"
+          else
+            "rails generate"
+          end
+
+          cmd = "bundle exec #{cmd} #{args.join(" ")}"
+          safe_system(cmd)
+        end
+
+        def running?
+          !! @running
+        end
+
+        private
+        attr_reader :container_dir, :options
+
+        def must_be_running!
+          unless running?
+            raise "You can only call this while the Rails helper is running, and it isn't right now."
+          end
+        end
+
+        def project_name
+          options[:project_name] || 'rails_project'
+        end
+
+        def preserve_state(&block)
+          old_dir = Dir.pwd
+          old_rails_env = ENV['RAILS_ENV']
+
+          begin
+            block.call
+          ensure
+            Dir.chdir(old_dir)
+            ENV['RAILS_ENV'] = old_rails_env
+          end
+        end
+
+        def notify(string, &block)
+          $stdout << "[#{string}..."
+          $stdout.flush
+
+          block.call
+
+          $stdout << "]"
+          $stdout.flush
+        end
+
+        def create_rails_holder!
+          raise "No version yet?!?" unless version
+          out = File.join(container_dir, "rails-#{Time.now.strftime("%Y%m%d-%H%M%S")}-#{rand(1_000_000)}-#{version}")
+          FileUtils.mkdir_p(out)
+          out
+        end
+
+        def new_rails_installation!
+          fetch_rails_version!
+          rails_holder = create_rails_holder!
+
+          Dir.chdir(rails_holder)
+          create_rails_project!
+
+          @root = File.join(rails_holder, project_name)
+          Dir.chdir(root)
+
+          set_gemfile!
+          modify_database_yml_as_needed!
+          copy_environment_as_needed!
+          run_bundle_install!
+
+          check_installed_rails_version!
+        end
+
+        def set_gemfile!
+          # For reasons I don't understand at all, running 'bundle install' against our installed Rails instance
+          # absolutely refuses to install remote gems -- all it will do is use ones that have already been installed.
+          # And that means it can only safely use gems in the top-level Gemfile of whatever gem or other code we're
+          # running under.
+          #
+          # As a result, we overwrite the Gemfile here to contain only the reference to Rails itself, rather than
+          # the additional stuff that the default Rails Gemfile contains. This, despite the fact that the command_helper
+          # explicitly strips out all BUNDLE_* environment variables before executing a subcommand.
+          #
+          # This is unfortunate, because it would be safer to use all the default gems. If a subsequent contributor
+          # knows what's going on here and how to make it work, by all means, please do!
+
+
+          # We need to specify the version for Rails exactly like the outer Gemfile specifies it, and it might be
+          # from git (e.g., if we're testing against the master branch of Rails), so we can't just use #version in this
+          # class. Rather, we go grab the spec from Bundler.
+          rails_spec = Bundler.environment.specs.detect { |s| s.name == 'rails' }
+          raise "Can't find Bundler spec for 'rails'" unless rails_spec
+          rails_spec_version = case rails_spec.source
+          when Bundler::Source::Git then ":git => '#{rails_spec.source.uri}'"
+          else "'#{rails_spec.version}'"
+          end
+
+          gem_lines = [
+            "source 'http://rubygems.org'",
+            "gem 'rails', #{rails_spec_version}"
+          ]
+
+          # Rails >= 3.2 uses sqlite3 by default, and won't even boot by default unless you add that to your Gemfile.
+          if major_and_minor_version >= 3.2
+            if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+              gem_lines << "gem 'activerecord-jdbcsqlite3-adapter'"
+            else
+              gem_lines << "gem 'sqlite3'"
+            end
+          end
+
+          if gem_lines.length > 0
+            notify("adding required lines to Gemfile") do
+              File.open("Gemfile", "w") { |f| f.puts gem_lines.join("\n") }
+            end
+          end
+        end
+
+        # If we're using a RAILS_ENV other than one of the three defaults, then database.yml needs to contain
+        # configuration for that environment, even if we never actually touch the database, because certain Rails
+        # versions refuse to even start if it's not present.
+        def modify_database_yml_as_needed!
+          require 'yaml'
+
+          db_yaml_file = File.join('config', 'database.yml')
+          db_yaml = YAML.load_file(db_yaml_file)
+
+          unless db_yaml[rails_env]
+            notify("adding environment '#{rails_env}' to database.yml") do
+              test_content = db_yaml['test']
+              raise "No default database.yml entry for 'test'?!?" unless test_content
+
+              db_yaml[rails_env] = test_content.dup
+              new_yaml = YAML.dump(db_yaml)
+              # Get rid of the silly '---' line that YAML.dump puts at the start.
+              new_yaml = new_yaml.split("\n").map { |l| l unless l =~ /^\-+$/i }.compact.join("\n")
+              File.open(db_yaml_file, 'w') { |f| f.puts new_yaml }
+            end
+          end
+        end
+
+        # Similarly, if we're using a non-default RAILS_ENV setting, we need to make sure we have an environment
+        # file for it.
+        def copy_environment_as_needed!
+          env_directory = File.join('config', 'environments')
+          env_file = File.join(env_directory, "#{rails_env}.rb")
+
+          unless File.exist?(env_file)
+            test_env_file = File.join(env_directory, "test.rb")
+            raise "No test.rb file at: #{test_env_file}?!?" unless File.exist?(test_env_file)
+            FileUtils.cp(test_env_file, env_file)
+          end
+        end
+
+        def check_installed_rails_version!
+          notify "checking version of Rails in our new project" do
+            output = run_as_script!(%{puts "Rails version: " + Rails.version},
+              :script_name => "check_rails_version",
+              :output_must_match => /^\s*Rails\s+version\s*:\s*\S+\s*$/mi,
+              :what_we_were_doing => "running a small script to check the version of Rails we installed")
+
+            if output =~ /^\s*Rails\s+version\s*:\s*(\S+)\s*$/mi
+              installed_version = $1
+
+              unless installed_version == version
+                raise "Whoa: the Rails project we created is reporting itself as version '#{installed_version}', but 'rails --version' gave us '#{version}'. Something is horribly wrong."
+              end
+            end
+          end
+        end
+
+        def fetch_rails_version!
+          v = nil
+
+          notify "checking version of Rails we're using" do
+            version_text = safe_system("rails --version", :output_must_match => /^\s*Rails\s+(\d+\.\d+\.\d+)/i, :what_we_were_doing => "checking the version of Rails used by the 'rails' command")
+            v = if version_text =~ /^\s*Rails\s+(\d+\.\d+\.\d+)/i
+              $1
+            else
+              raise "Unable to determine version of Rails; we got: #{version_text.inspect}"
+            end
+
+            $stdout << v
+            $stdout.flush
+          end
+
+          @version = v
+        end
+
+        def create_rails_project_command
+          if major_version <= 2
+            "rails"
+          else
+            "rails new"
+          end
+        end
+
+        def create_rails_project!
+          notify "creating new Rails installation" do
+            safe_system("#{create_rails_project_command} #{project_name}",
+              :what_we_were_doing => 'create a Rails project for our spec',
+              :output_must_match => %r{create.*config/boot}mi)
+          end
+        end
+
+        def run_bundle_install!
+          notify "running 'bundle install'" do
+            safe_system("bundle install", :what_we_were_doing => "run 'bundle install' for our test Rails project")
+          end
+        end
+      end
+    end
+  end
+end