docman 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d1034856fdc60a997b250d585f83e26d24417bc
-  data.tar.gz: e938706541e51075cd3bb3d3a962f4de8d74a2c2
+  metadata.gz: 03c6d600c4554cc1eb0570c4c1248f6662db3af0
+  data.tar.gz: 8511855ac1a09d583c0ce3cef70c7d4a5c96a228
 SHA512:
-  metadata.gz: ffc1b6c9a829ac5bacad49e09248152c2763128d07519414dc431696a6c5b7164952685b11e815be20549f6243ad181d8976ddf22947ce4caef6bfd153db51ad
-  data.tar.gz: 3a20e9bd9853ef90c12b48742d25a1458b994f5c45c96654590d140e0d66bce08d505d482d87386e69a3b6d54b43c9d70d50fcd326022b33fda88a0a9c18e6ab
+  metadata.gz: 4fec63186230d02c13e1df24e52c812a175fb63b590319bafa6d2c9175e088ea543cd4976f823e90ed9c4ea15c8137b4b013000bb663a353712ac11493194b19
+  data.tar.gz: 485796775944d65fa287c66e76140f42c3fb500dc3de54d445a54bc122b19701f73cb0a01ea11a1e8663ee1e0dcde511b4fc0073af1b0c391b9935fee15b6867

data/bin/bump-version.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+ 
+# works with a file called VERSION in the current directory,
+# the contents of which should be a semantic version number
+# such as "1.2.3"
+ 
+# this script will display the current version, automatically
+# suggest a "minor" version update, and ask for input to use
+# the suggestion, or a newly entered value.
+ 
+# once the new version number is determined, the script will
+# pull a list of changes from git history, prepend this to
+# a file called CHANGES (under the title of the new version
+# number) and create a GIT tag.
+ 
+if [ -f VERSION ]; then
+    BASE_STRING=`cat VERSION`
+    BASE_LIST=(`echo $BASE_STRING | tr '.' ' '`)
+    V_MAJOR=${BASE_LIST[0]}
+    V_MINOR=${BASE_LIST[1]}
+    V_PATCH=${BASE_LIST[2]}
+    echo "Current version : $BASE_STRING"
+    V_MINOR=$((V_MINOR + 1))
+    V_PATCH=0
+    SUGGESTED_VERSION="$V_MAJOR.$V_MINOR.$V_PATCH"
+    read -p "Enter a version number [$SUGGESTED_VERSION]: " INPUT_STRING
+    if [ "$INPUT_STRING" = "" ]; then
+        INPUT_STRING=$SUGGESTED_VERSION
+    fi
+    echo "Will set new version to be $INPUT_STRING"
+    echo $INPUT_STRING > VERSION
+    echo "Version $INPUT_STRING:" > tmpfile
+    git log --pretty=format:" - %s" "$BASE_STRING"...HEAD >> tmpfile
+    echo "" >> tmpfile
+    echo "" >> tmpfile
+    cat CHANGES >> tmpfile
+    mv tmpfile CHANGES
+    git add CHANGES VERSION
+    git commit -m "Version bump to $INPUT_STRING"
+    git tag -a -m "Tagging version $INPUT_STRING" "$INPUT_STRING"
+    git push origin --tags
+    git push
+else
+    echo "Could not find a VERSION file"
+    read -p "Do you want to create a version file and start from scratch? [y]" RESPONSE
+    if [ "$RESPONSE" = "" ]; then RESPONSE="y"; fi
+    if [ "$RESPONSE" = "Y" ]; then RESPONSE="y"; fi
+    if [ "$RESPONSE" = "Yes" ]; then RESPONSE="y"; fi
+    if [ "$RESPONSE" = "yes" ]; then RESPONSE="y"; fi
+    if [ "$RESPONSE" = "YES" ]; then RESPONSE="y"; fi
+    if [ "$RESPONSE" = "y" ]; then
+        echo "0.1.0" > VERSION
+        echo "Version 0.1.0" > CHANGES
+        git log --pretty=format:" - %s" >> CHANGES
+        echo "" >> CHANGES
+        echo "" >> CHANGES
+        git add VERSION CHANGES
+        git commit -m "Added VERSION and CHANGES files, Version bump to 0.1.0"
+        git tag -a -m "Tagging version 0.1.0" "0.1.0"
+        git push origin --tags
+        git push
+    fi
+ 
+fi

