snowglobe 0.1.0

data/lib/snowglobe/database_adapters/postgresql.rb

@@ -0,0 +1,25 @@
+module Snowglobe
+  module DatabaseAdapters
+    class PostgreSQL
+      def self.name
+        :postgresql
+      end
+
+      attr_reader :database
+
+      def initialize(database)
+        @database = database
+      end
+
+      def adapter
+        self.class.name
+      end
+
+      def require_dependencies
+        require "pg"
+      end
+    end
+
+    DatabaseConfigurationRegistry.instance.register(PostgreSQL)
+  end
+end

data/lib/snowglobe/database_adapters/sqlite3.rb

@@ -0,0 +1,26 @@
+module Snowglobe
+  module DatabaseAdapters
+    class SQLite3
+      def self.name
+        :sqlite3
+      end
+
+      def initialize(_database)
+      end
+
+      def adapter
+        self.class.name
+      end
+
+      def database
+        "db/db.sqlite3"
+      end
+
+      def require_dependencies
+        require "sqlite3"
+      end
+    end
+
+    DatabaseConfigurationRegistry.instance.register(SQLite3)
+  end
+end

data/lib/snowglobe/database_configuration.rb

@@ -0,0 +1,33 @@
+require_relative "database_configuration_registry"
+require "delegate"
+
+module Snowglobe
+  class DatabaseConfiguration < SimpleDelegator
+    ENVIRONMENTS = %w(development test production).freeze
+
+    attr_reader :adapter_class
+
+    def self.for(database_name, adapter_name)
+      config_class = DatabaseConfigurationRegistry.instance.get(adapter_name)
+      config = config_class.new(database_name)
+      new(config)
+    end
+
+    def initialize(config)
+      @adapter_class = config.class.to_s.split("::").last
+      super(config)
+    end
+
+    def to_hash
+      ENVIRONMENTS.each_with_object({}) do |env, config_as_hash|
+        config_as_hash[env] = inner_config_as_hash
+      end
+    end
+
+    private
+
+    def inner_config_as_hash
+      { "adapter" => adapter.to_s, "database" => database.to_s }
+    end
+  end
+end

data/lib/snowglobe/database_configuration_registry.rb

@@ -0,0 +1,28 @@
+require "singleton"
+
+module Snowglobe
+  class DatabaseConfigurationRegistry
+    include Singleton
+
+    def initialize
+      @registry = {}
+    end
+
+    def register(config_class)
+      registry[config_class.name] = config_class
+    end
+
+    def get(name)
+      registry.fetch(name) do
+        raise KeyError, "No such adapter registered: #{name}"
+      end
+    end
+
+    protected
+
+    attr_reader :registry
+  end
+end
+
+require_relative "database_adapters/postgresql"
+require_relative "database_adapters/sqlite3"

data/lib/snowglobe/filesystem.rb

@@ -0,0 +1,95 @@
+require "fileutils"
+
+module Snowglobe
+  class Filesystem
+    def clean
+      if root_directory.exist?
+        root_directory.rmtree
+      end
+    end
+
+    def project_directory
+      root_directory.join(Snowglobe.configuration.project_name)
+    end
+
+    def create_project
+      project_directory.mkpath
+    end
+
+    def within_project(&block)
+      Dir.chdir(project_directory, &block)
+    end
+
+    def find_in_project(path)
+      project_directory.join(path)
+    end
+
+    def open_file(path, *args, &block)
+      wrap_file(path).open(*args, &block)
+    end
+
+    def comment_lines_matching_in_file(path, pattern)
+      transform_file(path) do |lines|
+        lines.map do |line|
+          if line && line =~ pattern
+            "###{line}"
+          else
+            line
+          end
+        end
+      end
+    end
+
+    def transform_file(path)
+      content = read_file(path)
+      lines = content.split(/\n/)
+      transformed_lines = yield lines
+      write_file(path, transformed_lines.join("\n") + "\n")
+    end
+
+    def read_file(path)
+      wrap_file(path).read
+    end
+
+    def write_file(path, content)
+      pathname = wrap_file(path)
+      create_parents_of(pathname)
+      pathname.open("w") { |f| f.write(content) }
+      pathname
+    end
+
+    def append_to_file(path, content, _options = {})
+      pathname = wrap_file(path)
+      create_parents_of(pathname)
+      pathname.open("a") { |f| f.puts(content + "\n") }
+    end
+
+    def remove_from_file(path, pattern)
+      unless pattern.is_a?(Regexp)
+        pattern = Regexp.new("^" + Regexp.escape(pattern) + "$")
+      end
+
+      transform(path) do |lines|
+        lines.reject { |line| line =~ pattern }
+      end
+    end
+
+    private
+
+    def root_directory
+      Snowglobe.configuration.temporary_directory
+    end
+
+    def wrap_file(path)
+      if path.is_a?(Pathname)
+        path
+      else
+        find_in_project(path)
+      end
+    end
+
+    def create_parents_of(pathname)
+      pathname.dirname.mkpath
+    end
+  end
+end

