sequelizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6628c636f7aee3fc9ffc3c36b9877167756c2cc0
+  data.tar.gz: b24750aba87b1a882ee81dd18d0ec078deab4e9c
+SHA512:
+  metadata.gz: 986d3122766c0f9cac14bba4196469edc93d4c32718a716ae93e823898a84b35d7117d8c70d341f203c98d850cd83ceaa5867e57dab45ff5682e5a01bb405eec
+  data.tar.gz: cd2f304548d984e8d4229350bee9b8328f2bc7193b30c4b73c4d14c2dc90bc3a955d8349855b45c8f3eadd291a613f7b587efaf9446e6220ba9fa64490df9fa4

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/Gemfile

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

data/Guardfile

@@ -0,0 +1,28 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Outcomes Insights, Inc.
+
+MIT License
+
+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,78 @@
+# Sequelizer
+
+I was tired of writing the code to bootstrap a connection to my databases.
+
+[Sequel](https://github.com/jeremyevans/sequel/) provides an easy mechanism for connecting to a database, but I didn't want to store my username/password/other sensitive information in the scripts I was writing.
+
+So I wrote this gem that lets me store my database configuration options in either config/database.yml or .env and then lets me call `db` to get a connection to my database.
+
+I normally use this gem when I'm writing a quick script or a Thor-based command line utility.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sequelizer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sequelizer
+
+## Usage
+
+To get the most out of Sequelizer, you'll need to create a config/database.yml file or a .env file and specify your database configuration options in that file.
+
+You'll also need to make sure the gem for your database is installed.  You can do this by adding a the gem to your application's Gemfile.
+
+Sequelizer comes with a handy command that will update your Gemfile for you.  Once you've specified your database configuration, run `bundle exec sequelizer update_gemfile`.  The command will look up the right gem to use with the adapter you've specified, add a line to your Gemfile specifying that gem, and run `bundle install` to install the gem for you.
+
+Once you've specified your options and made sure your database's gem is installed, simply include the Sequelizer module in any class that needs a database connection and you'll get two handy-dandy methods: `db` and `new_db`
+
+Observe:
+```ruby
+require 'sequelizer'
+
+class ClassThatNeedsSomeDBLove
+  include Sequelizer
+
+  def my_super_cool_method_that_needs_to_talk_to_a_db
+    db[:my_awesome_table].join(
+      db[:another_great_table].select(:an_important_column),
+      [:an_important_column])
+  end
+end
+```
+
+`db` will create a new connection to the database and cache that connection so that subsequent calls to `db` will use the same connection.
+
+`new_db` will create a new connection to the database on each call.
+
+Both take a hash of database options if you don't want to create a config/database.yml or .env file, or simply wish to override those options.  The options you pass in aren't merged against any other configuration files you might have set up.
+
+Take a look at the examples directory for a few ways you can specify your database configuration options.
+
+## Frustrations
+
+I can't seem to figure out a way to avoid having to specify the database gem in the a user's bundler file.  If anyone has ideas on how to automagically load the correct database gem based on the database options fed to Sequelizer, please let me know!
+
+## Contributing
+
+1. Fork it ( http://github.com/outcomesinsights/sequelizer/fork )
+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
+
+## Thanks
+
+- [Outcomes Insights, Inc.](http://outins.com)
+    - Many thanks for allowing me to release a portion of my work as Open Source Software!
+- Jeremy Evans
+    - For writing Sequel!
+
+## License
+Released under the MIT license, Copyright (c) 2014 Outcomes Insights, Inc.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/sequelizer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sequelizer/cli'
+
+Sequelizer::CLI.start(ARGV)

data/examples/database.with_one_set_of_options.yml

@@ -0,0 +1,15 @@
+# A normal database.yml file contains a file with many different database
+# configurations specified, one for each "environment".
+#
+# This is a Rails convention, but frankly, most of the time I have a single
+# environment in my one-off scripts and don't want to bother with specifying
+# different environments.
+#
+# So I can just define my database options like so:
+---
+adapter: postgres # Note: postgresql also works, but Sequel prefers postgres
+database: my_database
+host: localhost
+username: my_user
+password: my_great_password
+

data/examples/database.yml

@@ -0,0 +1,30 @@
+# An example of a database.yml file that is very much like the kind we'd
+# find in a Rails app.
+#
+# There are three environments defined.
+#
+# Sequelizer will look for which environment to use by reading the contents
+# of your environment variables in the following order:
+# SEQUELIZER_ENV
+# RAILS_ENV
+# RACK_ENV
+#
+# If all of those are nil, we'll default to development
+common: &common
+  adapter: postgresql
+  host: localhost
+  username: my_username
+  password: my_password
+  schema_search_path: list,of,schemas
+
+development:
+  <<: *common
+  database: dev_database
+
+test:
+  adapter: sqlite
+  database: test.sqlite
+
+production:
+  <<: *common
+  database: production_database

data/examples/dot_env.txt

@@ -0,0 +1,10 @@
+# Normally you'd name this file '.env' and place it in
+# the root of your project's directoryo
+#
+# Then you'd specify your database options like so:
+SEQUELIZER_ADAPTER=postgres
+SEQUELIZER_USERNAME=my_username
+SEQUELIZER_PASSWORD=super_secret_password
+SEQUELIZER_DATABASE=name_of_database
+SEQUELIZER_HOST=localhost
+SEQUELIZER_SEARCH_PATH=list,of,schemas

data/lib/sequelizer.rb

@@ -0,0 +1,31 @@
+require 'sequelizer/version'
+require 'sequelizer/connection_maker'
+
+# Include this module in any class where you'd like to quickly establish
+# a Sequel connection to a database.
+module Sequelizer
+  # Instantiates and memoizes a database connection.  The +db+ method instantiates
+  # the connection on the first call and then memoizes itself so only a single
+  # connection is used on repeated calls
+  #
+  # options :: an optional set of database connection options.
+  #            If no options are provided, options are read from
+  #            config/database.yml or from .env or from environment variables.
+  def db(options = nil)
+    @_sequelizer_db ||= new_db(options)
+  end
+
+  # Instantiates and returns a new database connection on each call.
+  #
+  # options :: an optional set of database connection options.
+  #            If no options are provided, options are read from
+  #            config/database.yml or from .env or from environment variables.
+  def new_db(options = nil)
+    cm = ConnectionMaker.new(options)
+    conn = cm.connection
+    conn.define_singleton_method(:sequelizer_options) do
+      cm.options
+    end
+    conn
+  end
+end

data/lib/sequelizer/cli.rb

@@ -0,0 +1,13 @@
+require 'thor'
+require_relative 'gemfile_modifier'
+
+module Sequelizer
+  class CLI < Thor
+    desc 'update_gemfile', 'adds or replaces a line in your Gemfile to include the correct database adapter to work with Sequel'
+    option 'dry-run', type: :boolean, desc: 'Only prints out what it would do, but makes no changes'
+    option 'skip-bundle', type: :boolean, desc: "Don't run `bundle install` after modifying Gemfile"
+    def update_gemfile
+      GemfileModifier.new(options).modify
+    end
+  end
+end

data/lib/sequelizer/connection_maker.rb

@@ -0,0 +1,28 @@
+require 'sequel'
+require_relative 'options'
+
+module Sequelizer
+  # Class that handles loading/interpretting the database options and
+  # creates the Sequel connection
+  class ConnectionMaker
+    # The options for Sequel.connect
+    attr :options
+
+    # Accepts an optional set of database options
+    #
+    # If no options are provided, attempts to read options from
+    # config/database.yml
+    #
+    # If config/database.yml doesn't exist, Dotenv is used to try to load a
+    # .env file, then uses any SEQUELIZER_* environment variables as
+    # database options
+    def initialize(options = nil)
+      @options = Options.new(options)
+    end
+
+    # Returns a Sequel connection to the database
+    def connection
+      Sequel.connect(options.to_hash)
+    end
+  end
+end

data/lib/sequelizer/env_config.rb

@@ -0,0 +1,20 @@
+require 'dotenv'
+
+module Sequelizer
+  # Creates a set of database configuration options from environment
+  # variables
+  class EnvConfig
+    # Any environment variables in the .env file are loaded and then
+    # any environment variable starting with SEQUELIZER_ will be used
+    # as an option for the database
+    def options
+      Dotenv.load
+      env_config = ENV.keys.select { |key| key =~ /^SEQUELIZER_/ }.inject({}) do |config, key|
+        new_key = key.gsub(/^SEQUELIZER_/, '').downcase
+        config[new_key] = ENV[key]
+        config
+      end
+      env_config.empty? ? nil : env_config
+    end
+  end
+end

data/lib/sequelizer/gemfile_modifier.rb

@@ -0,0 +1,85 @@
+require_relative 'options'
+
+module Sequelizer
+  class GemfileModifier
+    attr :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def modify
+      check_for_gemfile
+      if gemfile_needs_modification?
+        modify_gemfile
+        run_bundle unless options['skip-bundle']
+      else
+        puts "Gemfile needs no modification"
+      end
+    end
+
+    private
+
+    def modify_gemfile
+      puts %Q|Adding "#{gem_line}" to Gemfile|
+      return if options['dry-run']
+
+      File.write(gemfile, modified_lines.join("\n"))
+    end
+
+    def proper_gem
+      opts = Options.new
+      @proper_gem ||= case opts.adapter
+      when 'postgres'
+        'pg'
+      when 'sqlite'
+        'sqlite3'
+      when 'mysql'
+        'mysql2'
+      when nil
+        raise "No database adapter defined in your Sequelizer configuration"
+      else
+        raise "Don't know which database gem to use with adapter: #{opts.adapter}"
+      end
+    end
+
+    def gem_line
+      "gem '#{proper_gem}'"
+    end
+
+    def gem_line_comment
+      '# ADDED BY SEQUELIZER'
+    end
+
+    def full_gem_line
+      [gem_line, gem_line_comment].join(' ')
+    end
+
+    def gemfile_needs_modification?
+      !(gemfile_lines.include?(gem_line) || gemfile_lines.include?(full_gem_line))
+    end
+
+    def gemfile_lines
+      @gemfile_lines ||= File.readlines(gemfile).map(&:chomp)
+    end
+
+    def modified_lines
+      gemfile_lines.select { |l| l !~ Regexp.new(gem_line_comment) } + [full_gem_line]
+    end
+
+    def check_for_gemfile
+      return if gemfile.exist?
+      raise "Could not find Gemfile in current directory: #{Pathname.pwd}"
+    end
+
+    def run_bundle
+      puts "Running `bundle install` to update dependencies"
+      system('bundle install')
+    end
+
+    def gemfile
+      @gemfile ||= Pathname.new('Gemfile')
+    end
+  end
+end
+

data/lib/sequelizer/options.rb

@@ -0,0 +1,64 @@
+require 'sequelizer/yaml_config'
+require 'sequelizer/env_config'
+
+module Sequelizer
+  class Options
+    def initialize(options = nil)
+      @options = fix_options(options || db_config)
+    end
+
+    def to_hash
+      @options
+    end
+
+    %w(adapter database username password search_path).each do |name|
+      define_method(name) do
+        @options[name]
+      end
+    end
+
+    private
+
+    # If passed a hash, scans hash for certain options and sets up hash
+    # to be fed to Sequel.connect
+    #
+    # If fed anything, like a string that represents the URL for a DB,
+    # the string is returned without modification
+    def fix_options(sequelizer_options)
+      return sequelizer_options unless sequelizer_options.is_a?(Hash)
+
+      search_path = sequelizer_options['search_path'] || sequelizer_options['schema_search_path']
+      sequelizer_options['adapter'] = 'postgres' if sequelizer_options['adapter'] =~ /^postgres/
+      if search_path && sequelizer_options['adapter'] =~ /postgres/i
+        sequelizer_options['after_connect'] = after_connect(search_path)
+      end
+
+      sequelizer_options
+    end
+
+    # Grabs the database options from
+    #  - config/database.yml if it exists
+    #  - environment variables (also reads from .env)
+    def db_config
+      @db_config ||= begin
+        YamlConfig.new.options || EnvConfig.new.options
+      end
+    end
+
+    # Returns a proc that should be executed after Sequel connects to the
+    # datebase.
+    #
+    # Right now, the only thing that happens is if we're connecting to
+    # PostgreSQL and the schema_search_path is defined, each schema
+    # is created if it doesn't exist, then the search_path is set for
+    # the connection.
+    def after_connect(search_path)
+      Proc.new do |conn|
+        search_path.split(',').map(&:strip).each do |schema|
+          conn.execute("CREATE SCHEMA IF NOT EXISTS #{schema}")
+        end
+        conn.execute("SET search_path TO #{search_path}")
+      end
+    end
+  end
+end

data/lib/sequelizer/version.rb

@@ -0,0 +1,4 @@
+module Sequelizer
+  # Version for the gem
+  VERSION = "0.0.1"
+end

data/lib/sequelizer/yaml_config.rb

@@ -0,0 +1,44 @@
+require 'psych'
+
+module Sequelizer
+  class YamlConfig
+    # Returns a set of options pulled from config/database.yml
+    # or +nil+ if config/database.yml doesn't exist
+    def options
+      return nil unless config_file.exist?
+      config['adapter'] ? config : config[environment]
+    end
+
+    # The environment to load from database.yml
+    #
+    # Searches the following environment variables in this order:
+    # * SEQUELIZER_ENV
+    # * RAILS_ENV
+    # * RACK_ENV
+    #
+    # Lastly, if none of those environment variables are specified, the
+    # environment defaults to 'development'
+    def environment
+      ENV['SEQUELIZER_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    private
+
+    # The Pathname to config/database.yml
+    def config_file
+      @config_file ||= begin
+        root + 'config' + 'database.yml'
+      end
+    end
+
+    # The root directory to search for config/database.yml
+    def root
+      @root ||= Pathname.pwd
+    end
+
+    # The config as read from config/database.yml
+    def config
+      @config ||= Psych.load_file(config_file)
+    end
+  end
+end

data/sequelizer.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequelizer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sequelizer'
+  spec.version       = Sequelizer::VERSION
+  spec.authors       = ['Ryan Duryea']
+  spec.email         = ['aguynamedryan@gmail.com']
+  spec.summary       = %q{Sequel database connections via config/database.yml or .env}
+  spec.description   = %q{Easily establish a connection to a database via Sequel gem using options specified in config/database.yml or .env files}
+  spec.homepage      = 'https://github.com/outcomesinsights/sequelizer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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', '~> 1.5'
+  spec.add_development_dependency 'guard', '~> 2.0'
+  spec.add_development_dependency 'guard-minitest', '~> 2.3'
+  spec.add_development_dependency 'minitest', '~> 5.3'
+  spec.add_dependency 'sequel', '~> 4.12'
+  spec.add_dependency 'dotenv', '~> 0.11'
+  spec.add_dependency 'thor', '~> 0.19'
+end

data/test/sequelizer/test_connection_maker.rb

@@ -0,0 +1,48 @@
+require_relative '../test_helper'
+require_relative '../../lib/sequelizer'
+
+class TestConnectionMaker < Minitest::Test
+  def setup
+    @options = { 'adapter' => 'sqlite' }
+    @sequel_mock = Minitest::Mock.new
+    stub_const(Sequelizer::ConnectionMaker, :Sequel, @sequel_mock)
+    @sequel_mock.expect :connect, :connection, [@options]
+  end
+
+  def teardown
+    @sequel_mock.verify
+    remove_stubbed_const(Sequelizer::ConnectionMaker, :Sequel)
+  end
+
+  def test_accepts_options_as_params
+    assert_equal :connection, Sequelizer::ConnectionMaker.new(@options).connection
+  end
+
+  def test_reads_options_from_yaml_config
+    yaml_config = Minitest::Mock.new
+    yaml_config.expect :options, @options
+
+    Sequelizer::YamlConfig.stub :new, yaml_config do
+      assert_equal :connection, Sequelizer::ConnectionMaker.new.connection
+    end
+
+    yaml_config.verify
+  end
+
+  def test_reads_options_from_env_config_if_no_yaml_config
+    yaml_config = Minitest::Mock.new
+    yaml_config.expect :options, nil
+
+    env_config = Minitest::Mock.new
+    env_config.expect :options, @options
+
+    Sequelizer::YamlConfig.stub :new, yaml_config do
+      Sequelizer::EnvConfig.stub :new, env_config do
+        assert_equal :connection, Sequelizer::ConnectionMaker.new.connection
+      end
+    end
+
+    env_config.verify
+    yaml_config.verify
+  end
+end

data/test/sequelizer/test_env_config.rb

@@ -0,0 +1,22 @@
+require_relative '../test_helper'
+require_relative '../../lib/sequelizer/env_config'
+
+
+class TestEnvConfig < Minitest::Test
+  def setup
+    @env_config = Sequelizer::EnvConfig.new
+  end
+  def test_loads_dotenv
+    mock = Minitest::Mock.new
+    stub_const(Sequelizer::EnvConfig, :Dotenv, mock) do
+      mock.expect :load, nil
+      @env_config.options
+      mock.verify
+    end
+  end
+
+  def test_converts_sequelizer_vars_to_options
+    ENV['SEQUELIZER_ADAPTER'] = 'sqlite'
+    assert_equal({ 'adapter' => 'sqlite' }, @env_config.options)
+  end
+end

data/test/sequelizer/test_gemfile_modifier.rb

@@ -0,0 +1,87 @@
+require_relative '../test_helper'
+require_relative '../../lib/sequelizer/gemfile_modifier'
+
+class TestGemfileModifier < Minitest::Test
+  def setup
+    @gm = Sequelizer::GemfileModifier.new
+  end
+
+  def test_dies_if_Gemfile_missing
+    pn_mock = Minitest::Mock.new
+    pn_mock.expect(:exist?, false)
+    Pathname.stub(:new, pn_mock) do
+      assert_raises(RuntimeError) { @gm.modify }
+    end
+    pn_mock.verify
+  end
+
+  def test_quits_if_no_modification_needed
+    opts_mock = Minitest::Mock.new
+    pn_mock = standard_pn_mock
+    opts_mock.expect(:adapter, 'postgres')
+    file_mock = Minitest::Mock.new
+    file_mock.expect(:readlines, ["gem 'pg'"], [pn_mock])
+
+    Pathname.stub(:new, pn_mock) do
+      Sequelizer::Options.stub(:new, opts_mock) do
+        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
+          stub_modifying_methods(@gm) do
+            @gm.modify
+          end
+        end
+      end
+    end
+  end
+
+  def test_quits_if_no_modification_needed2
+    opts_mock = Minitest::Mock.new
+    pn_mock = standard_pn_mock
+    opts_mock.expect(:adapter, 'postgres')
+    file_mock = Minitest::Mock.new
+    file_mock.expect(:readlines, ["gem 'pg' # ADDED BY SEQUELIZER"], [pn_mock])
+
+    Pathname.stub(:new, pn_mock) do
+      Sequelizer::Options.stub(:new, opts_mock) do
+        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
+          stub_modifying_methods(@gm) do
+            @gm.modify
+          end
+        end
+      end
+    end
+  end
+
+  def test_writes_if_modification_needed
+    opts_mock = Minitest::Mock.new
+    pn_mock = standard_pn_mock
+    opts_mock.expect(:adapter, 'postgres')
+    file_mock = Minitest::Mock.new
+    file_mock.expect(:readlines, ['#comment line', "gem 'sqlite3' # ADDED BY SEQUELIZER"], [pn_mock])
+    file_mock.expect(:write, nil, [pn_mock, ['#comment line', "gem 'pg' # ADDED BY SEQUELIZER"].join("\n")])
+
+    Pathname.stub(:new, pn_mock) do
+      Sequelizer::Options.stub(:new, opts_mock) do
+        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
+          stub_modifying_methods(@gm) do
+            @gm.modify
+          end
+        end
+      end
+    end
+  end
+
+  private
+  def standard_pn_mock
+    pn_mock = Minitest::Mock.new
+    pn_mock.expect(:exist?, true)
+  end
+
+  def stub_modifying_methods(obj)
+    obj.stub(:system, nil) do
+      obj.stub(:puts, nil) do
+        yield
+      end
+    end
+  end
+end
+

data/test/sequelizer/test_yaml_config.rb

@@ -0,0 +1,50 @@
+require_relative '../test_helper'
+require_relative '../../lib/sequelizer/yaml_config'
+
+
+class TestYamlConfig < Minitest::Test
+  def setup
+    @yaml_config = Sequelizer::YamlConfig.new
+  end
+
+  def test_loads_from_yaml_file_if_present
+    mock = Minitest::Mock.new
+    file_mock = Minitest::Mock.new
+
+    stub_const(Sequelizer::YamlConfig, :Psych, mock) do
+      mock.expect :load_file, { 'adapter' => 'sqlite' }, [file_mock]
+      file_mock.expect :exist?, true
+
+      @yaml_config.stub :config_file, file_mock do
+        assert_equal({ 'adapter' => 'sqlite' }, @yaml_config.options)
+      end
+
+      file_mock.verify
+      mock.verify
+    end
+  end
+
+  def test_loads_by_environment_if_present
+    file_mock = Minitest::Mock.new
+    file_mock.expect :exist?, true
+    @yaml_config.stub :config_file, file_mock do
+      @yaml_config.stub :config, {'development' => { 'adapter' => 'sqlite' }} do
+        assert_equal({ 'adapter' => 'sqlite' }, @yaml_config.options)
+      end
+    end
+    file_mock.verify
+  end
+
+  def test_environment_checks_environment_variables
+    env_mock = Minitest::Mock.new
+    env_mock.expect :[], nil, ['SEQUELIZER_ENV']
+    env_mock.expect :[], nil, ['RAILS_ENV']
+    env_mock.expect :[], nil, ['RACK_ENV']
+
+    stub_const(Sequelizer::YamlConfig, :ENV, env_mock) do
+      assert_equal 'development', @yaml_config.environment
+    end
+
+    env_mock.verify
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+
+class Minitest::Test
+  def stub_const(klass, const, replace, &block)
+    klass.send(:const_set, const, replace)
+    if block_given?
+      yield
+      remove_stubbed_const(klass, const)
+    end
+  end
+
+  def remove_stubbed_const(klass, const)
+    klass.send(:remove_const, const)
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: sequelizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Duryea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: Easily establish a connection to a database via Sequel gem using options
+  specified in config/database.yml or .env files
+email:
+- aguynamedryan@gmail.com
+executables:
+- sequelizer
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/sequelizer
+- examples/database.with_one_set_of_options.yml
+- examples/database.yml
+- examples/dot_env.txt
+- lib/sequelizer.rb
+- lib/sequelizer/cli.rb
+- lib/sequelizer/connection_maker.rb
+- lib/sequelizer/env_config.rb
+- lib/sequelizer/gemfile_modifier.rb
+- lib/sequelizer/options.rb
+- lib/sequelizer/version.rb
+- lib/sequelizer/yaml_config.rb
+- sequelizer.gemspec
+- test/sequelizer/test_connection_maker.rb
+- test/sequelizer/test_env_config.rb
+- test/sequelizer/test_gemfile_modifier.rb
+- test/sequelizer/test_yaml_config.rb
+- test/test_helper.rb
+homepage: https://github.com/outcomesinsights/sequelizer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Sequel database connections via config/database.yml or .env
+test_files:
+- test/sequelizer/test_connection_maker.rb
+- test/sequelizer/test_env_config.rb
+- test/sequelizer/test_gemfile_modifier.rb
+- test/sequelizer/test_yaml_config.rb
+- test/test_helper.rb