greenhouse 0.0.3

data/lib/greenhouse/resources/dotenv_file.rb

@@ -0,0 +1,69 @@
+module Greenhouse
+  module Resources
+    class DotenvFile
+      include FileResource
+
+      attr_reader :config
+
+      class ConfigVars < Hash
+        def format_key(key)
+          key.to_s.gsub(/[^a-z\d_]+/i, "_").upcase
+        end
+
+        def [](key)
+          super(format_key(key))
+        end
+
+        def []=(key, value)
+          super(format_key(key), value)
+        end
+
+        def initialize(hash={})
+          hash.each { |k,v| self[k] = v }
+        end
+      end
+
+      def config=(hash)
+        @config = ConfigVars.new(hash)
+      end
+
+      def reload
+        @config = ConfigVars.new
+        return @config unless exists?
+        # pulled this straight from Dotenv, too bad there's no simple Dotenv.parse method in the gem
+        read do |line|
+          if line =~ /\A(?:export\s+)?([\w\.]+)(?:=|: ?)(.*)\z/
+            key = $1
+            case val = $2
+            # Remove single quotes
+            when /\A'(.*)'\z/ then @config[key] = $1
+            # Remove double quotes and unescape string preserving newline characters
+            when /\A"(.*)"\z/ then @config[key] = $1.gsub('\n', "\n").gsub(/\\(.)/, '\1')
+            else @config[key] = val
+            end
+          end
+        end
+        @config
+      end
+
+      def write
+        open("w") do |f|
+          @config.each do |key,val|
+            f.write("#{key}=#{val}\n")
+          end
+        end
+      end
+
+      def unlink
+        super
+        reload
+      end
+
+      def initialize(path)
+        super
+        reload
+      end
+
+    end
+  end
+end

data/lib/greenhouse/resources/file_resource.rb

@@ -0,0 +1,50 @@
+module Greenhouse
+  module Resources
+    module FileResource
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def self.included(base)
+          base.send :attr_reader, :path
+        end
+
+        def exists?
+          File.exists?(path)
+        end
+
+        def open(mode, &block)
+          File.open(path, mode, &block)
+        end
+
+        def lines(reload=false)
+          @lines = nil if reload
+          @lines ||= [] unless exists?
+          @lines ||= File.read(path).split("\n")
+          @lines
+        end
+
+        def read(&block)
+          lines(true).each_with_index(&block)
+        end
+
+        def unlink
+          File.unlink(path) if exists?
+        end
+
+        def chdir(&block)
+          Dir.chdir(File.expand_path("../", path), &block)
+        end
+
+        def initialize(path)
+          @path = File.expand_path(path)
+        end
+      end
+
+    end
+  end
+end

data/lib/greenhouse/resources/ignore_file.rb

