redcar 0.3.10.1dev → 0.4

data/plugins/scm/lib/scm/scm_changes_mirror.rb

@@ -0,0 +1,51 @@
+
+module Redcar
+  module Scm
+    class ScmChangesMirror
+      include Redcar::Tree::Mirror
+      
+      def initialize(repo)
+        @repo = repo
+      end
+      
+      def title
+        @repo.translations[:uncommited_changes]
+      end
+      
+      def data_type
+        :text
+      end
+      
+      # Root items will never change
+      def changed?
+        false
+      end
+      
+      def drag_and_drop?
+        #@repo.supported_commands.include? :index
+        false
+      end
+      
+      def from_data(data)
+        data.split('::::').map {|n| @repo.from_data(n)}.find_all {|n| not n.nil?}
+      end
+      
+      def to_data(nodes)
+        nodes.find_all {|n| n.respond_to?(:to_data)}.map {|n| n.to_data}.join('::::')
+      end
+      
+      def top
+        @top ||= begin
+          if @repo.supported_commands.include? :index
+            [
+              ScmChangesMirror::ChangesNode.new(@repo, :indexed),
+              ScmChangesMirror::ChangesNode.new(@repo, :unindexed)
+            ]
+          else
+            [ScmChangesMirror::ChangesNode.new(@repo, :all)]
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_changes_mirror/change.rb

@@ -0,0 +1,61 @@
+
+module Redcar
+  module Scm
+    class ScmChangesMirror
+      module Change
+        include Redcar::Tree::Mirror::NodeMirror
+        
+        #####
+        # NodeMirror stuff
+        ###
+        def text
+          "#{File.basename(path)} (#{File.dirname(path)})"
+        end
+        
+        def tooltip_text
+          text
+        end
+        
+        def icon
+          :file
+        end
+        
+        def leaf?
+          true
+        end
+        
+        def to_data
+          path
+        end
+        
+        #####
+        # Change definition stuff
+        ###
+        
+        # The status is an array of symbols indicating the status of this change
+        # and hence what operations can be performed on it. This is only 
+        # consulted if the SCM supports the :index command.
+        #
+        # Possible values and their implications:
+        #   :new - can be passed to index_add, index_ignore
+        #   :indexed - can be passed to index_revert, index_unsave
+        #   :deleted - can be passed to index_restore, index_unsave
+        #   :missing - can be passed to index_restore, index_delete
+        #   :changed - can be passed to index_save, index_unsave
+        #   :commitable - can be passed to commit!
+        #                 Intended to represent subprojects.
+        def status
+          [:new]
+        end
+        
+        def path
+          ''
+        end
+        
+        def diff
+          nil
+        end
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_changes_mirror/changes_node.rb

@@ -0,0 +1,47 @@
+
+module Redcar
+  module Scm
+    class ScmChangesMirror
+      class ChangesNode
+        include Redcar::Tree::Mirror::NodeMirror
+        
+        attr_reader :change_types
+        
+        def initialize(repo, change_types)
+          @repo = repo
+          @change_types = change_types
+        end
+        
+        def text
+          case @change_types
+          when :indexed
+            @repo.translations[:indexed_changes]
+          when :unindexed
+            @repo.translations[:unindexed_changes]
+          when :all
+            @repo.translations[:uncommited_changes]
+          end
+        end
+        
+        def icon
+          :directory
+        end
+        
+        def leaf?
+          false
+        end
+        
+        def children
+          case @change_types
+          when :indexed
+            @repo.indexed_changes
+          when :unindexed
+            @repo.unindexed_changes
+          when :all
+            @repo.uncommited_changes
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_changes_mirror/drag_controller.rb

@@ -0,0 +1,78 @@
+
+module Redcar
+  module Scm
+    class ScmChangesController
+      class DragController
+        include Redcar::Tree::Controller::DragController
+        
+        def initialize(tree, repo)
+          @tree = tree
+          @repo = repo
+        end
+        
+        # Can elements in the tree be reordered by dragging and 
+        # dropping? Shows insertion feedback in the GUI.
+        def reorderable?
+          false
+        end
+        
+        # Called during a drag operation when the cursor hovers over other
+        # rows. 
+        #
+        # @param nodes - the dragged nodes
+        # @param target - the hovered over node, or nil if the empty tree area
+        # @param position - one of :onto, :before, :after (always :onto unless
+        #                   reorderable?)
+        def can_drop?(nodes, target, position)
+          # We can always attempt to drag anywhere. do_drop handles sanity
+          # checking.
+          true
+        end
+        
+        # Called when the user has dropped nodes onto another node.
+        #
+        # @param nodes - the dragged nodes
+        # @param target - the hovered over node, or nil if the empty tree area
+        # @param position - one of :onto, :before, :after (always :onto unless
+        #                   reorderable?)
+        def do_drop(nodes, target, position)
+          # Make sure we have a target, and that it is a top level item
+          target ||= @tree.tree_mirror.top[1]
+          target = type? target
+          
+          nodes.find_all {|n| target != type?(n)}.each do |n|
+            # At this point, we've verified that we're dragging from one node 
+            # to another, so just loop through the changes and do the first 
+            # action that we can, which will always be the least destructive,
+            # ie. will only affect the index.
+            command = n.status.map {|s| COMMAND_MAP[s]}.flatten.find_all{|s| s != :commit}.first
+            
+            if command
+              @repo.method(command).call(n)
+            end
+          end
+          
+          Redcar.update_gui { @tree.refresh }
+        end
+        
+        private
+        
+        # Finds the top level item that this node belongs to.
+        def type?(node)
+          @tree.tree_mirror.top.each do |top|
+            # Make sure we check the top level items themselves too.
+            children = [top]
+            
+            while c = children.shift
+              return top if c == node
+              children.push(*c.children)
+            end
+          end
+          
+          nil
+        end
+        
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_commits_controller.rb

