gem_suit 0.1.0

data/lib/gem_suit/cli/application.rb

@@ -0,0 +1,159 @@
+require "gem_suit/cli/application/io_buffer"
+
+module GemSuit
+  class CLI < Thor
+    module Application
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def test_suit(file_or_pattern = nil)
+          assert_suit_dir
+
+          data = IOBuffer.capture do |buffer|
+            (options.rails_versions || major_rails_versions).each do |rails_version|
+              path  = "suit/rails-#{rails_version}/dummy/test/integration/suit/"
+              match = Dir[File.join(path, "**", "#{file_or_pattern || "*"}.rb")]
+              match = Dir[File.join(path, file_or_pattern)] if match.empty?
+
+              match.each do |f|
+                buffer.execute "ruby #{f} #{"-v" if options.very_verbose?}"
+              end
+            end
+          end
+
+          print_test_results "Suit", data
+        end
+
+        def test_unit(file_or_pattern = nil)
+          assert_suit_dir
+
+          loader = File.expand_path "../application/test_loader.rb", __FILE__
+
+          proc = Proc.new do |buffer, path|
+            buffer.execute "suit restore"
+
+            match = Dir[File.join(path, "**", "#{file_or_pattern || "*"}.rb")]
+            match = Dir[File.join(path, file_or_pattern)] if match.empty?
+            files = match.collect{|x| x.inspect}.join " "
+
+            section    = path.match(/suit\/([^\/]*)\//).captures[0].capitalize.gsub "-", " "
+            files_desc = match.size == 1 ?
+                           match.first.gsub(path, "") :
+                           "#{file_or_pattern.nil? ? "All" : "Multiple"} tests"
+
+            buffer.log     "#{section} - #{files_desc}"
+            buffer.execute "ruby #{loader} #{"-I" if match.size > 1}#{files}"
+            buffer.execute "suit restore"
+          end
+
+          data = IOBuffer.capture do |buffer|
+            if options.rails_versions == ["0"]
+              proc.call buffer, "suit/shared/test/unit/"
+            else
+              (options.rails_versions || major_rails_versions).each do |rails_version|
+                proc.call buffer, "suit/rails-#{rails_version}/dummy/test/unit/"
+              end
+            end
+          end
+
+          print_test_results "Unit", data
+        end
+
+      private
+
+        def files(action)
+          assert_suit_dir
+
+          log "(in #{File.expand_path("")})"
+
+          require "suit/shared/test/suit_application.rb"
+          application = SuitApplication.new :validate_root_path => false, :verbose => options.verbose?
+          Dir["suit/rails-*/dummy"].each do |rails_root|
+            application.root_path = rails_root
+            application.send :"#{action}_all"
+          end
+
+          log "Done #{action.to_s[0..-2]}ing files".green
+        end
+
+        def rails(command, environment, args = nil)
+          assert_suit_dir
+
+          rails_version = (options.rails_version || major_rails_versions.last).to_i
+          root_path     = File.expand_path "suit/rails-#{rails_version}/dummy"
+          command       = {2 => "script/#{command}", 3 => "rails #{command.to_s[0, 1]}"}[rails_version]
+
+          require "suit/rails-#{rails_version}/dummy/test/suit_application.rb"
+          SuitApplication.new(:verbose => options.verbose?).bundle_install
+
+          system "cd #{root_path} && RAILS_ENV=#{environment} #{command} #{"-p #{options.port}" if options.port}"
+        end
+
+        MAJOR_RAILS_VERSIONS = [2, 3]
+        DESCRIPTION_MATCH    = /^Setting up test environment for (.*)$/
+        LOAD_MATCH           = /^Loaded suite suit\/rails-(\d+)\/dummy\/test\/integration\/suit\/(.*)$/
+        GEM_SUIT_MATCH       = /^GemSuit: (.*)$/
+        TIME_MATCH           = /^Finished in (.*)\.$/
+        SUMMARY_MATCH        = /^(\d+) (\w+), (\d+) (\w+), (\d+) (\w+), (\d+) (\w+)$/
+
+        def print_test_results(section, data)
+          return if (suit_tests = extract_test_results(data)).empty?
+
+          failures = suit_tests.inject(0) do |count, test|
+                       count += 1 if (test[:failures].to_i + test[:errors].to_i > 0) || test[:time].nil?
+                       count
+                     end
+
+          log "\n"
+          log "".ljust(100, "=")
+          log "#{section} tests (#{failures} failures in #{data.finish - data.start} seconds)"
+          suit_tests.each do |test|
+            log ""             .ljust(100, "-")
+            log "  Description".ljust(16 , ".") + ": #{description test}"
+            log "  Duration"   .ljust(16 , ".") + ": #{test[:time]     }"
+            log "  Summary"    .ljust(16 , ".") + ": #{test[:summary]  }"
+          end
+          log "".ljust(100, "=")
+          log "\n"
+        end
+
+        def extract_test_results(data)
+          [{}].tap do |result|
+            data.output.each do |line|
+              if line.match(DESCRIPTION_MATCH) || line.match(GEM_SUIT_MATCH)
+                result.last[:description] = $1
+              end
+              if line.match(LOAD_MATCH)
+                result.last[:load] = "Rails #{$1} - #{camelize $2}"
+              end
+              if line.match(TIME_MATCH)
+                result.last[:time] = $1
+              end
+              if line.match(SUMMARY_MATCH)
+                result.last[:summary ] = line
+                result.last[$2.to_sym] = $1
+                result.last[$4.to_sym] = $3
+                result.last[$6.to_sym] = $5
+                result.last[$8.to_sym] = $7
+                result << {}
+              end
+            end
+
+            result.reject!{|x| x.empty?}
+          end
+        end
+
+        def description(test)
+          failed = (test[:failures].to_i + test[:errors].to_i > 0) || test[:tests].nil?
+          ((test[:description] unless (test[:description] || "").empty?) || test[:load]).send failed ? :red : :green
+        end
+
+      end
+
+    end
+  end
+end

data/lib/gem_suit/cli/base/shell.rb

@@ -0,0 +1,41 @@
+require "thor/shell/basic"
+
+module GemSuit
+  class CLI < Thor
+    module Base
+      module Shell
+
+        def self.included(base)
+          base.send :include, InstanceMethods
+        end
+
+        module InstanceMethods
+
+          def shell
+            @shell ||= Thor::Shell::Basic.new
+          end
+
+          def is?(*args)
+            shell.send :is?, *args
+          end
+
+          def agree?(question, default = nil)
+            opts   = %w(y n).collect{|x| !default.nil? && x =~ is?(default) ? x.upcase : x}
+            answer = ask question, opts, default
+            !!(answer =~ is?(:yes))
+          end
+
+          def ask(question, opts = nil, default = nil)
+            in_brackets = [opts, default].compact.first
+            statement   = [question, ("[#{in_brackets}]" unless in_brackets.nil?)].compact.join " "
+
+            answer = shell.ask statement if options.interactive? || default.nil?
+            answer.nil? || answer.empty? ? default.to_s : answer
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/gem_suit/cli/base/utils.rb

@@ -0,0 +1,83 @@
+STDOUT.sync = true
+
+module GemSuit
+  class CLI < Thor
+    module Base
+      module Utils
+
+        def self.included(base)
+          base.send :include, InstanceMethods
+        end
+
+        module InstanceMethods
+
+          def execute(command, force = nil)
+            options.very_verbose? || options.verbose? || force ? system(command) : `#{command}`
+          end
+
+          def log(string, force = false)
+            puts string if options.very_verbose? || options.verbose? || force
+          end
+
+          def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+            if first_letter_in_uppercase
+              lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+            else
+              lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+            end
+          end
+
+        private
+
+          def assert_gem_dir(non_gemsuit = false)
+            if Dir["*.gemspec"].empty?
+              raise Error, "Missing *.gemspec in current directory. Is this really a gem directory?"
+            end
+            if non_gemsuit && !Dir[".suit"].empty?
+              raise Error, "Found .suit in current directory. Is this gem already provided with GemSuit?"
+            end
+          end
+
+          def assert_suit_dir
+            assert_gem_dir
+            if Dir[".suit"].empty?
+              raise Error, "Missing .suit in current directory. Is this really a GemSuit directory?"
+            end
+          end
+
+          def assert_rails_dir
+            unless File.expand_path("").match /suit\/rails-\d\/dummy$/
+              raise Error, "Current directory path does not match \"/suit/rails-{2,3}/dummy\". Is this really a GemSuit dummy app?"
+            end
+          end
+
+          def major_rails_versions
+            Dir["suit/rails-*"].collect{|dir| dir.match(/rails-(\d)/); $1}
+          end
+
+          def gem_name
+            File.basename File.expand_path("")
+          end
+
+          def suit_gem_path
+            File.expand_path "../../../../..", __FILE__
+          end
+
+          def templates_path
+            File.expand_path "templates", suit_gem_path
+          end
+
+          def static_templates_path
+            File.expand_path "static", templates_path
+          end
+
+          def dynamic_templates_path
+            File.expand_path "dynamic", templates_path
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/gem_suit/cli/base.rb

@@ -0,0 +1,15 @@
+require "gem_suit/cli/base/utils"
+require "gem_suit/cli/base/shell"
+
+module GemSuit
+  class CLI < Thor
+    module Base
+
+      def self.included(base)
+        base.send :include, CLI::Base::Utils
+        base.send :include, CLI::Base::Shell
+      end
+
+    end
+  end
+end

data/lib/gem_suit/cli/builder/boot

@@ -0,0 +1,14 @@
+class Rails::Boot
+  def run
+    load_initializer
+
+    Rails::Initializer.class_eval do
+      def load_gems
+        @bundler_loaded ||= Bundler.require :default, Rails.env
+      end
+    end
+
+    Rails::Initializer.run(:set_load_path)
+  end
+end
+

data/lib/gem_suit/cli/builder/generator.rb

@@ -0,0 +1,154 @@
+require "fileutils"
+require "thor"
+require "gem_suit/cli/base"
+
+module GemSuit
+  class CLI < Thor
+    module Builder
+
+      class Generator < Thor
+        include Thor::Actions
+        include Base
+
+        def initialize(builder)
+          @builder = builder
+          self.class.source_root = dynamic_templates_path
+          self.destination_root  = root
+        end
+
+        no_tasks do
+          def run
+            create_symlinks
+            generate
+            stage_files
+          end
+
+          def options
+            @builder.options
+          end
+
+          def suit_config
+            @builder.suit_config
+          end
+
+          def locals
+            @locals ||= {}
+          end
+        end
+
+        class << self
+          def source_root
+            @source_root
+          end
+
+          def source_root=(path)
+            @source_root = path
+          end
+        end
+
+      private
+
+        def method_missing(method, *args)
+          if locals.include?(method)
+            locals[method]
+          else
+            super
+          end
+        end
+
+        def root
+          File.expand_path ""
+        end
+
+        def changelog?
+          !Dir["CHANGELOG*"].empty?
+        end
+
+        def mit_licensed?
+          !Dir["MIT-LICENSE*"].empty?
+        end
+
+        def read_me?
+          !Dir["README*"].empty?
+        end
+
+        def create_symlinks
+          rails_root = Dir["suit/rails-*/dummy"].max
+          FileUtils.rm   File.expand_path("public/index.html", rails_root)
+          FileUtils.cp_r File.expand_path("public", rails_root), "suit/shared"
+
+          Dir["suit/rails-*/dummy"].each do |rails_root|
+            %w(app/models
+               app/views
+               db/schema.rb
+               db/seeds.rb
+               public
+               test).each do |relative_path|
+
+              path = File.expand_path relative_path, rails_root
+
+              if File.exists? path
+                method = File.directory?(path) ? :rm_rf : :rm
+                FileUtils.send method, path
+              end
+
+              prefix = ([".."] * relative_path.split("/").size).join("/")
+              create_link path, "#{prefix}/../shared/#{relative_path}", :verbose => false
+            end
+          end
+        end
+
+        def generate
+          if options.extras?
+            template "CHANGELOG.rdoc", :verbose => false unless changelog?
+
+            unless mit_licensed? || !agree?("Do you want to use a MIT-LICENSE?", :yes)
+              locals[:author] ||= ask "What is your author name?"
+              template "MIT-LICENSE", :verbose => false
+            end
+
+            unless read_me?
+              locals[:twitter] ||= ask "What is your Twitter name?"
+              locals[:email]   ||= ask "What is your email address?"
+              locals[:author]  ||= ask "What is your author name?"
+              template "README.textile", :verbose => false
+            end
+          end
+
+          Dir["suit/rails-*/dummy"].each do |rails_root|
+            file   = File.expand_path("config/routes.rb", rails_root)
+            routes = File.readlines file
+            routes.each_with_index do |line, index|
+              next unless line.match "to delete public/index.html"
+              routes[index + 1] = routes[index + 1].gsub("# ", "").gsub("welcome", "application")
+              break
+            end
+            File.open file, "w" do |file|
+              file << routes
+            end
+          end
+
+          gemspec = File.read "#{gem_name}.gemspec"
+          gemspec.gsub! "TODO: Write your email address", email  unless locals[:email ].to_s.empty?
+          gemspec.gsub! "TODO: Write your name"         , author unless locals[:author].to_s.empty?
+          File.open "#{gem_name}.gemspec", "w" do |file|
+            file << gemspec
+          end
+
+          template "suit/shared/app/views/application/index.html.erb", :verbose => false
+          template "suit/shared/public/stylesheets/app.css", :force => true, :verbose => false
+          template "suit/shared/test/test_helper.rb", :verbose => false
+          template "suit/templates/shared/Gemfile", :verbose => false
+          template "suit/templates/shared/config/database-#{suit_config[:mysql] ? "mysql" : "sqlite"}.yml", "suit/templates/shared/config/database.yml", :verbose => false
+        end
+
+        def stage_files
+          template "gitignore", ".gitignore", :force => true, :verbose => false
+          execute  "git add -A"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/gem_suit/cli/builder/rails_app.rb

@@ -0,0 +1,146 @@
+require "thor"
+require "gem_suit/cli/base"
+
+module GemSuit
+  class CLI < Thor
+    module Builder
+
+      class RailsApp < Thor
+        include Thor::Actions
+        include Base
+
+        def initialize(version_spec, builder, confirm = true)
+          @version_spec          = version_spec
+          @builder               = builder
+          self.class.source_root = dynamic_templates_path
+          confirm_version if confirm
+        end
+
+        no_tasks do
+          def install
+            confirm_version
+            generate
+            bundle
+            create_gemfile
+          end
+
+          def options
+            @builder.options
+          end
+
+          def rails_gem_version
+            version
+          end
+        end
+
+        class << self
+          def source_root
+            @source_root
+          end
+
+          def source_root=(path)
+            @source_root = path
+          end
+        end
+
+      private
+
+        def expand_version_spec
+          @version_spec == "latest" ? latest : @version_spec
+        end
+
+        def latest
+          [`rails -v`.match(/\d\.\d+\.\d+/).to_s, "3.0.6"].max
+        end
+
+        def target_dir
+          File.expand_path "suit/rails-#{version(:major)}"
+        end
+
+        def rails_root
+          File.expand_path("dummy", target_dir)
+        end
+
+        def generate_cmd
+          "rails #{version(:major) < 3 ? "_#{version}_" : "new"} dummy"
+        end
+
+        def version(segment = nil)
+          return @version if segment.nil?
+
+          segments = @version.match(/(\d+)\.(\d+)\.(\d+)/).captures.collect &:to_i
+          case segment
+          when :major
+            segments[0]
+          when :minor
+            segments[1]
+          when :patch
+            segments[2]
+          end
+        end
+
+        def valid_version?
+          !!version.match(/^\d+\.\d+\.\d+$/)
+        end
+
+        def bundled?
+          !Dir[File.expand_path("Gemfile", destination_root)].empty?
+        end
+
+        def confirm_version
+          return if @confirmed_version
+
+          @version = expand_version_spec
+          answer   = ask "Generate Rails #{version(:major)} application? You can specify another version or use 'n' to skip", version, version
+          if answer =~ is?(:no)
+            @version = nil
+            return
+          end
+          @version = answer unless answer.empty?
+
+          self.destination_root = rails_root
+          @confirmed_version    = true
+        end
+
+        def generate
+          unless valid_version?
+            log "Cannot generate Rails application with specified version #{version.inspect}".red
+            return
+          end
+
+          if File.exists? target_dir
+            log "Already installed a Rails #{version(:major)} application (skipping #{version})".red, true
+            return
+          end
+
+          unless `gem list rails -i -v #{version}`.strip == "true"
+            log "Installing Rails #{version} (this can take a while)".yellow, true
+            execute "gem install rails -v=#{version}"
+          end
+
+          FileUtils.mkdir target_dir
+          log "Generating Rails #{version(:major)} application"
+          log generate_cmd
+          execute "cd #{target_dir} && #{generate_cmd}"
+        end
+
+        def bundle
+          unless valid_version?
+            log "Cannot bundle Rails application with specified version #{version.inspect}".red
+            return
+          end
+
+          return if bundled?
+
+          insert_into_file "config/boot.rb", File.read(File.expand_path("../boot", __FILE__)), :before => "# All that for this:\n", :verbose => false
+          template "config/preinitializer.rb", :verbose => false
+        end
+
+        def create_gemfile
+          template "Gemfile", :force => true, :verbose => false
+        end
+      end
+
+    end
+  end
+end