gem_suit 0.1.0

data/lib/gem_suit/application/actions.rb

@@ -0,0 +1,203 @@
+require "pathname"
+require "rich/support/core/string/colorize"
+require "gem_suit/application/utils"
+
+module GemSuit
+  class Application < ::Thor::Group
+    module Actions
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, Utils
+        base.send :include, InstanceMethods
+        base.send :include, Thor::Actions
+      end
+
+      module ClassMethods
+        def restore_all
+          self.new.restore_all true
+        end
+
+        def stash_all
+          self.new.stash_all
+        end
+      end
+
+      module InstanceMethods
+        attr_accessor :config, :verbose
+
+        def restore_files
+          # Implement in subclass
+        end
+
+        def stash_files
+          # Implement in subclass
+        end
+
+        def locals_for_template(path)
+          # Implement in subclass
+        end
+
+        def config
+          @config || {}
+        end
+
+        def locals
+          @locals ||= (locals_for_template @relative_path if @relative_path) || {}
+        end
+
+        def restore_all(force = nil)
+          if @prepared
+            unless force
+              log "Cannot (non-forced) restore files after having prepared the test application" unless force.nil?
+              return
+            end
+          end
+
+          return if restore_files == false
+
+          if File.exists?(new_files = expand_path(".new_files"))
+            File.readlines(new_files).each do |line|
+              delete line.strip
+            end
+            File.delete new_files
+          end
+
+          restore "app/models/**/*.#{STASHED_EXT}"
+          restore "app/views/**/*.#{STASHED_EXT}"
+          restore "db/**/*.#{STASHED_EXT}"
+          restore "public/**/*.#{STASHED_EXT}"
+          restore "test/**/*.#{STASHED_EXT}"
+          restore "**/*.#{STASHED_EXT}"
+          true
+        end
+
+        def stash_all
+          return if stash_files == false
+          stash "Gemfile.lock"
+          ["shared", "rails-#{rails_version}"].each do |dir|
+            dir_path = File.expand_path dir, templates_path
+            next unless File.exists? dir_path
+            root = Pathname.new dir_path
+            Dir[File.expand_path("**/*", root.realpath)].each do |file|
+              next if File.directory? file
+              path = Pathname.new file
+              write path.relative_path_from(root).to_s
+            end
+          end
+          true
+        end
+
+        def skip(action, string)
+          ((@skipped_files ||= {})[action] ||= []) << string
+        end
+
+        def skip?(action, string)
+          return false if @skipped_files.nil? || @skipped_files[action].nil?
+          !!@skipped_files[action].detect{|x| File.fnmatch? expand_path(x), string}
+        end
+
+        def restore(string)
+          Dir[expand_path(string)].each do |file|
+            next unless File.exists? stashed(file)
+            next if skip? :restore, file
+            delete original(file)
+            log :restoring, stashed(file)
+            File.rename stashed(file), original(file)
+          end
+        end
+
+        def delete(string)
+          Dir[expand_path(string)].each do |file|
+            next if skip? :deleting, file
+            log :deleting, file
+            File.delete file
+          end
+
+          dirname = expand_path File.dirname(string)
+          return unless File.exists?(dirname)
+
+          Dir.glob("#{dirname}/*", File::FNM_DOTMATCH) do |file|
+            return unless %w(. ..).include? File.basename(file)
+          end
+
+          log :deleting, dirname
+          Dir.delete dirname
+        end
+
+        def write(string)
+          return if skip? :write, string
+          stash string
+          create string
+        end
+
+        def stash(string)
+          Dir[expand_path(string)].each do |file|
+            next if new_file?(file) || File.exists?(stashed(file))
+            next if skip? :stash, file
+            log :stashing, original(file)
+            File.rename original(file), stashed(file)
+          end
+        end
+
+        def create(string)
+          new_files = []
+
+          ["shared", "rails-#{rails_version}"].each do |dir|
+            path = File.expand_path dir, templates_path
+            next unless File.exists? path
+            root = Pathname.new path
+            Dir[File.expand_path(string, root.realpath)].each do |file|
+              next if File.directory? file
+              next if skip? :create, file
+              begin
+                @relative_path = Pathname.new(file).relative_path_from(root).to_s
+                @locals        = nil
+                new_files << @relative_path unless new_file?(expand_path(@relative_path)) || File.exists?(stashed(@relative_path))
+                log :creating, expand_path(@relative_path)
+                template file, expand_path(@relative_path), :verbose => false
+              ensure
+                @relative_path = nil
+              end
+            end
+          end
+
+          unless new_files.empty?
+            File.open(expand_path(".new_files"), "a") do |file|
+              file << new_files.collect{|x| "#{x}\n"}.join("")
+            end
+          end
+        end
+
+        def copy(source, destination)
+          log :copying, "#{source} -> #{destination}"
+          FileUtils.cp expand_path(source), expand_path(destination)
+        end
+
+        def generate(*args)
+          return if skip? :generate, args.first
+          command = case rails_version
+                    when 2
+                      "script/generate"
+                    when 3
+                      "rails g"
+                    end
+
+          execute "#{command} #{args.join(" ")}"
+          @ran_generator = true
+        end
+
+      private
+
+        def method_missing(method, *args)
+          if locals.include? method
+            locals[method]
+          else
+            super
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/gem_suit/application/test.rb

