royw-git_shoes 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Roy Wright
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,15 @@
+= git_shoes
+
+This is an exploration of using shoes for a real application.
+As this is a learning experience, the files are likely to be
+in a high state of flux.
+
+If the shoes UI works out, then this project's goal is to
+facilitate git workflows and not be a simple porting of the
+CLI to a GUI.
+
+Onward thru the fog...
+
+== Copyright
+
+Copyright (c) 2009 Roy Wright. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "git_shoes"
+    gem.summary = %Q{TODO}
+    gem.email = "roy@wright.org"
+    gem.homepage = "http://github.com/royw/git_shoes"
+    gem.authors = ["Roy Wright"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "git_shoes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 0

data/lib/controllers/controller.rb

@@ -0,0 +1,115 @@
+# This is the start of the application controller.
+
+class Controller
+  class << self
+    include GitHelper
+  end
+
+  ALL = 'All'
+  MANAGED = 'Managed'
+  MODIFIED = 'Modified'
+  CANDIDATE = 'Unmanaged'
+  GIT_FILTER_NAMES = [ALL, MANAGED, MODIFIED, CANDIDATE]
+  FILTER_NAMES = [ALL]
+
+  NAME = 'Name'
+  REVERSE_NAME = 'Reverse Name'
+  DATE = 'Newest First'
+  REVERSE_DATE = 'Oldest First'
+  SORT_NAMES = [NAME, REVERSE_NAME, DATE, REVERSE_DATE]
+
+  # current working directory
+  def self.cwd
+    Directory.cwd
+#     Dir.getwd
+  end
+
+  # change directory
+  # Yes, could just use Dir.chdir but I'm wanting project
+  # accesses encapsulated by the controller/model and not
+  # in the view.
+  def self.chdir(path)
+    Directory.change(path)
+  end
+
+  # return nil or the top level directory of the current
+  # git repository
+  def self.git_project_dir
+    Directory.repository_path
+  end
+
+  def self.in_repository?
+    Directory.git?
+  end
+
+  def self.repository_info
+    Directory.repository_info
+  end
+
+  def self.branch(verbose=false)
+    Directory.branch(verbose)
+  end
+
+  def self.branches
+    Directory.branches
+  end
+
+  def self.branch=(name)
+    Directory.branch = name
+  end
+
+  def self.stash
+    Directory.stash
+  end
+
+  def self.stash_pop
+    Directory.stash_pop
+  end
+
+  def self.get_git_log(name)
+    Directory.get_git_log(name)
+  end
+
+  # return the list of files in the current directory
+  def self.files(&blk)
+    items = Directory.contents.collect do |item|
+      item.options[:click] = lambda {Controller.chdir(item.path); blk.call(nil)} if item.directory?
+      item.options[:click] = lambda {blk.call(item.path)} if item.file?
+      item
+    end
+#     puts "files items => #{items.inspect}"
+    items
+  end
+
+  # filter the list of files
+  def self.filter_by(filter_name, values)
+    case filter_name
+    when ALL
+      # leave values alone
+    when MANAGED
+      values = values.select{|item| item.managed? || item.directory?}
+    when MODIFIED
+      values = values.select{|item| item.modified? || item.directory?}
+    when CANDIDATE
+      values = values.select{|item| item.candidate? || item.directory?}
+    end
+#     puts "filter_by values => #{values.inspect}"
+    values
+  end
+
+  # sort the list of files
+  def self.sort_by(sort_name, values)
+    case sort_name
+    when NAME
+      values = values.sort {|a,b| a.path <=> b.path}
+    when REVERSE_NAME
+      values = values.sort {|a,b| b.path <=> a.path}
+    when DATE
+      values = values.sort {|a,b| a.mtime <=> b.mtime}
+    when REVERSE_DATE
+      values = values.sort {|a,b| b.mtime <=> a.mtime}
+    end
+#     puts "sort_by values => #{values.inspect}"
+    values
+  end
+end

data/lib/loader.rb

@@ -0,0 +1,19 @@
+APP_ENV = "development" unless defined? APP_ENV
+$:.push(File.join(File.dirname(__FILE__)))
+require 'yaml'
+require 'logger'
+require 'singleton'
+# require 'ruby-debug'
+
+require 'logger_facade'
+
+require 'models/git_helper'
+require 'models/directory'
+require 'models/dir_item'
+
+require 'views/bullet_list'
+require 'views/action'
+require 'views/dir_action'
+
+require 'controllers/controller'
+

data/lib/logger_facade.rb

@@ -0,0 +1,29 @@
+# From Matt Payne's slimtimeronshoes
+class LoggerFacade
+
+  @@logger = Logger.new(APP_ENV == "development" ? STDOUT :
+      File.open('SlimTimerOnShoesErrors.log', File::WRONLY | File::APPEND | File::CREAT))
+  @@logger.level = APP_ENV == "production" ? Logger::WARN : Logger::INFO
+
+  FATAL = Logger::FATAL
+  ERROR = Logger::ERROR
+  WARN = Logger::WARN
+  INFO = Logger::INFO
+  DEBUG = Logger::DEBUG
+
+  def self.log(message, status=LoggerFacade::INFO)
+    case status
+    when LoggerFacade::DEBUG
+      @@logger.debug(message)
+    when LoggerFacade::ERROR
+      @@logger.error(message)
+    when LoggerFacade::FATAL
+      @@logger.fatal(message)
+    when LoggerFacade::INFO
+      @@logger.info(message)
+    when LoggerFacade::WARN
+      @@logger.warn(message)
+    end
+  end
+
+end

data/lib/models/dir_item.rb

@@ -0,0 +1,47 @@
+class DirItem
+  include GitHelper
+
+  attr_reader :path, :options
+  attr_writer :managed, :modified, :candidate
+
+  def initialize(path)
+    @path = path
+    @managed = false
+    @modified = false
+    @candidate = false
+    @options = {}
+  end
+
+  def managed?
+    @managed
+  end
+
+  def modified?
+    @modified
+  end
+
+  def candidate?
+    @candidate
+  end
+
+  def directory?
+    File.directory?(@path)
+  end
+
+  def file?
+    File.file?(@path)
+  end
+
+  def mtime
+    File.mtime(@path)
+  end
+
+  def diff
+    git_diff(@path)
+  end
+
+  def log
+    git_log(@path)
+  end
+
+end

data/lib/models/directory.rb

@@ -0,0 +1,146 @@
+class Directory
+  include Singleton
+  include GitHelper
+
+  def self.change(path,&blk)
+    instance.change(path, &blk)
+  end
+
+  def self.git?
+    instance.git?
+  end
+
+  def self.repository_path
+    instance.repository_path
+  end
+
+  def self.repository_info
+    instance.repository_info
+  end
+
+  def self.branch(verbose=false)
+    instance.branch(verbose)
+  end
+
+  def self.branches
+    instance.branches
+  end
+
+  def self.branch=(name)
+    instance.branch = name
+  end
+
+  def self.stash
+    instance.stash
+  end
+
+  def self.stash_pop
+    instance.stash_pop
+  end
+
+  def self.get_git_log(name)
+    instance.get_git_log(name)
+  end
+
+  def self.contents
+    instance.contents
+  end
+
+  def self.cwd
+    instance.cwd
+  end
+
+  protected
+
+  def initialize
+    @cwd = Dir.getwd
+  end
+
+  public
+
+  attr_reader :cwd
+
+  def change(path,&blk)
+    Dir.chdir(path, &blk)
+    @cwd = Dir.getwd
+  end
+
+  def git?
+    git_dir?(@cwd)
+  end
+
+  def repository_path
+    git_dir(@cwd)
+  end
+
+  def repository_info
+    repo_info = {}
+    if git?
+      # auto pop the directory when we are done
+      Dir.chdir(repository_path) do
+        repo_info['Managed'] = git_ls_files.length
+        repo_info['Modified'] = git_modified_files.length
+        repo_info['Unmanaged'] = git_new_files.length
+      end
+    end
+    repo_info
+  end
+
+  def branch(verbose=false)
+    git? ? git_branch(verbose) : ''
+  end
+
+  def branches
+    git_branch_names
+  end
+
+  def branch=(name)
+    git_checkout_branch(name)
+  end
+
+  def stash
+    git_stash
+  end
+
+  def stash_pop
+    git_stash_pop
+  end
+
+  def get_git_log(name)
+    git_log(name)
+  end
+
+  def contents
+    git? ? git_contents : non_git_contents
+  end
+
+  private
+
+  def git_contents
+    managed_files = git_ls_files
+    managed_dirs = managed_files.collect{|path| path =~ /^([^\/]+)\// ? $1 : nil}.compact.uniq
+    modified_files = git_modified_files
+    candidate_files = git_new_files
+    entries = Dir.entries(@cwd)
+    entries.delete('.')
+    items = entries.collect do |filename|
+      item = DirItem.new(filename)
+      item.managed = managed_files.include?(filename)
+      item.modified = modified_files.include?(filename)
+      item.candidate = candidate_files.include?(filename)
+      item
+    end
+    # puts "contents items => #{items.inspect}"
+    items
+  end
+
+  def non_git_contents
+    entries = Dir.entries(@cwd)
+    entries.delete('.')
+    items = entries.collect do |filename|
+      DirItem.new(filename)
+    end
+    items
+  end
+
+end

data/lib/models/git_helper.rb

@@ -0,0 +1,162 @@
+# This is a temporary hack while I learn more about git.
+# As such I'm using very ugly, non-portable code to invoke
+# git via the command line.  This ugliness will eventually
+# be replaced with a gem library.
+#
+# The current goal is to define the high level interface
+# needed to git.
+#
+# A really good git reference:
+# http://skwpspace.com/git-workflows-book/
+module GitHelper
+
+  # is the given path in a git repository?
+  def git_dir?(path)
+#     debug "git_dir?(#{path})"
+    result = false
+    unless path.nil? || path.strip.empty?
+      if File.directory?(path)
+        result = File.exist?(File.join(path, '.git'))
+      end
+      unless result
+        unless File.dirname(path) == path
+          result = git_dir?(File.dirname(path))
+        end
+      end
+    end
+    result
+  end
+
+  # return nil or the path to the top level directory of the
+  # git repository that includes the given path
+  def git_dir(path)
+#     debug "git_dir?(#{path})"
+    result = nil
+    unless path.nil? || path.strip.empty?
+      # if the given path is a directory then check if it has a .git sub-directory
+      if File.directory?(path)
+        git_pathspec = File.join(path, '.git')
+        if File.exist?(git_pathspec) && File.directory?(git_pathspec)
+          result = path
+        end
+      end
+      # only recurse if we haven't found a .git directory
+      if result.nil?
+        # stop recurse when we can't traverse up the tree any farther
+        unless File.dirname(path) == path
+          # recurse into the parent directory
+          result = git_dir(File.dirname(path))
+        end
+      end
+    end
+    result
+  end
+
+  # return an array of filespecs of all the files in the
+  # current directory that are already in the git repository
+  def git_ls_files
+    `git ls-files`.split("\n")
+  end
+
+  # return an array of filespecs of all the files that have
+  # been modified in the working tree relative to the current
+  # directory
+  def git_modified_files
+    s1 = `git status`
+    parse_modified_files(s1)
+  end
+
+  def parse_modified_files(s1)
+    s1.split("\n").collect{ |line| line =~ /^\#\s+modified\:\s+(\S.*)/ ? $1 : nil}.compact
+  end
+
+  # return an array of filespecs relative to the current directory
+  # of all the files in the working tree that are not ignored by
+  # .gitignore and are not currently in the repository.
+  def git_new_files
+    s1 = `git status`
+    parse_new_files(s1)
+  end
+
+  def parse_new_files(s1)
+    filenames = []
+    re1 = /^\#\s+Untracked files\:/m
+    md1 = re1.match(s1)
+    unless md1.nil?
+      s2 = md1.post_match
+      re2 = /^#\s+\(use \"git add \<file\>\.\.\.\" to include in what will be committed\)/m
+      md2 = re2.match(s2)
+      unless md2.nil?
+        s3 = md2.post_match
+        filenames = s3.split("\n").collect{|line| line =~ /^#\s+(\S.*)/ ? $1 : nil}.compact
+      end
+    end
+    filenames
+  end
+
+  def git_branch(verbose=false)
+    branch = ''
+    `git branch#{verbose ? ' -v' : ''}`.split("\n").each do |s|
+      if s =~ /^\*\s+(\S.*)\s*$/
+        branch = $1
+        break
+      end
+    end
+    branch
+  end
+
+  def git_branch_names
+    `git branch`.split("\n").collect{|name| (name =~ /^\*\s+(\S.*)\s*$/) ? $1 : name }
+  end
+
+  def git_create_branch(name)
+    `git branch #{name}`
+  end
+
+  def git_checkout_branch(name)
+    unless git_branch == name
+      `git checkout #{name}`
+    end
+  end
+
+  def git_squash(from_branch_name)
+    `git merge --squash #{from_branch_name}`
+  end
+
+  def git_delete_branch(name)
+    `git branch -D #{name}`
+  end
+
+  def git_uncommit
+    `git uncommit`
+  end
+
+  def git_stash
+    `git stash`
+  end
+
+  def git_stash_pop
+    `git stash pop`
+  end
+
+  def git_log(name)
+    `git log #{name}`
+  end
+
+  def git_diff(name)
+    `git diff #{name}`
+  end
+
+#   def git_config_list_popup
+#     window :title => 'Git Repository Config' do
+#       stack do
+#         para `git config --list`
+#         stack(:align => 'center') do
+#           button('OK') do
+#             close
+#           end
+#         end
+#       end
+#     end
+#   end
+end

data/lib/views/action.rb

@@ -0,0 +1,10 @@
+# From Matt Payne's slimtimeronshoes
+class Action
+
+  attr_accessor :app
+
+  def execute(obj=nil)
+
+  end
+
+end

data/lib/views/bullet_list.rb

@@ -0,0 +1,66 @@
+# As shoes does not provide a listview, here's the start
+# of one.  Yes, I know, pretty crude...
+module BulletList
+
+  STAR_BULLET   = :star
+  CIRCLE_BULLET = :circle
+  PLUS_BULLET   = :plus
+  SPACE_BULLET  = :space
+
+  BULLETS = {
+    :star   => lambda{|app| app.star(-6,13,5,6,3)},
+    :circle => lambda{|app| app.oval(-7,10,7)},
+    :plus   => lambda do |app|
+                 # rect(x,y,w,h) NOTE, docs are wrong
+                 length = 9
+                 beam = 1
+                 app.rect(-5,8,beam,length,1)   # vertical bar
+                 app.rect(-9,12,length,beam,1)  # horizontal bar
+               end,
+    :space  => lambda {|app| }
+    }
+
+  public
+
+  # create the bullet list and return as a stack instance
+  # values is an array of DirItem instances
+  #
+  # list_opts is a hash of options for the list itself
+  # Example:
+  #   list_opts => { :bullet => lambda{ |filename| star_bullet } }
+  # TODO a lot more docs here
+  def bullet_list(values, list_opts={})
+#     app.stroke = app.black
+#     app.fill = app.red
+    app.stack(:margin_bottom => 10) do
+      values.each do |dir_item|
+        opts = dir_item.options
+        slot_opts = {}
+        slot_opts[:height] = opts[:height] unless opts[:height].nil?
+        slot_opts[:scroll] = opts[:scroll] unless opts[:scroll].nil?
+        right = 0
+        right += opts[:margin_right] unless opts[:margin_right].nil?
+        left = 10
+        app.flow(:margin_left => 15) do
+          unless list_opts[:bullet].nil?
+#             app.debug "list_opts[:bullet] => #{list_opts[:bullet].inspect}.call(#{dir_item})"
+            BULLETS[list_opts[:bullet].call(dir_item)].call(app)
+          end
+          app.stack(slot_opts) do
+            if opts[:background]
+              app.background(opts[:background], :margin_left => left)
+              left += 5
+            end
+            if opts[:click].nil?
+              app.para(dir_item.path, :margin_left => left, :margin_right => right, :margin_bottom => 0)
+            else
+              app.para(app.link(dir_item.path, :click => opts[:click]), :margin_left => left, :margin_right => right, :margin_bottom => 0)
+            end
+          end
+        end
+      end
+    end
+  end
+
+end
+

data/lib/views/dir_action.rb

@@ -0,0 +1,217 @@
+class DirAction < Action
+  include BulletList
+
+  DIR_PAGE = '/'
+  FILE_PAGE = '/file'
+  VIEW_AREA_OPTS = {:width => -100, :margin_left => 10, :margin_right => @gutter}
+
+  def initialize
+    super
+    @filter_selection = Controller::FILTER_NAMES.first
+    @sort_selection   = Controller::SORT_NAMES.first
+  end
+
+
+  def execute(filename=nil)
+    info "dir_action.execute(#{filename})"
+    dir_item = @values.select{|item| item.path == filename}.first rescue nil
+    @gutter = app.gutter
+    app.background app.palegreen
+    app.style(Shoes::Link, :underline => false, :stroke => app.blue)
+    app.style(Shoes::LinkHover, :underline => true, :stroke => app.red)
+
+    app.flow(:width => '100%') do
+      title_stack = app.stack(:width => '100%') do
+        app.background app.gradient(app.rgb(0, 255, 0), app.rgb(225, 255, 0), :angle => 135)
+        app.title("Git Shoes", :align => 'center')
+      end
+      command_widget(dir_item, :width => 100)
+      if dir_item.nil?
+        @view_area = directory_widget(VIEW_AREA_OPTS)
+      else
+        @view_area = file_widget(dir_item, VIEW_AREA_OPTS)
+      end
+    end
+  end
+
+  def command_widget(dir_item, opt={})
+    app.stack(opt) do
+      app.background app.gradient(app.rgb(0, 255, 0), app.rgb(255, 255, 0), :angle => -35)
+      app.para app.link("Files",  :click => lambda{app.visit(DIR_PAGE)})
+      app.rect(5, 30, 90, 1)
+      if Controller.in_repository?
+        app.para app.link("Status", :click => lambda{status_action})
+        if !dir_item.nil? && (dir_item.modified? || dir_item.candidate?)
+          app.para app.link("Add", :click => lambda{add_action})
+        else
+          app.para "Add"
+        end
+        if !dir_item.nil? && dir_item.modified?
+          app.para app.link("Diff", :click => lambda{diff_action})
+        else
+          app.para "Diff"
+        end
+        app.para app.link("Commit", :click => lambda{commit_action})
+        app.para "Config"
+      else
+#         app.para 'Status'
+#         app.para "Diff"
+#         app.para "Commit"
+#         app.para "Branch"
+#         app.para "Config"
+      end
+    end
+  end
+
+  def add_action
+    # TODO implement
+    puts "need to implement add_action"
+  end
+
+  def diff_action
+    # TODO implement
+    puts "need to implement diff_action"
+  end
+
+  def commit_action
+    # TODO implement
+    puts "need to implement commit_action"
+  end
+
+  def status_action
+    if Controller.in_repository?
+      @view_area.clear {status_widget(VIEW_AREA_OPTS)}
+    end
+  end
+
+  def status_widget(opt={})
+    app.stack(opt) do
+      app.para `git status`
+      app.info app.para.text
+    end
+  end
+
+  def file_widget(dir_item, opt={})
+    app.stack(opt) do
+      app.para "filename: #{dir_item.path}"
+      # TODO: everything there is to know about the file ;)
+      app.para(app.strong('Log'))
+      app.flow(:height => 200, :margin_right => @gutter, :scroll => true) do
+        app.background app.turquoise
+        app.para(dir_item.log)
+      end
+      if dir_item.modified?
+        app.para
+        app.para(app.strong('Diff'))
+        app.flow(:height => 200, :margin_right => @gutter, :scroll => true) do
+          app.background app.turquoise
+          app.para dir_item.diff
+        end
+      end
+    end
+  end
+
+  def directory_widget(opt={})
+    app.stack(opt) do
+      cwd = Controller.cwd
+      git_project_dir = Controller.git_project_dir
+      if git_project_dir.nil?
+        app.caption("Directory", :align => 'center')
+        app.para(cwd)
+      else
+        repository_widget(cwd, git_project_dir)
+      end
+
+      file_selection(git_project_dir)
+    end
+  end
+
+  def repository_widget(cwd, git_project_dir)
+    app.caption("Git Repository", :align => 'center')
+    app.flow do
+      app.para "Branch: "
+      @branch_listbox = app.list_box(:items => Controller.branches) do |list|
+        Controller.branch = list.text
+        file_selection_changed
+      end
+      @branch_listbox.choose(Controller.branch(false))
+      app.button("New",       :margin_left => 10)  # TODO Hook it up
+      app.button("Delete",    :margin_left => 10)  # TODO Hook it up
+      app.button("Stash",     :margin_left => 10) { Controller.stash }
+      app.button("Stash Pop", :margin_left => 10) { Controller.stash_pop }
+    end
+    app.para("Branch: ", app.strong(Controller.branch(true)))
+    app.para(app.strong(git_project_dir, app.em(cwd.gsub(git_project_dir, ''))))
+    buf = []
+    repository_info = Controller.repository_info
+    repository_info.each do |key, value|
+      buf << "#{value} #{key} files"
+    end
+    app.para buf.join(", ")
+  end
+
+  def file_selection(git_project_dir)
+    app.flow do
+      app.para 'Filter by: '
+      if git_project_dir.nil?
+        filter_items = Controller::FILTER_NAMES
+        unless filter_items.include?(@filter_selection)
+          @filter_selection = filter_items.first
+        end
+      else
+        filter_items = Controller::GIT_FILTER_NAMES
+      end
+      @filter_by = app.list_box(:items => filter_items) do |list|
+        file_selection_changed
+      end
+      app.para '   Sort by: '
+      @sort_by = app.list_box(:items => Controller::SORT_NAMES) do |list|
+        file_selection_changed
+      end
+      @listing = app.stack
+      @filter_by.choose(@filter_selection)
+      @sort_by.choose(@sort_selection)
+
+      # need to fire a selection changed to get the intial loading of @listing
+      file_selection_changed
+    end
+  end
+
+  def file_selection_changed
+    @filter_selection = @filter_by.text
+    @sort_selection = @sort_by.text
+    @values = Controller.files do |filename|
+      if filename.nil?
+        app.visit(DIR_PAGE)
+      else
+        app.visit(FILE_PAGE + '/' + filename)
+      end
+    end
+    @values = Controller.filter_by(@filter_by.text, @values)
+    @values = Controller.sort_by(@sort_by.text, @values)
+    @listing.clear {bullet_list(@values, :bullet => fs_bullets)}
+  end
+
+  def fs_bullets
+    lambda do |item|
+      if item.path == '..'
+        bullet = BulletList::SPACE_BULLET
+      else
+        if item.directory?
+          app.fill app.black
+          bullet = BulletList::PLUS_BULLET
+        else
+          if item.modified?
+            app.fill app.red
+          elsif item.managed?
+            app.fill app.lime
+          else
+            app.fill app.black
+          end
+          bullet = BulletList::CIRCLE_BULLET
+        end
+      end
+      bullet
+    end
+  end
+end

data/spec/git_helper_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+STATUS_1 = <<END_STATUS_1
+# On branch master
+# Changed but not updated:
+#   (use "git add <file>..." to update what will be committed)
+#   (use "git checkout -- <file>..." to discard changes in working directory)
+#
+#       modified:   lib/dvdprofiler2xbmc/controllers/app.rb
+#       modified:   lib/dvdprofiler2xbmc/models/dvdprofiler_info.rb
+#
+# Untracked files:
+#   (use "git add <file>..." to include in what will be committed)
+#
+#       t1
+#       t2
+no changes added to commit (use "git add" and/or "git commit -a")
+END_STATUS_1
+
+describe "GitHelper" do
+  it "should parse the status and find modified files" do
+    class A
+      include GitHelper
+    end
+    a = A.new
+    a.parse_modified_files(STATUS_1).should == ['lib/dvdprofiler2xbmc/controllers/app.rb', 'lib/dvdprofiler2xbmc/models/dvdprofiler_info.rb']
+  end
+  it "should parse the status and find new files" do
+    class A
+      include GitHelper
+    end
+    a = A.new
+    a.parse_new_files(STATUS_1).should == ['t1', 't2']
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'git_shoes'
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: royw-git_shoes
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Roy Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: roy@wright.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/controllers/controller.rb
+- lib/loader.rb
+- lib/logger_facade.rb
+- lib/models/dir_item.rb
+- lib/models/directory.rb
+- lib/models/git_helper.rb
+- lib/views/action.rb
+- lib/views/bullet_list.rb
+- lib/views/dir_action.rb
+- spec/git_helper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/royw/git_shoes
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- spec/spec_helper.rb
+- spec/git_helper_spec.rb