@@ -0,0 +1,49 @@
+
+module Redcar
+  module Scm
+    class ScmCommitsController
+      include Redcar::Tree::Controller
+      
+      def initialize(repo)
+        @repo = repo
+      end
+      
+      def activated(tree, node)
+        if node.respond_to?(:log)
+          log = node.log
+          if log
+            # TODO: if we can provide a text log of ourselves, then display it
+          end
+        end
+      end
+      
+      def right_click(tree, node)
+        repo = @repo
+        
+        # In lieu of actually supporting multi-select, make it obvious
+        # that we don't.
+        if tree.selection.length > 1
+          tree.select(node)
+        end
+        
+        menu = Menu::Builder.build do
+          if node.is_a?(Scm::ScmCommitsMirror::CommitsNode)
+            item(repo.translations[:push]) { 
+              if node.branch
+                refresh = node.repo.push! node.branch
+              else
+                refresh = node.repo.push!
+              end
+              tree.refresh if refresh
+            }
+            
+            separator
+          end
+          item("Refresh", :priority => :last) { repo.refresh; tree.refresh }
+        end
+        
+        Application::Dialog.popup_menu(menu, :pointer)
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_commits_mirror.rb

@@ -0,0 +1,36 @@
+
+module Redcar
+  module Scm
+    class ScmCommitsMirror
+      include Redcar::Tree::Mirror
+      
+      def initialize(repo)
+        @repo = repo
+      end
+      
+      def title
+        @repo.translations[:unpushed_commits]
+      end
+      
+      def data_type
+        :text
+      end
+      
+      def changed?
+        @repo.push_targets.count > 0
+      end
+      
+      def drag_and_drop?
+        false
+      end
+      
+      def top
+        if @repo.push_targets.count > 0
+          @repo.push_targets
+        else
+          @top ||= [ScmCommitsMirror::CommitsNode.new(@repo)]
+        end
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_commits_mirror/commit.rb

@@ -0,0 +1,26 @@
+
+module Redcar
+  module Scm
+    class ScmCommitsMirror
+      module Commit
+        include Redcar::Tree::Mirror::NodeMirror
+        
+        def text
+          raise "not implemented"
+        end
+        
+        def icon
+          File.join(Scm::ICONS_DIR, "notebook--arrow.png")
+        end
+        
+        def leaf?
+          true
+        end
+        
+        def log
+          nil
+        end
+      end
+    end
+  end
+end

data/plugins/scm/lib/scm/scm_commits_mirror/commits_node.rb

@@ -0,0 +1,38 @@
+
+module Redcar
+  module Scm
+    class ScmCommitsMirror
+      class CommitsNode
+        include Redcar::Tree::Mirror::NodeMirror
+        
+        attr_reader :repo, :branch
+        
+        def initialize(repo, branch=nil, text=nil)
+          @repo = repo
+          @branch = branch
+          @text = text || branch || @repo.translations[:unpushed_commits]
+        end
+        
+        def text
+          @text
+        end
+        
+        def icon
+          File.join(Scm::ICONS_DIR, "folder--arrow.png")
+        end
+        
+        def leaf?
+          false
+        end
+        
+        def children
+          if branch
+            @repo.unpushed_commits(branch)
+          else
+            @repo.unpushed_commits
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/scm/plugin.rb

@@ -0,0 +1,8 @@
+Plugin.define do
+  name    "scm"
+  version "0.1"
+  file    "lib", "scm"
+  object  "Redcar::Scm::Manager"
+  dependencies "project", ">=1.1",
+               "application", ">=1.1"
+end

data/plugins/scm/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'redcar'
+Redcar.environment = :test
+Redcar.load

data/plugins/scm/vendor/ruby-blockcache/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010, Matthew Scharley
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Neither the name of the copyright holder, ObjectCache nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/plugins/scm/vendor/ruby-blockcache/README.md

@@ -0,0 +1,44 @@
+# BlockCache
+
+by Matthew Scharley
+http://github.com/mscharley/ruby-blockcache
+
+## Overview
+
+> In computer science, a cache is a component that improves performance 
+> by transparently storing data such that future requests for that 
+> data can be served faster.
+>
+> -- [Cache at Wikipedia](http://en.wikipedia.org/wiki/Cache)
+
+Typical caches do this by allowing you to store data in them, along with
+a time limit to describe how long this data is valid for. You then need
+to check if the data is available, and if not, regenerate it and store
+it again, ready for next time.
+
+BlockCache eliminates all this. You define your cache, describe the
+elements it contains, and then you never have to worry about making
+sure you have fresh data again. Of course, if you need to ensure that
+you are getting clean, uncached data, you can do that too.
+
+## Example Usage
+
+    require 'blockcache'
+    
+    cache = BlockCache.new
+    cache.add('name', 10) do
+      puts "Hello, what is your name?"
+      STDIN.gets.strip
+    end
+    
+    for i in [1,2]
+      for j in [1,3]
+        puts "Hello " + cache['name'] + "!"
+      end
+      cache.refresh
+    end
+
+In the example above, you get asked for your name, then it says 
+hello to you three times. Note, each time is using the exact same
+code. The program then tells the cache that it wants fresh data,
+and repeats the process.