@@ -0,0 +1,106 @@
+module GemSuit
+  class Application < ::Thor::Group
+    module Test
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def create_test_database
+          self.new.create_test_database
+        end
+
+        def setup(*args)
+          self.new.setup *args
+        end
+
+        def test(*args)
+          self.new.test *args
+        end
+      end
+
+      module InstanceMethods
+        attr_accessor :config, :verbose
+
+        def description
+          # Implement in subclass
+        end
+
+        def prepare
+          # Implement in subclass
+        end
+
+        def create_test_database
+          write   "config/database.yml"
+          execute "RAILS_ENV=test rake db:create"
+        ensure
+          restore "**/*.#{STASHED_EXT}"
+        end
+
+        def setup(config = {})
+          @skipped_files = nil
+          @config = config
+
+          log "\n".ljust 145, "="
+          log "Setting up test environment for Rails #{[rails_version, description].compact.join(" - ")}\n"
+          log "\n".rjust 145, "="
+
+          restore_all
+          stash_all
+          bundle_install
+
+          prepare
+          prepare_database
+          @prepared = true
+        end
+
+        def test(config = {})
+          setup config
+
+          log "\n".rjust 145, "="
+          log "Environment for Rails #{[rails_version, description].compact.join(" - ")} is ready for testing"
+          log "=" .ljust 144, "="
+
+          run_environment
+        end
+
+        def prepare_database
+          return if @db_prepared
+          if @ran_generator
+            stash   "db/schema.rb"
+            execute "rake db:test:purge"
+            execute "RAILS_ENV=test rake db:migrate"
+          else
+            execute "rake db:test:load"
+          end
+          @db_prepared = true
+        end
+
+        def run_environment
+          ENV["RAILS_ENV"] = "test"
+
+          require File.expand_path("config/environment.rb", root_path)
+          require "#{"rails/" if Rails::VERSION::MAJOR >= 3}test_help"
+
+          begin
+            require "gem_suit/integration_test"
+          rescue LoadError
+            gem_suit_path = File.expand_path "../../..", __FILE__
+            $:.unshift gem_suit_path
+            require "gem_suit/integration_test"
+          end
+
+          Dir[File.expand_path("../#{File.basename(self.class.__file__, ".rb")}/**/*.rb", self.class.__file__)].each do |file|
+            next if skip? :require, file
+            require file
+          end
+
+          log "\nRunning Rails #{Rails::VERSION::STRING}\n\n"
+        end
+      end
+
+    end
+  end
+end

data/lib/gem_suit/application/utils/gemfile.rb

@@ -0,0 +1,42 @@
+module GemSuit
+  class Application < ::Thor::Group
+    module Utils
+      class Gemfile
+
+        # A simple class which derives a Gemfile
+
+        attr_accessor :source
+
+        def initialize(*files)
+          @files = files
+        end
+
+        def gems
+          @gems ||= begin
+            @gems     = {}
+            gem_file  = @files.detect{|file| File.exists? file}
+            gem_specs = File.readlines(gem_file).join "\n"
+            instance_eval gem_specs
+            gems
+          end
+        end
+
+        def source(src)
+          source = src
+        end
+
+        def gem(name, *args)
+          options = (args.pop if args.last.is_a?(Hash)) || {}
+          options[:version] = args.first if args.first.is_a?(String)
+          @gems[name] = options
+        end
+
+        def method_missing(method, *args)
+          # e.g. group :test do
+          # end
+        end
+
+      end
+    end
+  end
+end

data/lib/gem_suit/application/utils.rb

