docman 0.0.5 → 0.0.6

data/lib/docman/deployers/git_deployer.rb

@@ -4,10 +4,13 @@ module Docman
 
       register_deployer :git_deployer
 
-      def push(info, state_name)
-        version = info['states'][state_name]['version']
-        GitUtil.push(info['full_build_path'], version)
+      def push
+        root = @docroot_config.root
+        root.state = self['state']
+        GitUtil.commit(root['full_build_path'], root['full_build_path'], 'Updated version.yaml')
+        GitUtil.push(root['full_build_path'], root.version)
       end
+
     end
   end
 end

data/lib/docman/docroot_config.rb

@@ -5,14 +5,17 @@ module Docman
 
   class DocrootConfig
 
-    attr_reader :structure, :deploy_target
-
+    attr_reader :structure, :deploy_target, :docroot_dir, :root
     def initialize(docroot_dir, deploy_target)
       @docroot_dir = docroot_dir
       @deploy_target = deploy_target
       @docroot_config_dir = File.join(docroot_dir, 'config')
       update
+      if File.file? File.join(@docroot_config_dir, 'config.yaml')
+        Docman::Application.instance.config.merge_config_from_file(File.join(@docroot_config_dir, 'config.yaml'))
+      end
       @names = {}
+      @raw_infos = []
       @structure = structure_build File.join(@docroot_config_dir, 'master')
     end
 
@@ -25,6 +28,10 @@ module Docman
 
       children = []
       info = YAML::load_file(File.join(path, 'info.yaml'))
+      @raw_infos << YAML::load_file(File.join(path, 'info.yaml'))
+      unless info['status'].nil?
+        return if info['status'] == 'disabled'
+      end
       name = File.basename path
       prefix = prefix.size > 0 ? File.join(prefix, name) : name
       info['full_path'] = path
@@ -37,11 +44,11 @@ module Docman
       info['children'] = children
 
       i = Docman::Info.new(info)
+      @root = i if parent.nil?
+      i['root'] = @root
 
       @names[name.to_s] = i
 
-      data = [i]
-      # data[:children] = children
       Dir.foreach(path) do |entry|
         next if (entry == '..' || entry == '.')
         full_path = File.join(path, entry)
@@ -55,7 +62,6 @@ module Docman
       i
     end
 
-
     def chain(info)
       chain = {}
       chain[info['name']] = info
@@ -66,18 +72,6 @@ module Docman
       Hash[chain.to_a.reverse!]
     end
 
-    def root(info)
-      chain(info).each do |name, item|
-        if item['type'] == 'root'
-          return item
-        end
-      end
-    end
-
-    def root_dir
-      @structure[:data]
-    end
-
     def info_by(name)
       @names[name]
     end
@@ -90,5 +84,9 @@ module Docman
       states
     end
 
+    def config_hash
+      Digest::MD5.hexdigest(Marshal::dump(@raw_infos))
+    end
+
   end
 end

data/lib/docman/docroot_controller.rb

@@ -1,62 +1,50 @@
 require 'docman/builders/builder'
-require 'docman/builders/common_builder'
-require 'docman/builders/git_builder'
+require 'docman/builders/dir_builder'
+require 'docman/builders/git_direct_builder'
+require 'docman/builders/git_strip_builder'
+require 'docman/builders/drupal_drush_builder'
 require 'docman/deployers/deployer'
 require 'docman/deployers/git_deployer'
 require 'docman/deployers/common_deployer'
+require 'docman/command'
+require 'docman/composite_command'
+require 'docman/builders/commands/create_symlink_cmd'
+require 'docman/builders/commands/execute_script_cmd'
+require 'docman/builders/commands/clean_changed_cmd'
+require 'docman/builders/commands/git_commit_cmd'
 
 # TODO: make universal logging class.
 
 module Docman
   class DocrootController
 
-    attr_reader :docroot_dir
+    attr_reader :docroot_dir, :docroot_config
 
     def initialize(docroot_dir, deploy_target_name, options = {})
       @deploy_target = Docman::Application.instance.config['deploy_targets'][deploy_target_name]
+      @deploy_target_name = deploy_target_name
       Docman::Application.instance.deploy_target = @deploy_target
       docroot_config = DocrootConfig.new(docroot_dir, @deploy_target)
-      @deployer = Docman::Deployers::Deployer.create(@deploy_target['handler'], @deploy_target)
       @docroot_dir = docroot_dir
       @docroot_config = docroot_config
     end
 
