blazing 0.0.16 → 0.1.0.alpha1

data/features/support/env.rb

@@ -0,0 +1,9 @@
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+end

data/lib/blazing.rb

@@ -1,18 +1,9 @@
-require 'thor'
-require 'thor/group'
-require 'blazing'
-require 'blazing/config'
-require 'blazing/runner'
-require 'blazing/logger'
-require 'blazing/target'
-require 'blazing/recipe'
-require 'blazing/cli/base'
-require 'blazing/cli/create'
-require 'blazing/cli/hook'
+require "blazing/version"
 
 module Blazing
 
-  DIRECTORY = 'config'
-  CONFIGURATION_FILE = 'config/blazing.rb'
+  TEMPLATE_ROOT = File.expand_path(File.dirname(__FILE__) + File.join('/', 'blazing', 'templates'))
+  DEFAULT_CONFIG_LOCATION = 'config/blazing.rb'
+  TMP_HOOK = '/tmp/post-receive'
 
 end

data/lib/blazing/config.rb

@@ -1,90 +1,55 @@
-require 'blazing'
 require 'blazing/target'
+require 'blazing/recipe'
+require 'blazing/dsl_setter'
 
-module Blazing
-  class Config
+class Blazing::Config
 
-    class << self
+  extend Blazing::DSLSetter
 
-      #
-      # Read the Configuration File
-      #
-      def read(&block)
-        config = Blazing::Config.new
-        config.instance_eval(&block)
+  attr_reader :file
+  attr_accessor :targets
+  dsl_setter :repository, :rvm, :rake
 
-        config
-      end
+  class << self
 
-      #
-      # Load configuration file and parse it
-      #
-      def parse
-        read do
-          instance_eval(File.read(Blazing::CONFIGURATION_FILE))
-        end
-      end
-
-      #
-      # DSL Setter helper method
-      #
-      def dsl_setter(*names)
-        names.each do |name|
-          class_eval <<-EVAL
-            def #{name}(value = nil)
-              if value
-                instance_variable_set("@#{name}", value)
-              else
-                instance_variable_get("@#{name}")
-              end
-            end
-          EVAL
-        end
-      end
+    def parse(configuration_file = nil)
+      config = self.new(configuration_file)
+      config.instance_eval(File.read(config.file))
 
+      config
     end
 
-    dsl_setter :repository
-    attr_accessor :targets, :recipes
+  end
 
-    def initialize
-      @targets = []
-      @recipes = []
-    end
+  def initialize(configuration_file = nil)
+    @file = configuration_file || Blazing::DEFAULT_CONFIG_LOCATION
+    @targets = []
+    @recipes = []
+  end
 
-    def target(name, options = {})
-      @targets << Blazing::Target.new(name, options.merge(:config => self))
-    end
+  def target(name, location, options = {})
+    raise "Name already taken" if targets.find { |t| t.name == name }
+    targets << Blazing::Target.new(name, location, self, options)
+  end
 
-    def use(name, options = {})
-      @recipes << Blazing::Recipe.new_recipe_by_name(name, options)
+  def recipes(recipes = nil)
+    if recipes.kind_of? Symbol
+      @recipes << Blazing::Recipe.init_by_name(recipes)
+    elsif recipes.kind_of? Array
+      @recipes = recipes.map { |r| Blazing::Recipe.init_by_name(r) }
+    else
+      @recipes
     end
+  end
 
-    #
-    # Determines which target is picked, based on defaults and CLI argument
-    # If only one target is defined, it is the default one
-    #
-    def find_target(target_name = nil)
-      active_target = nil
-
-      if target_name
-        active_target = targets.find {|target| target.name == target_name }
-      end
-
-      if active_target.nil? && targets.size == 1
-        active_target = targets.first
-      end
-
-      if active_target.nil?
-        active_target = targets.find {|target| target.default }
-      end
-
-      if active_target.nil?
-        raise 'no target specified and no default targets found'
-      end
-
-      active_target
+  def default_target
+    if @targets.size > 1
+      default = @targets.find { |t| t.options[:default] == true }
+      raise 'could not find default target' unless default
+      default
+    else
+      @targets.first
     end
-
   end
+
 end

data/lib/blazing/dsl_setter.rb

@@ -0,0 +1,20 @@
+module Blazing::DSLSetter
+
+  #
+  # DSL Setter helper method
+  #
+  def dsl_setter(*names)
+    names.each do |name|
+      class_eval <<-EVAL
+        def #{name}(value = nil)
+          if value
+            instance_variable_set("@#{name}", value)
+          else
+            instance_variable_get("@#{name}")
+          end
+        end
+      EVAL
+    end
+  end
+
+end

data/lib/blazing/recipe.rb

@@ -1,86 +1,13 @@
 require 'active_support/inflector'
-require 'blazing'
-# require 'blazing/logger'
 
-module Blazing
-  class Recipe
+class Blazing::Recipe
 
+  class << self
 