data/lib/snowglobe/gem_version.rb

@@ -0,0 +1,55 @@
+module Snowglobe
+  class GemVersion
+    def initialize(version)
+      @version = Gem::Version.new(version.to_s + "")
+    end
+
+    def major
+      segments[0]
+    end
+
+    def minor
+      segments[1]
+    end
+
+    def <(other)
+      compare?(:<, other)
+    end
+
+    def <=(other)
+      compare?(:<=, other)
+    end
+
+    def ==(other)
+      compare?(:==, other)
+    end
+
+    def >=(other)
+      compare?(:>=, other)
+    end
+
+    def >(other)
+      compare?(:>, other)
+    end
+
+    def =~(other)
+      Gem::Requirement.new(other).satisfied_by?(version)
+    end
+
+    def to_s
+      version.to_s
+    end
+
+    private
+
+    attr_reader :version
+
+    def segments
+      @_segments ||= version.to_s.split(".")
+    end
+
+    def compare?(op, other)
+      Gem::Requirement.new("#{op} #{other}").satisfied_by?(version)
+    end
+  end
+end

data/lib/snowglobe/project_command_runner.rb

@@ -0,0 +1,69 @@
+module Snowglobe
+  class ProjectCommandRunner
+    def initialize(fs)
+      @fs = fs
+    end
+
+    def run_migrations!
+      run_rake_tasks!(["db:drop", "db:create", "db:migrate"])
+    end
+
+    def run_n_unit_tests(*paths)
+      run_command_within_bundle("ruby -I lib -I test", *paths)
+    end
+
+    def run_n_unit_test_suite
+      run_rake_tasks("test", env: { TESTOPTS: "-v" })
+    end
+
+    def run_rake_tasks!(*args, **options, &block)
+      run_rake_tasks(
+        *args,
+        **options,
+        run_successfully: true,
+        &block
+      )
+    end
+
+    def run_rake_tasks(*tasks)
+      options = tasks.last.is_a?(Hash) ? tasks.pop : {}
+      args = ["bundle", "exec", "rake", *tasks, "--trace"] + [options]
+      run(*args)
+    end
+
+    def run_within_bundle(*args)
+      run(*args) do |runner|
+        runner.command_prefix = "bundle exec"
+        runner.env["BUNDLE_GEMFILE"] = fs.find_in_project("Gemfile").to_s
+
+        runner.around_command do |run_command|
+          Bundler.with_clean_env(&run_command)
+        end
+
+        yield runner if block_given?
+      end
+    end
+
+    def run!(*args, **options, &block)
+      CommandRunner.run!(
+        *args,
+        directory: fs.project_directory,
+        **options,
+        &block
+      )
+    end
+
+    def run(*args, **options, &block)
+      CommandRunner.run(
+        *args,
+        directory: fs.project_directory,
+        **options,
+        &block
+      )
+    end
+
+    private
+
+    attr_reader :fs
+  end
+end

data/lib/snowglobe/rails_application.rb

