rbtils 0.0.1

data/lib/model_data.rb

@@ -0,0 +1,97 @@
+module Granify
+  module Model
+    class Data
+      attr_accessor :identifier, :branch, :browser, :files_with_errors
+
+      def initialize()
+        @d = Hash.new([])
+
+        # setup defaults
+        defaults = {
+          :issues => {:errors => 0, :warnings => 0},
+          :status => {:success => 0, :error => 0, :total => 0, :errors_per_file => 0},
+          :success_rate => {:int => 0, :str => "0%"},
+          :log => '',
+          :below_acceptable_limit => false
+        }
+
+        @branch = Command::Exec.git_current_branch
+        @files_with_errors = []
+
+        @d.merge! defaults
+      end
+
+      def unset(key)
+        @d.delete(key.to_sym)
+      end
+
+      def instance_var(key, val = nil)
+        self.class.__send__(:attr_accessor, key)
+        instance_variable_set("@#{key}", val)
+      end
+
+      def serialize
+        @d.to_json
+      end
+
+      def status
+        get(:status)
+      end
+
+      def success_rate
+        get(:success_rate)
+      end
+
+      def increment_issues(key, val)
+        @d[:issues][key.to_sym] += val
+      end
+
+      def increment_status(key, val)
+        @d[:status][key.to_sym] += val
+      end
+
+      def issues
+        get(:issues)
+      end
+
+      def issues=(val)
+        set(:issues, val)
+      end
+
+      def log
+        get(:log, Granify::DEFAULT_LOG)
+      end
+
+      def add_to_error_list(file)
+        @files_with_errors << file
+      end
+
+      def identifier=(val)
+        @identifier = val
+
+        # create the log file now
+        @d[:log] = Log.new(@branch, Time.now, @identifier)
+      end
+
+      def below_acceptable_limit?
+        get(:below_acceptable_limit) == true
+      end
+
+      def below_acceptable_limit=(val)
+        set(:below_acceptable_limit, val)
+      end
+
+      def bind!(seed_data)
+        @d = seed_data
+      end
+
+      def get(key, default = @d.default)
+        @d[key] || default
+      end
+
+      def set(key, val = nil)
+        @d[key] = val
+      end
+    end
+  end
+end

data/lib/models/hound.rb

