space 0.0.5 → 0.0.6

data/lib/space/app/logger.rb

@@ -1,21 +0,0 @@
-require 'logger'
-require 'fileutils'
-
-module Space
-  class App
-    class Logger < ::Logger
-      def initialize
-        truncate
-        super('/tmp/space.log')
-      end
-
-      def truncate
-        File.open(filename, 'w+') { |f| f.write('-' * 80 + "\n") }
-      end
-
-      def filename
-        '/tmp/space.log'
-      end
-    end
-  end
-end

data/lib/space/events/buffer.rb

@@ -1,18 +0,0 @@
-module Space
-  module Events
-    class Buffer < Array
-      def push(event)
-        # if any? { |e| e.source == event.source }
-        #   App.logger.debug("REJECT event #{event.event.inspect} on #{event.source.class.name.split("\\n").last}")
-        # else
-          super
-        # end
-      end
-
-      def flush
-        each { |event| event.source.notify(*event) }
-        clear
-      end
-    end
-  end
-end

data/lib/space/events/event.rb

@@ -1,14 +0,0 @@
-module Space
-  module Events
-    class Event
-      attr_reader :source, :event, :data
-
-      def initialize(source, event, data = {})
-        @source = source
-        @event  = event
-        @data   = data
-      end
-    end
-  end
-end
-

data/lib/space/models.rb

@@ -1,7 +0,0 @@
-module Space
-  module Models
-    autoload :Project, 'space/models/project'
-    autoload :Repos,   'space/models/repos'
-    autoload :Repo,    'space/models/repo'
-  end
-end

data/lib/space/models/repo.rb

@@ -1,57 +0,0 @@
-module Space
-  module Models
-    class Repo
-      autoload :Bundle,     'space/models/repo/bundle'
-      autoload :Dependency, 'space/models/repo/dependency'
-      autoload :Git,        'space/models/repo/git'
-
-      include Events
-
-      attr_reader :project, :path, :git, :bundle
-
-      def initialize(project, path)
-        @project = project
-        @path    = File.expand_path(path)
-        @git     = Git.new(self)
-        @bundle  = Bundle.new(self, project.repos)
-      end
-
-      def name
-        @name ||= File.basename(path)
-      end
-
-      def number
-        @number ||= project.number(name)
-      end
-
-      def ref
-        git.commit
-      end
-
-      def deps
-        bundle.deps
-      end
-
-      def refresh
-        git.refresh
-        bundle.refresh
-      end
-
-      def execute(cmd)
-        chdir do
-          puts "in #{path}".ansi(:bold, :yellow)
-          system(cmd)
-        end
-      end
-
-      def chdir(&block)
-        Dir.chdir(path, &block)
-      end
-
-      def subscribe(*args)
-        super
-        [git, bundle].each { |object| object.subscribe(self) }
-      end
-    end
-  end
-end

data/lib/space/shell.rb

@@ -1,56 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

data/lib/space/shell/watcher.rb

@@ -1,40 +0,0 @@
-module Space
-  module Shell
-    module Watcher
-      class << self
-        def suspend
-          @suspended = true
-          yield.tap do
-            @suspended = false
-          end
-        end
-
-        def suspended?
-          !!@suspended
-        end
-      end
-
-      def initialize(*args)
-        watch
-      end
-
-      private
-
-        def watch
-          targets.each do |path|
-            Watch.new(path, &method(:trigger)).run
-          end
-        end
-
-        def trigger(paths)
-          refresh unless Watcher.suspended?
-        end
-
-        def targets
-          self.class.watch.map do |path|
-            path[0, 1] == '~' ? path : "#{self.path}/#{path}"
-          end
-        end
-    end
-  end
-end