rbtils 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b00e004f6a120b2c92a986e94d15ec4bdf84cecc
+  data.tar.gz: 8e5362f564d74b21410eadcc0b9c883431fa9e80
+SHA512:
+  metadata.gz: 61afcde4aec89976cf123edd60358ea1ac5e5a78bd18c0a9804d90102afb7486781dbce6b96c167f02a317c5019b7688b074105e7a4d3ffef34dcd51085a1590
+  data.tar.gz: 7e77c88344481538327a336b42f027614a8ef1a809903f271cace7cce2f2f83fc861bd9b723cd8594782c5719d4a6ccacc51566dc2582a3fad575bc5d8a471ed

data/lib/command.rb

@@ -0,0 +1,179 @@
+module Granify
+  module Command
+    class Exec
+      attr_reader :response, :exitcode
+      attr_accessor :enable_logging
+
+      # 
+      # class methods
+      # 
+      class << self
+        def git_queue_status
+          if global("git log origin/#{git_current_branch}..HEAD --oneline")
+            response = @response.split("\n")
+            response.size > 0
+          end
+        end
+
+        def git_push
+          global("git push -q origin #{git_current_branch}")
+        end
+
+        def git_checkout
+          begin
+            curr_branch = git_current_branch
+            branch = $request.custom.nil? ? curr_branch : $request.custom[0]
+
+            if !git_branch_verify branch
+              raise "Requested branch not found in the working copy: #{branch}"
+            end
+
+            if branch == curr_branch
+              return Notify.warning("Requested branch is already checked out, skipping checkout")
+            else
+              global("git checkout -q #{branch}")
+            end
+
+            # not found locally, checkout from origin
+            if !@response
+              branch = "origin/#{branch}"
+              global("git checkout -q #{branch}")
+            end
+
+            if !@response
+              Notify.error("Unable to locate #{branch} on the remote server or local working copy")
+            end
+
+            branch
+          rescue SystemExit, Interrupt
+            Notify.error("Interrupt caught, exiting")
+          rescue RuntimeError => e
+            Notify.error(e.message)
+          end
+        end
+
+        def git_current_branch
+          global("git rev-parse --abbrev-ref HEAD")
+        end
+
+        def git_branch_verify(branch = nil)
+          if branch.nil?
+            branch = git_current_branch
+          end
+          
+          global("git rev-parse --verify #{branch}")
+        end
+
+        def global(command, file = nil)
+          begin
+            # disable logging if user settings prohibit it
+            #file = nil if !@enable_logging
+            # default value for exit code is an error
+            @exitcode = 1
+
+            @response = `#{command}`.chomp
+            @exitcode = $?.exitstatus
+            
+            # Log output to a file
+            # This method is better than redirecting output to a file because now
+            # the response is always populated instead of being empty when output
+            # is sent to the log file
+            if file
+              File.open(file.path, 'w+') do |f|
+                f.write(@response)
+              end
+            end
+
+            @response
+          rescue SystemExit, Interrupt
+            Notify.error("Interrupt caught, exiting")
+          end
+        end
+      end
+
+      # 
+      # instance methods
+      #
+      def minify(file, destination)
+        begin
+          min_file = "#{destination}#{File.basename(file, File.extname(file))}.min.js"
+          
+          @response = `uglifyjs #{file} -cm -o "#{min_file}"`
+          
+          Notify.success("Minified #{file}")
+
+          $?.exitstatus == 0
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def lint(file, log_file)
+        begin
+          command = `coffeelint -f "#{Granify::INSTALLED_DIR}/lib/configs/coffeelint.json" #{file}`
+
+          @response = command.include?("Ok!")
+          
+          # only send errors to the log file
+          if !@response
+            File.open(log_file.path, 'a') do |f|
+              f.write("Logged at #{Time.now}\n============================================================\n\n")
+              f.write(command)
+            end
+          end
+
+          $?.exitstatus == 0
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def open_editor(file=nil)
+        begin
+          log_file = file || Granify::DEFAULT_LOG
+          
+          # System editor is not set/unavailable, use system default to open the
+          # file
+          if `echo $EDITOR` == ""
+            if Utils.os == :macosx
+              `open #{log_file.path}`
+            else
+              `xdg-open #{log_file.path}`
+            end
+          else
+            `$EDITOR #{log_file.path}`
+          end
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def arbitrary(command, file = nil)
+        begin
+          # default value for exit code is an error
+          @exitcode = 1
+          @response = `#{command}`.chomp
+          @exitcode = $?.exitstatus
+
+          # Log output to a file
+          # This method is better than redirecting output to a file because now
+          # the response is always populated instead of being empty when output
+          # is sent to the log file
+          if file
+            File.open(file.path, 'w+') do |f|
+              f.write("Logged at #{Time.now}\n============================================================\n\n")
+              f.write(@response)
+            end
+          end
+          
+          @exitcode == 0
+
+          # support chaining
+          self
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,52 @@
+module Granify
+  class Cfg
+    def bootstrap!
+      begin
+        # configure Notifaction gem
+        Notify.configure do |c|
+          c.plugins = []
+        end
+
+        if Utils.has_internet_connection?
+          # check for package updates
+          status = Command::Exec.global("(cd #{Granify::INSTALLED_DIR} && git fetch origin && git diff master origin/master) 2>&1")
+
+          if !status.empty?
+            Notify.warning("You are running an outdated version of #{Granify::PACKAGE_NAME}, please run `rbtils update` to update")
+          end
+        else
+          Notify.warning("Update check could not be performed because you are not connected to the internet")
+        end
+
+        # check for missing dependencies
+        missing = []
+
+        # test if we have all the required commands before sending anything to
+        # handlers
+        Granify::SHELL_COMMANDS[Utils.os].each do |command|
+          Command::Exec.global("type \"#{command}\" > /dev/null 2>&1")
+
+          if $?.exitstatus != 0
+            missing.push("- "+ command)
+          end
+        end
+
+        if !missing.empty?
+          Notify.error("Required system commands and/or configuration variables are not installed:\n#{missing.join("\n")}")
+        end
+
+        if missing.size > 0
+          # try to install the missing commands
+          #Command::Exec.global("npm install --silent -g #{missing.join(' ')}")
+
+          # commented out for now as it currently does nothing
+          # if $?.exitstatus > 0
+          #   # TODO: implement other auto-install commands such as apt-get
+          # end
+        end
+      rescue => e
+        Notify.error("#{e.to_s}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end

data/lib/configs/coffeelint.json

@@ -0,0 +1,116 @@
+{
+  "arrow_spacing": {
+      "level": "ignore"
+  },
+  "camel_case_classes": {
+      "level": "error"
+  },
+  "coffeescript_error": {
+      "level": "error"
+  },
+  "colon_assignment_spacing": {
+      "level": "ignore",
+      "spacing": {
+          "left": 0,
+          "right": 0
+      }
+  },
+  "cyclomatic_complexity": {
+      "value": 10,
+      "level": "ignore"
+  },
+  "duplicate_key": {
+      "level": "error"
+  },
+  "empty_constructor_needs_parens": {
+      "level": "ignore"
+  },
+  "ensure_comprehensions": {
+      "level": "warn"
+  },
+  "indentation": {
+      "value": 2,
+      "level": "error"
+  },
+  "line_endings": {
+      "level": "ignore",
+      "value": "unix"
+  },
+  "max_line_length": {
+      "value": 200,
+      "level": "ignore",
+      "limitComments": true
+  },
+  "missing_fat_arrows": {
+      "level": "ignore"
+  },
+  "newlines_after_classes": {
+      "value": 3,
+      "level": "ignore"
+  },
+  "no_backticks": {
+      "level": "error"
+  },
+  "no_debugger": {
+      "level": "warn"
+  },
+  "no_empty_functions": {
+      "level": "ignore"
+  },
+  "no_empty_param_list": {
+      "level": "ignore"
+  },
+  "no_implicit_braces": {
+      "level": "ignore",
+      "strict": true
+  },
+  "no_implicit_parens": {
+      "strict": true,
+      "level": "ignore"
+  },
+  "no_interpolation_in_single_quotes": {
+      "level": "ignore"
+  },
+  "no_plusplus": {
+      "level": "ignore"
+  },
+  "no_stand_alone_at": {
+      "level": "ignore"
+  },
+  "no_tabs": {
+      "level": "error"
+  },
+  "no_throwing_strings": {
+      "level": "error"
+  },
+  "no_trailing_semicolons": {
+      "level": "error"
+  },
+  "no_trailing_whitespace": {
+      "level": "error",
+      "allowed_in_comments": false,
+      "allowed_in_empty_lines": true
+  },
+  "no_unnecessary_double_quotes": {
+      "level": "ignore"
+  },
+  "no_unnecessary_fat_arrows": {
+      "level": "warn"
+  },
+  "non_empty_constructor_needs_parens": {
+      "level": "ignore"
+  },
+  "prefer_english_operator": {
+      "level": "ignore",
+      "doubleNotLevel": "ignore"
+  },
+  "space_operators": {
+      "level": "ignore"
+  },
+  "spacing_after_comma": {
+      "level": "ignore"
+  },
+  "transform_messes_up_line_numbers": {
+      "level": "warn"
+  }
+}

data/lib/constants.rb

@@ -0,0 +1,15 @@
+module Granify
+  PACKAGE_NAME = "rbtils"
+  INSTALLED_DIR = File.dirname($0)
+  LOG_DIR = INSTALLED_DIR + "/logs"
+  DEFAULT_LOG = Log.new # no args means default log
+  HELPER_DIR = INSTALLED_DIR + "/lib/helpers/"
+  CONTROLLER_DIR = INSTALLED_DIR + "/lib/controllers/"
+  MODEL_DIR = INSTALLED_DIR + "/lib/models/"
+  LOG_DIGEST_LENGTH = 20
+  SHELL_COMMANDS = {
+    :macosx => %w(git uglifyjs rubocop),
+    :linux => %w(git uglifyjs rubocop)
+  }
+  DEBUG = false
+end

data/lib/controller.rb

@@ -0,0 +1,127 @@
+module Granify
+  module Controller
+    class Base
+      attr_accessor :model, :helper, :methods_require_internet, :default_method
+
+      @@options = Hash.new
+      
+      # Perform pre-run tasks
+      def pre_exec
+        OptionParser.new do |opt|
+          opt.banner = "granify controller command [...-flags]"
+
+          opt.on("-v", "--verbose", "Verbose output") do |v|
+            # short output
+            @@options[:verbose] = v
+          end
+        end.parse!
+      end
+
+      # Handle the request
+      def exec(args = [])
+        self.send(@default_method.to_sym)
+      end
+
+      # Perform post-run cleanup tasks, such as deleting old logs
+      def post_exec(total_errors = 0, total_warnings = 0, total_files = 0)
+        # TODO: do post-test evaluation
+        # total_errors = @model.data.log.faults[:errors]
+        # total_warnings = @model.data.log.faults[:warnings]
+
+        # if @model.data.log.total_files_processed
+        #   total_files = @model.data.log.total_files_processed
+        # end
+
+        if @@options[:verbose]
+          Notify.info("Results:\nCommand: granify #{$request.controller} #{$request.command} #{($request.flags && $request.flags.size > 0 ? $request.flags.to_json : '')}\n#{total_errors} errors and #{total_warnings} warnings in #{total_files} source files.\nTotal execution time: #{Helper::Time.human_readable(@last_model.start, Time.now)}")
+        end
+
+        if Logs.dirty?
+          Logs.clean
+        end
+      end
+
+      # Determines if the command can execute
+      def can_exec?(command = nil, name = nil)
+        @model = Granify::Model.const_get(command.capitalize).new rescue nil
+        @helper = Granify::Helper.const_get(command.capitalize).new rescue nil
+        @methods_require_internet = []
+
+        # get user-defined methods to use as a fallback
+        user_defined_methods = []
+
+        # timeout is the first system defined method after the user defined
+        # ones
+        for i in 0..public_methods.index(:to_json) -1
+          user_defined_methods.push(public_methods[i].to_sym)
+        end
+
+        @default_method = name || user_defined_methods.first || :sample
+
+        if !respond_to? default_method.to_sym, true
+          Notify.error("Command not found: #{name}")
+        end
+
+        true
+      end
+
+      # default method called by exec if no argument is passed
+      def sample
+        Notify.warning("Method not implemented");
+      end
+
+      def required_modules(*modules)
+        auto_load_required(modules).each do |type, hash|
+          # Make each auto-loaded module available as an instance variable
+          # i.e. [:hound]: @hound_controller, @hound_model, @hound_helper
+          # i.e. [:test]: @test_controller, @test_model, @test_helper
+          # Only files that exist and can be called are loaded
+          hash.each do |key, value|
+            instance_variable_set("@#{key}_#{type}".to_sym, value)
+            @last_model = instance_variable_get("@#{key}_model")
+          end
+        end
+      end
+
+      private
+        # autoload and instantiate required libraries, models and helpers
+        def auto_load_required(modules = [])
+          loaded = {:controller => {}, :helper => {}, :model => {}}
+          
+          begin
+            modules.each do |mod|
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/controllers/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/controllers/#{mod}.rb"
+                
+                loaded[:controller][mod] = Granify::Controller.const_get(mod.capitalize).new
+              else
+                raise StandardError, "Controller not found: #{mod}"
+              end
+
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/helpers/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/helpers/#{mod}.rb"
+                loaded[:helper][mod] = Granify::Helper.const_get(mod.capitalize).new
+
+                # auto-instantiate new instance of helper for the new instance of the controller
+                loaded[:controller][mod].helper = loaded[:helper][mod]
+              end
+
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/models/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/models/#{mod}.rb"
+                loaded[:model][mod] = Granify::Model.const_get(mod.capitalize).new
+
+                # auto-instantiate new instance of model for the new instance of the controller
+                loaded[:controller][mod].model = loaded[:model][mod]
+              else
+                loaded[:controller][mod].model = Model::Base.new
+              end
+            end
+
+            loaded
+          rescue StandardError => e
+            Notify.error(e.message)
+          end
+        end
+    end
+  end
+end