zakuro 0.6.1 → 0.8.0

data/lib/zakuro/operation/month/parser.rb

@@ -15,199 +15,203 @@ module Zakuro
     # TypeParser 型ごと変換
     #
     module TypeParser
-      #
-      # 無効値かを判定する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [True] 無効値
-      # @return [False] 有効値
-      #
-      def self.invalid?(str:)
-        str == '-'
-      end
-
-      def self.text(str:)
-        return '' if invalid?(str: str)
-
-        str
-      end
+      class << self
+        #
+        # 無効値かを判定する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [True] 無効値
+        # @return [False] 有効値
+        #
+        def invalid?(str:)
+          str == '-'
+        end
 
-      #
-      # 有効行を変換する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [True] 有効
-      # @return [False] 無効
-      #
-      def self.modified?(str:)
-        str == 'true'
-      end
+        def text(str:)
+          return '' if invalid?(str: str)
 
-      #
-      # 月を変換する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [Integer] 月
-      #
-      def self.month_number(str:)
-        return -1 if invalid?(str: str)
-
-        str.to_i
-      end
+          str
+        end
 
-      #
-      # 閏有無を変換する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [True] 閏あり
-      # @return [True] 閏なし/閏設定なし
-      #
-      def self.month_leaped(str:)
-        str == 'true'
-      end
+        #
+        # 有効行を変換する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [True] 有効
+        # @return [False] 無効
+        #
+        def modified?(str:)
+          str == 'true'
+        end
 
-      #
-      # 西暦日を変換する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [Western::Calendar] 西暦日
-      #
-      def self.western_date(str:)
-        return Western::Calendar.new if invalid?(str: str)
+        #
+        # 月を変換する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [Integer] 月
+        #
+        def month_number(str:)
+          return -1 if invalid?(str: str)
+
+          str.to_i
+        end
 
-        Western::Calendar.parse(str: str)
-      end
+        #
+        # 閏有無を変換する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [True] 閏あり
+        # @return [True] 閏なし/閏設定なし
+        #
+        def month_leaped(str:)
+          str == 'true'
+        end
 
-      #
-      # 日（差分）を変換する
-      #
-      # @param [String] str 文字列
-      #
-      # @return [Integer] 日（差分）
-      #
-      def self.days(str:)
-        return INVALID_DAY_VALUE if invalid?(str: str)
+        #
+        # 西暦日を変換する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [Western::Calendar] 西暦日
+        #
+        def western_date(str:)
+          return Western::Calendar.new if invalid?(str: str)
+
+          Western::Calendar.parse(text: str)
+        end
 
-        str.to_i
-      end
+        #
+        # 日（差分）を変換する
+        #
+        # @param [String] str 文字列
+        #
+        # @return [Integer] 日（差分）
+        #
+        def days(str:)
+          return INVALID_DAY_VALUE if invalid?(str: str)
+
+          str.to_i
+        end
 
-      def self.solar_term_index(str:)
-        return -1 if invalid?(str: str)
+        def solar_term_index(str:)
+          return -1 if invalid?(str: str)
 
-        str.to_i
-      end
+          str.to_i
+        end
+    end
     end
 
     #
     # MonthParser 月情報解析（yaml）
     #
     module MonthParser
-      #
-      # 実行する
-      #
-      # @return [Array<MonthHistory>] 変更履歴
-      #
-      def self.run(filepath:)
-        hash = YAML.load_file(filepath)
-
-        failed = Validator.run(yaml_hash: hash)
-
-        raise ArgumentError, failed.join("\n") unless failed.empty?
-
-        load(yaml_hash: hash)
-      end
+      class << self
+        #
+        # 実行する
+        #
+        # @return [Array<MonthHistory>] 変更履歴
+        #
+        # @raise [ArgumentError] 引数エラー
+        #
+        def run(filepath:)
+          hash = YAML.load_file(filepath)
+
+          failed = Validator.run(yaml_hash: hash)
+
+          raise ArgumentError, failed.join("\n") unless failed.empty?
+
+          load(yaml_hash: hash)
+        end
 