data/bin/dm_repo_clean.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+#
+# Check if git directory has no changes.
+#
+cd $1
+
+git rev-parse --verify HEAD >/dev/null || echo 1
+git update-index -q --ignore-submodules --refresh
+
+err=0
+
+if ! git diff-files --quiet --ignore-submodules
+then
+  err=1
+fi
+
+if ! git diff-index --cached --quiet --ignore-submodules HEAD --
+then
+  err=1
+fi
+
+test -z "$(git status --porcelain)" || err=1
+
+if [ ${err} = "1" ]
+then
+  echo ${err}
+  exit 1
+fi

data/bin/docman.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'docman/cli'
+
+Docman::CLI.start(ARGV)

data/config/config.yaml

@@ -1,32 +1,55 @@
+---
 deploy_targets:
   local:
-    build_types:
-      root: dir
-      drupal: drupal
-      repo: repo
-      dir: dir
+    handler: LocalDeployer
+    builders:
+      root:
+        handler: :common
+        type: dir
+      drupal:
+        handler: :drupal
+        type: drupal
+      repo:
+        handler: :git
+        type: direct
+      dir:
+        handler: :common
+        type: dir
   acquia:
-    build_types:
-      root: repo
-      drupal: drupal
-      repo: subrepo
-      dir: dir
+    handler: GitDeployer
+    deploy_action: git_push
+    builders:
+      root:
+        handler: :git
+        type: direct
+        after_build_actions:
+          - git_commit
+      drupal:
+        handler: :drupal
+        type: drupal
+        after_build_actions:
+          - git_commit
+      repo:
+        handler: :git
+        type: strip
+        after_build_actions:
+          - git_commit
+      dir:
+        handler: :common
+        type: dir
+        after_build_actions:
+          - git_commit
 
 environments:
   local:
-    deploy_target:
-      local
+    deploy_target: local
+    state: development
   dev:
-    deploy_target:
-      acquia
+    deploy_target: acquia
+    state: development
   test:
-    deploy_target:
-      acquia
+    deploy_target: acquia
+    state: staging
   prod:
-    deploy_target:
-      acquia
-
-states:
-  - development
-  - staging
-  - stable
+    deploy_target: acquia
+    state: stable

data/docman.gemspec

@@ -23,5 +23,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "aruba"
 
   spec.add_dependency 'thor'
-  spec.add_dependency 'configliere'
 end

data/features/local.feature

@@ -1,4 +1,4 @@
-Feature: Docroot management (deploy to local)
+Feature: Docroot management
 
   In order to manage docroot
   As a developer using Cucumber

data/features/local_deploy.feature

@@ -0,0 +1,37 @@
+Feature: Local deploy
+
+  In order to manage docroot
+  As a developer using Cucumber
+  I want to use the deploy steps to deploy to local
+
+  @announce
+  @no-clobber
+  Scenario: Local deploy sample project 1 develop
+    Given I cd to "sample-docroot"
+    Then I run `docman deploy local sample_project1 branch develop`
+    Then the exit status should be 0
+    Then the following directories should exist:
+      | master |
+      | master/docroot |
+      | master/docroot/sites |
+      | master/hooks |
+      | master/profiles |
+      | master/profiles/sample_profile |
+      | master/projects/sample_project1 |
+      | master/projects/sample_project2 |
+
+  @announce
+  @no-clobber
+  Scenario: Local deploy sample project 2 master
+    Given I cd to "sample-docroot"
+    Then I run `docman deploy local sample_project2 branch master`
+    Then the exit status should be 0
+    Then the following directories should exist:
+      | master |
+      | master/docroot |
+      | master/docroot/sites |
+      | master/hooks |
+      | master/profiles |
+      | master/profiles/sample_profile |
+      | master/projects/sample_project1 |
+      | master/projects/sample_project2 |

data/features/support/env.rb

@@ -1,5 +1,6 @@
 require 'aruba/cucumber'
 
 Before do
+  @dirs = ['/Users/alex/dev/dm/aruba']
   @aruba_timeout_seconds = 600
 end

