ballantine 0.1.2 → 0.1.4.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2188ad3272546c25226bdbb1209075baadee05fb7f011cafe13874b1af45777
-  data.tar.gz: 0fe5889c616c93c7f62ce8353671543750604fc4c6def9958abdfe3a0f6e5c42
+  metadata.gz: 36f79167ee934830b2a9d8a59273ffb68970b81a2a48ba21b28f11779227722b
+  data.tar.gz: 37c6726d842dc7dd153c6b8545200ab31fd97586ee1c07e1270bd318a745dd92
 SHA512:
-  metadata.gz: ab52789a4ae2fb510d48f34cd7cf8c2920610e5f341fdbbd94f687fee7ace7ff1f1ff7cbce32fe2e4ce78a783762aa29cf1c9053be5f042ef5b12f84f9101b28
-  data.tar.gz: bda07819f4146ac05b3ab1c39f4debe647f9c72a3a1dc50cfac433bf3381ecc6b96e96c92559775c08ecbf4f4e14b39a235a5a23d8636d2e956b6eddee33ad60
+  metadata.gz: acb862515fde0497f8b7c592c29610c79368063594d8f0f3daa38ed252beabdad2c1ce8fbb2970ee7f30d81e88c2a8d6b95f4158ca67d878ccea0a10bf290f9d
+  data.tar.gz: 0a3b6021c754125ba74bba213df06e860e0a793b3b0027640ae3ae559adce7544c61e4e2ef70832f0fcadc07207cd51428223f4083aa85fe40db8e1b725ca5e5

data/lib/ballantine/author.rb

@@ -1,63 +1,67 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-class Author
-  attr_accessor :name, :commits
+module Ballantine
+  class Author
+    attr_accessor :name, :commits
+
+    class << self
+      # @param [String] name
+      # @return [Author] author
+      def find_or_create_by(name)
+        @_collections = {} unless defined?(@_collections)
+        return @_collections[name] unless @_collections[name].nil?
+
+        @_collections[name] = new(name)
+      end
+
+      # @return [Array<Author>] authors
+      def all
+        return [] unless defined?(@_collections)
+
+        @_collections.sort.map(&:last) # sort and take values
+      end
+    end
 
-  class << self
     # @param [String] name
-    # @return [Author] author
-    def find_or_create_by(name)
-      @@_collections = {} unless defined?(@@_collections)
-      return @@_collections[name] unless @@_collections[name].nil?
-      @@_collections[name] = new(name)
+    def initialize(name)
+      @name = name
+      @commits = {}
     end
 
-    # @return [Array<Author>] authors
-    def all
-      return [] unless defined?(@@_collections)
-      @@_collections.sort.map(&:last) # sort and take values
+    # @return [NilClass] nil
+    def print_commits
+      puts "\n" + "@#{name}".green
+      @commits.each do |repo, lists|
+        count, word = retrieve_count_and_word(lists)
+        puts " > #{repo.blue}: #{count} new #{word}\n"
+        puts lists
+      end
+      nil
     end
-  end
 
-  # @param [String] name
-  def initialize(name)
-    @name = name
-    @commits = {}
-  end
+    # returns an array to use slack attachments field
+    # reference: https://api.slack.com/messaging/composing/layouts#building-attachments
+    # @return [Hash] result
+    def serialize_commits
+      message = @commits.map do |repo, lists|
+        count, word = retrieve_count_and_word(lists)
+        "*#{repo}*: #{count} new #{word}\n#{lists.join("\n")}"
+      end.join("\n")
 
-  # @return [NilClass] nil
-  def print_commits
-    puts "\n" + "@#{name}".green
-    @commits.each do |repo, lists|
-      count, word = retrieve_count_and_word(lists)
-      puts " > #{repo.blue}: #{count} new #{word}\n"
-      puts lists
+      {
+        "text" => "- <@#{name}>\n#{message}",
+        "color" => "#00B86A", # green
+      }
     end
-    nil
-  end
 
-  # returns an array to use slack attachments field
-  # reference: https://api.slack.com/messaging/composing/layouts#building-attachments
-  # @return [Hash] result
-  def serialize_commits
-    message = @commits.map do |repo, lists|
-      count, word = retrieve_count_and_word(lists)
-      "*#{repo}*: #{count} new #{word}\n#{lists.join("\n")}"
-    end.join("\n")
-
-    results = {
-      'text' => "- <@#{name}>\n#{message}",
-      'color' => '#00B86A', # green
-    }
-  end
+    private
 
