refactoring

lib/space.rb

@@ -14,6 +14,7 @@ module Space
   autoload :Watch,      'space/watch'
 
   autoload :Bundler,    'space/models/bundler'
+  autoload :Bundle,     'space/models/bundle'
   autoload :Commands,   'space/models/commands'
   autoload :Command,    'space/models/command'
   autoload :Dependency, 'space/models/dependency'
@@ -22,9 +23,4 @@ module Space
   autoload :Repos,      'space/models/repos'
   autoload :Repo,       'space/models/repo'
   autoload :Watcher,    'space/models/watcher'
-
-  TEMPLATES = {
-    project: 'lib/space/templates/project.erb',
-    repo:    'lib/space/templates/repository.erb'
-  }
 end

lib/space/action.rb

@@ -7,18 +7,18 @@ class Action
     include Builtin, Development
 
     class << self
-      def run(app, line)
+      def run(project, line)
         ::Bundler.with_clean_env do
-          new(app, *Parser.new(app.repos.names).parse(line)).run
+          new(project, *Parser.new(project.names).parse(line)).run
         end
       end
     end
 
-    attr_reader :app, :repos, :command, :args
+    attr_reader :project, :repos, :command, :args
 
-    def initialize(app, repos, command, *args)
-      @app     = app
-      @repos   = app.repos.select_by_names(repos) if repos
+    def initialize(project, repos, command, *args)
+      @project = project
+      @repos   = project.repos.select_by_names(repos) if repos
       @command = normalize(command)
       @args    = args
     end
@@ -34,7 +34,7 @@ def run
     private
 
       def run_scoped(refreshing = false)
-        (repos || app.repos.scope).each { |repo| yield repo }
+        (repos || project.repos.scope).each { |repo| yield repo }
         confirm unless refreshing
       end
 

lib/space/action/builtin.rb

@@ -2,18 +2,18 @@ module Space
   class Action
     module Builtin
       def refresh
-        app.project.reset
+        project.bundler.reset
         run_scoped(true) do |repo|
           repo.reset
         end
       end
 
       def scope
-        app.repos.scope = repos
+        project.repos.scope = repos
       end
 
       def unscope
-        app.repos.scope = nil
+        project.repos.scope = nil
       end
 
       def execute(cmd)

lib/space/action/development.rb

@@ -12,7 +12,7 @@ def remote
         run_scoped do |repo|
           system "bundle config --delete local.#{repo.name}"
         end
-        app.project.reset
+        project.reset
       end
 
       def install

lib/space/app.rb

@@ -4,17 +4,15 @@ module Space
   class App
     include Readline
 
-    attr_reader :name, :config, :project, :repos, :screen
+    attr_reader :name, :config, :project, :screen
 
     def initialize(name)
       @name    = name
       @config  = Config.load(name)
-      @project = Project.new(self, name)
-      @repos   = Repos.new(project, config.paths)
-      @screen  = Screen.new(name, project, repos)
+      @project = Project.new(name, config)
+      @screen  = Screen.new(name, config, project, project.repos)
 
       project.add_observer(self)
-      repos.add_observer(self)
     end
 
     def run
@@ -34,19 +32,20 @@ def update
 
       def render(options = {})
         Watcher.ignore do
-          print "\e[2J\e[0;0H" # clear screen, move cursor to home
+          screen.clear
+          print 'gathering data '
           Commands.preload
           screen.render(options)
         end
       end
 
       def handle(line)
-        Action.run(self, line)
+        Action.run(project, line)
         render
       end
 
       def prompt
-        "#{repos.scoped? ? repos.scope.map { |r| r.name }.join(', ') : name} > "
+        "#{project.repos.scoped? ? project.repos.scope.map { |r| r.name }.join(', ') : name} > "
       end
   end
 end

lib/space/config.rb

@@ -2,15 +2,23 @@ module Space
   class Config < Hashr
     class << self
       def load(name)