@@ -0,0 +1,232 @@
+module Granify
+  module Model
+    class Hound < Model::Base
+      def coffee_data(files = [])
+        @data.identifier = :coffeelint
+
+        if files.size > 0
+          Notify.sinfo("Using command arguments as file list source")
+        end
+
+        # check if there are any files within the pwd
+        if files.size == 0
+          files = Utils.get_files(:coffee)
+          
+          if files.size > 0
+            Notify.sinfo("Using #{Dir.pwd} as file list source")
+          end
+        end
+
+        # check the current git queue for JS/Coffee files to lint
+        if files.size == 0
+          files = Utils.get_files_from_git(:coffee)
+          
+          if files.size > 0
+            Notify.sinfo("Using current git-commit queue as file list source")
+          end
+        end
+
+        # there were no files in the pwd, expand scope to all JS/Coffee files
+        if files.size == 0
+          files = Utils.get_all_files(:coffee)
+
+          if files.size > 0
+            Notify.sinfo("Using all .coffee files in current path (#{Dir.pwd}) as file list source")
+          end
+        end
+
+        # update total file size
+        @data.increment_status(:total, files.size)
+
+        # no coffeescript files anywhere?? don't try to lint anything
+        if files.size > 0
+          files.each do |file|
+            @command.lint(file, @data.log)
+
+            if @command.response
+              @data.status[:success] +=1
+            else
+              @data.status[:error] +=1
+              @data.add_to_error_list(file)
+            end
+          end
+
+          @data.log.total_files_processed = files.size
+          
+          validation_issues_in_coffee(@data.log)
+
+          @data.success_rate[:int] = ((@data.status[:success].to_f / files.size.to_f) * 100).round(0)
+          @data.success_rate[:str] = @data.success_rate[:int].to_s + "%"
+          @data.status[:errors_per_file] = (@data.issues[:errors] / files.size.to_f).round(0)
+          @data.below_acceptable_limit = @data.success_rate[:int] > 70 && @data.status[:errors_per_file] < 5
+        else
+          Notify.error("No coffeescript files to process, exiting")
+          # don't need the current log file
+          @data.log.delete
+        end
+
+        @data
+      end
+
+      def widgets_data(files = [])
+        @data.identifier = :coffeelint
+
+        if files.size > 0
+          Notify.sinfo("Using command arguments as file list source")
+        end
+
+        # check if there are any files within the pwd
+        if files.size == 0
+          files = Utils.get_files(:coffee)
+          
+          if files.size > 0
+            Notify.sinfo("Using #{Dir.pwd} as file list source")
+          end
+        end
+
+        # check the current git queue for JS/Coffee files to lint
+        if files.size == 0
+          files = Utils.get_files_from_git(:coffee)
+          
+          if files.size > 0
+            Notify.sinfo("Using current git-commit queue as file list source")
+          end
+        end
+
+        # there were no files in the pwd, expand scope to all widget files
+        if files.size == 0
+          files = Utils.get_all_files(:coffee, 'widgets|widget_component')
+
+          if files.size > 0
+            Notify.sinfo("Using #{files.size} #{@data.identifier} files in (#{Dir.pwd}/widgets|widget_component) as file list source")
+          end
+        end
+
+        # update total file size
+        @data.increment_status(:total, files.size)
+
+        # no coffeescript files anywhere?? don't try to lint anything
+        if files.size > 0
+          files.each do |file|
+            @command.lint(file, @data.log)
+
+            if @command.response
+              @data.status[:success] +=1
+            else
+              @data.status[:error] +=1
+              @data.add_to_error_list(file)
+            end
+          end
+
+          @data.log.total_files_processed = files.size
+          
+          validation_issues_in_coffee(@data.log)
+
+          @data.success_rate[:int] = ((@data.status[:success].to_f / files.size.to_f) * 100).round(0)
+          @data.success_rate[:str] = @data.success_rate[:int].to_s + "%"
+          @data.status[:errors_per_file] = (@data.issues[:errors] / files.size.to_f).round(0)
+          @data.below_acceptable_limit = @data.success_rate[:int] > 70 && @data.status[:errors_per_file] < 5
+        else
+          Notify.error("No coffeescript files to process, exiting")
+          # don't need the current log file
+          @data.log.delete
+        end
+
+        @data
+      end
+
+      def ruby_data(files = [])
+        @data.identifier = :ruby
+
+        if files.size > 0
+          Notify.sinfo("Using command arguments as file list source")
+        end
+
+        # check if there are any files within the pwd
+        # COMMENTED OUT for now because this may not be required functionality
+        # if files.size == 0
+        #   files = Utils.get_files(:rb)
+
+        #   if files.size > 0
+        #     Notify.sinfo("Using #{Dir.pwd} as file list source")
+        #   end
+        # end
+
+        # check the current git queue for JS/Coffee files to lint
+        if files.size == 0
+          files = Utils.get_files_from_git(:rb)
+
+          if files.size > 0
+            Notify.sinfo("Using current git-commit queue as file list source")
+          end
+        end
+
+        # there were no files in the pwd, expand scope to all widget files
+        if files.size == 0
+          files = Utils.get_all_files(:rb)
+
+          if files.size > 0
+            Notify.sinfo("Using #{files.size} #{@data.identifier} files in (#{Dir.pwd}/widgets|widget_component) as file list source")
+          end
+        end
+        
+        if files.size > 0
+          files.each do |file|
+            @command.arbitrary("rubocop #{file}", @data.log)
+
+            if @command.response
+              @data.status[:success] +=1
+            else
+              @data.status[:error] +=1
+              @data.add_to_error_list(file)
+            end
+          end
+          
+          @data.log.total_files_processed = @data.status[:total]
+
+          validation_issues_in_ruby(@data.log)
+
+          @data.status[:errors_per_file] = (@data.issues[:errors] / @data.status[:total]).round(0)
+          @data.success_rate[:int] = @data.status[:errors_per_file]
+          @data.success_rate[:str] = @data.success_rate[:int].to_s + "%"
+          @data.below_acceptable_limit = @data.success_rate[:int] > 90 && @data.status[:errors_per_file] < 5
+        else
+          Notify.error("No coffeescript files to process, exiting")
+          # don't need the current log file
+          @data.log.delete
+        end
+
+        @data
+      end
+
+      private
+        # TODO: can these be replaced by Log.errors
+        def validation_issues_in_coffee(file)
+          File.foreach(file.path) do |line|
+            matches = line.match(/Lint\! » (\d+) errors and (\d+)/)
+            
+            if matches
+              @data.increment_issues(:errors, matches[1].to_i)
+              @data.increment_issues(:warnings, matches[2].to_i)
+            end
+          end
+
+          @data.issues
+        end
+
+        # TODO: benchmark, this may be super slow
+        def validation_issues_in_ruby(file)
+          last_line = IO.readlines(file.path)[-1].chomp
+          #matches = last_line.match(/(\d+) files inspected\, (\d+)/)
+          matches = last_line.scan(/[0-9]+/)
+
+          if matches
+            @data.increment_issues(:errors, matches[1].to_i)
+            @data.increment_status(:total, matches[0].to_i)
+          end
+
+          @data.issues
+        end
+    end
+  end
+end