-      #
-      # 設定ファイルを読み込む
-      #
-      # @param [Hash] yaml_hash 設定ファイルテキスト
-      #
-      # @return [Array<MonthHistory>] 変更履歴
-      #
-      def self.load(yaml_hash: {})
-        histories = create_histories(yaml_hash: yaml_hash)
+        #
+        # 設定ファイルを読み込む
+        #
+        # @param [Hash] yaml_hash 設定ファイルテキスト
+        #
+        # @return [Array<MonthHistory>] 変更履歴
+        #
+        def load(yaml_hash: {})
+          histories = create_histories(yaml_hash: yaml_hash)
 
-        annotation_parser = AnnotationParser.new(yaml_hash: yaml_hash)
-        annotation_parser.create
+          annotation_parser = AnnotationParser.new(yaml_hash: yaml_hash)
+          annotation_parser.create
 
-        add_annotations(histories: histories, annotation_parser: annotation_parser)
-      end
+          add_annotations(histories: histories, annotation_parser: annotation_parser)
+        end
 
-      #
-      # 変更履歴を読み込む
-      #
-      # @param [Hash] yaml_hash 設定ファイルテキスト
-      #
-      # @return [Array<MonthHistory>] 変更履歴
-      #
-      def self.create_histories(yaml_hash: {})
-        result = []
-        yaml_hash.each do |month|
-          next unless Operation::TypeParser.modified?(str: month['modified'])
+        private
+
+        #
+        # 変更履歴を読み込む
+        #
+        # @param [Hash] yaml_hash 設定ファイルテキスト
+        #
+        # @return [Array<MonthHistory>] 変更履歴
+        #
+        def create_histories(yaml_hash: {})
+          result = []
+          yaml_hash.each do |month|
+            next unless Operation::TypeParser.modified?(str: month['modified'])
+
+            result.push(
+              create_history(yaml_hash: month)
+            )
+          end
+          result
+        end
 
-          result.push(
-            create_history(yaml_hash: month)
-          )
+        def create_history(yaml_hash: {})
+          diffs = MonthDiffsParser.create(yaml_hash: yaml_hash['diffs'])
+
+          western_date = Operation::TypeParser.western_date(str: yaml_hash['western_date'])
+          reference = Reference.new(page: yaml_hash['page'].to_i, number: yaml_hash['number'].to_i,
+                                    japan_date: yaml_hash['japan_date'])
+          MonthHistory.new(id: yaml_hash['id'],
+                           parent_id: Operation::TypeParser.text(str: yaml_hash['parent_id']),
+                           reference: reference,
+                           western_date: western_date,
+                           diffs: diffs)
         end
