site_hook 0.8.2 → 0.9.3

data/lib/site_hook/config_sections.rb

@@ -1,13 +1,64 @@
-require 'yaml'
 module SiteHook
-  module ConfigSections
-    autoload :Cli, 'site_hook/config_sections/cli'
-    autoload :LogLevels, 'site_hook/config_sections/log_levels'
-    autoload :Projects, 'site_hook/config_sections/projects'
-    module_function
-    def print_example_config
-      full_config = [Cli.example, LogLevels.example, Projects.example].flatten(1)
-      puts full_config
+  class ConfigSections
+    def self.all_samples
+      sections = self.constants
+      @@sample = []
+      sections.each do |section|
+        @@sample << self.const_get(section).sample
+      end
+      puts @@sample
+    end
+    class Webhook
+      def self.sample
+        <<~WEBHOOK
+          webhook:
+            host: 127.0.0.1
+            port: 9090
+
+        WEBHOOK
+      end
+
+    end
+    class LogLevels
+      def self.sample
+        <<~LOGLEVELS
+          log_levels:
+            # unknown, fatal, error, warn, info, debug
+            app: info
+            build: info
+            git: info
+            hook: info
+
+        LOGLEVELS
+      end
+    end
+    class Cli
+      def self.sample
+        <<~CLI
+          cli:
+            config:
+              mkpass:
+                length: 20
+                symbols: false
+
+        CLI
+      end
+    end
+    class Projects
+      def self.sample
+        <<~PROJECTS
+          projects:
+            project1:
+              config: _config.yml
+              src: /path/2/site/source
+              dst: /path/2/build/destination
+              host: github.com
+              repo: some/repo
+              hookpass: SOMESECRETSTRING
+              private: false
+
+        PROJECTS
+      end
     end
   end
 end

data/lib/site_hook/deprecate.rb

@@ -1,16 +1,39 @@
+require 'paint/util'
 module SiteHook
+
+  class DeprecationError < SiteHookError
+    def initialize(msg)
+      super(msg, 99)
+    end
+  end
   class Deprecation
-    attr_reader :instructions
-    def initialize(message, situation, instructions)
-      @str = "▼▼▼ [#{Paint['DEPRECATION ERROR', :red, :bold]}] —— The following situation is deprecated! ▼▼▼"
-      @situation = situation
-      @str << "\n#{@situation}"
-      @instructions = instructions
-      @str << "\n#{@instructions}"
+
+    def self.deprecate(command, situation, instructions, continue)
+      @@exe_name = command.topmost_ancestor.parent.exe_name
+      @@str = "▼▼▼ [#{Paint['DEPRECATION ERROR', 'red', :bold]}] —— #{Paint['The following situation is deprecated', 'yellow', :bold, :blink]}! ▼▼▼"
+      @@situation = situation
+      @@str << "\n#{@@situation}"
+      @@instructions = instructions
+      @@str << "\n#{@@instructions}"
+
+      return {msg: @@str, exit: !continue}
+    end
+    def self.deprecate_config(command)
+      return self.deprecate(
+          command,
+          "'#{Paint[SiteHook::Paths.old_config.to_s, 'red']}' is deprecated in favor of '#{Paint[SiteHook::Paths.config, 'green']}'",
+          <<~INSTRUCT,
+              Please run `#{Paint["#{command.topmost_ancestor.parent.exe_name} config upgrade-shrc", 'red', :blink]}` to rectify this.
+              Once version 1.0.0 is released, '#{Paint["#{SiteHook::Paths.config}", 'green']}' will
+              be the only config file option, and '#{Paint["#{SiteHook::Paths.old_config}", 'orange']}' will not be allowed.
+              any existance of '#{Paint["#{Dir.home}/.jph", 'red']}' after the #{Paint['1.0.0', :bold]} release will result in an Exception being raised.
+              #{"#{Paint['Once the exception is raised', 'red']}, site_hook will #{Paint['exit', 'red']} and return a #{Paint['99', 'red']} status code."}
+          INSTRUCT
+          true
+      )
     end