@@ -0,0 +1,135 @@
+STDOUT.sync = true
+
+require "gem_suit/application/utils/gemfile"
+
+module GemSuit
+  class Application < ::Thor::Group
+    module Utils
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        attr_accessor :__file__
+
+        def inherited(klass)
+          klass.__file__ = caller.first[/^[^:]+/]
+        end
+
+        def bundle_install
+          self.new.bundle_install
+        end
+      end
+
+      module InstanceMethods
+        attr_accessor :root_path, :validate_root_path
+
+        def bundle_install
+          return unless bundle_install?
+          if verbose
+            execute "bundle install", "(this can take several minutes...)"
+          else
+            puts "Running `bundle install` (this can take several minutes...)".yellow
+            puts "(in #{root_path})"
+            `cd #{root_path} && bundle install`
+          end
+        end
+
+        def bundle_install?
+          `cd #{root_path} && bundle check`.any?{|line| line.include? "`bundle install`"}
+        end
+
+        def validate_root_path!(path)
+          unless path.match(/rails-\d/)
+            log "Running a #{self.class.name} instance from an invalid path: '#{path}' needs to match ".red + "/rails-\\d/".yellow
+            exit
+          end
+        end
+
+        def root_path
+          (@root_path || (Rails.root if defined? Rails) || begin
+            dir = File.expand_path "../..", self.class.__file__
+            File.exists?("#{dir}/config/environment.rb") ? dir : Dir[File.expand_path("#{dir}/../rails-*/dummy")].last
+          end).to_s.tap do |path|
+            validate_root_path! path if validate_root_path
+            self.class.source_root = path
+          end
+        end
+
+        def shared_path
+          File.expand_path("../../shared", root_path)
+        end
+
+        def templates_path
+          File.expand_path("../../templates", root_path)
+        end
+
+        def expand_path(path)
+          Pathname.new(path).absolute? ?
+            path :
+            File.expand_path(path, root_path)
+        end
+
+        def original(file)
+          expand_path file.gsub(/\.#{STASHED_EXT}$/, "")
+        end
+
+        def stashed(file)
+          expand_path file.match(/\.#{STASHED_EXT}$/) ? file : "#{file}.#{STASHED_EXT}"
+        end
+
+        def new_file?(file)
+          return false unless File.exists? expand_path(".new_files")
+          root          = Pathname.new root_path
+          relative_path = Pathname.new(file).relative_path_from(root).to_s
+          File.readlines(expand_path(".new_files")).any?{|line| line.strip == relative_path}
+        end
+
+        def rails_version
+          root_path.match(/\/rails-(\d)\//)[1].to_i
+        end
+
+        def rails_gem_version
+          case rails_version
+          when 2
+            File.readlines(expand_path("config/environment.rb")).each do |line|
+              match = line.match /RAILS_GEM_VERSION\s*=\s*["']([\d\.]+)["']/
+              return $1 if match
+            end
+          when 3
+            files = [expand_path(stashed("Gemfile")), expand_path("Gemfile")]
+            Gemfile.new(*files).gems["rails"][:version]
+          end
+        end
+
+        def mysql_password
+          file = File.expand_path("mysql", shared_path)
+          "#{File.new(file).read}".strip if File.exists? file
+        end
+
+        def execute(command, text = "")
+          return if command.to_s.gsub(/\s/, "").size == 0
+          log :executing, "#{command} #{text}"
+          `cd #{root_path} && #{command}`
+        end
+
+        def log(action, string_or_force = nil, force = nil)
+          if %w(TrueClass FalseClass).include? string_or_force.class.name
+            string = nil
+            force  = string_or_force
+          else
+            string = string_or_force
+            force  = false
+          end
+          return unless verbose || force
+          output = [string || action]
+          output.unshift action.to_s.capitalize.ljust(10, " ") unless string.nil?
+          puts output.join("  ")
+        end
+      end
+
+    end
+  end
+end

data/lib/gem_suit/application.rb

@@ -0,0 +1,42 @@
+require "optparse"
+require "thor/group"
+require "gem_suit/application/actions"
+require "gem_suit/application/test"
+
+module GemSuit
+  class Application < ::Thor::Group
+
+    include Application::Actions
+    include Application::Test
+
+    STASHED_EXT = "stashed"
+
+    def initialize(options = {:validate_root_path => true})
+      super [], {}, {}
+
+      begin
+        OptionParser.new do |opts|
+          opts.on "-v", "--[no-]verbose" do |v|
+            options[:verbose] ||= v
+          end
+        end.parse! ARGV
+      rescue OptionParser::InvalidOption
+      end
+
+      options.each do |key, value|
+        send :"#{key}=", value
+      end
+    end
+
+    class << self
+      def source_root
+        @source_root
+      end
+
+      def source_root=(path)
+        @source_root = path
+      end
+    end
+
+  end
+end

data/lib/gem_suit/cli/application/io_buffer.rb

@@ -0,0 +1,54 @@
+module GemSuit
+  class CLI < Thor
+    module Application
+      class IOBuffer
+
+        def self.capture(&block)
+          self.new.capture &block
+        end
+
+        def capture(&block)
+          @data = nil
+          data.record do
+            yield self
+          end
+        end
+
+        def log(line)
+          data << "GemSuit: #{line}"
+        end
+
+        def execute(command)
+          IO.popen(command) do |io|
+            until io.eof?
+              puts (data << io.gets).last
+            end
+          end
+        end
+
+      private
+
+        def data
+          @data ||= BufferData.new
+        end
+
+        class BufferData
+          attr_reader :output, :start, :finish
+
+          def record(&block)
+            @output = []
+            @start  = Time.now
+            yield
+            @finish = Time.now
+            self
+          end
+
+          def <<(string)
+            @output << string
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/gem_suit/cli/application/test_loader.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# Load the test files from the command line.
+
+ARGV.each { |f| load f unless f =~ /^-/  }