data/features/support/step_definitions/dm_steps.rb

@@ -5,17 +5,17 @@
 #   end
 # end
 #
-# When(/^I store bump version from file "(.*?)"$/) do |file|
-#   ENV['DM_BUMPED_VERSION'] = IO.read(file)
-# end
-#
-# When(/^I change repo state to last bumped tag for "(.*?)" version$/) do |state|
-#   version = ENV["DM_BUMPED_VERSION"]
-#   run "state.sh tag #{version} #{state}"
-# end
-#
-# Then(/^the file "(.*?)" should contain last bumped tag$/) do |file|
-#   version = ENV["DM_BUMPED_VERSION"]
-#   puts "Last bumped tag: #{version}"
-#   prep_for_fs_check { expect(IO.read(file)).to eq version }
-# end
+When(/^I store bump version from file "(.*?)"$/) do |file|
+  ENV['DM_BUMPED_VERSION'] = IO.read(file)
+end
+
+When(/^I change repo state to last bumped tag for "(.*?)" version$/) do |state|
+  version = ENV["DM_BUMPED_VERSION"]
+  run "state.sh tag #{version} #{state}"
+end
+
+Then(/^the file "(.*?)" should contain last bumped tag$/) do |file|
+  version = ENV["DM_BUMPED_VERSION"]
+  puts "Last bumped tag: #{version}"
+  prep_for_fs_check { expect(IO.read(file)).to eq version }
+end

data/lib/application.rb

@@ -0,0 +1,56 @@
+require 'docman/version'
+require 'yaml'
+require 'pathname'
+require 'fileutils'
+require 'docman/git_util'
+require 'docman/docroot_config'
+require 'docman/docroot_controller'
+require 'docman/exec'
+require 'singleton'
+
+module Docman
+  class Application
+
+    attr_reader :config, :options
+    attr_accessor :deploy_target
+
+    include Singleton
+
+    def initialize
+      # TODO: Define workspace properly
+      @workspace_dir = Dir.pwd
+      @config = YAML::load_file(File.join(Pathname(__FILE__).dirname.parent, 'config', 'config.yaml'))
+    end
+
+    def init(name, repo)
+      `mkdir #{name} && cd #{name} && git clone #{repo} config`
+    end
+
+    def build(deploy_target, state, options = false)
+      @options = options
+      DocrootController.new(@workspace_dir, deploy_target, options).build(state)
+    end
+
+    def deploy(deploy_target, name, type, version)
+      DocrootController.new(@workspace_dir, deploy_target).deploy(name, type, version)
+    end
+
+    def state(name, type, version)
+      DocrootController.new(@workspace_dir, deploy_target).state(name, type, version)
+    end
+
+    def self.root
+      Pathname(__FILE__).dirname.parent
+    end
+
+    def self.bin
+      File.join root, 'bin'
+    end
+
+    def self.lib
+      File.join root, 'lib'
+    end
+
+  end
+
+end