-    def deploy(name, type, version)
-      puts "Deploy #{name}, type: #{type}"
-      @docroot_config.states_dependin_on(name, version).each do |state_name, state|
-        deploy_dir_chain(state_name, @docroot_config.info_by(name))
-        @deployer.push(@docroot_config.root_dir, state_name)
-      end
+    def build(state_name)
+      execute(state_name)
     end
 
-    def build(state)
-      build_recursive(state)
-      @deployer.push(@docroot_config.root_dir, state)
-    end
-
-    def build_recursive(state, info = nil)
-      info = info ? info : @docroot_config.structure
-      build_dir(state, info)
-
-      info['children'].each do |child|
-        build_recursive(state, child)
-      end
-    end
-
-    def deploy_dir_chain(state, info)
-      @docroot_config.chain(info).each do |name, item|
-        if item.need_rebuild?
-          build_recursive(state, item)
-          return
-        elsif
-          build_dir(state, item)
-        end
+    def deploy(name, type, version)
+      @docroot_config.states_dependin_on(name, version).keys.each do |state_name|
+        execute(state_name, name)
       end
     end
 
-    def build_dir(state, info)
-      info.state = state
-      @deployer.build(@docroot_config.root(info), info)
+    def execute(state, name = nil)
+      #Docman::Application.instance.config.environment(state_name, @deploy_target_name)
+      params = @deploy_target
+      params['state'] = state
+      params['name'] = name
+      Docman::Deployers::Deployer.create(params, self).perform
     end
 
   end

data/lib/docman/exceptions/command_validation_error.rb

@@ -0,0 +1,5 @@
+module Docman
+  class CommandValidationError < StandardError
+
+  end
+end

data/lib/docman/exceptions/no_changes_error.rb

@@ -0,0 +1,5 @@
+module Docman
+  class NoChangesError < StandardError
+
+  end
+end

data/lib/docman/exec.rb

@@ -2,7 +2,7 @@ module Docman
 
   class Exec
 
-    def Exec.do(cmd)
+    def Exec.do(cmd, output = false)
       `#{cmd}`
       $?.exitstatus == 0
     end

data/lib/docman/git_util.rb

@@ -1,45 +1,73 @@
+require 'logger'
+
 module Docman
 
-  class GitUtil
+  module GitUtil
+
+    @logger = Logger.new(STDOUT)
+
+    def self.exec(command)
+      @logger.info command
+      @logger.info `#{command}`.delete!("\n")
+    end
 
     def self.get(repo, path, type, version)
-      if File.directory? path
+      if File.directory? path and File.directory?(File.join(path, '.git'))
         Dir.chdir path
-        `git checkout #{version} && git pull origin #{version}` if type == 'branch'
+        if type == 'branch'
+          exec "git checkout #{version}"
+          exec "git pull origin #{version}"
+        end
         if type == 'tag'
-          `git fetch --tags`
-          `git checkout "tags/#{version}"`
+          exec "git fetch --tags"
+          exec "git checkout tags/#{version}"
         end
       else
-        `git clone #{repo} #{path}`
+        FileUtils.rm_rf path if File.directory? path
+        exec "git clone #{repo} #{path}"
         Dir.chdir path
-        `git checkout #{version}`
+        exec "git checkout #{version}"
       end
       result = `git rev-parse --short HEAD`
+      @logger.info "Commit hash: #{result}"
       result.delete!("\n")
     end
 
     def self.update(path)
-      `cd #{path} && git pull`
+      pull path
     end
 
     def self.commit(root_path, path, message)