-    # TODO: provide hooks for recipe to use bundle exec
-
-    attr_accessor :name, :options
-
-    def initialize(name, options = {})
-      @name = name.to_s
-      @options = options
-      @logger = options[:_logger] ||= Blazing::Logger.new
-      @runner = Blazing::Runner.new
-    end
-
-    def recipe_class
-      # TODO: Unify naming conventions
-      # Gem Recipe Naming Convention
-      ('Blazing::' + @name.to_s.gsub('_','/').camelize).constantize
-    rescue NameError
-      begin
-        # Builtin Recipe Naming Convention
-        ('Blazing::' + (@name.to_s + '_recipe').camelize).constantize
-      rescue NameError
-        @logger.log :error, "unable to load #{@name} recipe"
-        return nil
-      end
+    def init_by_name(name)
+      "Blazing::Recipe::#{name.to_s.camelize}".constantize.new
     end
 
-    def run
-     raise 'run method must be implemented in recipe' 
-    end
-
-    class << self
-
-      def new_recipe_by_name(name, options = {})
-        load_builtin_recipes
-        load_gem_recipes
-        new(name, options).recipe_class.new(name, options)
-      end
-
-      def load_builtin_recipes
-        dir = File.join(File.dirname(__FILE__), "/recipes")
-        $LOAD_PATH.unshift(dir)
-        Dir[File.join(dir, "*.rb")].each { |file| load File.basename(file) }
-      end
-
-      def load_gem_recipes
-        # TODO: I'm sure there is a better way to do this...
-        gems = open('Gemfile').grep(/blazing-/).map { |l| l.match(/(blazing-.*)\'\,/)[1] }
-        gems.each do |gem|
-          gem_lib_path = $:.find { |p| p.include? gem }
-          recipes_path = File.join(gem_lib_path, gem, 'recipes')
-          recipes = Dir.entries(recipes_path).delete_if { |r| r == '.' || r == '..' }
-          recipes.each { |recipe| require File.join(gem, 'recipes', recipe) }
-        end
-      end
-
-      def load_local_recipes
-        #TODO: Implement
-      end
-
-      #
-      # Return the list of available recipes based
-      # on class hierarchy
-      #
-      def list
-        descendants = []
-
-        load_builtin_recipes
-        load_gem_recipes
-
-        ObjectSpace.each_object(Class) do |k|
-          descendants.unshift k if k < self
-        end
-        descendants.uniq!
-        descendants
-      end
-
-    end
   end
+
 end

data/lib/blazing/runner.rb

@@ -1,7 +1,49 @@
+require 'erb'
+require 'methadone'
+
 class Blazing::Runner
 
-  def run(command)
-    system command
+  include Methadone::CLILogging
+
+  def initialize(config = nil, target = nil)
+    if config
+      @config = config
+      @target = @config.targets.find { |t| t.name == target.to_s } || @config.default_target
+    end
+  end
+
+  def exec(command)
+    command_method = "#{command.gsub(':', '_')}_command"
+    raise "Unknown Command: #{command}" unless self.respond_to? command_method
+    self.send command_method
+  end
+
+  def init_command
+    info("Creating an example config file in #{Blazing::DEFAULT_CONFIG_LOCATION}")
+    info("Customize it to your needs")
+
+    Dir.mkdir 'config' unless Dir.exists? 'config'
+    configuration_file = ERB.new(File.read("#{Blazing::TEMPLATE_ROOT}/config.erb")).result
+
+    File.open(Blazing::DEFAULT_CONFIG_LOCATION,"wb") do |f|
+      f.puts configuration_file
+    end
+  end
+
+  def setup_local_command
+    repository = Grit::Repo.new(Dir.pwd)
+    @config.targets.each do |target|
+      info("Adding new remote #{target.name} pointing to #{target.location}")
+      repository.config["remote.#{target.name}.url"] = target.location
+    end
+  end
+
+  def setup_remote_command
+    @config.default_target.setup
+  end
+
+  def update_command
+    @config.default_target.update
   end
 
 end

data/lib/blazing/shell.rb

@@ -0,0 +1,7 @@
+class Blazing::Shell
+
+  def run(command)
+    system command
+  end
+
+end

data/lib/blazing/target.rb

@@ -1,151 +1,61 @@
-require 'blazing'
-require 'blazing/core_ext/object'
-require 'blazing/config'
-require 'blazing/bootstrap'
+require 'blazing/shell'
 
-module Blazing
-  class Target
+class Blazing::Target
 
-    include Blazing::Target::Bootstrap
+  attr_accessor :name, :location, :options
 
-    attr_accessor :name, :recipes
-
-    AVAILABLE_SETTINGS = [:deploy_to, :host, :user, :path, :default, :branch]
-
-    class << self
-
-      def bootstrap(name)
-        target = config.find_target(name)
-        runner = Blazing::Runner.new
-        # TODO: Use a Wrapper to Net::SSH
-        target.clone_repository
-        target.setup_post_receive_hook
-        setup target.name
-      end
-
-      def deploy(name)
-        target = config.find_target(name)
-        runner = Blazing::Runner.new
-        deploy_command = "git push #{name}"
-        deploy_command += " #{target.branch}:#{target.branch}" if target.branch
-
-        # TODO: checkout branch if we pushed to a branch which is not checked out
-        runner.run deploy_command
-      end
-
-      def setup(name)
-        if name
-          config.find_target(name).add_target_as_remote
-        else
-          config.targets.each do |target|
-            target.add_target_as_remote
-          end
-        end
-      end
-
-      def post_receive(name)
-        target = config.find_target(name)
-        target.set_git_dir
-        target.reset_head!
-        @recipes.delete_if { |recipe| recipe.name == 'rvm' }
-        target.run_recipes
-      end
-
-      def config
-        Blazing::Config.parse
-      end
-
-      def runner
-        Blazing::Runner.new
-      end
-
-    end
-
-    def initialize(name, options = {})
-      @name = name.to_s
-      @logger = options[:_logger] ||= Blazing::Logger.new
-      @runner = options[:_runner] ||= Blazing::Runner.new
-      @hook = options[:_hook] ||= Blazing::CLI::Hook
-
-      @config = options[:config] || Blazing::Config.parse
-
-      @repository = @config.repository
-      create_accessors_from_config(options)
-      load_recipes
-    end
-
-    def create_accessors_from_config(options)
-      assign_settings(options)
-      parse_deploy_to_string unless @deploy_to.blank?
-      ensure_mandatory_settings
-    end
+  def initialize(name, location, config, options = {})
+    @name = name
+    @location = location
+    @config = config
+    @options = options
+    @shell = Blazing::Shell.new
+  end
 
-    def assign_settings(options)
-      AVAILABLE_SETTINGS.each do |option|
-        instance_variable_set("@#{option}", options[option])
-        self.class.send(:attr_accessor, option)
-      end
-    end
+  def setup
+    @shell.run "ssh #{user}@#{host} '#{clone_repository} && #{setup_repository}'"
+    self.update
+  end
 
-    # If the :deploy_to option is set, user, host and path are overriden
-    def parse_deploy_to_string
-      @host = @deploy_to.scan(/@(.*):/).join
-      @user = @deploy_to.scan(/(.*)@/).join
-      @path = @deploy_to.scan(/:(.*)/).join
-    end
+  def update
+    hook = ERB.new(File.read("#{Blazing::TEMPLATE_ROOT}/hook.erb")).result(binding)
 
-    # Raise an error if one of the required options is still empty
-    def ensure_mandatory_settings
-      [:host, :user, :path].each do |option|
-        raise "#{option} can't be blank!" if instance_variable_get("@#{option}").blank?
-      end
+    File.open(Blazing::TMP_HOOK, "wb") do |f|
+      f.puts hook
     end
 
-    def set_git_dir
-      ENV['GIT_DIR'] = '.git'
-    end
+    copy_hook
+    @shell.run "ssh #{user}@#{host} #{make_hook_executable}"
+  end
 
-    def reset_head!
-      @runner ||= Blazing::Runner.new
-      @runner.run 'git reset --hard HEAD'
-    end
+  def path
+    @location.match(/:(.*)$/)[1]
+  end
 
-    #
-    # Called by post-receive hook to determine rvm usage
-    #
-    def use_rvm?
-      @rvm_recipe = @recipes.find { |recipe| recipe.name == 'rvm' }
-      @recipes.delete_if { |recipe| recipe.name == 'rvm' }
-      if @rvm_recipe
-        @rvm_recipe.options[:rvm_string]
-      else
-        'none'
-      end
-    end
+  def host
+    host = @location.match(/@(.*):/)
+    host[1] unless host.nil?
+  end
 
-    def load_recipes
+  def user
+    user = @location.match(/(.*)@/)
+    user[1] unless user.nil?
+  end
 
-      # TODO: For now, recipes can be assigned only in the global
-      # namespace of the config. Make it possible for targets to
-      # define recipes individually
+  def clone_repository
+    "git clone #{@config.repository} #{path}"
+  end
 
-      @recipes = @config.recipes if @recipes.blank?
-      Blazing::Recipe.load_builtin_recipes
-    end
+  def copy_hook
+    @shell.run "scp #{Blazing::TMP_HOOK} #{user}@#{host}:#{path}/.git/hooks/post-receive"
+  end
 
-    def run_recipes
-      run_bootstrap_recipes
-      @recipes.each do |recipe|
-        recipe.run
-      end
-    end
+  def make_hook_executable
+    "chmod +x #{path}/.git/hooks/post-receive"
+  end
 
-    def run_bootstrap_recipes
-      bundler = @recipes.find { |r| r.name == 'bundler' }
-      if bundler
-        bundler.run
-        @recipes.delete_if { |r| r.name == 'bundler' }
-      end
-    end
+  def setup_repository
+    "cd #{path} && git config receive.denyCurrentBranch ignore"
   end
+
 end