data/lib/docman/builders/builder.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+
+module Docman
+  module Builders
+    class Builder
+      @@subclasses = {}
+
+      def self.create(type, root, build_type, state, info)
+        c = @@subclasses[type]
+        if c
+          c.new(root, build_type, state, info)
+        else
+          raise "Bad builder type: #{type}"
+        end
+      end
+
+      def self.register_builder(name)
+        @@subclasses[name] = self
+      end
+
+      def initialize(root, build_type, state, info)
+        @root = root
+        @build_type = build_type
+        @state = state
+        @info = info
+        @before_build_actions = @build_type['before_build_actions'].nil? ? [] : @build_type['before_build_actions']
+        @after_build_actions = @build_type['after_build_actions'].nil? ? [] : @build_type['after_build_actions']
+        @before_build_actions << 'clean_if_changed'
+      end
+
+      def before_build_action_clean_if_changed
+        if File.directory? @info['full_build_path']
+          FileUtils.rm_r @info['full_build_path'] if @info.need_rebuild?
+        end
+      end
+
+      def do
+        perform(@before_build_actions, 'before_build_action')
+        # Dispatch to corresponding method.
+        write_info self.send("#{@build_type['type']}")
+        perform(@after_build_actions, 'after_build_action')
+      end
+
+      def write_info(result)
+        to_save = {}
+        # to_save = @info.clone
+        to_save['state'] = @state
+        to_save['version_type'] = @info.version_type(@state) unless @info.version_type(@state).nil?
+        to_save['version'] = @info.version(@state) unless @info.version(@state).nil?
+        to_save['ref'] = result
+        to_save['build_type'] = @build_type['type']
+        # to_save.delete('full_build_path')
+        # to_save.delete('full_path')
+        # to_save.delete('temp_path')
+        # to_save.delete('repo')
+        # to_save.delete('states')
+        File.open("#{@info['full_build_path']}/info.yaml", 'w') {|f| f.write to_save.to_yaml}
+      end
+
+      def perform(actions, method_prefix)
+        unless actions.nil?
+          actions.each do |action|
+            method = "#{method_prefix}_#{action}"
+            self.send(method)
+          end
+        end
+      end
+
+      def repo?(path)
+        File.directory? File.join(path, '.git')
+      end
+
+      def after_build_action_git_commit
+        message = "name: #{@info['name']} updated, state: #{@state}"
+        GitUtil.commit(@root['full_build_path'], @info['full_build_path'], message)
+      end
+    end
+  end
+end

data/lib/docman/builders/common_builder.rb

@@ -0,0 +1,16 @@
+module Docman
+  module Builders
+    class CommonBuilder < Builder
+
+      register_builder :common
+
+      def dir
+        if File.directory? @info['full_build_path']
+          FileUtils.rm_r(@info['full_build_path']) if self.repo? @info['full_build_path']
+        end
+        FileUtils::mkdir_p @info['full_build_path']
+        @info['build_path']
+      end
+    end
+  end
+end

data/lib/docman/builders/git_builder.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+module Docman
+  module Builders
+    class GitBuilder < Builder
+
+      register_builder :git
+
+      def direct
+        puts 'Do direct'
+        GitUtil.get(@info['repo'], @info['full_build_path'], version_type, version)
+      end
+
+      def strip
+        puts 'Do strip'
+        FileUtils.rm_r(@info['full_build_path']) if File.directory? @info['full_build_path']
+        result = GitUtil.get(@info['repo'], @info['temp_path'], version_type, version)
+        FileUtils.mkdir_p(@info['full_build_path'])
+        FileUtils.cp_r(Dir["#{@info['temp_path']}/."], @info['full_build_path'])
+        FileUtils.rm_r(File.join(@info['full_build_path'], '.git'))
+        result
+      end
+
+      # TODO: need to refactor into into @info class.
+      def version
+        @info['states'][@state]['version']
+      end
+
+      def version_type
+        @info['states'][@state]['type']
+      end
+    end
+  end
+end

data/lib/docman/cli.rb

@@ -1,26 +1,51 @@
 require 'thor'
-require 'docman'
+require 'application'
 
 module Docman
   class CLI < Thor
+
+    # TODO: add proper descriptions.
+
     desc 'init NAME', 'init to NAME'
     def init(name, repo)
-      puts "Init docroot directory #{name} and retrieve config from provided repo."
       if File.directory? "#{name}"
-        `rm -fR #{name}`
+        say("Complete!", :green)
+        $stderr.puts "Directory #{name} already exists"
+        choice = ask('Are you sure you want do delete existing docroot?')
+        FileUtils.rm_r(name) if choice == 'yes'
       end
-      `mkdir #{name} && cd #{name} && git clone #{repo} config`
+
+      puts "Init docroot directory #{name} and retrieve config from provided repo."
+      Application.instance.init(name, repo)
     end
 
     desc 'build NAME', 'init to NAME'
-    def build(target, state)
-      unless File.directory?('config')
-        $stderr.puts 'ERROR: No config directory in docroot'
-        exit 1
-      end
+    method_option :force, :aliases => '-f', :desc => 'Force full rebuild'
+    def build(deploy_target, state)
+      config_dir?
 
-      `cd config && git reset --hard && git clean -f -d && git pull origin master`
-      Docman.new.build(target, state)
+      Application.instance.build(deploy_target, state, options)
     end