@@ -0,0 +1,115 @@
+module Greenhouse
+  module Resources
+    class IgnoreFile
+      include FileResource
+      
+      class IgnoredFiles < Array
+        
+        def unshift(file)
+          if !file.is_a?(IgnoredFile)
+            file = IgnoredFile.new(file, @ignore_file.lines.length)
+          end
+          super(file)
+          @ignore_file.lines[file.line] = file.to_s
+        end
+
+        def push(file)
+          if !file.is_a?(IgnoredFile)
+            file = IgnoredFile.new(file, @ignore_file.lines.length)
+          end
+          super(file)
+          @ignore_file.lines[file.line] = file.to_s
+        end
+
+        def <<(file)
+          push(file)
+        end
+
+        def []=(index,file)
+          delete_at index if index < length
+          file = IgnoredFile.new(file, @ignore_file.lines.length) if !file.is_a?(IgnoredFile)
+          super(index,file)
+          @ignore_file.lines[file.line] = file.to_s
+        end
+
+        def delete(filename)
+          # TODO delete any comments immediately preceding the filename
+          deleted = super(select { |f| f.file == filename}.first)
+          @ignore_file.ignored.each do |ignored|
+            next if ignored.line < deleted.line
+            ignored.line -= 1
+          end
+          line = @ignore_file.lines.slice!(deleted.line,1)
+          deleted
+        end
+
+        def delete_at(index)
+          delete self[index].file
+        end
+
+        def delete_if(&block)
+          select(&block).map { |ignored| delete ignored.file }
+        end
+
+        def keep_if(&block)
+          kept = select(&block)
+          clone.select { |ignored| !kept.map(&:file).include?(ignored.file) }.map { |ignored| delete ignored.file }
+        end
+
+        def initialize(ignore_file)
+          @ignore_file = ignore_file
+          super()
+        end
+      end
+
+      class IgnoredFile
+        attr_accessor :file, :line
+
+        def to_s
+          @file.to_s
+        end
+
+        def inspect
+          to_s
+        end
+
+        def initialize(file, line)
+          @file = file
+          @line = line
+        end
+      end
+
+      attr_accessor :ignored
+
+      def write
+        ignored.each { |ignored| lines[ignored.line] = ignored.to_s}
+        open('w') do |ifile|
+          lines.each do |line|
+            ifile.write "#{line}\n"
+          end
+        end
+      end
+      alias_method :save, :write
+
+      def reload
+        @ignored = IgnoredFiles.new(self)
+        return @ignored unless exists?
+        read do |line,l|
+          next if line.strip[0] == "#" || line.strip.empty?
+          @ignored << IgnoredFile.new(line,l)
+        end
+        @ignored
+      end
+
+      def unlink
+        super
+        reload
+      end
+
+      def initialize(path)
+        super
+        reload
+      end
+    end
+  end
+end

data/lib/greenhouse/resources/procfile.rb

