dandelion 0.3.15 → 0.4.0.beta2

data/lib/dandelion/command/status.rb

@@ -1,21 +1,22 @@
 module Dandelion
   module Command
     class Status < Command::Base
-      command 'status'
-  
-      class << self
-        def parser(options)
-          OptionParser.new do |opts|
-            opts.banner = 'Usage: dandelion status'
-          end
+      command :status
+
+      def self.parser(options)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: dandelion status'
         end
       end
-  
-      def execute
-        @deployment = deployment('HEAD')
-        
-        log.info("Remote revision:       #{@deployment.remote_revision || '---'}")
-        log.info("Local HEAD revision:   #{@deployment.local_revision}")
+
+      def execute!
+        log.info("Connecting to #{adapter.to_s}")
+
+        local_commit = workspace.local_commit
+        remote_commit = workspace.remote_commit
+
+        log.info("Remote revision:      #{remote_commit ? remote_commit.oid : '---'}")
+        log.info("Local HEAD revision:  #{workspace.local_commit.oid}")
       end
     end
   end

data/lib/dandelion/config.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module Dandelion
+  class Config
+    attr_reader :path, :data
+    
+    def initialize(options = {})
+      @path = options[:path]
+      @data = @path ? load : (options[:data] || {})
+    end
+
+    def [](key)
+      @data[key] || @data[key.to_s]
+    end
+
+    def []=(key, value)
+      @data[key.to_s] = value
+    end
+
+    def defaults(values)
+      values.each do |k, v|
+        if self[k].nil?
+          self[k] = v
+        end
+      end
+
+      self
+    end
+
+  private
+
+    def load
+      YAML.load_file(path) || {}
+    end
+  end
+end

data/lib/dandelion/deployer.rb

@@ -0,0 +1,53 @@
+module Dandelion
+  class Deployer
+    def initialize(adapter, options = {})
+      @adapter = adapter
+      @options = options
+    end
+
+    def deploy_changeset!(changeset)
+      changeset.each do |change|
+        if exclude?(change.path)
+          log.debug("Skipping file: #{change.path}")
+        else
+          deploy_change!(change)
+        end
+      end
+    end
+
+    def deploy_files!(files)
+      files.each do |path|
+        local_path = remote_path = path
+
+        if path.is_a?(Hash)
+          local_path, remote_path = path.first
+        end
+
+        log.debug("Writing file:  #{local_path} -> #{remote_path}")
+        @adapter.write(remote_path, IO.read(local_path))
+      end
+    end
+
+  private
+
+    def deploy_change!(change)
+      case change.type
+      when :write
+        log.debug("Writing file:  #{change.path}")
+        @adapter.write(change.path, change.data)
+      when :delete
+        log.debug("Deleting file: #{change.path}")  
+        @adapter.delete(change.path)
+      end
+    end
+
+    def exclude?(path)
+      excluded = @options[:exclude] || []
+      excluded.map { |e| path.start_with?(e) }.any?
+    end
+
+    def log
+      Dandelion.logger
+    end
+  end
+end

data/lib/dandelion/diff.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module Dandelion
+  class Diff
+    extend Forwardable
+    include Enumerable
+
+    def_delegator :@target, :empty?
+    def_delegator :@target, :each
+
+    attr_reader :from_commit, :to_commit
+
+    def initialize(from_commit, to_commit)
+      @from_commit = from_commit
+      @to_commit = to_commit
+
+      if from_commit.nil?
+        @target = FullDiff.new(to_commit.diff(nil))
+      else
+        @target = PartialDiff.new(from_commit.diff(to_commit))
+      end
+    end
+  end
+
+private
+
+  class PartialDiff
+    def initialize(diff)
+      @deltas = diff.deltas
+    end
+
+    def empty?
+      @deltas.empty?
+    end
+
+    def each
+      @deltas.each do |delta|
+        if delta.deleted?
+          yield Change.new(delta.old_file[:path], :delete)
+        else
+          yield Change.new(delta.new_file[:path], :write)
+        end
+      end
+    end
+  end
+
+  class FullDiff
+    def initialize(diff)
+      @deltas = diff.patches.map(&:delta)
+    end
+
+    def empty?
+      @deltas.empty?
+    end
+
+    def each
+      @deltas.each do |delta|
+        yield Change.new(delta.new_file[:path], :write)
+      end
+    end
+  end
+end

data/lib/dandelion/tree.rb

@@ -0,0 +1,22 @@
+module Dandelion
+  class Tree
+    attr_reader :commit
+
+    def initialize(repo, commit)
+      @repo = repo
+      @commit = commit
+    end
+
+    def data(path)
+      object = @commit.tree
+
+      path.split('/').each do |name|
+        return nil unless object[name]
+        object = @repo.lookup(object[name][:oid])
+        return nil unless object
+      end
+
+      object.read_raw.data
+    end
+  end
+end

data/lib/dandelion/utils.rb

@@ -0,0 +1,13 @@
+require 'tempfile'
+
+module Dandelion
+  module Utils
+    def temp(file, data)
+      tmp = Tempfile.new(file.gsub('/', '.'))
+      tmp << data
+      tmp.flush
+      yield(tmp.path)
+      tmp.close
+    end
+  end
+end

data/lib/dandelion/version.rb

@@ -1,3 +1,3 @@
 module Dandelion
-  VERSION = '0.3.15'
-end
+  VERSION = '0.4.0.beta2'
+end