+
+    desc 'deploy NAME', 'init to NAME'
+    def deploy(deploy_target, name, type, version)
+      config_dir?
+      Application.instance.deploy(deploy_target, name, type, version)
+    end
+
+    desc 'state NAME', 'init to NAME'
+    def state(name, type, version)
+      config_dir?
+      Application.instance.state(name, type, version)
+    end
+
+    no_commands {
+      def config_dir?
+        unless File.directory?('config')
+          $stderr.puts 'ERROR: No config directory in docroot'
+          exit 1
+        end
+      end
+    }
   end
 end

data/lib/docman/deployers/deployer.rb

@@ -0,0 +1,25 @@
+module Docman
+  module Deployers
+    class Deployer
+
+      attr_reader :deploy_target
+
+      def build(root, state, info)
+        return if @deployed.include? info['name']
+        build_type = build_type(info['type'])
+        Docman::Builders::Builder.create(build_type['handler'], root, build_type, state, info).do()
+        @deployed << info['name']
+      end
+
+      def initialize(deploy_target)
+        @deployed = []
+        @deploy_target = deploy_target
+      end
+
+      def build_type(type)
+        @deploy_target['builders'][type]
+      end
+
+    end
+  end
+end

data/lib/docman/deployers/git_deployer.rb

@@ -0,0 +1,10 @@
+module Docman
+  module Deployers
+    class GitDeployer < Deployer
+      def push(info, state_name)
+        version = info['states'][state_name]['version']
+        GitUtil.push(info['full_build_path'], version)
+      end
+    end
+  end
+end

data/lib/docman/deployers/local_deployer.rb

@@ -0,0 +1,8 @@
+module Docman
+  module Deployers
+    class LocalDeployer < Deployer
+      def push(info)
+      end
+    end
+  end
+end

data/lib/docman/docroot_config.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+require 'docman/info'
+
+module Docman
+
+  class DocrootConfig
+
+    attr_reader :structure
+
+    def initialize(docroot_dir, deploy_target)
+      @docroot_dir = docroot_dir
+      @deploy_target = deploy_target
+      @docroot_config_dir = File.join(docroot_dir, 'config')
+      update
+      @names = {}
+      @structure = structure_build File.join(@docroot_config_dir, 'master')
+    end
+
+    def update
+      GitUtil.update @docroot_config_dir
+    end
+
+    def structure_build(path, prefix = '', parent = nil)
+      return unless File.file? File.join(path, 'info.yaml')
+
+      info = YAML::load_file(File.join(path, 'info.yaml'))
+      name = File.basename path
+      prefix = prefix.size > 0 ? File.join(prefix, name) : name
+      info['full_path'] = path
+      info['build_path'] = prefix
+      info['full_build_path'] = File.join(@docroot_dir, prefix)
+      info['temp_path'] = File.join(@docroot_dir, 'tmp', info['build_path'])
+      info['name'] = name
+      info['parent'] = parent
+
+      i = Docman::Info.new(info)
+
+      @names[name.to_s] = i
+
+      data = {:data => info, :info => i}
+      data[:children] = children = []
+      Dir.foreach(path) do |entry|
+        next if (entry == '..' || entry == '.')
+        full_path = File.join(path, entry)
+        if File.directory?(full_path)
+          dir_hash = structure_build(full_path, prefix, i)
+          unless dir_hash == nil
+            children << dir_hash
+          end
+        end
+      end
+      data
+    end
+
+
+    def chain(info)
+      chain = {}
+      chain[info['name']] = info
+      while info['parent'] do
+        chain[info['parent']['name']] = info['parent']
+        info = info['parent']
+      end
+      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
+
+    def states_dependin_on(name, version)
+      states = {}
+      @names[name]['states'].each do |state, info|
+        states[state] = info if info['version'] == version
+      end
+      states
+    end
+
+  end
+end

data/lib/docman/docroot_controller.rb