-      if self.repo_changed? path
-        puts message
-        Dir.chdir root_path
-        path.slice! "#{root_path}/"
-        `git pull`
-        `git add --all #{path}`
-        `git commit -m "#{message}"`
+      if repo_changed? path
+        # puts message
+        pull root_path
+        exec %Q(git add --all #{path.slice "#{root_path}/"})
+        exec %Q(git commit -m "#{message}")
       end
     end
 
+    def self.pull(path)
+      Dir.chdir path
+      exec 'git pull'
+    end
+
+    def self.repo?(path)
+      File.directory? File.join(path, '.git')
+    end
+
     def self.repo_changed?(path)
       not Exec.do "#{Application::bin}/dm_repo_clean.sh #{path}"
     end
 
+    def self.last_commit_hash(path, branch)
+      Dir.chdir path
+      result = `git rev-parse --short origin/#{branch}`
+      result.delete!("\n")
+    end
+
     def self.push(root_path, version)
       Dir.chdir root_path
+      `git pull origin #{version}`
       `git push origin #{version}`
     end
   end

data/lib/docman/info.rb

@@ -1,12 +1,19 @@
+require 'docman/context'
+
 module Docman
   class Info < Hash
 
+    include Docman::Context
+
+    attr_accessor :need_rebuild
+
     def initialize(hash = {})
       super
       hash.each_pair do |k, v|
         self[k] = v
       end
-      self['build_type'] = self['docroot_config'].deploy_target['builders'][self['type']]['type']
+      self['build_type'] = self['docroot_config'].deploy_target['builders'][self['type']]['handler']
+      @need_rebuild = Hash.new
     end
 
     def version
@@ -17,32 +24,79 @@ module Docman
       self['states'][self['state']].nil? ? nil : self['states'][self['state']]['type']
     end
 
+    def describe(type = 'short')
+      properties_info(%w(name type build_type))
+    end
+
     def write_info(result)
       to_save = {}
       to_save['state'] = self['state']
       to_save['version_type'] = self.version_type unless self.version_type.nil?
       to_save['version'] = self.version unless self.version.nil?
-      # to_save['ref'] = result
+      to_save['result'] = result
       to_save['type'] = self['type']
       to_save['build_type'] = self['build_type']
 
       File.open(File.join(self['full_build_path'], 'info.yaml'), 'w') {|f| f.write to_save.to_yaml}
+      to_save
     end
 
     def need_rebuild?
-      return TRUE if Docman::Application.instance.options[:force]
-      return TRUE unless File.directory? self['full_build_path']
-      info_filename = File.join(self['full_build_path'], 'info.yaml')
-      return TRUE unless File.file?(info_filename)
-      version = YAML::load_file(info_filename)
-      return TRUE if version['type'] != self['type']
-      return TRUE if version['build_type'] != self['build_type']
+      return @need_rebuild[self['state']] if not @need_rebuild.nil? and @need_rebuild.has_key? self['state'] and not @need_rebuild[self['state']].nil?
+      @need_rebuild[self['state']] = _need_rebuild?
+      if @need_rebuild[self['state']]
+        set_rebuild_recursive(self, true)
+      end
+      @need_rebuild[self['state']]
+    end
+
+    def set_rebuild_recursive(obj, value)
+      obj.need_rebuild[self['state']] = value
+      if obj.has_key?('children')
+        obj['children'].each do |info|
+          set_rebuild_recursive(info, value)
+        end
+      end
+    end
+
+    def _need_rebuild?
+      return true if Docman::Application.instance.force?
+      return true unless File.directory? self['full_build_path']
+      v = stored_version
+      return true unless v
+      return true if v['type'] != self['type']
+      return true if v['build_type'] != self['build_type']
+      return true if (not v['version'].nil? and v['version'] != self.version)
+      return true if (not v['version_type'].nil? and v['version_type'] != self.version_type)
+      unless v['state'].nil?
+        return true if v['state'] != self['state']
+      end
       false
     end
 
+    def stored_version
+      info_filename = File.join(self['full_build_path'], 'info.yaml')
+      return false unless File.file?(info_filename)
+      YAML::load_file(info_filename)
+    end
+
     def state=(state)
       self['state'] = state
     end
 
+    def disabled?
+      unless self['status'].nil?
+        return self['status'] == 'disabled'
+      end
+      false
+    end
+
+    def commands(type, hook)
+       if self.has_key? 'actions' and self['actions'].has_key? type and self['actions'][type].has_key? hook
+         return self['actions'][type][hook]
+       end
+      []
+    end
+
   end
 end

data/lib/docman/logging.rb

@@ -0,0 +1,41 @@
+module Docman
+  module Logging
+
+    def logger
+      Logging.logger
+    end
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def properties_info(properties = [])
+      arr = ["name=#{self.class.name}"]
+      properties.each do |property|
+        if self.is_a? Hash
+          arr << "#{property}=#{self[property]}" if self.include?(property)
+        else
+          arr << "#{property}=#{self.send(property)}" if self.respond_to?(property)
+        end
+      end
+      arr.join(', ')
+    end
+
+    def with_logging(message = nil, type = 'debug')
+      # logger.send(type, "#{prefix} - #{message} - start") if @log
+      log("#{message} - start", type)
+      result = yield
+      log("#{message} - finish", type)
+      # logger.send(type, "#{prefix} - #{message} - finish") if @log
+      result
+    end
+
+    def log(message, type = 'debug')
+      logger.send(type, "#{prefix} - #{message}")
+    end
+
+    def prefix
+    end
+
+  end
+end