data/lib/dandelion/workspace.rb

@@ -0,0 +1,71 @@
+module Dandelion
+  class RevisionError < StandardError; end
+
+  class Workspace
+    attr_reader :adapter, :config
+    
+    def initialize(repo, adapter, config = nil)
+      @repo = repo
+      @adapter = adapter
+
+      if config.is_a?(Hash)
+        @config = Config.new(data: config)
+      else
+        @config = config || Config.new
+      end
+
+      @config.defaults(revision_file: '.revision', local_path: '')
+    end
+
+    def tree
+      Tree.new(@repo, local_commit)
+    end
+
+    def changeset
+      Changeset.new(tree, remote_commit, @config)
+    end
+
+    def local_commit
+      lookup(local_sha)
+    end
+
+    def remote_commit
+      sha = remote_sha
+      sha ? lookup(remote_sha) : nil
+    end
+
+    def remote_commit=(commit)
+      self.remote_sha = commit.oid
+    end
+
+  private
+
+    def lookup(val)
+      begin
+        begin
+          if ref = @repo.ref(val)
+            val = ref.target.to_s
+          end
+        rescue Rugged::ReferenceError
+        end
+
+        @repo.lookup(val)
+      rescue Rugged::OdbError, Rugged::InvalidError
+        raise RevisionError.new(val)
+      end
+    end
+
+    def local_sha
+      @config[:revision] || @repo.head.target
+    end
+
+    def remote_sha
+      @remote_sha ||= @adapter.read(@config[:revision_file])
+    end
+
+    def remote_sha=(sha)
+      @adapter.write(@config[:revision_file], sha)
+      @remote_sha = sha
+    end
+  end
+end

data/spec/dandelion/adapter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Dandelion::Adapter::Base do
+  describe '#create_adapter' do
+    it 'registers adapter classes' do
+      class TestAdapter < Dandelion::Adapter::Base
+        adapter :test
+      end
+
+      expect(Dandelion::Adapter::Base.create_adapter(:test)).to be_a(TestAdapter)
+    end
+
+    it 'raises error on invalid adapter' do
+      expect {
+        Dandelion::Adapter::Base.create_adapter(:another)
+      }.to raise_error(Dandelion::Adapter::InvalidAdapterError)
+    end
+
+    it 'registers gem list' do
+      class TestAdapter < Dandelion::Adapter::Base
+        adapter :test
+        requires_gems :foo, :bar
+      end
+
+      expect(TestAdapter.required_gems).to eq [:foo, :bar]
+    end
+
+    it 'catches load errors' do
+      class TestAdapter < Dandelion::Adapter::Base
+        adapter :test
+
+        def initialize(options)
+          raise LoadError
+        end
+      end
+
+      expect {
+        Dandelion::Adapter::Base.create_adapter(:test)
+      }.to raise_error(Dandelion::Adapter::MissingDependencyError)
+    end
+  end
+end

data/spec/dandelion/change_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Dandelion::Change do
+  let(:change) { Dandelion::Change.new('foo', 'bar', 'baz') }
+
+  it 'has path' do
+    expect(change.path).to eq 'foo'
+  end
+
+  it 'has type' do
+    expect(change.type).to eq 'bar'
+  end
+
+  it 'has data' do
+    expect(change.data).to eq 'baz'
+  end
+end

data/spec/dandelion/changeset_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Dandelion::Changeset do
+  context 'empty local path' do
+    let(:changeset) { test_changeset }
+
+    describe '#enumerable' do
+      let(:changes) { changeset.to_a }
+
+      it 'returns all changes' do
+        expect(changes).to be_a(Array)
+        expect(changes.length).to eq 5
+        expect(changes.map(&:path)).to eq ['bar', 'baz/bar', 'baz/foo', 'foo', 'qux']
+        expect(changes.map(&:type)).to eq [:delete, :write, :delete, :write, :write]
+      end
+
+      it 'returns data for write changes' do
+        expect(changes.select { |c| c.type == :write }.map(&:data)).to eq ["bar\n", "foo\n", ""]
+      end
+    end
+
+    describe '#empty?' do
+      it 'returns false' do
+        expect(changeset.empty?).to eq false
+      end
+    end
+  end
+
+  context 'non-empty local path' do
+    let(:changeset) { test_changeset(local_path: 'baz') }
+
+    describe '#enumerable' do
+      let(:changes) { changeset.to_a }
+
+      it 'returns all changes' do
+        expect(changes).to be_a(Array)
+        expect(changes.length).to eq 2
+        expect(changes.map(&:path)).to eq ['bar', 'foo']
+        expect(changes.map(&:type)).to eq [:write, :delete]
+      end
+
+      it 'returns data for write changes' do
+        expect(changes.first.data).to eq "bar\n"
+      end
+    end
+
+    describe '#empty?' do
+      it 'returns false' do
+        expect(changeset.empty?).to eq false
+      end
+    end
+  end
+
+  context 'empty diff' do
+    let(:changeset) { test_changeset }
+    before(:each) { changeset.stub(:diff).and_return([]) }
+
+    describe '#enumerable' do
+      let(:changes) { changeset.to_a }
+
+      it 'returns no changes' do
+        expect(changes).to be_a(Array)
+        expect(changes.length).to eq 0
+      end
+    end
+
+    describe '#empty?' do
+      it 'returns true' do
+        expect(changeset.empty?).to eq true
+      end
+    end
+  end
+end