@@ -0,0 +1,194 @@
+require "forwardable"
+require "yaml"
+
+require_relative "bundle"
+require_relative "database"
+require_relative "filesystem"
+require_relative "project_command_runner"
+
+module Snowglobe
+  class RailsApplication
+    extend Forwardable
+
+    def_delegators :bundle, :add_gem
+    def_delegators :fs, :append_to_file, :write_file
+    def_delegators :command_runner, :run_migrations!, :run_n_unit_test_suite
+
+    def initialize
+      @fs = Filesystem.new
+      @command_runner = ProjectCommandRunner.new(fs)
+      @bundle = Bundle.new(fs: fs, command_runner: command_runner)
+      @database = Database.new
+    end
+
+    def create
+      fs.clean
+      generate
+
+      fs.within_project do
+        # install_gems
+        remove_unwanted_gems
+      end
+    end
+
+    # def load
+    # load_environment
+    # run_migrations
+    # end
+
+    def evaluate!(code)
+      command_runner = nil
+
+      Dir::Tmpname.create(
+        ["", ".rb"],
+        fs.find_in_project("tmp"),
+      ) do |path, _, _, _|
+        tempfile = fs.write_file(path, code)
+
+        command_runner = run_command!(
+          "ruby",
+          tempfile.to_s,
+          err: nil,
+          env: { "RUBYOPT" => "" },
+        )
+      end
+
+      command_runner.output
+    end
+
+    def run_command!(*args, &block)
+      command_runner.run!(*args, &block)
+    end
+
+    # def gemfile_path
+    # fs.find("Gemfile")
+    # end
+
+    # def temp_views_directory
+    # fs.find_in_project("tmp/views")
+    # end
+
+    # def create_temp_view(path, contents)
+    # full_path = temp_view_path_for(path)
+    # full_path.dirname.mkpath
+    # full_path.open("w") { |f| f.write(contents) }
+    # end
+
+    # def delete_temp_views
+    # if temp_views_directory.exist?
+    # temp_views_directory.rmtree
+    # end
+    # end
+
+    # def draw_routes(&block)
+    # Rails.application.routes.draw(&block)
+    # Rails.application.routes
+    # end
+
+    def migration_class_name
+      if rails_version > 5
+        number = [rails_version.major, rails_version.minor].join(".").to_f
+        "ActiveRecord::Migration[#{number}]"
+      else
+        "ActiveRecord::Migration"
+      end
+    end
+
+    private
+
+    attr_reader :fs, :command_runner, :bundle, :database
+
+    def rails_version
+      @_rails_version ||= bundle.version_of("rails")
+    end
+
+    def migrations_directory
+      fs.find_in_project("db/migrate")
+    end
+
+    def temp_view_path_for(path)
+      temp_views_directory.join(path)
+    end
+
+    def generate
+      rails_new
+      fix_available_locales_warning
+      remove_bootsnap
+      write_database_configuration
+
+      if bundle.version_of("rails") >= 5
+        add_initializer_for_time_zone_aware_types
+      end
+    end
+
+    def rails_new
+      CommandRunner.run!(
+        %W(rails new #{fs.project_directory} --skip-bundle --no-rc),
+      )
+    end
+
+    def fix_available_locales_warning
+      # See here for more on this:
+      # http://stackoverflow.com/questions/20361428/rails-i18n-validation-deprecation-warning
+      fs.transform_file("config/application.rb") do |lines|
+        lines.insert(-3, <<-TEXT)
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = false
+end
+        TEXT
+      end
+    end
+
+    def remove_bootsnap
+      # Rails 5.2 introduced bootsnap, which is helpful when you're developing
+      # or deploying an app, but we don't really need it (and it messes with
+      # Zeus anyhow)
+      fs.comment_lines_matching_in_file(
+        "config/boot.rb",
+        %r{\Arequire 'bootsnap/setup'},
+      )
+    end
+
+    def write_database_configuration
+      fs.open_file("config/database.yml", "w") do |f|
+        YAML.dump(database.config.to_hash, f)
+      end
+    end
+
+    def add_initializer_for_time_zone_aware_types
+      path = "config/initializers/configure_time_zone_aware_types.rb"
+      fs.write_file(path, <<-TEXT)
+Rails.application.configure do
+  config.active_record.time_zone_aware_types = [:datetime, :time]
+end
+      TEXT
+    end
+
+    # def load_environment
+    # require environment_file_path
+    # end
+
+    # def environment_file_path
+    # fs.find_in_project("config/environment")
+    # end
+
+    # def run_migrations
+    # fs.within_project do
+    # run_command! "bundle exec rake db:drop db:create db:migrate"
+    # end
+    # end
+
+    # def install_gems
+    # bundle.install_gems
+    # end
+
+    def remove_unwanted_gems
+      bundle.updating do
+        bundle.remove_gem "debugger"
+        bundle.remove_gem "byebug"
+        bundle.add_gem "pry-byebug"
+        bundle.remove_gem "web-console"
+      end
+    end
+  end
+end

data/lib/snowglobe/test_helpers.rb

@@ -0,0 +1,19 @@
+module Snowglobe
+  module TestHelpers
+    def rails_app
+      @_rails_app ||= RailsApplication.new
+    end
+
+    def fs
+      rails_app.fs
+    end
+
+    def bundle
+      rails_app.bundle
+    end
+
+    def database
+      rails_app.database
+    end
+  end
+end

data/lib/snowglobe/version.rb

@@ -0,0 +1,3 @@
+module Snowglobe
+  VERSION = "0.1.0"
+end

data/lib/snowglobe.rb

@@ -0,0 +1,13 @@
+require_relative "snowglobe/configuration"
+require_relative "snowglobe/rails_application"
+require_relative "snowglobe/version"
+
+module Snowglobe
+  def self.configure(&block)
+    configuration.update!(&block)
+  end
+
+  def self.configuration
+    @_configuration ||= Configuration.new
+  end
+end

data/snowglobe.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "snowglobe/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "snowglobe"
+  spec.version       = Snowglobe::VERSION
+  spec.authors       = ["Elliot Winkler"]
+  spec.email         = ["elliot.winkler@gmail.com"]
+
+  spec.summary       = %q{Create temporary Rails applications for use in testing}
+  spec.description   = %q{Snowglobe is a gem that helps erect and destroy Rails applications for use in tests.}
+  spec.homepage      = "https://github.com/mcmire/snowglobe"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+    # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+end