@@ -0,0 +1,144 @@
+module Greenhouse
+  module Resources
+    class Procfile
+      include FileResource
+      
+      class Processes < Hash
+        def [](key)
+          super(key.to_s)
+        end
+
+        def []=(key, value)
+          if value.is_a?(Process)
+            super(key.to_s, value)
+          else
+            parr = value.strip.split(":")
+            key = parr.slice!(0)
+            command = parr.join(":").strip
+            # TODO might need to rework this line index, won't account for blank/comment lines at the end of the file
+            value = Process.new(key, command, (values.map(&:line).sort.last || -1) + 1)
+            super(key.to_s, value)
+          end
+          @procfile.lines[value.line] = value.to_s
+        end
+
+        def delete(key)
+          del = super(key)
+          @procfile.processes.each do |key,process|
+            next if process.line < del.line
+            process.line -= 1
+          end
+          line = @procfile.lines.slice!(del.line,1)
+          del
+        end
+
+        def delete_if(&block)
+          select(&block).keys.map { |key| delete key }
+        end
+
+        def keep_if(&block)
+          kept = select(&block)
+          clone.select { |key,process| !kept.keys.include?(key) }.keys.map { |key| delete key }
+        end
+
+        def initialize(procfile)
+          @procfile = procfile
+        end
+      end
+
+      class Process
+        attr_accessor :key, :command, :line
+        
+        def enabled?
+          !@disabled
+        end
+
+        def disabled?
+          @disabled
+        end
+
+        def enable
+          @disabled = false
+        end
+
+        def disable
+          @disabled = true
+        end
+
+        def to_s
+          "#{"#" if disabled?}#{key}: #{command}"
+        end
+
+        def inspect
+          to_s
+        end
+
+        def initialize(key, command, line)
+          @line = line
+          @disabled = key.strip[0] == "#"
+          @key = key.gsub(/\A#+/, "")
+          @command = command
+        end
+      end
+      
+      def disabled(refresh=false)
+        return @processes.select { |key,process| process.disabled? } unless refresh || @processes.nil? || @processes.empty?
+        reload.select { |key,process| process.disabled? }
+      end
+      
+      def enabled(refresh=false)
+        return @processes.select { |key,process| process.enabled? } unless refresh || @processes.nil? || @processes.empty?
+        reload.select { |key,process| process.enabled? }
+      end
+      
+      def processes(refresh=false)
+        return @processes unless refresh || @processes.nil? || @processes.empty?
+        reload
+      end
+
+      def process_exists?(key)
+        processes.keys.include?(key.to_s)
+      end
+
+      def process(key)
+        processes.values.select { |p| p.key.to_s == key.to_s }.first
+      end
+
+      def write
+        processes.values.each { |process| lines[process.line] = process.to_s}
+        open('w') do |pfile|
+          lines.each do |line|
+            pfile.write "#{line}\n"
+          end
+        end
+        reload
+      end
+      alias_method :save, :write
+
+      def reload
+        @processes = Processes.new(self)
+        return @processes unless exists?
+        
+        read do |line,l|
+          if line.match(/\A[#]*[a-z0-9_]+:\s*.*\Z/)
+            parr = line.strip.split(":")
+            key = parr.slice!(0)
+            command = parr.join(":").strip
+            process = Process.new(key, command, l)
+            @processes[process.key] = process
+          end
+        end
+        @processes
+      end
+
+      def unlink
+        super
+        reload
+      end
+
+      def initialize(path)
+        super
+      end
+    end
+  end
+end

data/lib/greenhouse/resources/projects_file.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+
+module Greenhouse
+  module Resources
+    class ProjectsFile
+      include FileResource
+      
+      def projects(refresh=false)
+        return @projects unless refresh || @projects.nil? || @projects.empty?
+        reload
+      end
+
+      def write
+        open('w') do |pfile|
+          #pfile.write @projects.to_yaml.gsub("!ruby/symbol ", ":").sub("---","").split("\n").map(&:rstrip).join("\n").strip
+          @projects.each do |name,project|
+            pfile.write "#{name}:\n"
+            project.each do |key,val|
+              pfile.write "  #{key}: #{val.to_s}\n"
+            end
+          end
+        end
+      end
+      alias_method :save, :write
+
+      def reload
+        @projects = {}
+        return @projects unless exists?
+        @projects = YAML::load_file(path)
+        @projects ||= {}
+        @projects
+      end
+
+      def unlink
+        super
+        reload
+      end
+
+      def initialize(path)
+        super
+      end
+    end
+  end
+end

data/lib/greenhouse/resources.rb

@@ -0,0 +1,10 @@
+module Greenhouse
+  module Resources
+  end
+end
+
+require 'greenhouse/resources/file_resource'
+require 'greenhouse/resources/procfile'
+require 'greenhouse/resources/projects_file'
+require 'greenhouse/resources/ignore_file'
+require 'greenhouse/resources/dotenv_file'

data/lib/greenhouse/scripts/argument.rb

@@ -0,0 +1,36 @@
+module Greenhouse
+  module Scripts
+    class Argument
+      attr_reader :value, :valid, :summary
+
+      def value=(val)
+        raise "Invalid value for `#{key}` flag: '#{val}'" if (!@valid.nil? && !@valid.include?(val)) && (!val.nil? && !val.empty?)
+        @value = val
+      end
+
+      def key
+        @keys.is_a?(Array) ? @keys[0] : @keys
+      end
+
+      def keys
+        @keys.is_a?(Array) ? @keys : [@keys]
+      end
+
+      protected
+
+      def initialize(keys, *args)
+        @keys = (keys.is_a?(String) && keys.match(/,?\s/) ? keys.gsub(/,?\s+/, " ").split(" ") : keys)
+        
+        val = args.slice!(0) if %w(String Symbol Integer).include?(args[0].class.name)
+
+        if args.length > 0 && args[0].is_a?(Hash)
+          opts = args.slice!(0)
+          @valid = (opts[:valid].is_a?(Array) ? opts[:valid].map(&:to_s) : opts[:valid].to_s) if opts.has_key?(:valid)
+          @summary = opts[:summary] if opts.has_key?(:summary)
+        end
+        
+        self.value = val
+      end
+    end
+  end
+end

data/lib/greenhouse/scripts/arguments.rb

@@ -0,0 +1,28 @@
+module Greenhouse
+  module Scripts
+    class Arguments < Array
+      
+      def to_s
+        map do |arg|
+          #if arg.valid.nil? || arg.valid.empty?
+            "[#{arg.keys.join(", ")}]"
+          #else
+          #  "[#{arg.keys.join(", ")} = (#{arg.valid.join("|")})]"
+          #end
+        end.join(" ")
+      end
+
+      def to_help
+        map do |arg|
+          "  #{"%-#{sort { |a,b| a.keys.join(", ").length <=> b.keys.join(", ").length }.last.keys.join(", ").length + 2}s" % arg.keys.join(", ")}# #{arg.summary}"
+        end.join("\n")
+      end
+
+      protected
+
+      def initialize
+        super
+      end
+    end
+  end
+end

data/lib/greenhouse/scripts/invalid_argument.rb

@@ -0,0 +1,6 @@
+module Greenhouse
+  module Scripts
+    class InvalidArgument < Exception
+    end
+  end
+end

data/lib/greenhouse/scripts/script.rb

@@ -0,0 +1,109 @@
+module Greenhouse
+  module Scripts
+    module Script
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def self.extended(base)
+        end
+        
+        def run
+          @script ||= new
+          raise "You have not defined a `run` method for your script." unless @script.respond_to?(:run)
+          @script.run
+        end
+
+        def validate_arguments(val=nil)
+          return validate_arguments? if val.nil?
+          @validate_arguments = val
+        end
+
+        def validate_arguments?
+          @validate_arguments = true if @validate_arguments.nil?
+          @validate_arguments
+        end
+
+        def valid_argument(arg)
+          @valid_args ||= Arguments.new
+          if arg.is_a?(Argument)
+            @valid_args << arg
+          elsif arg.is_a?(Hash)
+            @valid_args << Argument.new(arg.keys.first.to_s, arg.values.first)
+          elsif arg.is_a?(Array)
+            @valid_args << Argument.new(arg[0].to_s, (arg.length > 1 ? arg[1] : []))
+          else
+            @valid_args << Argument.new(arg.to_s)
+          end
+          @valid_args.last
+        end
+
+        def valid_arguments(*args)
+          @valid_args ||= Arguments.new
+          return @valid_args if args.empty?
+          
+          args.each { |arg| valid_argument(arg) }
+          @valid_args
+        end
+        
+        def project_argument(proj)
+          @valid_projs ||= Arguments.new
+          if proj.is_a?(Argument)
+            @valid_projs << proj
+          elsif proj.is_a?(Hash)
+            @valid_projs << Argument.new(proj.keys.first.to_s, proj.values.first)
+          elsif proj.is_a?(Array)
+            @valid_projs << Argument.new(proj[0].to_s, (proj.length > 1 ? proj[1] : []))
+          else
+            @valid_projs << Argument.new(proj.to_s)
+          end
+          @valid_projs.last
+        end
+
+        def project_arguments(*projs)
+          @valid_projs ||= Arguments.new
+          return @valid_projs if projs.empty?
+          
+          projs.each { |proj| project_argument(proj) }
+          @valid_projs
+        end
+
+        def arguments(*args)
+          @arguments ||= nil
+          return @arguments unless @arguments.nil?
+          @arguments = Arguments.new
+          args.each_with_index do |arg,a|
+            argarr = arg.split("=")
+            argkey = argarr.slice!(0)
+            
+            if !valid_arguments.concat(project_arguments).map(&:keys).any? { |keys| keys.include?(argkey) } && !arg.match(/\A(-)+[a-z0-9\-]=?.*\Z/i) && (a > 0 && args[a-1].match(/\A(-)+[a-z0-9\-]=?.*\Z/i)) && !@arguments.empty?
+              @arguments.last.value = arg
+              next
+            end
+
+            if validate_arguments?
+              raise InvalidArgument, "Invalid Argument: #{arg}" unless valid_arguments.concat(project_arguments).map(&:keys).any? { |keys| keys.include?(argkey) }
+              @arguments << valid_arguments.concat(project_arguments).select { |varg| varg.keys.include?(argkey) }.first
+            else
+              valid_arg = valid_arguments.concat(project_arguments).select { |varg| varg.keys.include?(argkey) }.first
+              @arguments << (valid_arg || Argument.new(argkey))
+            end
+            @arguments.last.value = argarr.join("=") unless argarr.empty?
+          end
+          @arguments
+        end
+      end
+
+      module InstanceMethods
+        %w(arguments valid_arguments project_arguments).each do |method|
+          define_method method do |*args|
+            self.class.send method, *args
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/greenhouse/scripts.rb

@@ -0,0 +1,4 @@
+require 'greenhouse/scripts/invalid_argument'
+require 'greenhouse/scripts/argument'
+require 'greenhouse/scripts/arguments'
+require 'greenhouse/scripts/script'

data/lib/greenhouse/tasks/add_project.rb

@@ -0,0 +1,57 @@
+module Greenhouse
+  module Tasks
+    class AddProject
+      include Task
+        
+      def prompt_for_project
+        remote = nil
+        print "Enter a git remote to add a project (leave blank to skip): "
+        remote = STDIN.gets.chomp.downcase
+        return if remote.empty?
+        project = Projects::Project.new(remote.match(/([^\/]*)\.git/)[1], {remote: remote})
+        
+        if Projects::projects_file.projects.keys.include?(project.name) || Projects::projects_file.projects.values.map { |p| p['git'].downcase }.include?(project.repository.remote.downcase)
+          puts "\e[31mCannot add project. Another project with the same name already exists.\e[0m"
+          # TODO prompt to replace it?
+          # would need to probably remove the project, remove procs from procfile, resync project, reconfig, etc.
+          return
+        end
+
+        print "Enter a custom title for this project (leave blank for default) [#{project.title}]: "
+        title = STDIN.gets.chomp
+        project.title = title unless title.empty?
+
+        print "Is this project a 'gem', rails 'application', rails 'engine' or other type of project (leave blank to skip)?: "
+        type = STDIN.gets.chomp.downcase
+        type = 'application' if type == 'app' # hacky :/
+        unless type.empty?
+          classname = "::Greenhouse::Projects::#{type.singularize.camelize}"
+          if defined?(classname.constantize)
+            project = classname.constantize.new(project.name, {remote: project.repository.remote, title: project.title})
+            puts "Configuring #{project.title} as #{type == 'gem' ? 'a' : 'an'} #{type}"
+          end
+        end
+
+        project
+      end
+
+      def add_project(project)
+        Projects::projects_file.projects[project.name] = {'git' => project.repository.remote}
+        Projects::projects_file.projects[project.name]['title'] = project.title unless project.title == project.name.camelize
+        Projects::projects_file.projects[project.name]['type'] = project.class.name.underscore.split("/").last unless project.class == Projects::Project
+        
+        Projects::projects_file.write
+
+        puts "Added \e[36m#{project.title}\e[0m to the ecosystem."
+        project
+      end
+
+      def perform
+        project = prompt_for_project
+        return if project.nil?
+        
+        add_project(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/tasks/generate_procfile.rb

@@ -0,0 +1,22 @@
+module Greenhouse
+  module Tasks
+    class GenerateProcfile
+      include Task
+
+      def perform
+        Projects::applications.each do |app|
+          next unless app.procfile.exists?
+          app.procfile.reload
+
+          if app.procfile.processes.keys.length == 1
+            Projects::procfile.processes[app.name] = "#{app.name}: greenhouse launch #{app.name} #{app.procfile.processes.keys.first}" unless Projects::procfile.processes.has_key?(app.name)
+          else
+            app.procfile.processes.keys.each { |process| Projects::procfile.processes["#{app.name}_#{process}"] = "#{app.name}_#{process}: greenhouse launch #{app.name} #{process}" unless Projects::procfile.processes.has_key?("#{app.name}_#{process}") }
+          end
+        end
+        Projects::procfile.write
+      end
+
+    end
+  end
+end