-  private
-
-  # @param [Array<String>] lists
-  # @param [Array(Integer, String)] count, word
-  def retrieve_count_and_word(lists)
-    count = lists.size
-    word = count == 1 ? 'commit' : 'commits'
-    [count, word]
+    # @param [Array<String>] lists
+    # @param [Array(Integer, String)] count, word
+    def retrieve_count_and_word(lists)
+      count = lists.size
+      word = count == 1 ? "commit" : "commits"
+      [count, word]
+    end
   end
 end

data/lib/ballantine/cli.rb

@@ -1,11 +1,6 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 module Ballantine
-  require 'thor'
-  require 'json'
-  require_relative './author'
-  require_relative './string'
-
   class CLI < Thor
     # reference: https://github.com/desktop/desktop/blob/a7bca44088b105a04714dc4628f4af50f6f179c3/app/src/lib/remote-parsing.ts#L27-L44
     GITHUB_REGEXES = [
@@ -18,141 +13,145 @@ module Ballantine
       '^ssh://git@(.+)/(.+)/(.+)\.git$',  # protocol: ssh   -> ssh://git@github.com/oohyun15/ballantine.git
     ].freeze
 
-    FILE_GITMODULES = '.gitmodules'
-    FILE_BALLANTINE_CONFIG = '.ballantine.json'
+    FILE_GITMODULES = ".gitmodules"
 
-    TYPE_TERMINAL = 'terminal'
-    TYPE_SLACK = 'slack'
+    TYPE_TERMINAL = "terminal"
+    TYPE_SLACK = "slack"
 
     DEFAULT_LJUST = 80
 
-    AVAILABLE_CONFIG = ['slack_webhook'].freeze
-
-    attr_reader :app_name, :main_path, :sub_path, :slack_webhook, :send_type
+    attr_reader :app_name, :main_path, :sub_path, :send_type
 
-    package_name 'Ballantine'
+    class << self
+      def exit_on_failure?; exit(1) end
+    end
 
-    desc 'init', 'Initialize ballantine configuration'
+    package_name "Ballantine"
+    option "force", type: :boolean, aliases: "-f", default: false, desc: "Initialize forcely if already initialized."
+    desc "init", "Initialize ballantine"
     def init
-      puts "🥃 Init ballantine configuration"
-      slack_webhook = ask("Q. Set slack webhook\n> ")
+      conf.init_file(force: options["force"])
 
-      config = {
-        slack_webhook: slack_webhook
-      }
-      File.write('./' + FILE_BALLANTINE_CONFIG, JSON.dump(config))
+      puts "🥃 Initialized ballantine."
+
+      true
     end
 
