space 0.0.3 → 0.0.4

data/lib/space/models/repo/git.rb

@@ -0,0 +1,52 @@
+require 'observer'
+
+module Space
+  module Models
+    class Repo
+      class Git
+        include Events, Shell
+
+        commands  status: 'git status',
+                  branch: 'git branch --no-color',
+                  commit: 'git log -1 --no-color HEAD'
+
+        watch '.'
+
+        attr_reader :repo
+
+        def initialize(repo)
+          @repo = repo
+          super(repo.path)
+        end
+
+        def branch
+          result(:branch) =~ /^\* (.+)/ && $1.strip
+        end
+
+        def commit
+          result(:commit) =~ /^commit (\S{7})/ && $1
+        end
+
+        def status
+          dirty? ? :dirty : (ahead? ? :ahead : :clean)
+        end
+
+        def ahead?
+          ahead > 0
+        end
+
+        def ahead
+          result(:status) =~ /Your branch is ahead of .* by (\d+) commits?\./ ? $1.to_i : 0
+        end
+
+        def dirty?
+          !clean?
+        end
+
+        def clean?
+          result(:status).include?('nothing to commit (working directory clean)')
+        end
+      end
+    end
+  end
+end

data/lib/space/models/repos.rb

@@ -1,45 +1,50 @@
 module Space
-  class Repos < Array
-    class << self
+  module Models
+    class Repos
+      include Events
+
+      autoload :Collection, 'space/models/repos/collection'
+
+      attr_accessor :project, :paths, :scope
+
+      def initialize(project, paths)
+        @project = project
+        @paths = paths
+      end
+
       def all
-        @all ||= create(App.config.paths)
+        @all ||= Collection.new(self, paths.map { |path| Repo.new(project, path) })
       end
 
       def names
         @names ||= all.map(&:name)
       end
 
-      def select(names)
-        new(all.select { |repo| names.include?(repo.name) })
+      def scope=(scope)
+        @scope = scope
+        notify(:update, nil)
       end
 
-      def find_by_name(name)
-        all.find_by_name(name)
+      def scope
+        @scope || all
       end
 
-      def create(paths)
-        new(paths.map_with_index { |path, ix| Repo.new(ix + 1, path) })
+      def scoped?
+        !!@scope
       end
-    end
-
-    def names
-      map(&:name)
-    end
-
-    def scoped?
-      size != self.class.all.size
-    end
 
-    # def name
-    #   "#{App.name}-(#{names.join('|').gsub("#{App.config.name}-", '')})"
-    # end
+      def find_by_name(name)
+        all.detect { |repo| repo.name == name } || raise("cannot find repo #{name.inspect}")
+      end
 
-    def find_by_name(name)
-      detect { |repo| repo.name == name }
-    end
+      def select_by_names(names)
+        Collection.new(self, all.select { |repo| names.include?(repo.name) })
+      end
 
-    def self_and_dependencies
-      self.class.new(map { |repo| [repo] + repo.dependencies }.flatten.uniq)
+      def subscribe(*args)
+        super
+        all.each { |repo| repo.subscribe(*args) }
+      end
     end
   end
 end

data/lib/space/models/repos/collection.rb

@@ -0,0 +1,26 @@
+module Space
+  module Models
+    class Repos
+      class Collection < Array
+        attr_reader :repos
+
+        def initialize(repos, elements)
+          @repos = repos
+          super(elements)
+        end
+
+        def names
+          map(&:name)
+        end
+
+        def self_and_deps
+          Collection.new(repos, (self + deps).uniq)
+        end
+
+        def deps
+          map(&:deps).flatten.map(&:repo).compact
+        end
+      end
+    end
+  end
+end

data/lib/space/models/repos/scope.rb

@@ -0,0 +1,18 @@
+module Space
+  module Models
+    class Repos
+      class Collection < Array
+        attr_reader :repos
+
+        def initialize(repos, elements)
+          @repos = repos
+          super(elements)
+        end
+
+        def self_and_dependencies
+          Collection.new(repos, (self + map(&:dependencies)).flatten.uniq)
+        end
+      end
+    end
+  end
+end

data/lib/space/screen.rb

@@ -1,28 +1,32 @@
 module Space
   class Screen
-    attr_reader :app
+    autoload :Progress,  'space/screen/progress'
+    autoload :Dashboard, 'space/screen/dashboard'
+    autoload :View,      'space/screen/view'
 
-    def initialize(app)
-      @app = app
+    attr_reader :project, :view
+
+    def initialize(project)
+      @project = project
+    end
+
+    def display(name)
+      @view = create(name)
+      render
     end
 
     def render
-      system 'clear'
-      puts render_project
-      repos = app.repos.scoped? ? app.repos.self_and_dependencies : app.repos
-      repos.each do |repo|
-        puts render_repo(repo)
-      end
+      view.render
     end
 
-    private
+    def notify(event)
+      view.notify(event)
+    end
 
-      def render_project
-         View.new.render(:project, :app => app, :bundle => app.bundle)
-      end
+    private
 
-      def render_repo(repo)
-        View.new.render(:repo, :app => app, :repo => repo, :git => repo.git, :bundle => repo.bundle)
+      def create(screen)
+        self.class.const_get(screen.to_s.capitalize).new(project)
       end
   end
 end

data/lib/space/screen/dashboard.rb

