objectified_environments 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0dbbd5683857aac46cbc41e94b23c14acd7589e8
+  data.tar.gz: 3b966cafec177eed3f2f0dd1b3e213e6d7929133
+SHA512:
+  metadata.gz: 4fa915c3b54bd57762abde66537f713fbf16e2bd1ed22d48e0e4594ed24f93c0c420380af61f3a3b6be807317be644a830f1fb1b829a465090145bf8711dfb26
+  data.tar.gz: b0d57fab7cd0f80a1f38f2bef26002fc94687246b5066a159b02b3988b3cdb107c47d292cf2c5b37aaaa477cdbc806b5db1285300c6cbcceb4824546b16a5575

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,29 @@
+rvm:
+    - "2.0.0"
+    - "1.9.3"
+    - "1.9.2"
+    - "1.8.7"
+    - "jruby-1.7.4"
+env:
+    - OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=3.0.20
+    - OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=3.1.12
+    - OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=3.2.14
+    - OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=4.0.0
+    # - OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master
+matrix:
+    exclude:
+        -   rvm: 1.8.7
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=4.0.0
+        -   rvm: 1.9.2
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=4.0.0
+        -   rvm: 1.8.7
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master
+        -   rvm: 1.9.2
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master
+    allow_failures:
+        -   rvm: 1.9.3
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master
+        -   rvm: 2.0.0
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master
+        -   rvm: jruby-1.7.4
+            env: OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION=master

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in objectified_environments.gemspec
+gemspec
+
+rails_version = ENV['OBJECTIFIED_ENVIRONMENTS_RAILS_TEST_VERSION']
+rails_version = rails_version.strip if rails_version
+
+version_spec = case rails_version
+when nil then nil
+when 'master' then { :git => 'git://github.com/rails/rails.git' }
+else "=#{rails_version}"
+end
+
+if version_spec
+  gem("rails", version_spec)
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2013, Andrew Geweke
+
+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,196 @@
+# ObjectifiedEnvironments
+
+Vastly improve maintainability of your Rails.env-dependent code by using object-oriented environments. Supports Rails 3.x and 4.x, running on Ruby 1.8.7 (3.x only), 1.9.2, 1.9.3, 2.0.0, and JRuby 1.7.4.
+
+Current build status: ![Current Build Status](https://api.travis-ci.org/ageweke/objectified_environments.png?branch=master)
+
+## What? Why?
+
+Before:
+
+    class UsersController < ApplicationController
+      def create_user_from_remote
+        ...
+
+        timeout = case Rails.env
+        when 'development' then 10
+        when 'test' then 300
+        when 'qa', 'beta' then 30
+        else 5
+        end
+
+        Timeout::timeout(timeout) {
+          ...
+        }
+
+        ...
+      end
+    end
+
+After:
+
+    class UsersController < ApplicationController
+      def create_user_from_remote
+        ...
+        Timeout::timeout(Rails.objenv.timeout_for_create_user_from_remote) {
+          ...
+        }
+        ...
+      end
+    end
+
+You get:
+
+* Elegant encapsulation of environment settings: they're just methods on a class that you define.
+* All the power of Ruby to define those settings: inheritance, encapsulation, modules, delegation, and anything else you want.
+* Utter [DRYness](http://en.wikipedia.org/wiki/Don't_repeat_yourself) of your environment code: if the `production` and `qa` environments are *almost* the same, you have a single superclass that defines all the ways in which they're the same &mdash; and the `Production` and `Qa` subclasses override only the things that vary in those environments. (Want to know why QA is behaving differently from production? Just open up its environment file!)
+* Trivial maintenance of developer- or host-specific settings: if your login name is `joe`, create an environment `users/joe_development.rb` that subclasses `development.rb`, and override only what you want changed. And **check it in**. Now your fellow developers can refactor your changes along with everything else &mdash; and know why your machine behaves differently from everyone else's.
+* Easy creation of new environments: inherit from (or factor out a common superclass from) the environment that is most like your new one, and then override only what you need.
+* Wonderful behavior if you forget a setting: depending on the superclass, you'll get a reasonable default or a blindingly-obvious message about what you need to set, rather than an unintended and possibly-awful fallback.
+
+## Wait, what? Really, why?
+
+In large Ruby systems, there is inevitably a *lot* of behavior that is environment-dependent &mdash; cache sizes,
+API keys, timeouts, debugging information, and so on. Rails' default environment mechanism does not accommodate
+such large projects particularly well, and often big maintenance headaches ensue.
+
+### The Theory
+
+The way you are supposed to manage this is to create configuration points throughout your code, and set them in
+the environment files in `config/environments`:
+
+    class UsersController
+      cattr_accessor :timeout_for_create_user_from_remote
+
+      def create_user_from_remote
+        Timeout::timeout(timeout_for_create_user_from_remote) {
+          ...
+        }
+      end
+    end
+
+And then, for example, in `config/environments`:
+
+    development.rb:
+      ...
+      UsersController.timeout_for_create_user_from_remote = 10
+      ...
+    test.rb:
+      ...
+      UsersController.timeout_for_create_user_from_remote = 300
+      ...
+    qa.rb:
+      ...
+      UsersController.timeout_for_create_user_from_remote = 30
+      ...
+    beta.rb:
+      ...
+      UsersController.timeout_for_create_user_from_remote = 30
+      ...
+    production.rb:
+      ...
+      UsersController.timeout_for_create_user_from_remote = 5
+      ...
+
+This does work. However, as you create more environments, you end up with more and more files that are almost always
+copy-and-pasted from each other, suffering many of the problems that [Repeating Yourself](http://en.wikipedia.org/wiki/Don't_repeat_yourself) causes. Can you be certain that whoever creates a new environment has carefully thought through every single setting? Can you be certain that, when a developer creates a new setting, they have carefully added it to every environment file? And when someone needs to change a default, they have to go edit every single environment file and carefully think about it. (Is QA's timeout set to 5 for a good reason, or just because it was copy-and-pasted from production's?)
+
+Compared to the above, using `objectified_environments` gives you significant improvements in maintainability, extension, and reliability.
+
+### The Practice
+
+In reality, unless your developers have incredible discipline, you very often end up with something different, like our first example above: code strewn all over your codebase, explicitly testing against `Rails.env`.
+
+**This is a disaster**:
+
+* When someone adds a new environment, they need to search *your entire codebase* for tests against `Rails.env` (or `RAILS_ENV`, or `ENV['RAILS_ENV']`), sit and think about every single one, figure out what the right value for the new environment is, and insert it.
+* If someone misses a setting, then, depending on the exact syntax of the code in question (is there an `else` clause? does it use a default value, or raise an exception?), you might: get a reasonable value, get an exception that's clear, get an exception that's very unclear (maybe that variable just stays `nil`, and this causes problems far, far from the call site), or, worst of all, get silent failures that cause bad data in your database, bad pages or API results, or so on.
+* Do you want to know how QA and production differ? Go search the entire codebase again, and think about each one.
+
+When code is built in such a way that it naturally tends to cause problems, blaming developers (we're creative! we're wonderful! we're [lazy](http://threevirtues.com/)!) is the cheap way out. Let's build systems that make the easy way also the *right* way.
+
+### The Solution
+
+`objectified_environments` simply instantiates a class named after your `Rails.env` setting and binds it to `Rails.objenv`. You can then add methods to those classes, make them inherit from each other, override methods in subclasses, use delegation, modules, and any other tools that Ruby gives you to make them behave appropriately. The result is an easy-to-maintain, powerful environment system that makes it easy to add new environments, figure out the differences between environments, and so on.
+
+## Installation
+
+1. In any supported Rails environment, add this to your Gemfile, and then run `bundle install`:
+
+        gem 'objectified_environments'
+
+1. Run the generator:
+
+        rails generate objectified_environments
+
+1. This will generate a hierarchy of classes in `config/lib/objenv`, as so:
+
+        ObjectifiedEnvironments::Base         # this is built-in to the Gem
+          Objenv::Environment                 # 'Objenv::' prefix is required for your classes
+            Objenv::LocalEnvironment
+              Objenv::Development
+              Objenv::Test
+            Objenv::ProductionEnvironment
+              Objenv::Production
+
+1. If you have any environments beyond the standard three (`development`, `test`, and `production`) defined in `config/environments`, you'll also have classes defined for them. However, because the gem cannot know the proper superclass for them, they will all derive directly from the base `Objenv::Environment` class. Feel free to change this.
+
+## Usage
+
+The *only* change this makes in your system is that now `Rails.objenv` will automatically be a reference to an instance of whatever class is named the same as your environment (using Rails' camel-casing conventions) in the `Objenv::` namespace. This enables all the functionality above, but does not require any immediate changes.
+
+As you introduce new features &mdash; or want to move existing ones to this system &mdash; simply add a method to one or more of these classes, and call it from your code via `Rails.objenv.my_method`. How you do this depends on the desired behavior of the code in question:
+
+* **Reasonable default, needs to be overridden in some environments**: Add the method to `Objenv::Environment` returning the right value or doing the right thing. Override it in whatever subclasses need a different value.
+* **No reasonable default, needs to be defined in all environments**: While you don't need to define the method on `Objenv::Environment`, doing so in such a way that raises an exception (the `ObjectifiedEnvironments::Base#must_implement` method will do this automatically for you) is a nice way to make it clear to other developers that they need to implement this method &mdash; and lets them instantly see what's going on if they forget to override it.
+
+**The `LocalEnvironment` and `ProductionEnvironment` classes**: These classes are created by the generator for convenience' sake. Typically, the `development` and `test` environments have a lot in common. The generator sets up `Development` and `Test` to inherit from `LocalEnvironment` &mdash; so, if you put the code they have in common in `LocalEnvironment`, it will automatically be shared. And while Rails does not ship with a default `qa`, `beta`, or other such environment, these are incredibly common and almost always share a lot of code with `production`. Thus, `ProductionEnvironment` is created as a good place for this code.
+
+Note that these are all simply suggestions; there is nothing more mysterious going on here than ordinary Ruby object-oriented structure. Do whatever works best for you. The generator sets up defaults that seem reasonable according to the author of this Gem, but the world is yours, and the Gem doesn't enforce any particular structure at all.
+
+You may also wish to explore creating methods that actually do things, rather than simply returning configuration information. For example, having a method that returns the client object for Memcached can be very powerful, because now your environment can do anything it needs to do to set up that client &mdash; potentially returning a proxy for multiple servers, for example &mdash; rather than being restricted to only returning a single host and port.
+
+### User- and Host-Specific Environments
+
+Often, developers want to override certain environmental behavior on just machines they're logged into. Sometimes, we want to change environmental behavior on only particular hosts. Typically this is done via some (gross) combination of leaving environment files modified, adding a new 'local environment' file and calling it from the end of the master environment file, or even automating this with `patch`, `sed`, or some other such tool.
+
+No matter what system is used to do this, it has significant drawbacks &mdash; one of the biggest of which is that these 'local changes' are almost never visible to other developers. If you've changed `MyController.user_cache_size` on your machine, and then someone else renames it to `MyController.people_cache_size`, then at best your next pull breaks your development environment in a very frustrating way &mdash; and at worst, your cache-size change is now forever silently ignored.
+
+`objectified_environments` provides a better way. If you are logged in as user `acid_burn` on a machine called `the_gibson` with `Rails.env` set to `development`, then the Gem will assign to `Rails.objenv` the first class that exists from the following list:
+
+    Objenv::UserHost::AcidBurnTheGibsonDevelopment
+    Objenv::Host::TheGibsonDevelopment
+    Objenv::User::AcidBurnDevelopment
+    Objenv::Development
+
+Thus, you can create `Objenv::User::AcidBurnDevelopment` as a subclass of `Objenv::Development`, override whatever settings you want, and *check it in*. Now, all other developers can see what you've overridden locally, cleanly change it for you if they're refactoring, and so on.
+
+It is possible to tie yourself into insane knots by creating massive numbers of user-specific, host-specific, and (especially) user-and-host-specific overrides this way. We recommend keeping this extremely simple &mdash; but the power is there, if you need it.
+
+### Relationship with `config/environments` files
+
+Because Rails still loads files in `config/environments` for each environment, you will need to keep those files there and create them for any new environments you make, in addition to `Objenv::` classes &mdash; Rails really doesn't like not having one. (A patch that eliminates this requirement would be fantastic!)
+
+Also, the configuration done in these files is *not* automatically subsumed by `objectified_environments`. If you wish (and it's highly recommended), you can move this code into the objectified environments, call it from the files in `config/environments`, and refactor it in any way you want. (The generator doesn't move this code automatically because the files in `config/environments` can contain any arbitrary Ruby code that's structured in any manner you want, and doing this safely borders on the impossible.)
+
+### A Few Last Details:
+
+* Once you install this gem, having an `Objenv::` class defined that matches your `Rails.env` setting is **mandatory**. This is required because otherwise we would have no idea what object to assign to `Rails.objenv`.
+* The `Objenv::` namespace prefix requirement is so that environment names won't conflict with any classes of your own that you define with these names. (If you want to create a class called `Development` for other purposes, we don't want to stop you.)
+* There is no requirement that your classes inherit from `ObjectifiedEnvironments::Base`; they can be any kind of Ruby object. They must be able to be instantiated with either no arguments, or one argument; if the constructor accepts an argument, it will be passed a hash containing `:rails_env`, `:user_name`, and `:host_name`. `ObjectifiedEnvironments::Base` stores this away and exposes it via *private* methods. (The fact that they're private is important; having you call `Rails.objenv.rails_env` subverts the entire system.)
+* There is actually no requirement that your environment classes live under `config/lib`; this is merely a convention. As long as Rails is able to find them using its autoloading behavior, they will work just fine.
+* `ObjectifiedEnvironments::Base` defines a nice `must_implement` method that simply raises an exception, saying you must implement a method. This is a nice thing to call in methods you define in `Environment` that have no reasonable default.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+While I thoroughly encourage any and all contributions, ideas, bug reports, bug fixes, and so on, I do request that you include full tests (specs) in your patch if you do contribute a patch back.
+
+## License
+
+This code is licensed under the terms in the accompanying `LICENSE` file.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/objectified_environments/base.rb

@@ -0,0 +1,16 @@
+module ObjectifiedEnvironments
+  class Base
+    def initialize(environment_properties)
+      @rails_env = environment_properties[:rails_env]
+      @user_name = environment_properties[:user_name]
+      @host_name = environment_properties[:host_name]
+    end
+
+    private
+    attr_reader :rails_env, :user_name, :host_name
+
+    def must_implement
+      raise "You must override this method in #{self.class.name} or a superclass."
+    end
+  end
+end

data/lib/objectified_environments/data_provider.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'rails_requirer')
+
+module ObjectifiedEnvironments
+  class DataProvider
+    def rails_env
+      @rails_env ||= begin
+        out = Rails.env || ''
+        if out.strip.length == 0
+          raise "#{self.name}: There appears to be no Rails.env set; I can't create an objectified environment for you. I don't know why this would happen. Rails.env is: #{Rails.env.inspect}"
+        end
+
+        out
+      end
+    end
+
+    def user_name
+      @user_name ||= begin
+        require 'etc'
+
+        candidates = [ Etc.getlogin, ENV['USER'], ENV['LOGNAME'], ENV['USERNAME'] ]
+        candidates = candidates.map { |c| c.strip unless (! c) || c.strip.length == 0 }.compact
+        candidates[0] || :none
+      end
+
+      @user_name unless @user_name == :none
+    end
+
+    def host_name
+      @host_name ||= begin
+        candidates = [ host_name_from_hostname_command, socket_gethostname ]
+        candidates = candidates.map { |c| normalize_hostname(c) }.compact
+        candidates[0] || :none
+      end
+
+      @host_name unless @host_name == :none
+    end
+
+    private
+    def host_name_from_hostname_command
+      out = `hostname`
+      out if $?.success? && out && out.strip.length > 0
+    end
+
+    def socket_gethostname
+      require 'socket'
+
+      out = Socket.gethostname rescue nil
+      out.strip if out && out.strip.length > 0
+    end
+
+    def normalize_hostname(hostname)
+      return nil unless hostname && hostname.strip.length > 0
+
+      out = hostname.strip.downcase.gsub(/[\-_]+/, '_')
+      out if out =~ /^[A-Z_][A-Z0-9_]*$/i # must be a valid Ruby identifier
+    end
+  end
+end

data/lib/objectified_environments/environment_builder.rb

@@ -0,0 +1,97 @@
+require 'objectified_environments/errors'
+
+module ObjectifiedEnvironments
+  class EnvironmentBuilder
+    def initialize(data_provider)
+      @rails_env = normalize(data_provider.rails_env)
+      @user_name = normalize(data_provider.user_name)
+      @host_name = normalize(data_provider.host_name)
+
+      raise ArgumentError, "@rails_env is required: #{rails_env.inspect}" unless @rails_env && @rails_env.strip.length > 0
+    end
+
+    def environment
+      candidate_names = [ ]
+
+      candidate_names << class_name_for_candidate(@rails_env, @user_name, @host_name) if @user_name && @host_name
+      candidate_names << class_name_for_candidate(@rails_env, nil, @host_name) if @host_name
+      candidate_names << class_name_for_candidate(@rails_env, @user_name, @nil) if @user_name
+      candidate_names << class_name_for_candidate(@rails_env, nil, nil)
+
+      raise "This should be impossible: we should always have a candidate" unless candidate_names.length > 0
+
+      out = nil
+      candidate_names.each do |candidate_name|
+        klass = begin
+          candidate_name.constantize
+        rescue NameError
+          nil
+        end
+
+        return instantiate_from_class(klass) if klass
+      end
+
+      no_environment_found!(candidate_names)
+    end
+
+    private
+    def normalize(s)
+      s.strip unless (!s) || (s.strip.length == 0)
+    end
+
+    def class_name_for_candidate(rails_env, user_name, host_name)
+      rails_env = normalize(rails_env)
+      user_name = normalize(user_name)
+      host_name = normalize(host_name)
+
+      if user_name && host_name
+        target = "#{user_name}_#{host_name}_#{rails_env}"
+        "Objenv::UserHost::#{target.camelize}"
+      elsif host_name
+        target = "#{host_name}_#{rails_env}"
+        "Objenv::Host::#{target.camelize}"
+      elsif user_name
+        target = "#{user_name}_#{rails_env}"
+        "Objenv::User::#{target.camelize}"
+      else
+        "Objenv::#{rails_env.camelize}"
+      end
+    end
+
+    def instantiate_from_class(klass)
+      begin
+        constructor = klass.instance_method(:initialize)
+
+        args = [ ]
+        if constructor.arity != 0
+          args = [ { :rails_env => @rails_env, :user_name => @user_name, :host_name => @host_name } ]
+        end
+
+        return klass.new(*args)
+      rescue => e
+        raise ObjectifiedEnvironments::UnableToInstantiateEnvironmentError, %{We found a valid objectified environment class '#{klass.name}', but,
+when we tried to instantiate it, we got the following exception:
+
+#{e.class.name}: #{e.message}
+#{e.backtrace.join("\n")}}
+      end
+    end
+
+    def no_environment_found!(candidate_names)
+      raise ObjectifiedEnvironments::EnvironmentMissingError, %{No ObjectifiedEnvironment definition was found.
+
+Rails.env: #{@rails_env.inspect}
+Username:  #{@user_name.inspect}
+Host name: #{@host_name.inspect}
+
+This caused us to look for any environment named one of these (in order):
+
+#{candidate_names.join("\n")}
+
+...but none of those exist.
+
+You may want to run 'rails generate objectified_environments'.
+}
+    end
+  end
+end

data/lib/objectified_environments/errors.rb

@@ -0,0 +1,5 @@
+module ObjectifiedEnvironments
+  class ObjectifiedEnvironmentError < StandardError; end
+  class EnvironmentMissingError < ObjectifiedEnvironmentError; end
+  class UnableToInstantiateEnvironmentError < ObjectifiedEnvironmentError; end
+end

data/lib/objectified_environments/rails_requirer.rb

@@ -0,0 +1,8 @@
+# Rails 3.0 and later let you just "require 'rails'". Rails 2.3 is far less modular; you have to require
+# activesupport and then, super-grossly, just raw 'initializer'. Ick. But it does work.
+begin
+  require 'rails'
+rescue LoadError => le
+  require 'activesupport'
+  require 'initializer'
+end

data/lib/objectified_environments/railtie.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'rails_requirer')
+
+module ObjectifiedEnvironments
+  class Railtie < Rails::Railtie
+    initializer "objectified_environments.setup", :before => :load_environment_config do |app|
+      autoload_directory = File.expand_path(File.join(Rails.root, 'config', 'lib'))
+      ActiveSupport::Dependencies.autoload_paths << autoload_directory
+
+      unless defined?(Rails) && Rails.kind_of?(Module)
+        raise %{ObjectifiedEnvironments declares a dependency on Rails, and Rails appears to be
+running our initialization code (the Railtie), yet Rails does not appear to be defined as a module.
+We don't know what's wrong, and are bailing out lest we cause more problems. Please report this
+issue, including the version of Rails you are running: #{Rails.version}.}
+      end
+
+      module ::Rails
+        class << self
+          def objenv
+            @_objectified_environment ||= ObjectifiedEnvironments.create_objectified_environment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/objectified_environments/version.rb

@@ -0,0 +1,3 @@
+module ObjectifiedEnvironments
+  VERSION = "1.0.0"
+end

data/lib/objectified_environments.rb

@@ -0,0 +1,24 @@
+require "objectified_environments/version"
+require "objectified_environments/railtie"
+require "objectified_environments/data_provider"
+require "objectified_environments/environment_builder"
+require "objectified_environments/base"
+require "objectified_environments_generator"
+
+module ObjectifiedEnvironments
+  class << self
+    def create_objectified_environment
+      eb = environment_builder.new(data_provider)
+      eb.environment
+    end
+
+    private
+    def environment_builder
+      ObjectifiedEnvironments::EnvironmentBuilder
+    end
+
+    def data_provider
+      @data_provider ||= ObjectifiedEnvironments::DataProvider.new
+    end
+  end
+end