nicker_pocker 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e7deb51ce3139db804c630002ca57d9ba14e1eae83b9838814ce88fed339d07
-  data.tar.gz: 42b090b3a581625bb1554e85365cfb27f70429c1a0df067149eb12c7171260ed
+  metadata.gz: 74a52c39ca930e3720480a937ad3decec09f0ea61b13bc99fecceb7d258acfa7
+  data.tar.gz: b79e0dd5a16e4e62236234708371787abfc4dede1e54a58b3eb8298d934fdcf8
 SHA512:
-  metadata.gz: b3c9afc9c7c15b9f4fbe34ad2e0afac7b95ecc7b90b2eefa8ede52d6cbac65d5305f5abc158e831adbf4ee5e97c8fc5ee7b668b3d6fc1a85166c4dd4098b5972
-  data.tar.gz: 2ef075af0ca18c1cc998702b74ddccb315eb3c86c6f3abc95de9517b1b7a57a0abbfce0379c52632cbdec422b27b490e28f2f82078f48ab552b5019274eb6ee6
+  metadata.gz: 8c7e7d4ee9bee1c8b102627626aeb1803e9ecf015c163a8fb527aa0fa760f42237c92d652d45ce9338e8d11ffeef1e3e76b8803ffaddaa785c7a3c43037a6470
+  data.tar.gz: ca79c04b1fddc0faba5818b637c029103bcf81a76ecc6b1c70732c33a158090904412173da305e1864fc072f19e83fa92575cd0ad64732d83df8b47980dab3a0

data/Gemfile