-    desc 'config', 'Describe ballantine configuration'
-    def config
-      load_config
-      AVAILABLE_CONFIG.each do |key|
-        puts "#{key}: #{instance_variable_get('@' + key)}"
+    Config::AVAILABLE_ENVIRONMENTS.each { |env| option env, type: :boolean, default: false, desc: "Set envirment to `#{env}'." }
+    desc "config [--env] [KEY] [VALUE]", "Set ballantine's configuration"
+    def config(key = nil, value = nil)
+      # check environment value
+      if Config::AVAILABLE_ENVIRONMENTS.map { |key| !options[key] }.reduce(:&)
+        raise NotAllowed, "Set environment value (#{Config::AVAILABLE_ENVIRONMENTS.map { |key| "`--#{key}'" }.join(", ")})"
+      elsif Config::AVAILABLE_ENVIRONMENTS.map { |key| !!options[key] }.reduce(:&)
+        raise NotAllowed, "Environment value must be unique."
       end
-    end
 
-    desc 'diff [TARGET] [SOURCE]', 'Diff commits between TARGET and SOURCE'
-    option TYPE_SLACK, type: :boolean, aliases: '-s', default: false, desc: 'send to slack using slack webhook URL.'
-    def diff(from, to = `git rev-parse --abbrev-ref HEAD`.chomp)
-      load_config
-      preprocess(from, to, **options)
+      @env = Config::AVAILABLE_ENVIRONMENTS.find { |key| options[key] }
+      raise AssertionFailed, "Environment value must exist: #{@env}" if @env.nil?
 
-      # check argument is tag
-      from = check_tag(from)
-      to = check_tag(to)
+      value ? conf.set_data(key, value) : conf.print_data(key)
+    end
+
+    desc "diff [TARGET] [SOURCE]", "Diff commits between TARGET and SOURCE"
+    option TYPE_SLACK, type: :boolean, aliases: "-s", default: false, desc: "Send to slack using slack webhook URL."
+    def diff(target, source = %x(git rev-parse --abbrev-ref HEAD).chomp)
+      # validate arguments
+      validate(target, source, **options)
 
       # check commits are newest
-      system 'git pull -f &> /dev/null'
+      system("git pull -f &> /dev/null")
 
-      # set instance variables
-      @send_type = options[TYPE_SLACK] ? TYPE_SLACK : TYPE_TERMINAL
-      @app_name = File.basename(`git config --get remote.origin.url`.chomp, '.git')
-      @main_path = Dir.pwd
-      @sub_path = if Dir[FILE_GITMODULES].any?
-        file = File.open(FILE_GITMODULES)
-        lines = file.readlines.map(&:chomp)
-        file.close
-        lines.grep(/path =/).map{ |line| line[/(?<=path \=).*/, 0].strip }.sort
-      else
-        []
-      end
+      # init instance variables
+      init_variables(**options)
 
       # find github url, branch
-      main_url = github_url(`git config --get remote.origin.url`.chomp)
-      current_branch = `git rev-parse --abbrev-ref HEAD`.chomp
+      url = github_url(%x(git config --get remote.origin.url).chomp)
+      current_revision = %x(git rev-parse --abbrev-ref HEAD).chomp
 
       # get commit hash
-      main_from, sub_from = commit_hash(from)
-      main_to, sub_to = commit_hash(to)
-      system "git checkout #{current_branch} -f &> /dev/null"
+      from, sub_from = commit_hash(target)
+      to, sub_to = commit_hash(source)
+      system("git checkout #{current_revision} -f &> /dev/null")
 
       # check commits
-      check_commits(main_from, main_to, main_url)
-      @sub_path.each_with_index do |path, idx|
+      check_commits(from, to, url)
+      sub_path.each_with_index do |path, idx|
         next if sub_from[idx] == sub_to[idx]
+
         Dir.chdir(path)
-        sub_url = github_url(`git config --get remote.origin.url`.chomp)
+        sub_url = github_url(%x(git config --get remote.origin.url).chomp)
         check_commits(sub_from[idx], sub_to[idx], sub_url)
-        Dir.chdir(@main_path)
+        Dir.chdir(main_path)
       end
 
-      send_commits(from, to, main_url)
+      # send commits
+      send_commits(target, source, from, to, url)
 
-      exit 0
+      exit(0)
     end
 
-    desc 'version', 'Display version information about ballntine'
+    desc "version", "Display version information about ballntine"
     def version
       puts "ballantine version #{Ballantine::VERSION}"
-    end
-
-    private
 
-    def self.exit_on_failure?
-      exit 1
+      Ballantine::VERSION
     end
 
-    def load_config
-      return if Dir[FILE_BALLANTINE_CONFIG].empty?
+    private
 
-      JSON.parse(File.read('./' + FILE_BALLANTINE_CONFIG)).each do |key, value|
-        next unless AVAILABLE_CONFIG.include?(key)
-        instance_variable_set('@' + key, value)
-      end
-    end
+    def conf; @conf ||= Config.new(@env) end
 
-    # @param [String] from
-    # @param [String] to
+    # @param [String] target
+    # @param [String] source
     # @param [Hash] options
     # @return [NilClass] nil
-    def preprocess(from, to, **options)
-      if Dir['.git'].empty?
-        raise SystemCallError, "ERROR: There is no \".git\" in #{Dir.pwd}."
+    def validate(target, source, **options)
+      if Dir[".git"].empty?
+        raise NotAllowed, "ERROR: There is no \".git\" in #{Dir.pwd}."
       end
 
-      if (uncommitted = `git diff HEAD --name-only`.split("\n")).any?
-        raise SystemCallError, "ERROR: Uncommitted file exists. stash or commit uncommitted files.\n#{uncommitted.join("\n")}"
+      if (uncommitted = %x(git diff HEAD --name-only).split("\n")).any?
+        raise NotAllowed, "ERROR: Uncommitted file exists. stash or commit uncommitted files.\n#{uncommitted.join("\n")}"
       end
 
-      if from == to
-        raise ArgumentError, "ERROR: target(#{from}) and source(#{to}) can't be equal."
+      if target == source
+        raise NotAllowed, "ERROR: target(#{target}) and source(#{source}) can't be equal."
       end
 
-      if options[TYPE_SLACK] && !@slack_webhook
-        raise ArgumentError, "ERROR: Can't find any slack webhook. Set slack webhook using `ballantine init`."
+      if options[TYPE_SLACK] && !conf.get_data(Config::KEY_SLACK_WEBHOOK)
+        raise NotAllowed, "ERROR: Can't find any slack webhook. Set slack webhook using `ballantine config --#{Config::ENV_LOCAL} slack_webhook [YOUR_WEBHOOK]'."
       end
 
       nil
     end
 
