greenhouse 0.0.3

data/lib/greenhouse/commands/push.rb

@@ -0,0 +1,45 @@
+module Greenhouse
+  module Commands
+    class Push
+      include Command
+      command_summary "Push local branches for all projects to their git remotes"
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} [<project>] #{valid_arguments.to_s}
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def push_all
+        if Projects.projects.empty?
+          puts "No projects defined."
+          return
+        end
+
+        Projects.projects.each do |project|
+          Tasks::PushProject.perform(project)
+        end
+      end
+
+      def push_project(project)
+        unless project.exists?
+          puts "Project \e[36m#{project.title}\e[0m does not exist. Try initializing it with `greenhouse init`"
+          return
+        end
+
+        Tasks::PushProject.perform(project)
+      end
+
+      def run
+        project = Projects::projects.select { |project| arguments.map(&:key).include?(project.name) }.first
+        project.nil? ? push_all : push_project(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/remove.rb

@@ -0,0 +1,32 @@
+module Greenhouse
+  module Commands
+    class Remove
+      include Command
+      command_summary "Purge a project and remove it from the ecosystem .projects file"
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} <project>
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+      
+      def run
+        if arguments.empty?
+          puts "You must provide the name of the project you want to remove from your ecosystem."
+          usage
+          return
+        end
+
+        project = Projects::projects.select { |proj| proj.name == arguments[0].key }.first
+        Tasks::PurgeProject.perform(project)
+        Tasks::RemoveProject.perform(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/start.rb

@@ -0,0 +1,21 @@
+module Greenhouse
+  module Commands
+    class Start
+      include Command
+
+      command_summary "Startup the entire ecosystem of apps using your Procfile (aliases `foreman start`)"
+
+      class << self
+        def usage
+          puts "usage: #{::Greenhouse::CLI.command_name} #{command_name} #{valid_arguments.to_s}"
+        end
+      end
+
+      def run
+        Dir.chdir(Projects::path) do
+          exec 'foreman start'
+        end
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/status.rb

@@ -0,0 +1,50 @@
+module Greenhouse
+  module Commands
+    class Status
+      include Command
+      command_summary "List projects and their current status"
+      valid_arguments Scripts::Argument.new("-v, --verbose", :summary => "Print out detailed information about project status (local changes, ahead/behind/diverged branches, etc.)")
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} [<project>] #{valid_arguments.to_s}
+
+Arguments:
+#{valid_arguments.to_help}
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def verbose
+        arguments.map(&:key).include?("-v")
+      end
+      
+      def ecosystem_status
+        if Projects::projects.empty?
+          puts "No projects configured."
+          return
+        end
+
+        puts "The following projects are configured in your ecosystem: "
+        Projects::projects.each do |project|
+          puts
+          Tasks::ProjectStatus.perform(project, verbose)
+        end
+      end
+
+      def project_status(project)
+        Tasks::ProjectStatus.perform(project, verbose)
+      end
+
+      def run
+        project = Projects::projects.select { |project| arguments.map(&:key).include?(project.name) }.first
+        project.nil? ? ecosystem_status : project_status(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/sync.rb

@@ -0,0 +1,42 @@
+module Greenhouse
+  module Commands
+    class Sync
+      include Command
+      command_summary "Sync all projects with their git remotes"
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} [<project>] #{valid_arguments.to_s}
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def sync_all
+        if Projects.projects.empty?
+          puts "No projects defined."
+          return
+        end
+
+        Projects.projects.each do |project|
+          Tasks::SyncProject.perform(project)
+        end
+        Tasks::GenerateProcfile.perform
+      end
+
+      def sync_project(project)
+        Tasks::SyncProject.perform(project)
+        Tasks::GenerateProcfile.perform if project.type == 'application'
+      end
+
+      def run
+        project = Projects::projects.select { |project| arguments.map(&:key).include?(project.name) }.first
+        project.nil? ? sync_all : sync_project(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/commands.rb

@@ -0,0 +1,32 @@
+module Greenhouse
+  module Commands
+    def self.commands
+      @commands ||= []
+      @commands
+    end
+
+    def self.exists?(cmd)
+      commands.map(&:command_name).include?(cmd.underscore.to_s)
+    end
+
+    def self.command(cmd)
+      raise "Command does not exist: #{cmd}" unless exists?(cmd)
+      commands.select { |command| command.command_name == cmd.underscore.to_s }.first
+    end
+  end
+end
+
+require 'greenhouse/commands/command'
+require 'greenhouse/commands/new'
+require 'greenhouse/commands/init'
+require 'greenhouse/commands/configure'
+require 'greenhouse/commands/add'
+require 'greenhouse/commands/status'
+require 'greenhouse/commands/launch'
+require 'greenhouse/commands/start'
+require 'greenhouse/commands/push'
+require 'greenhouse/commands/pull'
+require 'greenhouse/commands/sync'
+require 'greenhouse/commands/purge'
+require 'greenhouse/commands/remove'
+require 'greenhouse/commands/help'

data/lib/greenhouse/projects/application.rb

@@ -0,0 +1,19 @@
+module Greenhouse
+  module Projects
+    class Application < Project
+      attr_reader :dotenv, :procfile
+
+      def configured?
+        @dotenv.exists?
+      end
+
+      protected
+
+      def initialize(name, args={})
+        super
+        @procfile = Resources::Procfile.new("#{path}/Procfile")
+        @dotenv = Resources::DotenvFile.new("#{path}/.env")
+      end
+    end
+  end
+end

data/lib/greenhouse/projects/collection.rb

@@ -0,0 +1,23 @@
+module Greenhouse
+  module Projects
+    class Collection < Array
+      protected
+
+      def initialize(*args)
+        super
+        
+        # DEPRECATED - moving this to Projects itself
+        each do |project|
+          meth = project.class.name.pluralize.underscore.split("/").last.to_sym
+          next if respond_to?(meth)
+          
+          self.class.instance_eval do
+            define_method meth do
+              select { |proj| proj.class.name.pluralize.underscore.split("/").last.to_sym == meth }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/greenhouse/projects/engine.rb

@@ -0,0 +1,6 @@
+module Greenhouse
+  module Projects
+    class Engine < Project
+    end
+  end
+end

data/lib/greenhouse/projects/gem.rb

@@ -0,0 +1,6 @@
+module Greenhouse
+  module Projects
+    class Gem < Project
+    end
+  end
+end

data/lib/greenhouse/projects/project.rb

@@ -0,0 +1,77 @@
+module Greenhouse
+  module Projects
+    class Project
+      attr_accessor :name, :repository, :title
+
+      class << self
+        attr_reader :subclasses
+
+        # Keep track of inheriting classes (to use as project "types")
+        def inherited(subclass)
+          (@subclasses ||= [self]) << subclass
+        end
+      end
+
+      
+      def initialize(name, args={})
+        @name = name
+        @title = args.delete('title') || name.camelize
+        @ignored = (args.has_key?('ignore') ? [args.delete('ignore')] : []).flatten
+        @repository = Repository.new(name, args)
+        @ignore_file = Resources::IgnoreFile.new("#{path}/.ignore")
+      end
+
+      def ignored
+        Projects.ignored.concat(@ignore_file.ignored).concat(@ignored)
+      end
+    
+      def chdir(&block)
+        Dir.chdir(path, &block)
+      end
+
+      # Return the local path to the project repo
+      def path
+        @repository.path
+      end
+
+      def gemfile
+        return nil unless gemfile?
+        "#{path}/Gemfile"
+      end
+
+      def gemfile?
+        chdir { return File.exists?("Gemfile") }
+      end
+
+      # Check if the repository exists
+      def exists?
+        @repository.exists?
+      end
+
+      def type
+        self.class.name.underscore.split('/').last
+      end
+
+      def to_arg
+        Scripts::Argument.new(name, :summary => "#{title} (#{type.capitalize})")
+      end
+
+      # Go into the local directory and run Bundler
+      def bundle(cmd='install')
+        raise "Directory does not exist: #{path}" unless exists?
+        Dir.chdir(path) do
+          Bundler.with_clean_env do
+            # TODO look into using Bundler to install instead of executing system cmd
+            Greenhouse::CLI::exec "bundle #{cmd.to_s} 2>&1"
+          end
+        end
+      end
+
+      # Remove the project directory
+      def destroy
+        @repository.destroy # use the repository object to destroy itself/directory
+      end
+
+    end
+  end
+end

data/lib/greenhouse/projects/repository.rb

@@ -0,0 +1,197 @@
+module Greenhouse
+  module Projects
+    class Repository
+      attr_accessor :local, :remote
+      alias_method :path, :local
+
+      def method_missing(meth, *args)
+        return git.send(meth, *args) if git.respond_to?(meth)
+        super
+      end
+
+      # Clone the remote into the local path
+      def clone
+        raise "Repository already exists: #{@local}" if cloned?
+        Git.clone(@remote, @local.split("/").last)
+      end
+
+      # Check if the remote has been cloned locally
+      def cloned?
+        File.exists?(@local) && @git ||= Git.open(@local)
+      end
+      alias_method :exists?, :cloned?
+
+      # Check whether there are any uncommited local changes
+      def changes?(untracked=true)
+        raise "Repository does not exist: #{@local}" unless cloned?
+        !changes(untracked).empty?
+      end
+
+      # Get a list of all local changes (modified, added, deleted & untracked)
+      def changes(include_untracked=true)
+        raise "Repository does not exist: #{@local}" unless cloned?
+        changes = changed.merge(git.status.added).merge(git.status.deleted)
+        changes.merge!(untracked) if include_untracked
+        changes
+      end
+
+      def changed?
+        !changed.empty?
+      end
+
+      def changed
+        git.status.changed.select { |name,file| !git.diff('HEAD', '--').path(name).to_s.empty? }
+      end
+
+      def untracked
+        git.status.untracked.select { |name,file| !name.match(/\Atmp\/.*\Z/) } # temporary hack to avoid untracked tmp files, since they're not being properly ignored(?)
+      end
+
+      def untracked?
+        !untracked.empty?
+      end
+
+      def staged
+        changed.merge(git.status.added).merge(git.status.deleted).delete_if { |name,file| file.sha_index.empty? || file.sha_index == '0000000000000000000000000000000000000000' }
+      end
+
+      def staged?
+        !staged.empty?
+      end
+
+      def unstaged
+        changed.merge(untracked).select { |name,file| file.sha_index.empty? || file.sha_index == '0000000000000000000000000000000000000000' }
+      end
+
+      def unstaged?
+        !unstaged.empty?
+      end
+
+      # Return the results of `ls-files --others` to list ignored/untracked files
+      def others
+        git.chdir do
+          return `git ls-files --others`.split("\n")
+        end
+      end
+
+      # Check whether local branches are synced with the remotes
+      def synced?
+        unsynced.empty?
+      end
+      
+      # Return any unsynced branches for all remotes
+      def unsynced
+        branches = []
+        git.branches.local.each do |branch|
+          git.remotes.each do |remote|
+            lcommit = git.object(branch.name).log.first
+            rcommit = git.object("#{remote.name}/#{branch.name}").log.first
+            next if lcommit.sha == rcommit.sha
+            branches << [branch, remote]
+          end
+        end
+        branches
+      end
+
+      # Check whether there are unpushed local changes on all branches/remotes
+      def ahead?
+        !ahead.empty?
+      end
+      
+      # Return any unpushed local changes on all branches/remotes
+      def ahead
+        unsynced.select do |branch|
+          lbranch = git.object(branch[0].name)
+          rbranch = git.object("#{branch[1].name}/#{branch[0].name}")
+          lcommit = lbranch.log.first
+          rcommit = rbranch.log.first
+          
+          !rbranch.log.map(&:sha).include?(lcommit.sha) && lbranch.log.map(&:sha).include?(rcommit.sha)
+          
+          #lcommit.date <= rcommit.date
+        end
+      end
+
+      # Check if there are any unpulled changes on all branches/remotes
+      def behind?
+        !behind.empty?
+      end
+      
+      # Return any unpulled changes on all branches/remotes
+      def behind
+        unsynced.select do |branch|
+          lbranch = git.object(branch[0].name)
+          rbranch = git.object("#{branch[1].name}/#{branch[0].name}")
+          lcommit = lbranch.log.first
+          rcommit = rbranch.log.first
+          
+          rbranch.log.map(&:sha).include?(lcommit.sha) && !lbranch.log.map(&:sha).include?(rcommit.sha)
+          
+          #lcommit.date >= rcommit.date
+        end
+      end
+
+      def diverged?
+        !diverged.empty?
+      end
+
+      def diverged
+        unsynced.select do |branch|
+          lbranch = git.object(branch[0].name)
+          rbranch = git.object("#{branch[1].name}/#{branch[0].name}")
+          lcommit = lbranch.log.first
+          rcommit = rbranch.log.first
+          
+          !rbranch.log.map(&:sha).include?(lcommit.sha) && !lbranch.log.map(&:sha).include?(rcommit.sha)
+        end
+      end
+
+      def up_to_date?
+        !out_of_sync?
+      end
+
+      def out_of_sync?
+        behind? || diverged?
+      end
+
+      def out_of_sync
+        unsynced.select do |branch|
+          lbranch = git.object(branch[0].name)
+          rbranch = git.object("#{branch[1].name}/#{branch[0].name}")
+          lcommit = lbranch.log.first
+          rcommit = rbranch.log.first
+          
+          (rbranch.log.map(&:sha).include?(lcommit.sha) && !lbranch.log.map(&:sha).include?(rcommit.sha)) ||
+          (!rbranch.log.map(&:sha).include?(lcommit.sha) && !lbranch.log.map(&:sha).include?(rcommit.sha))
+        end
+      end
+
+      def stash
+        git.chdir { `git stash 2>&1` }
+      end
+
+      def pop_stash
+        git.chdir { `git stash pop 2>&1` }
+      end
+
+      # Remove the local repository
+      def destroy
+        FileUtils.rm_rf @local
+      end
+
+      def git
+        @git ||= Git.open(@local)
+        @git
+      end
+
+      protected
+
+      def initialize(name, args={})
+        raise "A git remote is required." unless args.has_key?(:remote)
+        @local = File.expand_path(args[:local] || name)
+        @remote = args[:remote]# || "git@github.com:Graphicly/#{name}.git"
+      end
+
+    end
+  end
+end

data/lib/greenhouse/projects.rb

@@ -0,0 +1,86 @@
+require 'yaml'
+require 'git'
+require 'greenhouse/projects/repository'
+require 'greenhouse/projects/collection'
+require 'greenhouse/projects/project'
+require 'greenhouse/projects/engine'
+require 'greenhouse/projects/application'
+require 'greenhouse/projects/gem'
+
+module Greenhouse
+  module Projects
+    @@path = nil
+    @@procfile = nil
+    @@ignore_file = nil
+    @@projects_file = nil
+    @@dotenv = nil
+    @@projects = nil
+
+    def self.method_missing(meth, *args)
+      if Project.subclasses.map { |subclass| subclass.name.pluralize.underscore.split("/").last.to_sym }.include?(meth.to_sym)
+        projects.select { |proj| proj.class.name.pluralize.underscore.split("/").last.to_sym == meth.to_sym }
+      else
+        super
+      end
+    end
+
+    def self.projects
+      @@projects = Collection.new
+      return @@projects unless projects_file.exists?
+      
+      projects_file.projects.each do |name,project|
+        type = (project.has_key?('type') ? project['type'] : 'project')
+        projargs = project.merge({:remote => (project['remote'] || project['git'])})
+        classname = "Greenhouse::Projects::#{type.singularize.camelize}"
+        @@projects << (defined?(classname.constantize) ? classname.constantize.new(name, projargs) : Greenhouse::Projects::Project.new(name, projargs))
+      end
+      @@projects
+    end
+
+    # Attempts to look for and returns the path of the root projects directory
+    #
+    # Looks up the tree from the current directory, currently checking for a .projects
+    # file (this might change in the future).
+    #
+    # If no projects path is found, the current directory is returned.
+    def self.path
+      return @@path unless @@path.nil?
+      dir = Dir.pwd
+      while dir != "" do
+        if File.exists?("#{dir}/.projects")
+          @@path = dir
+          return @@path
+        end
+        dir = dir.gsub(/\/[^\/]*\Z/,'')
+      end
+      @@path = Dir.pwd # if we haven't found a .projects file, this must be where they want to work
+      @@path
+    end
+
+    def self.ignore_file
+      return @@ignore_file unless @@ignore_file.nil?
+      @@ignore_file = Resources::IgnoreFile.new("#{path}/.ignore")
+    end
+
+    def self.projects_file
+      return @@projects_file unless @@projects_file.nil?
+      @@projects_file = Resources::ProjectsFile.new("#{path}/.projects")
+    end
+
+    def self.procfile
+      return @@procfile unless @@procfile.nil?
+      @@procfile = Resources::Procfile.new("#{path}/Procfile")
+    end
+
+    def self.dotenv
+      return @@dotenv unless @@dotenv.nil?
+      @@dotenv = Resources::DotenvFile.new("#{path}/.env")
+    end
+
+    def self.ignored
+      return [] unless ignore_file.exists?
+      ignore_file.ignored
+    end
+  
+  end
+end