-    def self.deprecate(situation, instructions, continue)
-      puts @str if @str
-      return continue
+    def self.raise_error(msg)
+      raise DeprecationError.new(msg)
     end
   end
   class NotImplemented
@@ -18,7 +41,7 @@ module SiteHook
 
     def initialize(command)
       @command_object = command
-      @exe_name = @command_object.parent.parent.exe_name
+      @exe_name = @command_object.topmost_ancestor.parent.exe_name
       @output_string = "Command `#{@exe_name} #{command.name_for_help.join(' ')}"
     end
     def self.declare(command)

data/lib/site_hook/env/env.rb

@@ -0,0 +1,2 @@
+require 'grape'
+require 'grape-route-helpers'

data/lib/site_hook/exceptions.rb

@@ -1,9 +1,33 @@
 require 'paint'
 module SiteHook
   class SiteHookError < StandardError
+    def initialize(msg, err)
+      super(msg)
+      exit err
+    end
   end
   class ConfigExistsError < SiteHookError
   end
-
-
+  class NoConfigError < SiteHookError
+    attr_reader :path
+    def initialize(path)
+      @str = "Config path '#{Paint[path, 'red']}' does not exist!"
+      @path = path
+      super(@str,98)
+    end
+  end
+  class NeitherConfigError < SiteHookError
+    attr_reader :paths
+    def initialize
+      @str = "Neither '#{SiteHook::Paths.old_config}' nor '#{SiteHook::Paths.config}'"
+    end
+  end
+  class NoLogsError < SiteHookError
+    attr_reader :path
+    def initialize(path)
+      @str = "Log path '#{Paint[path, 'red']}' does not exist!"
+      @path = path
+      super(@str,97)
+    end
+  end
 end

data/lib/site_hook/log.rb

@@ -1,26 +1,31 @@
+require 'site_hook/configs/log_levels'
 module SiteHook
   autoload :Paths, 'site_hook/paths'
+  autoload :Config, 'site_hook/config'
+  ##
   # Logs
   # Give logs related methods
+  #
+
   module Logs
     module_function
-    def self.log_levels
-      default = {
-        'hook' => 'info',
+    DEFAULT   = {
+        'hook'  => 'info',
         'build' => 'info',
-        'git' => 'info',
-        'app' => 'info'
-      }
-      begin
-        log_level = YAML.load_file(SiteHook::Paths.config).fetch('log_levels')
-        if log_level
-          log_level
-        end
-      rescue KeyError
-        default
-      rescue Errno::ENOENT
-        default
+        'git'   => 'info',
+        'app'   => 'info'
+    }
+    # @return [Hash] the log levels
+    def self.log_levels
+      puts SiteHook::Configs::LogLevels.methods
+      log_level = SiteHook::Configs::LogLevels
+      if log_level
+        log_level
       end
+    rescue KeyError
+      DEFAULT
+    rescue Errno::ENOENT
+      DEFAULT
     end
   end
 end

data/lib/site_hook/logger.rb

@@ -1,194 +1,115 @@
-require 'paint'
-require 'logging'
-require 'pathname'
-require 'active_support/core_ext/string'
-
-Logging.init %w(NONE DEBUG INFO WARN ERROR FATAL)
-Logging.color_scheme(
-    'bright',
-    :levels  => {
-        :debug => [:yellow, :on_white],
-        :info  => :blue,
-        :warn  => :yellow,
-        :error => :red,
-        :fatal => [:red, :on_white],
-    },
-    :date    => :white,
-    :logger  => :cyan,
-    :message => :green,
-    )
-PATTERN = '[%d] %-5l %c: %m\n'
-DATE_PATTERN = '%Y-%m-%d %H:%M:%S'
-layout = Logging.layouts.pattern \
-  :pattern      => PATTERN,
-  :date_pattern => DATE_PATTERN,
-  :color_scheme => 'bright'
-
-Logging.appenders.stdout \
-  :layout => layout
-
+require 'logger'
+require 'recursive_open_struct'
+require 'site_hook/loggers'
+require 'site_hook/paths'
+require 'yaml'
+require 'site_hook/string_ext'
+#require 'site_hook/configs'
 module SiteHook