-        result
-      end
-      private_class_method :create_histories
-
-      def self.create_history(yaml_hash: {})
-        diffs = MonthDiffsParser.create(yaml_hash: yaml_hash['diffs'])
-
-        western_date = Operation::TypeParser.western_date(str: yaml_hash['western_date'])
-        reference = Reference.new(page: yaml_hash['page'].to_i, number: yaml_hash['number'].to_i,
-                                  japan_date: yaml_hash['japan_date'])
-        MonthHistory.new(id: yaml_hash['id'],
-                         parent_id: Operation::TypeParser.text(str: yaml_hash['parent_id']),
-                         reference: reference,
-                         western_date: western_date,
-                         diffs: diffs)
-      end
-      private_class_method :create_history
-
-      def self.add_annotations(annotation_parser:, histories: [])
-        result = []
-        histories.each do |history|
-          id = history.id
-          result.push(
-            MonthHistory.new(
-              id: id, parent_id: history.parent_id, reference: history.reference,
-              western_date: history.western_date,
-              annotations: annotation_parser.specify(id: id),
-              diffs: history.diffs
+
+        def add_annotations(annotation_parser:, histories: [])
+          result = []
+          histories.each do |history|
+            id = history.id
+            result.push(
+              MonthHistory.new(
+                id: id, parent_id: history.parent_id, reference: history.reference,
+                western_date: history.western_date,
+                annotations: annotation_parser.specify(id: id),
+                diffs: history.diffs
+              )
             )
-          )
-        end
+          end
 
-        result
-      end
-      private_class_method :add_annotations
-
-      def self.create_history_annnotations(history:, annotations: {}, relations: {})
-        history_id = history.id
-        history_annotations = []
-        [history_id, relations.fetch(history_id, '')].each do |id|
-          add_annotation(history_annotations: history_annotations,
-                         annotations: annotations, id: id)
+          result
         end
 
-        history_annotations
-      end
+        def create_history_annnotations(history:, annotations: {}, relations: {})
+          history_id = history.id
+          history_annotations = []
+          [history_id, relations.fetch(history_id, '')].each do |id|
+            add_annotation(history_annotations: history_annotations,
+                           annotations: annotations, id: id)
+          end
 
-      def self.add_annotation(history_annotations: [], annotations: {}, id: '')
-        annotation = annotations.fetch(id, Annotation.new)
-        return if annotation.invalid?
+          history_annotations
+        end
 
-        history_annotations.push(annotation)
+        def add_annotation(history_annotations: [], annotations: {}, id: '')
+          annotation = annotations.fetch(id, Annotation.new)
+          return if annotation.invalid?
+
+          history_annotations.push(annotation)
+        end
       end
-      private_class_method :add_annotation
     end
 
     #
@@ -236,31 +240,33 @@ module Zakuro
       def create
         @yaml_hash.each do |month|
           AnnotationParser.resolve_history(
-            hash: month, annotations: @annotations, relations: @relations
+            hash: month, annotations: annotations, relations: relations
           )
         end
       end
 
-      #
-      # 月別履歴情報から注釈情報を取り出す
-      #
-      # @param [<Type>] hash 月別履歴情報yaml
-      # @param [Hash<String, Annotation>] annotations 注釈
-      # @param [Hash<String, String>] relations 関連注釈の対応関係
-      #
-      def self.resolve_history(hash: {}, annotations: {}, relations: {})
-        id = hash['id']
-        annotations[id] = Annotation.new(
-          id: id,
-          description: Operation::TypeParser.text(str: hash['description']),
-          note: Operation::TypeParser.text(str: hash['note'])
-        )
-        relation_id = hash['relation_id']
-
-        return if Operation::TypeParser.invalid?(str: relation_id)
-
-        relations[id] = relation_id
-      end
+      class << self
+        #
+        # 月別履歴情報から注釈情報を取り出す
+        #
+        # @param [<Type>] hash 月別履歴情報yaml
+        # @param [Hash<String, Annotation>] annotations 注釈
+        # @param [Hash<String, String>] relations 関連注釈の対応関係
+        #
+        def resolve_history(hash: {}, annotations: {}, relations: {})
+          id = hash['id']
+          annotations[id] = Annotation.new(
+            id: id,
+            description: Operation::TypeParser.text(str: hash['description']),
+            note: Operation::TypeParser.text(str: hash['note'])
+          )
+          relation_id = hash['relation_id']
+
+          return if Operation::TypeParser.invalid?(str: relation_id)
+
+          relations[id] = relation_id
+        end
+    end
 
       #
       # 注釈を特定する
@@ -293,7 +299,7 @@ module Zakuro
       end
 
       def annotation(id: '')
-        @annotations.fetch(id, Annotation.new)
+        annotations.fetch(id, Annotation.new)
       end
     end
 
@@ -301,73 +307,70 @@ module Zakuro
     # MonthDiffsParser 月情報（差分）解析
     #
     module MonthDiffsParser
-      def self.create(yaml_hash: {})
-        Diffs.new(
-          month: create_month(yaml_hash: yaml_hash['month']),
-          solar_term: create_solar_term(yaml_hash: yaml_hash['solar_term']),
-          days: Operation::TypeParser.days(str: yaml_hash['days'])
-        )
-      end
+      class << self
+        def create(yaml_hash: {})
+          Diffs.new(
+            month: create_month(yaml_hash: yaml_hash['month']),
+            solar_term: create_solar_term(yaml_hash: yaml_hash['solar_term']),
+            days: Operation::TypeParser.days(str: yaml_hash['days'])
+          )
+        end
 
-      def self.create_solar_term(yaml_hash: {})
-        SolarTerm::Direction.new(
-          source: create_source_solar_term(yaml_hash: yaml_hash['calc']),
-          destination: create_destination_solar_term(yaml_hash: yaml_hash['actual']),
-          days: Operation::TypeParser.days(str: yaml_hash['days'])
-        )
-      end
-      private_class_method :create_solar_term
-
-      def self.create_source_solar_term(yaml_hash: {})
-        SolarTerm::Source.new(
-          index: Operation::TypeParser.solar_term_index(str: yaml_hash['index']),
-          to: Operation::TypeParser.western_date(str: yaml_hash['to']),
-          zodiac_name: Operation::TypeParser.text(str: yaml_hash['zodiac_name'])
-        )
-      end
-      private_class_method :create_source_solar_term
-
-      def self.create_destination_solar_term(yaml_hash: {})
-        SolarTerm::Destination.new(
-          index: Operation::TypeParser.solar_term_index(str: yaml_hash['index']),
-          from: Operation::TypeParser.western_date(str: yaml_hash['from']),
-          zodiac_name: Operation::TypeParser.text(str: yaml_hash['zodiac_name'])
-        )
-      end
-      private_class_method :create_destination_solar_term
-
-      def self.create_month(yaml_hash: {})
-        Month.new(
-          number: create_month_number(yaml_hash: yaml_hash['number']),
-          leaped: create_month_leaped(yaml_hash: yaml_hash['leaped']),
-          is_many_days: create_month_day(yaml_hash: yaml_hash['days'])
-        )
-      end
-      private_class_method :create_month
+        private
 
-      def self.create_month_number(yaml_hash: {})
-        Number.new(
-          calc: Operation::TypeParser.month_number(str: yaml_hash['calc']),
-          actual: Operation::TypeParser.month_number(str: yaml_hash['actual'])
-        )
-      end
-      private_class_method :create_month_number
+        def create_solar_term(yaml_hash: {})
+          SolarTerm::Direction.new(
+            source: create_source_solar_term(yaml_hash: yaml_hash['src']),
+            destination: create_destination_solar_term(yaml_hash: yaml_hash['dest']),
+            days: Operation::TypeParser.days(str: yaml_hash['days'])
+          )
+        end
 
-      def self.create_month_leaped(yaml_hash: {})
-        Leaped.new(
-          calc: Operation::TypeParser.month_leaped(str: yaml_hash['calc']),
-          actual: Operation::TypeParser.month_leaped(str: yaml_hash['actual'])
-        )
-      end
-      private_class_method :create_month_leaped
+        def create_source_solar_term(yaml_hash: {})
+          SolarTerm::Source.new(
+            index: Operation::TypeParser.solar_term_index(str: yaml_hash['index']),
+            to: Operation::TypeParser.western_date(str: yaml_hash['to']),
+            zodiac_name: Operation::TypeParser.text(str: yaml_hash['zodiac_name'])
+          )
+        end
 
-      def self.create_month_day(yaml_hash: {})
-        Days.new(
-          calc: yaml_hash['calc'],
-          actual: yaml_hash['actual']
-        )
+        def create_destination_solar_term(yaml_hash: {})
+          SolarTerm::Destination.new(
+            index: Operation::TypeParser.solar_term_index(str: yaml_hash['index']),
+            from: Operation::TypeParser.western_date(str: yaml_hash['from']),
+            zodiac_name: Operation::TypeParser.text(str: yaml_hash['zodiac_name'])
+          )
+        end
+
+        def create_month(yaml_hash: {})
+          Month.new(
+            number: create_month_number(yaml_hash: yaml_hash['number']),
+            leaped: create_month_leaped(yaml_hash: yaml_hash['leaped']),
+            is_many_days: create_month_day(yaml_hash: yaml_hash['days'])
+          )
+        end
+
+        def create_month_number(yaml_hash: {})
+          Number.new(
+            src: Operation::TypeParser.month_number(str: yaml_hash['src']),
+            dest: Operation::TypeParser.month_number(str: yaml_hash['dest'])
+          )
+        end
+
+        def create_month_leaped(yaml_hash: {})
+          Leaped.new(
+            src: Operation::TypeParser.month_leaped(str: yaml_hash['src']),
+            dest: Operation::TypeParser.month_leaped(str: yaml_hash['dest'])
+          )
+        end
+
+        def create_month_day(yaml_hash: {})
+          Days.new(
+            src: yaml_hash['src'],
+            dest: yaml_hash['dest']
+          )
+        end
       end
-      private_class_method :create_month_day
     end
   end
 end