rbtils 0.0.1

data/lib/controllers/branch.rb

@@ -0,0 +1,14 @@
+module Granify
+  module Controller
+    class Branch < Controller::Base
+      def current
+        Notify.info("Current branch: #{Command::Exec.git_current_branch}")
+      end
+
+      def recent
+        # TODO: format this
+        Notify.spit Command::Exec.global("git for-each-ref --sort=-committerdate --format='%(committerdate:short) %(refname)' refs/heads refs/remotes --count=10")
+      end
+    end
+  end
+end

data/lib/controllers/clean.rb

@@ -0,0 +1,10 @@
+module Granify
+  module Controller
+    class Clean < Controller::Base
+      # force clean logs
+      def logs
+        Logs.clean
+      end
+    end
+  end
+end

data/lib/controllers/hound.rb

@@ -0,0 +1,72 @@
+module Granify
+  module Controller
+    class Hound < Controller::Base
+      def coffee
+        m = @model.data
+        
+        if m.below_acceptable_limit?
+          Notify.info("Linting #{m.status[:total]} coffeescript files\nPrinting files with errors")
+
+          m.files_with_errors.each do |file|
+            Notify.spit(file)
+          end
+
+          success_message(m)
+        else
+          if m.log.exists?
+            @model.command.open_editor(m.log)
+          end
+
+          error_message(m, :coffeescript)
+        end
+
+        Notify.bubble("Running coffeescript files through coffeelint", "Linting...")
+      end
+
+      def widgets
+        m = @model.data
+        
+        if m.below_acceptable_limit?
+          Notify.info("Linting #{m.status[:total]} coffeescript files\nPrinting files with errors")
+
+          m.files_with_errors.each do |file|
+            Notify.spit(file)
+          end
+
+          success_message(m)
+        else
+          if m.log.exists?
+            @model.command.open_editor(m.log)
+          end
+
+          error_message(m, :coffeescript)
+        end
+
+        Notify.bubble("Running coffeescript files through coffeelint", "Linting...")
+      end
+
+      def ruby
+        m = @model.data
+
+        if m.below_acceptable_limit?
+          Notify.info("Pass rate is above the acceptable limit, proceeding to next step")
+        else
+          error_message(m, :ruby)
+        end
+
+        Notify.bubble("Running ruby files through rubocop.", "Linting...")
+      end
+
+      private
+        def error_message(m, type)
+          post_exec
+          Notify.warning("#{m.issues[:errors]} error(s), #{m.status[:errors_per_file]} EPF - EPF must be less than 5\n#{m.success_rate[:str]} success rate - 90% required")
+          Notify.error("Too many #{type} errors to continue.  Errors logged to:\n#{m.log}")
+        end
+
+        def success_message(m)
+          Notify.spit("\nResults:\n - #{Style.format(m.status[:success].to_s + " passed", :green)}\n - #{Style.format(m.status[:error].to_s + " failed", :red)}\nSuccess rate: #{Style.format(m.success_rate[:str], :green)}\nErrors logged to #{Style.format(m.log, :green)}")
+        end
+    end
+  end
+end

data/lib/controllers/minify.rb

@@ -0,0 +1,40 @@
+module Granify
+  module Controller
+    class Minify < Controller::Base
+      # Purpose: minify all JS files in the current directory, move them to a
+      # min directory and rename them file.min.js
+      @@folder = :min
+
+      # We don't need to clean logs here
+      def post_exec
+        false
+      end
+
+      def all
+        # future method
+        Notify.warning("Method not implemented")
+      end
+
+      def js
+        min_folder = Utils.mklocaldir(@@folder)
+        files = Utils.get_files(:js)
+        command = Command::Exec.new
+
+        if files.size > 0
+          files.each do |file|
+            command.minify(file, min_folder)
+          end
+
+          Notify.bubble("Minified #{files.size} files.", "Success")
+        else
+          Notify.warning("No JS files detected in this directory")
+        end
+      end
+
+      def cs
+        # future method
+        Notify.warning("Method not implemented")
+      end
+    end
+  end
+end

data/lib/controllers/open.rb