-        paths = %W(~/.space/#{name}.yml ./.#{name}.yml).map { |path| File.expand_path(path) }
-        unless path = paths.detect { |path| File.exists?(path) }
-          puts("Could not find #{name}.yml at either of ~/.space/#{name}.yml and ./.#{name}.yml")
-          exit
+        new(YAML.load(File.read(path(name))))
+      end
+
+      def path(name)
+        path = paths(name).detect { |path| File.exists?(path) }
+        path || abort("Could not find #{name}.yml at either of ~/.space/#{name}.yml and ./.#{name}.yml")
+      end
+
+      def paths(name)
+        %W(~/.space/#{name}.yml ./.#{name}.yml).map do |path|
+          File.expand_path(path)
         end
-        new(YAML.load(File.read(path)))
       end
     end
 
+    define :template_dir => File.expand_path('../templates', __FILE__)
+
     def paths
       @paths ||= repositories.map { |path| base_dir ? "#{base_dir}/#{path}" : path }
     end

lib/space/helpers.rb

@@ -12,7 +12,7 @@ def project_title
     end
 
     def local_repos
-      "\n#{format_list(project.local_repos, :width => terminal_width - 2, :prefix => 'Local: ')}\n" unless project.local_repos.empty?
+      format_list(project.local_repos, :width => terminal_width - 2, :prefix => 'Local: ') + "\n" unless project.local_repos.empty?
     end
 
     def tableize(string)
@@ -38,16 +38,16 @@ def git_ahead
       " #{git.ahead} commit#{'s' if git.ahead > 1} ahead".ansi(:yellow)
     end
 
-    def bundler_status
-      "Bundle: #{format_boolean(bundler.clean?)}"
+    def bundle_status
+      "Bundle: #{format_boolean(bundle.clean?)}"
     end
 
-    def bundler_info
-      bundler.info.ansi(:red) unless bundler.clean?
+    def bundle_info
+      bundle.info.ansi(:red) unless bundle.clean?
     end
 
-    def bundler_deps
-      bundler.deps.map { |dep| "• #{dep.ref} #{format_boolean(dep.fresh?)} #{dep.name}" }.join("\n")
+    def bundle_deps
+      bundle.deps.map { |dep| "• #{dep.ref} #{format_boolean(dep.fresh?)} #{dep.name}" }.join("\n")
     end
 
     def format_boolean(value)

lib/space/models/bundle.rb

@@ -0,0 +1,44 @@
+require 'observer'
+
+module Space
+  class Bundle
+    include Watcher, Observable, Commands
+
+    COMMANDS = {
+      check:  'bundle check',
+      list:   ->(command) { "bundle list | grep #{command.name}" }
+    }
+
+    WATCH = [
+      'Gemfile',
+      'Gemfile.lock'
+    ]
+
+    attr_reader :project
+
+    def initialize(project, path)
+      @project = project
+      super(path)
+    end
+
+    def name
+      project.name
+    end
+
+    def clean?
+      info =~ /dependencies are satisfied/
+    end
+
+    def info
+      result(:check).split("\n").first
+    end
+
+    def deps
+      result(:list).split("\n").map do |dep|
+        if matches = dep.strip.match(/^\* (?<name>[\S]+) \(\d+\.\d+\.\d+(?: (?<ref>.+))?\)/)
+          Dependency.new(project.repos, matches[:name], matches[:ref])
+        end
+      end.compact
+    end
+  end
+end

lib/space/models/bundler.rb

@@ -5,41 +5,23 @@ class Bundler
     include Watcher, Observable, Commands
 
     COMMANDS = {
-      check:  'bundle check',
-      list:   ->(command) { "bundle list | grep #{command.name}" }
+      config: 'bundle config'
     }
 
     WATCH = [
-      'Gemfile',
-      'Gemfile.lock'
+      '.bundle/config'
     ]
 
-    attr_reader :project, :repos
-
-    def initialize(project, repos, path)
-      @project = project
-      @repos = repos
-      super(path)
-    end
-
-    def name
-      project.name
-    end
-
-    def clean?
-      info =~ /dependencies are satisfied/
-    end
-
-    def info
-      result(:check).split("\n").first
+    def initialize
+      super('.')
     end
 
-    def deps
-      result(:list).split("\n").map do |dep|
-        if matches = dep.strip.match(/^\* (?<name>[\S]+) \(\d+\.\d+\.\d+(?: (?<ref>.+))?\)/)
-          Dependency.new(repos, matches[:name], matches[:ref])
-        end
-      end.compact
+    def config
+      lines  = result(:config).split("\n")[2..-1]
+      values = lines.map_slice(3) do |name, value, _|
+        [name, value =~ /: "(.*)"/ && $1]
+      end
+      Hash[*values.compact.flatten]
     end
   end
 end

lib/space/models/commands.rb

@@ -6,9 +6,7 @@ def all
       end
 
       def preload
-        print 'gathering data '
         all.map(&:preload)
-        print "\e[2J\e[0;0H" # clear screen, move cursor to home
       end
     end
 

lib/space/models/project.rb

@@ -2,50 +2,37 @@
 
 module Space
   class Project
-    include Watcher, Observable, Commands
+    attr_reader :name, :repos, :bundler
 
-    COMMANDS = {
-      config: 'bundle config'
-    }
-
-    WATCH = [
-      '.bundle/config'
-    ]
-
-    attr_reader :app, :name
-
-    def initialize(app, name)
-      @app = app
+    def initialize(name, config)
       @name = name
-      super('.')
+      @repos = Repos.new(self, config.paths)
+      @bundler = Bundler.new
+    end
+
+    def names
+      @names ||= Tmux.windows || repos.names
     end
 
     def local_repos
-      config.keys.map do |key|
+      bundler.config.keys.map do |key|
         key =~ /^local\.(.+)$/
-        $1 if app.repos.names.include?($1)
+        $1 if repos.names.include?($1)
       end.compact
     end
 
-    def config
-      lines  = result(:config).split("\n")[2..-1]
-      values = lines.map_slice(3) do |name, value, _|
-        [name, value =~ /: "(.*)"/ && $1]
-      end
-      Hash[*values.compact.flatten]
-    end
-
-    def windows
-      @windows ||= Tmux.windows || app.repos.names
-    end
-
     def number(name)
-      if number = windows.index(name)
+      if number = names.index(name)
         number + 1
       else
-        windows << name
+        names << name
         number(name)
       end
     end
+
+    def add_observer(observer)
+      repos.add_observer(observer)
+      bundler.add_observer(observer)
+    end
   end
 end