@@ -0,0 +1,65 @@
+require 'docman/builders/builder'
+require 'docman/builders/common_builder'
+require 'docman/builders/git_builder'
+require 'docman/deployers/deployer'
+require 'docman/deployers/git_deployer'
+require 'docman/deployers/local_deployer'
+
+# TODO: refactor info into class.
+# TODO: make universal logging class.
+
+module Docman
+  class DocrootController
+
+    attr_reader :docroot_dir, :temp_dir
+
+    def initialize(docroot_dir, deploy_target_name, options = {})
+      @deploy_target = Docman::Application.instance.config['deploy_targets'][deploy_target_name]
+      Docman::Application.instance.deploy_target = @deploy_target
+      docroot_config = DocrootConfig.new(docroot_dir, @deploy_target)
+      @deployer = Object.const_get("Docman::Deployers::#{@deploy_target['handler']}").new(@deploy_target)
+      @docroot_dir = docroot_dir
+      @temp_dir = File.join(docroot_dir, 'tmp')
+      @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
+    end
+
+    def build(state)
+      build_recursive(state)
+      @deployer.push(@docroot_config.root_dir, state)
+    end
+
+    def build_recursive(state, dir = nil)
+      dir = dir ? dir : @docroot_config.structure
+      build_dir(state, dir[:info])
+
+      dir[: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
+      end
+    end
+
+    def build_dir(state, info)
+      @deployer.build(@docroot_config.root(info), state, info)
+    end
+
+  end
+
+end

data/lib/docman/exec.rb

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

data/lib/docman/git_util.rb

@@ -0,0 +1,47 @@
+module Docman
+
+  class GitUtil
+
+    def self.get(repo, path, type, version)
+      if File.directory? path
+        Dir.chdir path
+        `git checkout #{version} && git pull origin #{version}` if type == 'branch'
+        if type == 'tag'
+          `git fetch --tags`
+          `git checkout "tags/#{version}"`
+        end
+      else
+        `git clone #{repo} #{path}`
+        Dir.chdir path
+        `git checkout #{version}`
+      end
+      result = `git rev-parse --short HEAD`
+      result.delete!("\n")
+    end
+
+    def self.update(path)
+      `cd #{path} && git pull`
+    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}"`
+      end
+    end
+
+    def self.repo_changed?(path)
+      not Exec.do "#{Application::bin}/dm_repo_clean.sh #{path}"
+    end
+
+    def self.push(root_path, version)
+      Dir.chdir root_path
+      `git push origin #{version}`
+    end
+  end
+
+end

data/lib/docman/info.rb

@@ -0,0 +1,35 @@
+module Docman
+  class Info < Hash
+    def initialize(hash = {})
+      super
+      hash.each_pair do |k, v|
+        self[k] = v
+      end
+      set_build_type
+      # self['rebuild'] = need_rebuild?
+    end
+
+    def version(state)
+      self['states'][state].nil? ? nil : self['states'][state]['version']
+    end
+
+    def version_type(state)
+      self['states'][state].nil? ? nil : self['states'][state]['type']
+    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']
+      false
+    end
+
+    def set_build_type
+      Docman::Application.instance.deploy_target['builders'][self['type']]['type']
+    end
+  end
+end

data/lib/docman/version.rb

@@ -1,3 +1,3 @@
 module Docman
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docman
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Alexander Tolstikov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-25 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,25 +80,14 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: configliere
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: 
 email:
 - atolstikov@adyax.com
 executables:
+- bump-version.sh
+- dm_repo_clean.sh
 - docman
+- docman.rb
 extensions: []
 extra_rdoc_files: []
 files:
@@ -107,15 +96,29 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bump-version.sh
+- bin/dm_repo_clean.sh
 - bin/docman
+- bin/docman.rb
 - config/config.yaml
 - docman.gemspec
 - features/local.feature
+- features/local_deploy.feature
 - features/support/env.rb
 - features/support/step_definitions/dm_steps.rb
-- lib/docman.rb
+- lib/application.rb
+- lib/docman/builders/builder.rb
+- lib/docman/builders/common_builder.rb
+- lib/docman/builders/git_builder.rb
 - lib/docman/cli.rb
-- lib/docman/git.rb
+- lib/docman/deployers/deployer.rb
+- lib/docman/deployers/git_deployer.rb
+- lib/docman/deployers/local_deployer.rb
+- lib/docman/docroot_config.rb
+- lib/docman/docroot_controller.rb
+- lib/docman/exec.rb
+- lib/docman/git_util.rb
+- lib/docman/info.rb
 - lib/docman/version.rb
 homepage: ''
 licenses:
@@ -143,5 +146,6 @@ specification_version: 4
 summary: Docman made for DOCroot MANagement for Drupal projects
 test_files:
 - features/local.feature
+- features/local_deploy.feature
 - features/support/env.rb
 - features/support/step_definitions/dm_steps.rb

data/lib/docman.rb

@@ -1,117 +0,0 @@
-require 'docman/version'
-require 'yaml'
-require 'configliere'
-require 'pathname'
-require 'fileutils'
-require 'docman/git'
-
-module Docman
-  class Docman
-
-    def initialize()
-      @app_root_dir = Pathname(__FILE__).dirname.parent
-      @current_dir = Dir.pwd
-      # TODO: Define workspace properly
-      @workspace_dir = @current_dir
-      @docroot_dir = @workspace_dir
-      @docroot_config_dir = File.join(@docroot_dir, 'config')
-      @docroot_structure = directory_hash File.join(@docroot_config_dir, 'master')
-
-      Settings.read File.join(@app_root_dir, 'config', 'config.yaml')
-      Settings.resolve!
-      @app_settings = Settings
-      @environments = Settings['environments']
-      @deploy_targets = Settings['deploy_targets']
-    end
-
-    def directory_hash(path, prefix = '')
-      return unless File.file? File.join(path, 'info.yaml')
-
-      name = File.basename path
-      prefix = prefix.size > 0 ? File.join(prefix, name) : name
-      info = YAML::load_file(File.join(path, 'info.yaml'))
-      info['full_path'] = path
-      info['build_path'] = prefix
-      info['name'] = name
-
-      data = {:data => info}
-      data[:children] = children = []
-      Dir.foreach(path) do |entry|
-        next if (entry == '..' || entry == '.' || entry == '_states')
-        full_path = File.join(path, entry)
-        if File.directory?(full_path)
-          dir_hash = directory_hash(full_path, prefix)
-          unless dir_hash == nil
-            children << dir_hash
-          end
-        end
-      end
-
-      data
-    end
-
-    def build(target, state)
-      @target = target
-      @state = state
-      traverse_docroot_structure
-    end
-
-    def deploy
-
-    end
-
-    def traverse_docroot_structure(dir = nil)
-      dir = dir ? dir : @docroot_structure
-
-      build_dir dir[:data]
-
-      dir[:children].each do |child|
-        traverse_docroot_structure child
-      end
-    end
-
-    def build_dir(info)
-      case get_build_type info
-        when 'dir'
-          build_dir_dir info
-        when 'repo'
-          build_dir_repo info
-        when 'subrepo'
-          build_dir_subrepo info
-      end
-    end
-
-    def get_version(info)
-      info['states'][@state]
-    end
-
-    def get_deploy_target
-      @deploy_targets[@environments[@target]['deploy_target']]
-    end
-
-    def get_build_type(info)
-      get_deploy_target['build_types'][info['type']]
-    end
-
-    def build_dir_dir(info)
-      FileUtils::mkdir_p get_path_in_docroot info['build_path']
-    end
-
-    def build_dir_repo(info)
-      repo = info['repo']
-      build_path = get_path_in_docroot info['build_path']
-      version_type = get_version(info)['type']
-      version = get_version(info)['version']
-      Git.new.get_repo(repo, build_path, version_type, version)
-    end
-
-    def build_dir_subrepo(info)
-
-    end
-
-    def get_path_in_docroot(path)
-      File.join(@docroot_dir, path)
-    end
-  end
-
-end

data/lib/docman/git.rb

@@ -1,21 +0,0 @@
-module Docman
-
-  class Git
-    def get_repo(repo, path, type, version)
-      if File.directory? path
-        Dir.chdir path
-        `git checkout #{version} && git pull origin #{version}` if type == 'branch'
-        `git checkout #{version}` if type == 'tag'
-      else
-        `git clone #{repo} #{path}`
-        Dir.chdir path
-        `git checkout #{version}`
-      end
-
-      # if result.nil?
-      #   puts "Error: #{$?}"
-      # end
-    end
-  end
-
-end