@@ -0,0 +1,58 @@
+module Granify
+  module Controller
+    class Open < Controller::Base
+      def files
+        begin
+          files = []
+          
+          if !$request.custom.nil? && $request.custom.size > 0
+            # pull file list from CLI args
+            $request.custom.each do |requested_file|
+              files.push(requested_file) if File.exists? requested_file.to_s
+            end
+          else
+            raise ::ArgumentError, "Command requires a list of files to open\ni.e. #{Granify::PACKAGE_NAME} open files file1.ext file2.ext file3.ext"
+          end
+
+          # we have some files, lets open them
+          if files.size > 0
+            `$EDITOR -n #{files.join(' ')}`
+
+            Notify.success("Opened #{files.size} file(s) in sublime text")
+          else
+            Notify.warning("The requested files (#{$request.custom.join(', ')}) could not be opened")
+          end
+
+        rescue => e
+          Notify.error(e.message)
+        end
+      end
+
+      def files_from_log
+        begin
+          files = []
+
+          if File.exists? $request.custom[0].to_s
+            # pull file list from a log file
+            files = IO.readlines($request.custom[0].to_s)
+            files.each do |l|
+              l.gsub!(/\r\n?/, "")
+            end
+          else
+            raise ::ArgumentError, "Command requires a log file\ni.e. #{Granify::PACKAGE_NAME} open files_from_log file1.log"
+          end
+
+          if files.size > 0
+            `$EDITOR -n #{files.join(' ')}`
+
+            Notify.success("Opened #{files.size} file(s) in sublime text")
+          else
+            Notify.warning("The requested files (#{$request.custom.join(', ')}) could not be opened")
+          end
+        rescue => e
+          Notify.error(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/controllers/update.rb

@@ -0,0 +1,41 @@
+module Granify
+  module Controller
+    class Update < Controller::Base
+      # Setup all flags supported by this command
+      def pre_exec
+        # flag methods that require internet access
+        @methods_require_internet.push(:rbtils)
+
+        super
+      end
+
+      def rbtils
+        Notify.info("Checking for updates")
+
+        status = Command::Exec.global("(cd #{Granify::INSTALLED_DIR} && git checkout master && git pull) 2>&1").split("\n")
+        
+        if status.include? "Your branch is up-to-date with 'origin/master'."
+          Notify.warning("You are running the current version of #{Granify::PACKAGE_NAME}")
+        else
+          # TODO: run on a different machine, currently this just assumes it worked..
+          Notify.success("Successfully updated to the latest version")
+        end
+      end
+
+      def granify
+        Notify.info("Checking for updates")
+
+        status = @model.command.arbitrary("git checkout master && git pull")
+        puts status.inspect
+        exit
+      end
+
+      def goliath
+        Notify.info("Checking for updates")
+
+
+
+      end
+    end
+  end
+end

data/lib/helper.rb

@@ -0,0 +1,19 @@
+module Granify
+  module Helper
+    def self.load(klass, args = nil)
+      begin
+        klass_instance = Granify::Helper.const_get(klass.capitalize)
+        
+        if klass_instance
+          if args.nil?
+            klass_instance.new
+          else
+            klass_instance.new(args)
+          end
+        end
+      rescue => e
+        Notify.error(e.message)
+      end
+    end
+  end
+end

data/lib/helpers/time.rb

@@ -0,0 +1,28 @@
+module Granify
+  module Helper
+    class Time
+      def self.human_readable(start, finish)
+        seconds = finish.to_f - start.to_f
+
+        if seconds < 60
+          "No time at all!"
+        else
+          minutes = (seconds / 60).round(1)
+          if minutes < 1
+            "#{minutes} minute"
+          else
+            "#{minutes} minutes"
+          end
+        end
+      end
+
+      def self.formatted(time = nil)
+        if time.nil?
+          time = ::Time.now
+        end
+        
+        time.strftime("%e/%-m/%Y @ %I:%M:%S%P")
+      end
+    end
+  end
+end

data/lib/log.rb

@@ -0,0 +1,111 @@
+module Granify
+  class Log
+    attr_accessor :path, :total_files_processed
+    attr_reader :template
+
+    def initialize(*args)
+      if args.length == 0
+        # default log
+        @template = "#{Granify::LOG_DIR}/%s"
+        @path = sprintf(@template, "default.log")
+      else
+        @template = "#{Granify::LOG_DIR}/%s/%s-%s.log"
+        
+        format(args)
+      end
+
+      @path
+    end
+
+    def stale?
+      Time.now - last_write > 60
+    end
+
+    def exists?
+      File.exist? @path
+    end
+
+    def delete
+      if exists?
+        File.delete @path
+      end
+
+      Notify.sinfo("Deleting truncated log file #{@path}")
+      @path = nil
+    end
+
+    def num_lines
+      File.foreach(@path).inject(0) {|c, line| c+1}
+    end
+
+    def faults
+      matchdata = { :errors => 0, :warnings => 0, :total => 0 }
+
+      begin
+        case @log_type
+        when :js
+          last_line = IO.readlines(@path)[-5].chomp
+          matches = last_line.match(/(\d+) example, (\d+) failure/)
+          
+          if matches
+            matchdata[:errors] += matches[2].to_i
+          end
+        when :coffeelint
+          total = 0
+          File.foreach(@path) do |line|
+            matches = line.match(/Lint\! » (\d+) errors and (\d+)/)
+
+            if matches
+              matchdata[:errors] += matches[1].to_i
+              matchdata[:warnings] += matches[2].to_i
+            end
+          end
+        when :ruby
+          last_line = IO.readlines(@path)[-1].chomp
+          matches = last_line.match(/(\d+) files inspected\, (\d+)/)
+
+          if matches
+            matchdata[:errors] += matches[2].to_i
+            matchdata[:total] += matches[1].to_i
+          end
+        when :goliath
+
+        else
+          raise ArgumentError, "Unknown log type - #{log_type}"
+        end
+      rescue => e
+        Notify.error(e.message)
+      end
+
+      matchdata
+    end
+
+    def to_s
+      @path
+    end
+
+    private
+      def format(args)
+        @identifier = args[2]
+
+        @path = sprintf(@template,
+          @identifier,
+          args[0],
+          args[1].strftime('%Y-%m-%d-%T')
+          )
+
+        if !File.exists? @path
+          Utils.generate_path(args[0], args[1].strftime('%Y-%m-%d-%T'), @identifier)
+        end
+
+        # create the log file, populate it with temporary data
+        File.open(@path, 'w+') do |f|
+          f.write("Command output will be logged below when it finishes running\n")
+        end
+      end
+
+      def last_write
+        File.mtime(@path)
+      end
+  end
+end

data/lib/logs.rb

@@ -0,0 +1,34 @@
+module Granify
+  class Logs
+    MAX_LOGS_TO_STORE = 30
+
+    @files = Dir["#{Granify::LOG_DIR}/*/*.log"]
+
+    def self.clean
+      if @files.size > 0
+        @files.each do |file|
+          File.delete file if File.exist? file
+        end
+        Notify.info("Removed #{@files.size} old log files")
+      end
+    end
+
+    def self.dirty?
+      @files.size >= MAX_LOGS_TO_STORE
+    end
+
+    # Create a directory if required
+    def self.mkdir(name)
+      dir = "#{Granify::LOG_DIR}/#{name.downcase}"
+
+      if !Dir.exist? dir
+        Dir.mkdir dir
+      end
+
+      # Create the default .gitignore
+      File.open("#{dir}/.gitignore", "w+") do |file|
+        file.write "# Ignore everything in this directory\n*\n# Except this file\n!.gitignore"
+      end
+    end
+  end
+end

data/lib/model.rb

@@ -0,0 +1,26 @@
+module Granify
+  module Model
+    class Base
+      attr_accessor :data, :branch, :browser, :command, :start
+
+      def initialize(hash = nil)
+        @data = hash || Granify::Model::Data.new
+
+        # Current time
+        #@time = @data.start
+        # Time the command was executed
+        @start = Time.now
+        # Current working branch
+        @branch = @data.branch
+        # Browser to execute tests in
+        @browser = @data.browser
+        # Instantiate the command execution class
+        @command = Command::Exec.new
+      end
+
+      def bind(hash)
+        initialize(hash)
+      end
+    end
+  end
+end