+    # @param [Hash] options
+    # @return [Boolean]
+    def init_variables(**options)
+      @send_type = options[TYPE_SLACK] ? TYPE_SLACK : TYPE_TERMINAL
+      @app_name = File.basename(%x(git config --get remote.origin.url).chomp, ".git")
+      @main_path = Dir.pwd
+      @sub_path =
+        if Dir[FILE_GITMODULES].any?
+          file = File.open(FILE_GITMODULES)
+          lines = file.readlines.map(&:chomp)
+          file.close
+          lines.grep(/path =/).map { |line| line[/(?<=path \=).*/, 0].strip }.sort
+        else
+          []
+        end
+      true
+    end
+
     # @param [String] name
     # @return [String] hash
     def check_tag(name)
-      list = `git tag -l`.split("\n")
+      list = %x(git tag -l).split("\n")
       return name unless list.grep(name).any?
 
-      system "git fetch origin tag #{name} -f &> /dev/null"
-      `git rev-list -n 1 #{name}`.chomp[0...7]
+      system("git fetch origin tag #{name} -f &> /dev/null")
+      %x(git rev-list -n 1 #{name}).chomp[0...7]
     end
 
     # @param [String] from
@@ -160,13 +159,17 @@ module Ballantine
     # @param [String] url
     # @return [NilClass] nil
     def check_commits(from, to, url)
-      repo = File.basename(`git config --get remote.origin.url`.chomp, '.git')
-      names = `git --no-pager log --pretty=format:"%an" #{from}..#{to}`.split("\n").uniq.sort
-      authors = names.map{ |name| Author.find_or_create_by(name) }
+      repo = File.basename(%x(git config --get remote.origin.url).chomp, ".git")
+      names = %x(git --no-pager log --pretty=format:"%an" #{from}..#{to}).split("\n").uniq.sort
+      authors = names.map { |name| Author.find_or_create_by(name) }
       authors.each do |author|
         format = commit_format(url, ljust: DEFAULT_LJUST - 10)
-        commits = `git --no-pager log --reverse --no-merges --author="#{author.name}" --format="#{format}" --abbrev=7 #{from}..#{to}`.gsub('"', '\"').gsub(/[\u0080-\u00ff]/, '')
+        commits =
+          %x(git --no-pager log --reverse --no-merges --author="#{author.name}" --format="#{format}" --abbrev=7 #{from}..#{to})
+            .gsub('"', '\"')
+            .gsub(/[\u0080-\u00ff]/, "")
         next if commits.empty?
+
         author.commits[repo] = commits.split("\n")
       end
       nil
@@ -185,17 +188,20 @@ module Ballantine
     end
 
     # @param [String] hash
-    # @param [Array<String>] sub_path
     # @return [Array(String, Array<String>)] main, sub's hash
     def commit_hash(hash)
-      system "git checkout #{hash} -f &> /dev/null"
-      system 'git pull &> /dev/null'
-      main_hash = `git --no-pager log -1 --format='%h'`.chomp
-      sub_hash = if @sub_path.any?
-        `git ls-tree HEAD #{@sub_path.join(' ')}`.split("\n").map{ |line| line.split(' ')[2] }
-      else
-        []
-      end
+      # check argument is tag
+      hash = check_tag(hash)
+
+      system("git checkout #{hash} -f &> /dev/null")
+      system("git pull &> /dev/null")
+      main_hash = %x(git --no-pager log -1 --format='%h').chomp
+      sub_hash =
+        if sub_path.any?
+          %x(git ls-tree HEAD #{@sub_path.join(" ")}).split("\n").map { |line| line.split(" ")[2] }
+        else
+          []
+        end
 
       [main_hash, sub_hash]
     end
@@ -204,52 +210,58 @@ module Ballantine
     # @param [String] format
     # @param [Integer] ljust
     def commit_format(url, ljust: DEFAULT_LJUST)
-      case @send_type
+      case send_type
       when TYPE_TERMINAL
-        " - "+ "%h".yellow + " %<(#{ljust})%s " + "#{url}/commit/%H".gray
+        " - " + "%h".yellow + " %<(#{ljust})%s " + "#{url}/commit/%H".gray
       when TYPE_SLACK
         "\\\`<#{url}/commit/%H|%h>\\\` %s - %an"
+      else raise AssertionFailed, "Unknown send type: #{send_type}"
       end
     end
 
+    # @param [String] target
+    # @param [String] source
     # @param [String] from
     # @param [String] to
     # @param [String] url
     # @return [NilClass] nil
-    def send_commits(from, to, url)
+    def send_commits(target, source, from, to, url)
       authors = Author.all
       if authors.empty?
-        raise ArgumentError, "ERROR: There is no commits between \"#{from}\" and \"#{to}\""
+        raise ArgumentError, "ERROR: There is no commits between \"#{target}\" and \"#{source}\""
       end
+
       number = authors.size
-      last_commit = `git --no-pager log --reverse --format="#{commit_format(url, ljust: DEFAULT_LJUST - 22)}" --abbrev=7 #{from}..#{to} -1`.strip
+      last_commit = %x(git --no-pager log --reverse --format="#{commit_format(url, ljust: DEFAULT_LJUST - 22)}" --abbrev=7 #{from}..#{to} -1).strip
 
-      case @send_type
+      case send_type
       when TYPE_TERMINAL
-        puts "Check commits before #{@app_name.red} deployment. (#{from.cyan} <- #{to.cyan})".ljust(DEFAULT_LJUST + 34) + " #{url}/compare/#{from}...#{to}".gray
+        puts "Check commits before #{app_name.red} deployment. (#{target.cyan} <- #{source.cyan})".ljust(DEFAULT_LJUST + 34) + " #{url}/compare/#{from}...#{to}".gray
         puts "Author".yellow + ": #{number}"
         puts "Last commit".blue + ": #{last_commit}"
         authors.map(&:print_commits)
       when TYPE_SLACK
         # set message for each author
         messages = authors.map(&:serialize_commits)
-        actor = `git config user.name`
+        actor = %x(git config user.name).chomp
 
         # send message to slack
-        require 'net/http'
-        require 'uri'
-        uri = URI.parse(@slack_webhook)
+        require "net/http"
+        require "uri"
+        uri = URI.parse(conf.get_data(Config::KEY_SLACK_WEBHOOK))
         request = Net::HTTP::Post.new(uri)
-        request.content_type = 'application/json'
+        request.content_type = "application/json"
         request.body = JSON.dump({
-          'text' => ":check: *#{@app_name}* deployment request by <@#{actor}> (\`<#{url}/tree/#{from}|#{from}>\` <- \`<#{url}/tree/#{to}|#{to}>\` <#{url}/compare/#{from}...#{to}|compare>)\n:technologist: Author: #{number}\nLast commit: #{last_commit}",
-          'attachments' => messages
+          "text" => ":white_check_mark: *#{app_name}* deployment request by <@#{actor}> (\`<#{url}/tree/#{from}|#{target}>\` <- \`<#{url}/tree/#{to}|#{source}>\` <#{url}/compare/#{from}...#{to}|compare>)\n:technologist: Author: #{number}\nLast commit: #{last_commit}",
+          "attachments" => messages,
         })
-        req_options = { use_ssl: uri.scheme == 'https' }
+        req_options = { use_ssl: uri.scheme == "https" }
         response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
           http.request(request)
         end
         puts response.message
+      else
+        raise AssertionFailed, "Unknown send type: #{send_type}"
       end
     end
   end

data/lib/ballantine/config.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ballantine
+  class Config
+    ENV_LOCAL = "local"
+    ENV_GLOBAL = "global"
+    AVAILABLE_ENVIRONMENTS = [
+      ENV_LOCAL,
+      ENV_GLOBAL,
+    ].freeze
+
+    KEY_SLACK_WEBHOOK = "slack_webhook"
+    AVAILABLE_KEYS = [
+      KEY_SLACK_WEBHOOK,
+    ].freeze
+
+    FILE_BALLANTINE_CONFIG = ".ballantine.json"
+
+    attr_reader :env, :data, :loaded
+
+    def initialize(env)
+      @env = env || ENV_LOCAL
+      @data = {}
+      @loaded = false
+    end
+
+    # @param [Hash] options
+    # @return [Boolean] result
+    def init_file(**options)
+      raise NotAllowed, "#{FILE_BALLANTINE_CONFIG} already exists." if Dir[file_path].any? && !options[:force]
+
+      File.write(file_path, {})
+      @loaded = false
+    end
+
+    # @param [Hash] options
+    # @return [Boolean] result
+    def load_file(**options)
+      return false if @loaded
+      raise NotAllowed, "Can't find #{FILE_BALLANTINE_CONFIG}" if Dir[file_path].empty?
+
+      JSON.parse(File.read(file_path)).each do |key, value|
+        next unless AVAILABLE_KEYS.include?(key)
+
+        @data[key] = value
+      end
+
+      @loaded = true
+    end
+
+    # @param [String] key
+    # @param [Hash] options
+    # @return [Boolean] result
+    def print_data(key, **options)
+      load_file unless @loaded
+
+      if key
+        raise InvalidParameter, "Key must be within #{AVAILABLE_KEYS}" unless AVAILABLE_KEYS.include?(key)
+
+        puts @data[key]
+      else
+        @data.each do |key, value|
+          puts "#{key}: #{value}"
+        end
+      end
+
+      true
+    end
+
+    # @param [String] key
+    # @param [String] value
+    # @param [Hash] options
+    # @return [Stirng] value
+    def set_data(key, value, **options)
+      load_file unless @loaded
+
+      @data[key] = value
+      File.write(file_path, JSON.dump(@data))
+      value
+    end
+
+    # @param [String] key
+    # @param [Hash] options
+    # @return [Stirng] value
+    def get_data(key, **options)
+      load_file unless @loaded
+      @data[key]
+    end
+
+    private
+
+    def file_path(env = @env)
+      case env
+      when ENV_LOCAL then "./#{FILE_BALLANTINE_CONFIG}"
+      when ENV_GLOBAL then "#{Dir.home}/#{FILE_BALLANTINE_CONFIG}"
+      else raise AssertionFailed, "Unknown environment: #{env}"
+      end
+    end
+  end
+end

data/lib/ballantine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ballantine
-  VERSION = "0.1.2"
+  VERSION = "0.1.4-beta"
 end

data/lib/ballantine.rb

@@ -1,7 +1,17 @@
 # frozen_string_literal: true
-require_relative "ballantine/cli"
+
+require "thor"
+require "json"
+require_relative "string"
 require_relative "ballantine/version"
+require_relative "ballantine/config"
+require_relative "ballantine/author"
+require_relative "ballantine/cli"
 
 module Ballantine
   class Error < StandardError; end
+  class NotAllowed < Error; end
+  class InvalidParameter < Error; end
+  class AssertionFailed < Error; end
+  class NotImplemented < Error; end
 end

data/lib/{ballantine/string.rb → string.rb}

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # @override
 class String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ballantine
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4.pre.beta
 platform: ruby
 authors:
 - oohyun15
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-15 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -51,13 +51,14 @@ files:
 - lib/ballantine.rb
 - lib/ballantine/author.rb
 - lib/ballantine/cli.rb
-- lib/ballantine/string.rb
+- lib/ballantine/config.rb
 - lib/ballantine/version.rb
+- lib/string.rb
 homepage: https://github.com/oohyun15/ballantine
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -65,15 +66,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.6
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.3.26
+signing_key: 
 specification_version: 4
 summary: Describe your commits.
 test_files: []