@@ -0,0 +1,28 @@
+module Space
+  class Screen
+    class Dashboard < View
+      def render
+        App.logger.debug('RENDER dashboard')
+        clear
+        render_header
+        render_repos
+      end
+
+      def notify(event)
+        render
+      end
+
+      private
+
+        def render_repos
+          project.repos.scope.self_and_deps.each do |repo|
+            render_template(:repo, assigns(repo))
+          end
+        end
+
+        def assigns(repo)
+          { repos: project.repos, repo: repo, git: repo.git, bundle: repo.bundle }
+        end
+    end
+  end
+end

data/lib/space/screen/progress.rb

@@ -0,0 +1,15 @@
+module Space
+  class Screen
+    class Progress < View
+      def render
+        App.logger.debug('RENDER dashboard')
+        clear
+        render_header
+      end
+
+      def notify(event)
+        print '.'
+      end
+    end
+  end
+end

data/lib/space/screen/view.rb

@@ -0,0 +1,43 @@
+require 'erb'
+
+module Space
+  class Screen
+    class View
+      include Helpers
+
+      attr_reader :project
+
+      def initialize(project)
+        @project = project
+      end
+
+      private
+
+        def clear
+          print "\e[2J\e[0;0H" # clear screen, move cursor to home
+        end
+
+        def render_header
+          puts "Project #{project.name}\n\n"
+        end
+
+        def render_template(name, assigns)
+          assigns.each { |name, value| assign(name, value) }
+          print template(name).result(binding)
+        end
+
+        def assign(key, value)
+          instance_variable_set(:"@#{key}", value)
+          (class << self; self; end).send(:attr_reader, key)
+        end
+
+        def templates
+          @templates ||= {}
+        end
+
+        def template(name)
+          templates[name] ||= ERB.new(File.read("#{project.config.template_dir}/#{name}.erb"), nil, '%<>-')
+        end
+    end
+  end
+end

data/lib/space/shell.rb

@@ -0,0 +1,56 @@
+module Space
+  module Shell
+    autoload :Command, 'space/shell/command'
+    autoload :Watch,   'space/shell/watch'
+    autoload :Watcher, 'space/shell/watcher'
+
+    module ClassMethods
+      def commands(commands = nil)
+        commands ? @commands = commands : @commands
+      end
+
+      def watch(*paths)
+        paths.empty? ? (@paths || []) : (@paths = paths)
+      end
+    end
+
+    include Watcher
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+
+      def all
+        @all ||= []
+      end
+
+      def refresh
+        all.map(&:refresh)
+      end
+    end
+
+    attr_reader :path
+
+    def initialize(path = '.')
+      @path = File.expand_path(path)
+      Shell.all << self
+      super
+    end
+
+    def result(command)
+      commands[command].result
+    end
+
+    def commands
+      @commands ||= self.class.commands.inject({}) do |commands, (key, command)|
+        commands.merge(key => Command.new(self, command))
+      end
+    end
+
+    def refresh
+      commands.each { |key, command| command.run }
+      # notify(:refresh, self.class.name)
+    end
+  end
+end

data/lib/space/shell/command.rb

@@ -0,0 +1,63 @@
+require 'ansi/code'
+
+module Space
+  module Shell
+    class Command
+      class << self
+        def execute(command)
+          `#{command}`
+        end
+      end
+
+      attr_reader :context, :command, :result
+
+      def initialize(context, command)
+        @context = context
+        @command = command
+      end
+
+      def run
+        Watcher.suspend do
+          App.logger.debug "RUNNING #{command} [#{context.path}]"
+          notifying do
+            @result = chain.call
+          end
+        end
+      end
+
+      private
+
+        def notifying(&block)
+          old = result
+          yield.tap do |new|
+            notify unless old == new
+          end
+        end
+
+        def notify
+          context.notify(command, result)
+        end
+
+        def chain
+          runner = -> { clean(self.class.execute(command)) }
+          filters.reverse.inject(runner) { |runner, filter| -> { filter.call(&runner) } }
+        end
+
+        def filters
+          [method(:chdir), ::Bundler.method(:with_clean_env) ]
+        end
+
+        def chdir(&block)
+          Dir.chdir(context.path) { |path| block.call }
+        end
+
+        def clean(string)
+          strip_ansi(string.chomp)
+        end
+
+        def strip_ansi(string)
+          string.gsub(ANSI::Code::PATTERN, '')
+        end
+    end
+  end
+end

data/lib/space/shell/watch.rb

@@ -0,0 +1,50 @@
+require 'rb-fsevent'
+
+module Space
+  module Shell
+    class Watch
+      LATENCY = 0
+      NO_DEFER = FALSE
+
+      attr_reader :path, :callback, :mutex
+
+      def initialize(path, &block)
+        @path = File.expand_path(path)
+        @callback = block
+        @mutex = Mutex.new
+        self
+      end
+
+      def run
+        Thread.new do
+          App.logger.debug("WATCHING #{path}")
+          watch
+        end
+      end
+
+      private
+
+        def watch
+          fsevent.watch(path, file: file?, latency: LATENCY, no_defer: NO_DEFER) do |paths|
+            App.logger.debug("WATCH triggered: #{paths.inspect}")
+            fsevent.stop
+            mutex.synchronize do
+              callback.call(paths)
+            end
+            fsevent.run
+          end
+          fsevent.run
+        rescue Exception => e
+          puts e.message, e.backtrace
+        end
+
+        def file?
+          File.file?(path)
+        end
+
+        def fsevent
+          @fsevent ||= FSEvent.new
+        end
+    end
+  end
+end