-  def mklogdir
-    path = Pathname(Dir.home).join('.jph', 'logs')
-    if path.exist?
-      # Path exists, don't do anything
-    else
-      FileUtils.mkpath(path.to_s)
+  class Log
+    def self.defaults
+      RecursiveOpenStruct.new(
+          {
+              Hook:   {
+                  level: 'info'
+              },
+              App:    {
+                  level: 'info'
+              },
+              Build:  {
+                  level: 'info'
+              },
+              Git:    {
+                  level: 'info'
+              },
+              Access: {
+                  level: nil
+              },
+              Fake:   {
+                  level: nil
+              }
+          })
     end
-  end
-
-  def safe_log_name(klass)
-    klass.class.name.split('::').last.underscore
-  end
-
-  module_function :mklogdir, :safe_log_name
-
-  class LogLogger
-    attr :log
-    attr :log_level
 
-    def initialize(log_level = 'info') # only change this to debug when testing
-      @log    = Logging.logger[SiteHook.safe_log_name(self)]
-      @log_level = log_level
-
-      flayout = Logging.appenders.rolling_file \
-        Pathname(Dir.home).join('.jph', 'logs', "#{SiteHook.safe_log_name(self)}-#{@log_level}.log").to_s,
-        :age     => 'daily',
-        :pattern => PATTERN
-      @log.add_appenders 'stdout', flayout
-      @log.level = log_level
-    end
-  end
-
-  mklogdir
-  LL = LogLogger.new.log
-  LL.debug "#{SiteHook.safe_log_name(LL.class)} initialized."
-
-  class HookLogger
-
-    # Log App Actions
-    class AppLog
-      attr :log
-      attr :log_level
-
-      def initialize(log_level = nil)
-        LL.debug "Initializing #{SiteHook.safe_log_name(self)}"
-        @log    = Logging.logger[SiteHook.safe_log_name(self)]
-        @log_level = log_level
-
-        flayout = Logging.appenders.rolling_file \
-          Pathname(Dir.home).join('.jph', 'logs', "#{SiteHook.safe_log_name(self)}-#{@log_level}.log").to_s,
-          :age     => 'daily',
-          :pattern => PATTERN
-        @log.add_appenders 'stdout', flayout
-        @log.level = log_level
-        LL.debug "Initialized #{SiteHook.safe_log_name(self)}"
+    def self.validate(config)
+      invalid_types            = []
+      valid_config_log_types   = [
+          'hook',
+          'git',
+          'app',
+          'build'
+      ]
+      invalid_config_log_types = [
+          'access',
+          'fake'
+      ]
+      config                   = config['log_levels']
+      is_config_valid          = config.all? do |x|
+        if valid_config_log_types.include? x
+          true
+        else
+          if invalid_config_log_types.include? x
+            invalid_types << x
+            false
+          end
+        end
+      end
+      unless is_config_valid
+        raise ArgumentError "invalid log type(s) in config, [#{invalid_types.join(', ')}]"
       end
     end
 
-    # Log Hook Actions
-    class HookLog
-      attr :log
-      attr :log_level
-
-      def initialize(log_level = nil)
-        LL.debug "Initializing #{SiteHook.safe_log_name(self)}"
-        @log    = Logging.logger[SiteHook.safe_log_name(self)]
-        @log_level = log_level
-        flayout = Logging.appenders.rolling_file \
-          Pathname(Dir.home).join('.jph', 'logs', "#{SiteHook.safe_log_name(self)}-#{@log_level}.log").to_s,
-          :age     => 'daily',
-          :pattern => PATTERN
-        @log.add_appenders 'stdout', flayout
-        @log.level = @log_level
-        LL.debug "Initialized #{SiteHook.safe_log_name(self)}"
+    def inspect
+      meths    = %i[hook build git app fake access]
+      sections = {}
+      meths.each do |m|
+        sections[m] = self.class.send(m).inspect
       end