data/lib/request.rb

@@ -0,0 +1,20 @@
+module Granify
+  class Request
+    attr_reader :controller, :command, :custom, :flags, :raw_flags
+
+    def initialize
+      @controller = ARGV[0].to_sym rescue nil
+      
+      if ARGV.size > 1
+        @command = ARGV[1].to_sym rescue nil
+
+        if ARGV.size > 2
+          @custom = ARGV[2..ARGV.size].select { |p| !p.start_with?('-') }.map &:to_sym || []
+          # TODO: parameterize flag key/values
+          @flags = ARGV[2..ARGV.size].select { |f| f.start_with?('-') }.map { |f| f.split("=").map &:to_sym } || []
+          @raw_flags = ARGV[2..ARGV.size].select { |f| f.start_with?('-') } || []
+        end
+      end
+    end
+  end
+end

data/lib/router.rb

@@ -0,0 +1,73 @@
+module Granify
+  class Router
+    def route
+      # Populate request params
+      $request = Request.new
+
+      # include the controller
+      if File.exists? "#{Granify::CONTROLLER_DIR}#{$request.controller}.rb"
+        require "#{Granify::CONTROLLER_DIR}#{$request.controller}.rb"
+      end
+
+      # include helpers
+      if File.exists? "#{Granify::HELPER_DIR}#{$request.controller}.rb"
+        require "#{Granify::HELPER_DIR}#{$request.controller}.rb"
+      end
+
+      # include models
+      if File.exists? "#{Granify::MODEL_DIR}#{$request.controller}.rb"
+        require "#{Granify::MODEL_DIR}#{$request.controller}.rb"
+      end
+
+      # Create object context and pass it the required command line arguments
+      begin
+        controller = Granify::Controller.const_get $request.controller.capitalize rescue false
+        
+        if !controller
+          raise "Controller not found: #{$request.controller.capitalize}"
+        end
+
+        context = controller.new
+
+        if context.can_exec? $request.controller, $request.command
+          context.pre_exec
+
+          # no command sent?  Use default to populate model data
+          model_method = ($request.command ? $request.command : context.default_method).to_s + "_data"
+
+          # populate model data
+          method = context.model.public_method(model_method) rescue false
+
+          # model is not set, use Base model instead so the controller still has
+          # access to model methods
+          if context.model.nil?
+            context.model = Model::Base.new
+          end
+          
+          # If the method exists, set model data accordingly
+          # If it doesn't exist then just fail silently, the model may not
+          # be required by some controllers
+          if method.respond_to? :call
+            context.model.data = method.call($request.custom || [])
+          end
+
+          if context.methods_require_internet.include? $request.command
+            if !Utils.has_internet_connection?
+              raise RuntimeError, "Command `granify #{$request.controller} #{$request.command}` requires a connection to the internet.\nPlease check your network configuration settings."
+            end
+          end
+
+          # Run the controller
+          context.exec
+
+          # Run cleanup commands
+          context.post_exec
+        end
+      rescue RuntimeError => e
+        Notify.error("#{e.to_s}")
+      rescue NameError => e
+        Notify.error("#{e.to_s}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,123 @@
+module Granify
+  class Utils
+    @cache = Hash.new
+    
+    # Gets a list of files from the current directory with a specific extension
+    def self.get_files(ext)
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      Dir["*.#{ext}"].each do |file|
+        @cache[:files][ext].push file
+      end
+
+      @cache[:files][ext]
+    end
+
+    # Gets a list of all files in the project with a specific extension
+    def self.get_all_files(ext, ignore_paths = '')
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      if @cache[:files][ext].empty?
+        Dir["**/*.#{ext}"].each do |file|
+          if !ignore_paths.empty?
+            # file is a widget
+            if /\/#{ignore_paths}/.match(file)
+              @cache[:files][ext].push file
+            end
+          else
+            # file is not a widget
+            @cache[:files][ext].push file
+          end
+        end
+      end
+
+      @cache[:files][ext]
+    end
+
+    # Gets a list of files from the current git commit queue with a specific
+    # extension
+    def self.get_files_from_git(ext)
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      modified_files = `git status --porcelain`.split("\n")
+      modified_files.each do |file|
+        if file.match(/#{ext}/)
+          @cache[:files][ext].push file.strip.match(/[A-Z ]+(.*)/)[1]
+        end
+      end
+      
+      @cache[:files][ext]
+    end
+
+    # Generate a filename
+    def self.generate_path(branch, time, identifier)
+      # create the directory if needed
+      Logs.mkdir identifier
+
+      # create a new log file with a path based on the input parameters
+      #Log.new(identifier, branch, time)
+    end
+
+    # Convert hash keys to symbols
+    def self.symbolize_keys(hash)
+      Hash[hash.map{ |k, v| [k.to_sym, v] }]
+    end
+
+     # Create a directory wherever the script is called from, if required
+    def self.mklocaldir(name)
+      dir = "#{Dir.pwd}/#{name.downcase}/"
+
+      if !Dir.exist? dir
+        Dir.mkdir dir
+      else
+        dir
+      end
+    end
+
+    def self.os
+      begin
+        @os ||= (
+          host_os = RbConfig::CONFIG['host_os']
+          case host_os
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            :windows
+          when /darwin|mac os/
+            :macosx
+          when /linux/
+            :linux
+          when /solaris|bsd/
+            :unix
+          else
+            raise TypeError, "unknown os: #{host_os.inspect}"
+          end
+        )
+      rescue err
+        Notify.error(err.message)
+      end
+    end
+
+    def self.json?(string)
+      begin
+        !!JSON.parse(string)
+      rescue
+        false
+      end
+    end
+
+    def self.http_response_code(url = nil)
+      begin
+        request = Net::HTTP.get_response(URI.parse(url || "http://google.com"))
+        request.code.to_i
+      rescue
+        500
+      end
+    end
+
+    def self.has_internet_connection?
+      Utils.http_response_code < 499
+    end
+  end
+end