@@ -8,5 +8,6 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+gem "factory_bot"
 
 gem "rubocop", "~> 1.21"

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    nicker_pocker (0.1.2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.4.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    concurrent-ruby (1.2.2)
+    diff-lcs (1.5.0)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    minitest (5.18.0)
+    parallel (1.22.1)
+    parser (3.2.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.7.0)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.50.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  factory_bot
+  nicker_pocker!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.4.8

data/lib/nicker_pocker/command.rb

@@ -0,0 +1,149 @@
+# 指定オプションに基づいて処理実行
+require 'fileutils'
+require 'csv'
+
+module NickerPocker
+  MIGRATE_METHODS =
+    Format::Operator::PROTOTYPE_METHODS +
+    Format::Operator::DETAIL_METHODS
+
+  class Command
+    class << self
+      def exec(options = {})
+        new(options).run
+      end
+    end
+
+    # 各設定をセット
+    def initialize(options)
+      @options = options
+
+      # 初期値設定
+      @options[:input]  ||= './db/migrate/'
+      @options[:output] ||= './nicker_pocker/'
+      @options[:format] ||= :csv
+    end
+
+    # 実行
+    def run
+      return if Dir.glob("#{@options[:input]}*\.rb").empty?
+
+      output(read_data)
+    end
+
+    private
+
+    # 対象マイグレーションファイルを読み込み
+    #
+    # @return [Array]
+    def read_data
+      temp_data = {}
+
+      Dir::foreach(@options[:input]) do |file_name|
+        next if ['.', '..'].include?(file_name)
+
+        File.open(@options[:input] + file_name) do |f|
+          temp_data[file_name.to_i] = f.readlines.each(&:strip!)
+        end
+      end
+
+      # migrationファイルの実行順に並べ替える
+      temp_data_list = temp_data.sort.to_h.values
+      temp_data_list.flatten!.select! { |row| target_data?(row) }.compact!
+
+      data_list = necessary_data(temp_data_list)
+
+      groups = Grouping.exec(data_list)
+      Format::Operator.exec(groups)
+    end
+
+    # 対象データ判定
+    #
+    # @params [String] row
+    # @return [Boolean]
+    def target_data?(row)
+      return true if /^t\..*|^def\s.*/.match(row)
+
+      MIGRATE_METHODS.each do |method_name|
+        return true if /#{method_name.to_s}\s/.match(row)
+      end
+
+      false
+    end
+
+    # 必要なデータを抽出
+    #
+    # @params [Array] data_list
+    # @return [Array]
+    def necessary_data(temp_data_list)
+      data_list = data_list(temp_data_list)
+      necessary_data_list = []
+      pattern = MIGRATE_METHODS.map(&:to_s).join('|')
+      scan_pattern = Regexp.new(".*?[#{pattern}].*")
+
+      # グルーピングしやすいように整形
+      data_list.each_with_index do |data, index|
+        pattern_match_list = data.map do |content|
+          scan_list = content.scan(scan_pattern)
+          scan_list if scan_list.any?
+        end.compact
+
+        # 同じファイルに複数のmigrationメソッドが記載されている場合の対応
+        if pattern_match_list.length > 1
+          sub_list = []
+          pattern_match_list.each do |pattern_match|
+            if pattern_match.first.match?(/#{pattern}/)
+              sub_list.push([*pattern_match])
+            else
+              sub_list.last.push(*pattern_match)
+            end
+          end
+
+          necessary_data_list.push(sub_list)
+        else
+          necessary_data_list.push(pattern_match_list)
+        end
+      end
+
+      necessary_data_list
+    end
+
+    def data_list(temp_data_list)
+      data_list = []
+      methods_contents_list = []
+
+      # def ごとの配列に格納
+      temp_data_list.each do |data|
+       if /^def\s.*/.match(data)
+          data_list.push(methods_contents_list) if methods_contents_list.any?
+          methods_contents_list = []
+       end
+
+       methods_contents_list.push(data)
+      end
+      data_list.push(methods_contents_list) if methods_contents_list.any?
+
+      # 不要データを除外
+      data_list.reject! { |data| data.include?('def down') }
+      data_list.map { |data| data.reject { |x| /^def\s.*/.match(x) } }.reject(&:empty?)
+    end
+
+    # 出力
+    #
+    # @params [Array] formatted_list
+    def output(formatted_list)
+      # ディレクトリ作成（なければ）
+      FileUtils.mkdir_p(@options[:output])
+
+      # csv作成
+      CSV.open("#{@options[:output]}table_definition.csv", 'w') do |csv|
+        formatted_list.each do |formatted_table|
+          formatted_table.each do |formatted_row|
+            csv << formatted_row
+          end
+          csv << []
+        end
+      end
+    end
+  end
+end

data/lib/nicker_pocker/format/detail.rb

@@ -0,0 +1,152 @@
+# カラム整形
+module NickerPocker
+  module Format
+    class Detail
+      # フォーマット後の各データ格納列
+      COL_PK      = 0
+      COL_FK      = 1
+      COL_INDEX   = 2
+      COL_UNIQUE  = 3
+      COL_TYPE    = 4
+      COL_COLUMN  = 5
+      COL_NULL    = 7
+      COL_LIMIT   = 8
+      COL_DEFAULT = 9
+      COL_COMMENT = 10
+      COL_MEMO    = 12
+
+      # フォーマット後のカラムデータの先頭行
+      ROW_COLUMN_START = 3
+
+      # 各データの格納位置
+      INDEX_COLUMN        = 0
+      INDEX_TYPE          = 1
+      INDEX_OPTIONS_START = 2
+
+      # add_column用
+      #
+      # @params [Array] method_data_list
+      # @params [Array] table_list
+      # @return [Array]
+      def add_column(method_data_list, table_list)
+        add_list = column_migrate_list(method_data_list)
+        index = table_list.index(table_list.last)
+
+        counter = 0
+        add_list.map do |additions|
+          counter += 1
+          add_row = %W(
+            #{nil} #{nil} #{nil} #{nil}
+            #{additions[:type]} #{additions[:column]} #{nil} #{additions[:null]}
+            #{additions[:limit]} #{additions[:default]} #{additions[:comment]}
+          )
+
+          { (index + counter) => add_row }
+        end
+      end
+
+      # change_column用
+      #
+      # @params [Array] method_data_list
+      # @params [Array] table_list
+      # @return [Array]
+      def change_column(method_data_list, table_list)
+        change_list = column_migrate_list(method_data_list)
+        column_formatted_list = table_list[ROW_COLUMN_START..]
+
+        change_list.map do |changes|
+          change_row = column_formatted_list.find { |row| row[COL_COLUMN] == changes[:column] }
+          target_index = column_formatted_list.index(change_row) + ROW_COLUMN_START
+          change_row[COL_TYPE] = changes[:type]
+          change_row[COL_NULL] = changes[:null] || change_row[COL_NULL]
+          change_row[COL_LIMIT] = changes[:limit] || change_row[COL_LIMIT]
+          change_row[COL_DEFAULT] = changes[:default] || change_row[COL_DEFAULT]
+          change_row[COL_COMMENT] = changes[:comment] || change_row[COL_COMMENT]
+
+          { target_index => change_row }
+        end
+      end
+
+      # add_index用
+      #
+      # @params [Array] method_data_list
+      # @params [Array] table_list
+      # @return [Array]
+      def add_index(method_data_list, table_list)
+        column_formatted_list = table_list[ROW_COLUMN_START..]
+        change_list = []
+
+        method_data_list.each do |method_data|
+          index_column_list = [method_data.first]
+          option_list = method_data[1..]
+
+          if index_column_list.first.match(/^\[/)
+            index_end = method_data.index { |x| x.match(/\]/) }
+            index_column_list = method_data[..index_end]
+            option_list = method_data[index_end + 1..]
+          end
+
+          index_column_list.each do |index_column|
+            column_formatted_list.each_with_index do |column_formatted_data, index|
+              next unless index_column.include?(column_formatted_data[COL_COLUMN])
+
+              column_formatted_data[COL_INDEX] = '*'
+
+              if option_list.any?
+                if option_list.find { |option| option.match(/^unique/) }&.match(/true/i)
+                  column_formatted_data[COL_UNIQUE] = '*'
+                end
+
+                column_formatted_data[COL_MEMO] = option_list.find { |option| option.match(/^name/) }&.gsub(/^name|\s|:|"/, '')
+              end
+
+              change_list.push({ (index + ROW_COLUMN_START) => column_formatted_data })
+              break
+            end
+          end
+        end
+
+        change_list
+      end
+
+      # remove_column用
+      #
+      # @params [Array] method_data_list
+      # @params [Array] table_list
+      # @return [Array]
+      def remove_column(method_data_list, table_list)
+        remove_column_list = method_data_list.map { |method_data| method_data[INDEX_COLUMN] }
+        column_formatted_list = table_list[ROW_COLUMN_START..]
+
+        column_formatted_list.map.with_index do |column_formatted_data, index|
+          if remove_column_list.include?(column_formatted_data[COL_COLUMN])
+            { (index + ROW_COLUMN_START) => nil }
+          end
+        end.compact
+      end
+
+      private
+
+      def column_migrate_list(method_data_list)
+        method_data_list.map do |method_data|
+          migrates = {}
+
+          migrates[:column] = method_data[INDEX_COLUMN]
+          migrates[:type] = method_data[INDEX_TYPE]
+
+          option_list = method_data[INDEX_OPTIONS_START..]
+          unless option_list
+            migrates
+            next
+          end
+
+          migrates[:null] = option_list.find { |option| option.match(/^null/) }&.match(/true|false/i)
+          migrates[:limit] = option_list.find { |option| option.match(/^limit/) }&.gsub(/[^\d]/, '')
+          migrates[:default] = option_list.find { |option| option.match(/^default/) }&.gsub(/^default:|\s/, '')
+          migrates[:comment] = option_list.find { |option| option.match(/^comment/) }&.gsub(/^comment:|\s/, '')
+          migrates
+        end
+      end
+    end
+  end
+end

data/lib/nicker_pocker/format/operator.rb

@@ -0,0 +1,88 @@
+# フォーマッタ
+module NickerPocker
+  module Format
+    class Operator
+      PROTOTYPE_METHODS = %i(
+        rename_table
+        drop_table
+        rename_column
+        create_table
+      ).freeze
+
+      DETAIL_METHODS = %i(
+        add_column
+        change_column
+        add_index
+        remove_column
+      ).freeze
+
+      class << self
+        def exec(groups, options = {})
+          new(options).run(groups)
+        end
+      end
+
+      # options[:target_format]
+      def initialize(options)
+        @options = options
+      end
+
+      # 実行
+      #
+      # @params [Hash] groups
+      # @return [Array]
+      def run(groups)
+        return [] if groups.length == 0
+
+        # 各関数の処理をする
+        formatted_list(groups)
+      end
+
+      private
+
+      # 整形した配列を返す
+      #
+      # @params [Hash] groups
+      # @return [Array]
+      def formatted_list(groups)
+        prototype_formatter = Prototype.new
+
+        # 定義書の原型をつくる
+        table_groups = prototype_formatter.format_groups(groups)
+        table_list = prototype_formatter.table_list(table_groups)
+
+        # カラム整形
+        format_column(table_groups, table_list)
+      end
+
+      # 整形したカラムを返す
+      #
+      # @params [Hash] table_groups
+      # @params [Array] table_list
+      # @return [Array]
+      def format_column(table_groups, table_list)
+        detail_formatter = Detail.new
+
+        table_groups.map do |table_data|
+          target_table_list = table_list.find { |table| table[1].first == table_data.first }
+
+          DETAIL_METHODS.each do |method_name|
+            method_data = table_data[1][method_name]
+            next unless method_data
+
+            change_content_list =
+              detail_formatter.send(method_name, method_data, target_table_list)
+
+            change_content_list.each do |change_contents|
+              index = change_contents.keys.first
+              value = change_contents.values.first
+
+              target_table_list[index] = value
+            end
+          end
+          target_table_list.compact
+        end
+      end
+    end
+  end
+end

data/lib/nicker_pocker/format/prototype.rb

@@ -0,0 +1,242 @@
+# 定義書の原型をつくる
+module NickerPocker
+  module Format
+    class Prototype
+      TABLE_HEADER_LIST = %W(
+        table_name
+        #{nil}
+        #{nil}
+        table_name(jp)
+        #{nil}
+        #{nil}
+        created_by
+        created_date
+        updated_by
+        updated_date
+        table_memo
+      ).freeze
+
+      COLMN_HEADER_LIST = %W(
+        PK
+        FK
+        index
+        unique
+        type
+        column_name
+        #{nil}
+        null
+        limit
+        default
+        column_name(jp)
+        #{nil}
+        column_memo
+      ).freeze
+
+      # グループ整形
+      #
+      # @params [Hash] groups
+      # @return [Hash]
+      def format_groups(groups)
+        return [] if groups.length == 0
+
+        # リネームテーブル処理
+        renamed_groups = rename_table(groups)
+
+        # テーブル削除処理
+        dropped_groups = drop_table(renamed_groups)
+
+        # リネームカラム処理
+        rename_column(dropped_groups)
+      end
+
+      # テーブル作成用配列
+      #
+      # @params [Hash] groups
+      # @return [Hash]
+      def table_list(table_groups)
+        table_groups.map { |table_data| create_table_format(table_data) }
+      end
+
+      private
+
+      # テーブルリネーム処理
+      #
+      # @params [Hash] groups
+      # @return [Hash]
+      def rename_table(groups)
+        temp_list =
+          groups.map do |table_data|
+            if table_data[1][:rename_table]
+              new_table_name = table_data[1][:rename_table].first.first.to_sym
+              [table_data[0], new_table_name]
+            end
+          end.compact
+
+        temp_list.each do |rename_table|
+          old_val = groups[rename_table[1]]
+          # リネーム後のテーブル名に対するmigrateの有無
+          if old_val
+            groups[rename_table[1]] =
+              old_val.merge(groups.delete(rename_table[0])) { |key, old_v, new_v| old_v + new_v }
+          else
+            groups[rename_table[1]] = groups.delete(rename_table[0])
+          end
+        end
+
+        groups
+      end
+
+      # テーブル削除処理
+      #
+      # @params [Hash] groups
+      # @return [Hash]
+      def drop_table(groups)
+        # 削除対象tableリスト
+        drop_table_list = []
+        groups.each do |table_data|
+          next unless table_data[1][:drop_table]
+          drop_table_list.push(table_data[0])
+        end
+
+        return groups if drop_table_list.empty?
+
+        drop_table_list.each do |drop_table_name|
+          groups.delete(drop_table_name)
+        end
+
+        groups
+      end
+
+      # rename_column用
+      #
+      # @params [Hash] table_groups
+      # @return [Hash]
+      def rename_column(table_groups)
+        rename_target_list = rename_target_list(table_groups)
+        return table_groups if rename_target_list.empty?
+
+        rename_target_list.each do |rename_target|
+          table_name = rename_target.keys.first
+          rename_val_list = rename_target.values.first
+
+          rename_targets = table_groups.delete(table_name)
+
+          key_arr = rename_targets.keys
+          values_arr = rename_targets.values
+
+          rename_val_list.each do |rename_val|
+            old_name = rename_val[0]
+
+            new_name = rename_val[1]
+            values_arr = values_arr.map do |val_arr|
+              val_arr.map { |val|
+                val.map { |v|
+                  if /^#{old_name}$/.match?(v)
+                    next v.gsub(/^#{old_name}$/, new_name)
+                  end
+                  v.gsub(/:#{old_name}$/, ":#{new_name}")
+                }
+              }
+            end
+          end
+          table_datas = {}
+          renamed_targets = [key_arr, values_arr].transpose.to_h
+          table_datas[table_name] = renamed_targets
+          table_groups.update(table_datas)
+        end
+
+        table_groups
+      end
+
+      # リネーム対象を返す
+      #
+      # @params [Hash]
+      # @return [Array]
+      def rename_target_list(table_groups)
+        table_groups.map do |table_group|
+          rename_list = table_group[1][:rename_column]
+          next unless rename_list
+
+          { table_group[0] => rename_list }
+        end.compact
+      end
+
+      # テーブル作成用に整形した配列を返す
+      #
+      # @params [Array] table_data
+      # @return [Array]
+      def create_table_format(table_data)
+        formatted_table_list = []
+
+        # テーブル情報
+        formatted_table_list.push(TABLE_HEADER_LIST)
+        formatted_table_list.push([table_data[0]])
+
+        # カラムヘッダー追加
+        formatted_table_list.push(COLMN_HEADER_LIST)
+
+        methods = table_data[1]
+        columns_list = methods[:create_table].join.split(/t\./).reject(&:empty?)
+        formatted_column_list = create_table(columns_list)
+
+        formatted_table_list.push(*formatted_column_list)
+      end
+
+      # テーブル作成処理
+      #
+      # @params [Array] columns_list
+      # @return [Array]
+      def create_table(columns_list)
+        result_list = []
+
+        # Pキー追加
+        result_list.push(%W(* #{nil} #{nil} #{nil} integer id #{nil} false #{nil} #{nil} ID))
+
+        columns_list.each do |column|
+          column_data_list = column.split(/\s|,|=>/)
+          column_data_list.delete('')
+
+          type = column_data_list[0]
+
+          if type == 'timestamps'
+            timestamps_list = timestamps(column_data_list[1..])
+            result_list.push(*timestamps_list)
+            next
+          end
+
+          name = column_data_list[1]&.sub(/^:/, '')
+          null, limit, default, comment = constraints(column_data_list[2..])
+
+          result_list.push(%W(#{nil} #{nil} #{nil} #{nil} #{type} #{name} #{nil} #{null} #{limit} #{default} #{comment}))
+        end
+
+        result_list
+      end
+
+      # 作成・更新日時カラム追加処理
+      #
+      # @params [Array] timestamps_left_list
+      # @return [Array]
+      def timestamps(timestamps_left_list)
+        timestamps_list = []
+
+        null, limit, default, comment = constraints(timestamps_left_list)
+
+        timestamps_list.push(%W(#{nil} #{nil} #{nil} #{nil} timestamp created_at #{nil} #{null} #{limit} #{default} #{comment}))
+        timestamps_list.push(%W(#{nil} #{nil} #{nil} #{nil} timestamp updated_at #{nil} #{null} #{limit} #{default} #{comment}))
+      end
+
+      # 各制約
+      #
+      # @params [Array] left_list
+      def constraints(left_list)
+        return if left_list.nil? || left_list.empty?
+
+        temp_constraint_list = left_list.map { |column_data| column_data.gsub(/:|'/, '') }
+        constraints = temp_constraint_list.each_slice(2).to_h
+
+        %W(#{constraints['null']} #{constraints['limit']} #{constraints['default']} #{constraints['comment']})
+      end
+    end
+  end
+end

data/lib/nicker_pocker/grouping.rb

@@ -0,0 +1,82 @@
+# テーブルごとにグループ化
+module NickerPocker
+  class Grouping
+    class << self
+      def exec(data_list, options = {})
+        new(options).run(data_list)
+      end
+    end
+
+    # options[:target_tables]
+    # options[:target_files]
+    def initialize(options)
+      @options = options
+    end
+
+    # 実行
+    #
+    # @params [Array] data_list
+    # @return [Hash]
+    def run(data_list)
+      return {} if data_list.length == 0
+
+      # テーブルごとにまとめる
+      grouping(data_list)
+    end
+
+    private
+
+    # テーブルごと・メソッドごとにグルーピング
+    #
+    # @params [Array] data_list
+    # @return [Hash]
+    def grouping(data_list)
+      temp_group_list = data_list.map { |data| data.map { |row| format_raw_data(row) } }.flatten
+
+      groups = {}
+      temp_group_list.each do |temp_group|
+        table_name = temp_group.first.first
+        methods = temp_group.first[1]
+        method_name = methods.keys.first
+
+        groups[table_name] = {} unless groups[table_name]
+        groups[table_name][method_name] = [] unless groups[table_name][method_name]
+
+        groups[table_name][method_name].push(methods.values.first)
+      end
+
+      # 出力対象を絞る
+      groups.each { |group| group.delete(group[0]) }
+      groups
+    end
+
+    # データを整形
+    def format_raw_data(data)
+      # メソッド・対象テーブルを取得
+      tables = {}
+      methods = {}
+
+      target_method = target_method(data.first).to_sym
+      return unless target_method
+
+      method_row = data.first.split(/,/)
+      table_name = method_row[0].split(/\s/)[1].sub(/^:/, '').to_sym
+
+      method_contents = data.length > 1 ? data[1..] : method_row[1..]
+      method_contents = method_contents.map { |content| content.strip.sub(/^:/, '') }.reject(&:empty?)
+
+      methods[target_method] = method_contents
+
+      tables[table_name] = methods
+      tables
+    end
+
+    def target_method(str)
+      MIGRATE_METHODS.each do |method_name|
+        return method_name if /#{method_name.to_s}/.match(str)
+      end
+
+      return
+    end
+  end
+end

data/lib/nicker_pocker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NickerPocker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/nicker_pocker.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
-
-require_relative "nicker_pocker/version"
+require_relative 'nicker_pocker/format/operator'
+require_relative 'nicker_pocker/format/prototype'
+require_relative 'nicker_pocker/format/detail'
+require_relative 'nicker_pocker/command'
+require_relative 'nicker_pocker/grouping'
 
 module NickerPocker
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nicker_pocker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ms919
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-15 00:00:00.000000000 Z
+date: 2023-06-10 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -21,10 +21,16 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/nicker_pocker.rb
+- lib/nicker_pocker/command.rb
+- lib/nicker_pocker/format/detail.rb
+- lib/nicker_pocker/format/operator.rb
+- lib/nicker_pocker/format/prototype.rb
+- lib/nicker_pocker/grouping.rb
 - lib/nicker_pocker/version.rb
 - nicker_pocker.gemspec
 - sig/nicker_pocker.rbs