+      secs = []
+      sections.each { |name, instance| secs << "#{name}=#{instance}" }
+      "#<SiteHook::Log #{secs.join(' ')}>"
     end
 
-    # Log Build Actions
-    class BuildLog
-      attr :log
-
-      def initialize(log_level = nil)
-        LL.debug "Initializing #{SiteHook.safe_log_name(self)}"
-        @log    = Logging.logger[SiteHook.safe_log_name(self)]
-        @log_level = log_level
+    def initialize(input, output, errput)
 
-        flayout = Logging.appenders.rolling_file \
-          Pathname(Dir.home).join('.jph', 'logs', "#{SiteHook.safe_log_name(self)}-#{@log_level}.log").to_s,
-          :age     => 'daily',
-          :pattern => PATTERN
-        @log.add_appenders 'stdout', flayout
-        @log.level = log_level
+      begin
+        @@config = SiteHook::Config.log_levels
+      rescue Errno::ENOENT
+        raise NoConfigError path
+      rescue NoMethodError
 
-        LL.debug "Initialized #{SiteHook.safe_log_name(self)}"
       end
+
     end
 
-    # Log Git Actions
-    class GitLog
-      attr :log
+    # @return [Access]
+    def self.access
+      Loggers::Access.new(base: 'SiteHook::Log::Access')
+    end
 
-      def initialize(log_level = nil)
-        LL.debug "Initializing #{SiteHook.safe_log_name(self)}"
-        @log    = Logging.logger[SiteHook.safe_log_name(self)]
-        @log_level = log_level
+    # @return [Loggers::Fake]
+    def self.fake
+      Loggers::Fake.new
+    end
 
-        flayout = Logging.appenders.rolling_file \
-          Pathname(Dir.home).join('.jph', 'logs', "#{SiteHook.safe_log_name(self)}-#{@log_level}.log").to_s,
-          :age     => 'daily',
-          :pattern => PATTERN
-        @log.add_appenders 'stdout', flayout
-        @log.level = log_level
-        LL.debug "Initialized #{SiteHook.safe_log_name(self)}"
-      end
+    # @return [Loggers::Hook]
+    def self.hook
+      Loggers::Hook.new(level: @@config.hook, base: 'SiteHook::Log::Hook')
     end
 
-    # Fake Logger for GitLog to preprocess output
-    class FakeLog < StringIO
-      attr :info_output, :debug_output
-      def initialize
-        @info_output = []
-        @debug_output = []
-      end
-      # @param [Any] message message to log
-      def info(message)
-        case
-        when message =~ /git .* pull/
-          @info_output << "Starting Git"
-          @debug_output << message
-        else
-          @debug_output << message
-        end
-      end
-      # @param [Any] message message to log
-      def debug(message)
-        case
-        when message =~ /\n/
-          msgs = message.lines
-          msgs.each do |msg|
-            msg.squish!
-            case
-            when msg =~ /From (.*?):(.*?)\/(.*)(\.git)?/
-              @info_output << "Pulling via #{$2}/#{$3} on #{$1}."
-            when msg =~ /\* branch (.*?) -> .*/
-              @info_output << "Using #{$1} branch"
-            else
-              @debug_output << msg
-            end
-          end
-        else
-          @debug_output << message
-        end
-      end
+    # @return [Loggers::Git]
+    def self.git
+      Loggers::Git.new(level: @@config.git, base: 'SiteHook::Log::Git')
+    end
 
-      # @return [Hash] Hash of log entries
-      def entries
-        {
-            info: @info_output,
-            debug: @debug_output
-        }
-      end
+    # @return [Loggers::Build]
+    def self.build
+      Loggers::Build.new(level: @@config.build, base: 'SiteHook::Log::Build')
+    end
+
+    # @return [Loggers::App]
+    def self.app
+      Loggers::App.new(level: @@config.app, base: 'SiteHook::Log::App')
     end
   end
-end
+end