uniprop 0.1.0

data/lib/uniprop/metadata_validator.rb

@@ -0,0 +1,282 @@
+module UniProp
+  class MetaDataValidator
+    attr_reader :metadata
+
+    # @param [MetaData] metadata
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    # メタデータが記述されているバージョンすべてで検証を実行
+    def validate
+      metadata.prop_data.versions.each do |version|
+        if version.has_version_metadata?
+          version.version_metadata.version_metadata_validator.run_all_validations
+        end
+      end
+    end
+  end
+
+  class VersionMetaDataValidator
+    attr_reader :version_metadata, :version
+
+    def initialize(version_metadata)
+      @version_metadata = version_metadata
+      @version = @version_metadata.version
+
+      # validate_files_shortage, validate_files_excessでは、実際のキャッシュとメタデータを照らし合わせて検証を行う必要があるため、@versionはEfficientVersionではなくVersionでなければならない。
+      if @version.class != Version
+        raise TypeError, "The argument must be a VersionMetaData object associated with Version object (not EfficientVersion)"
+      end
+    end
+
+    # 全ての検証を実行
+    def run_all_validations
+      puts "== validation results for version #{version.version_name} =="
+      validate_files_shortage(reconfirm: true)
+      validate_files_excess(reconfirm: false)
+      validate_properties_shortage
+      validate_properties_excess
+      validate_row_perfection
+      validate_column_perfection
+      validate_type
+
+      if version.has_unihan?
+        validate_unihan_properties_shortage
+        validate_unihan_properties_excess
+      end
+    end
+    
+    # メタデータの記述が不足しているファイルを取得
+    # @return [Set<PropFile>]
+    def metadata_insufficient_files
+      return @metadata_insufficient_files if @metadata_insufficient_files
+
+      @metadata_insufficient_files = version.files.reject{_1.is_meta_file?} - version_metadata.actual_propfiles
+
+      @metadata_insufficient_files
+    end
+
+    # メタデータ内で記述が不足しているファイルを標準出力に出力
+    def validate_files_shortage(reconfirm: false)
+      version.files(reconfirm: reconfirm, reload: reconfirm) if reconfirm
+      
+      if metadata_insufficient_files.empty?
+        puts "All files are described in the metadata"
+      else
+        puts "Files that are not described in the metadata"
+        metadata_insufficient_files.each { puts "・#{_1.basename_prefix}" }
+      end
+    end
+
+    # メタデータ内に余分に記述されたファイル(実際には存在しないにも関わらず、メタデータに記述されたファイル)を標準出力に出力
+    def validate_files_excess(reconfirm: false)
+      version.files(reconfirm: reconfirm, reload: reconfirm) if reconfirm
+
+      nonexist_files = version_metadata.propfile_names.filter { !version.has_file?(_1) }
+
+      if nonexist_files.empty?
+        puts "There are no excessive files in the metadata."
+      else
+        puts "Files that are described in the metadata even though it does not actually exist"
+        nonexist_files.each { puts "・#{_1}" }
+      end
+    end
+
+    # メタデータ内で記述が不足しているプロパティを標準出力に出力
+    def validate_properties_shortage
+      metadata_insufficient_properties = version.properties - version_metadata.actual_properties
+
+      if metadata_insufficient_properties.empty?
+        puts "All properties are described in the metadata"
+      else
+        puts "Properties that not described in the metadata"
+        metadata_insufficient_properties.each { puts "・#{_1.longest_alias}" }
+      end
+    end
+
+    # メタデータ内に余分に記述されたプロパティ(実際には存在しないにも関わらず、メタデータに記述されたプロパティ)を標準出力に出力
+    def validate_properties_excess
+      nonexist_props = version_metadata.property_names
+        .reject { _1=="" || _1=="codepoint" }
+        .reject { version.has_property?(_1) }
+      
+      if nonexist_props.empty?
+        puts "There are no excessive properties in the metadata."
+      else
+        puts "Properties that's described in the metadata even though it does not actually exist"
+        nonexist_props.each { puts "・#{_1}" }
+      end
+    end
+
+    # information_containing_rangesのうち、block_rangesに含まれていない範囲を返す
+    # @param [Array<Range<Integer>>] block_ranges
+    # @param [Array<Range<Integer>>] information_containing_ranges
+    # @return [Array<Range<Integer>>]
+    def metadata_insufficient_ranges(block_ranges, information_containing_ranges)
+      result = information_containing_ranges
+      block_ranges.each do |block_range|
+        pre_result = result
+        result = []
+        pre_result.each { result.concat(UniPropUtils::RangeProcessor.cut_internal(_1, block_range.begin, block_range.end)) }
+      end      
+      result
+    end
+
+    # 各PropFileの、メタデータに記述されていない行の範囲を取得
+    # @return [Hash<PropFile,Array<Range>]
+    def propfile_to_metadata_insufficient_ranges
+      return @propfile_to_metadata_insufficient_ranges if @propfile_to_metadata_insufficient_ranges
+
+      @propfile_to_metadata_insufficient_ranges = Hash.new { |hash,key| hash[key]=[] }
+
+      version_metadata.propfile_metadatas.each do |propfile_metadata|
+        propfile = propfile_metadata.propfile
+
+        @propfile_to_metadata_insufficient_ranges[propfile] = metadata_insufficient_ranges(propfile_metadata.property_written_ranges, propfile.information_containing_ranges)
+      end
+      
+      @propfile_to_metadata_insufficient_ranges
+    end
+
+    # メタデータに記述されていない行の範囲が存在するファイルを標準出力に出力(Unihan, メタデータが記述されていないファイルを除く)
+    def validate_row_perfection      
+      if propfile_to_metadata_insufficient_ranges.all? { _2.empty? }
+        puts "There are no files for which a file name is described in the metadata but for which this information is missing."
+      else
+        puts "Ranges where metadata is missing in propfiles"
+        propfile_to_metadata_insufficient_ranges.each do |propfile, insufficient_ranges|
+          if !insufficient_ranges.empty?
+            puts "・#{propfile.basename_prefix}"
+  
+            insufficient_ranges.each do |range|
+              if range.size==1
+                puts "\t#{range.begin}"
+              else
+                puts "\t#{range.begin} to #{range.end}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # 実際の列数とメタデータに記述されている列数に違いがあるファイルを標準出力に出力
+    def validate_column_perfection
+      error_logs = []
+      version_metadata.propfile_metadatas.each do |propfile_metadata|
+        propfile_metadata.blocks.each_with_index do |block, block_no|
+          metadata_col_size = block.content.size
+          actual_col_size = propfile_metadata.propfile.max_column_size(block.range)
+
+          if metadata_col_size != actual_col_size
+            error_logs << "#{propfile_metadata.propfile.basename_prefix} (in block #{block_no})\n\tmetadata column size: #{metadata_col_size}\n\tactual column size: #{actual_col_size}"
+          end
+        end
+      end
+
+      if error_logs.empty?
+        puts "There are no difference in column size between the metadata and the actual description in all files"
+      else
+        puts "Files that the number of columns differs between the metadata and the actual description"
+        error_logs.each { puts _1 }
+      end
+    end
+
+    # validate_typeで出力するための理想の型の名称を取得
+    # @param [Property] prop
+    # @return [String]
+    def expected_type(prop)
+      type = prop.property_value_type
+
+      case type
+      when :string, :numeric
+        return type
+      when :binary, :catalog, :enumerated
+        return "#{type} (#{prop.longest_alias})"
+      when :miscellaneous
+        return prop.miscellaneous_format
+      end
+    end
+    
+    # メタデータと実際のファイルで、記述されているべき値の型に違いがある箇所を出力
+    MismatchPosition = Struct.new(:propfile, :column, :expected_type, :row_ranges)
+    def validate_type
+      # 違いがある箇所を検出
+      mismatches = []
+
+      version_metadata.propfile_metadatas.each do |propfile_metadata|
+        propfile = propfile_metadata.propfile
+
+        propfile_metadata.blocks.each do |block|
+          block.content.each_with_index do |prop, col|
+            # 列の値がArrayを使用して記述されている場合、検証をスキップする
+            next if !prop || prop.class==Array
+
+            mismatch_row_ranges = UniPropUtils::RangeProcessor.sub(
+              block.range,
+              propfile.verbose_property_value_type_match_ranges(col, prop)
+            )
+            
+            if !mismatch_row_ranges.empty?
+              mismatches << MismatchPosition.new(propfile, col, expected_type(prop), mismatch_row_ranges)
+            end
+          end
+        end
+      end
+
+      # 検出結果を出力
+      if mismatches.empty?
+        puts "In all blocks in the metadata, the type of the property described in the block matches the type of the values in the actual file."
+      else
+        mismatches.each do |mismatch|
+          puts "According to the metadata, column #{mismatch.column} in #{mismatch.propfile.basename_prefix} should be #{mismatch.expected_type} value, but the following line is wrong."
+
+          mismatch.row_ranges.each do |range|
+            if range.size==1
+              puts "\t#{range.begin}"
+            else
+              puts "\t#{range.begin} to #{range.end}"
+            end
+          end
+        end
+      end
+    end
+
+    # メタデータに記述が不足しているUnihanプロパティを出力
+    def validate_unihan_properties_shortage
+      metadata_insufficient_properties = []
+
+      version.unihanprop.unihan_properties.each do |prop|
+        if version_metadata.unihan_property_names.all? { !prop.has_alias?(_1) }
+          metadata_insufficient_properties << prop
+        end
+      end
+
+      if metadata_insufficient_properties.empty?
+        puts "All Unihan properties are described in the metadata"
+      else
+        puts "Unihan properties that's not described in the metadata"
+        metadata_insufficient_properties.each { puts "・#{_1.longest_alias}" }
+      end
+    end
+
+    # メタデータ内に余分に記述されたUnihanプロパティ(実際には存在しないにも関わらず、メタデータに記述されたUnihanプロパティ)を出力
+    def validate_unihan_properties_excess
+      nonexist_prop_names = []
+
+      version_metadata.unihan_property_names.each do |prop_name|
+        if version.unihanprop.unihan_properties.all? { !_1.has_alias?(prop_name) }
+          nonexist_prop_names << prop_name
+        end
+      end
+    
+      if nonexist_prop_names.empty?
+        puts "There are no excessive Unihan properties in the metadata."
+      else
+        puts "Unihan properties that's described in the metadata even though it does not actually exist"
+        nonexist_prop_names.each { puts "・#{_1}" }
+      end
+    end
+  end
+end

data/lib/uniprop/propdata.rb

@@ -0,0 +1,293 @@
+module UniProp
+  class PropData
+    attr_reader :excluded_extensions, :excluded_directories, :excluded_files, :metadata_path
+    attr_accessor :cache_path, :settings
+    
+    # @note VersionMetaDataRecreator#output_metadata_revising_hintsなど、2つ以上のメタデータを使用して処理を行う場合がある。そのような場合に対応するため、PropDataは1つのsettings.rbと1つのメタデータを使用し、Unicodeのファイル全体を扱うためのクラスとした。
+    def initialize(settings_path, metadata_path=nil)
+      @settings = Settings.new(settings_path)
+      cache_path_str = ENV["UniPropCache"] || @settings.cache_path
+      @cache_path = Pathname.new(cache_path_str).cleanpath.expand_path
+      @metadata_path = metadata_path
+    end
+
+    # unicode.orgから存在するバージョンの一覧を取得し、それを元にVersionオブジェクトを作成する
+    # @note メタデータが紐づけられていればその情報を使用し、紐づけられていなければUnicode.orgから情報を取得
+    # @param [Boolean] update trueの場合バージョン一覧を再取得
+    # @return [Set<Version>]
+    def versions(update: false)
+      return @versions if @versions && !update
+
+      @versions = Set.new
+
+      if has_metadata?
+        metadata.version_names(update_metadata: true, confirm: update).each { @versions << Version.new(self, _1) }
+      else
+        UniPropUtils::DownloaderWrapper.get_version_names.each { @versions << Version.new(self, _1) }
+      end
+
+      @versions
+    end
+
+    # @return [EfficientVersion]
+    def find_efficient_version(version_name)
+      weight = Version.name_to_weight(version_name)
+      @weight_to_efficient_version ||= {}
+      return @weight_to_efficient_version[weight] if @weight_to_efficient_version[weight]
+
+      if metadata.version_names.map { Version.name_to_weight(_1) }.include?(weight)
+        @weight_to_efficient_version[weight] = EfficientVersion.new(self, version_name)
+      else
+        raise VersionNotMatchedError, "version #{version_name} is not exists"
+      end
+
+      @weight_to_efficient_version[weight]
+    end
+
+    # @param [String] version_name
+    # @param [Boolean] reconfirm trueの場合、version_nameに対応するバージョンが見つからない時にバージョン一覧を取得する
+    # @return [Version]
+    def find_version(version_name, reconfirm: true)
+      parsed_version_name = Version.parse(version_name)
+          
+      versions.each do |version|
+        if version.major == parsed_version_name[:major] && version.minor == parsed_version_name[:minor] && version.tiny == parsed_version_name[:tiny] 
+          return version
+        end
+      end
+
+      # 一致するバージョンが見つからなかった場合
+      if reconfirm
+        versions(update: true) # バージョン一覧を更新
+        find_version(version_name, reconfirm: false)
+      else
+        raise VersionNotMatchedError
+      end
+    end
+
+    # vesionsのうち、最も古いバージョンを取得
+    # @return [Version]
+    def oldest_version
+      versions.sort_by { _1.weight } .first
+    end
+
+    # versionsのうち、最も新しいバージョンを取得
+    # @return [Version]
+    def latest_version
+      versions.sort_by { _1.weight } .last
+    end
+
+    # @return [Metadata]
+    # @raise [MetaDataNotFoundError] PropDataのinitialize時にmetadata_pathを指定していない場合に発生
+    def metadata
+      return @metadata if @metadata
+
+      if metadata_path
+        @metadata = MetaData.new(self, metadata_path)
+        return @metadata
+      else
+        raise(MetaDataNotFoundError, "This PropData object doesn't have metadata path.")
+      end
+    end
+
+    # @return [EfficientMetadata]
+    # @raise [MetaDataNotFoundError] PropDataのinitialize時にmetadata_pathを指定していない場合に発生
+    def efficient_metadata
+      return @efficient_metadata if @efficient_metadata
+
+      if metadata_path
+        @efficient_metadata = EfficientMetaData.new(self, metadata_path)
+        return @efficient_metadata
+      else
+        raise(MetaDataNotFoundError, "This PropData object doesn't have metadata path.")
+      end
+    end
+
+    # PropDataがメタデータに紐づけられているかを判定
+    def has_metadata?
+      !!metadata rescue false
+    end
+
+    # version1とversion2の間で、ファイル名(basename_prefix)が同じPropFileのハッシュを作成
+    # @param [Version] version1 キーとされるバージョン
+    # @param [Version] version2 値とされるバージョン
+    # @return [Hash<PropFile, PropFile>]
+    def file_correspondence(version1, version2)
+      return @file_correspondences[version1][version2] if @file_correspondences&&@file_correspondences[version1]&&@file_correspondences[version1][version2]
+
+      propfile_to_same_name_propfile = {}
+      version1.files.each do |f1|
+        version2.files.each do |f2|
+          if Alias.canonical(f1.basename_prefix)==Alias.canonical(f2.basename_prefix)
+            propfile_to_same_name_propfile[f1] = f2
+            break # 1つのバージョン内にbasename_prefixが同じファイルは2つ以上無いので、1つ見つかった段階でbreakする
+          end
+        end
+      end
+
+      @file_correspondences ||= {}
+      @file_correspondences[version1] ||= {}
+      @file_correspondences[version1][version2] = propfile_to_same_name_propfile
+
+      @file_correspondences[version1][version2]
+    end
+
+    # metadata_pathのファイルをnew_metadataの内容に上書き
+    # @param [Array/Hash] new_metadata JSONとして解釈できるオブジェクト
+    # @raise [MetaDataNotFoundError] PropDataがメタデータに関連付けられていない場合に発生
+    def update_metadata(new_metadata)
+      if metadata_path && metadata_path.exist?
+        metadata_path.write(JSON.pretty_generate(new_metadata))
+      else
+        raise MetaDataNotFoundError
+      end
+    end
+
+    # @return [UnicodeManager]
+    def unicode_manager
+      @unicode_manager ||= UnicodeManager.new(self)
+    end
+
+    # @param [String] version_name
+    # @return [VersionManager]
+    def version_manager(version_name)
+      vm = version_managers.find { _1.version.weight==Version.name_to_weight(version_name) }
+      
+      vm || raise(MetaDataNotFoundError, "MetaData for #{version_name} is not found.")
+    end
+
+    # メタデータに含まれる全バージョンのVersionManagerを作成
+    # @return [Array<VersionManager>]
+    def version_managers
+      return @version_managers if @version_managers
+      
+      @version_managers = metadata.version_names
+                            .filter { metadata.has_raw_version_metadata?(_1) }
+                            .map { find_efficient_version(_1) }
+                            .map { VersionManager.new(_1) }
+
+      @version_managers
+    end
+
+    # @param [Pathname] path
+    # @note pathが指定されていない場合、メタデータの先頭にproperty_をつけたファイルを使用
+    # @return [PropertyMetadata]
+    # @raise [MetaDataNotFoundError] pathが指定されているがそのpathが存在しない場合に発生
+    def property_metadata(path=nil)
+      return @property_metadata if @property_metadata
+
+      select_path = !!path
+      path ||= metadata_path.parent / ("property_"+metadata_path.basename.to_s)
+
+      if !path.exist?
+        if select_path
+          raise MetaDataNotFoundError, "#{path} is not found."
+        else
+          path.write([])
+        end
+      end
+
+      @property_metadata = PropertyMetaData.new(self, path)
+    end
+  end
+
+  # 設定ファイルから値を取得するためのクラス
+  class Settings
+    attr_reader :setting_names
+  
+    # @param [Pathname] path 設定ファイルの絶対パス
+    def initialize(path)
+      require path
+      @setting_names = {
+        downloader_settings: DOWNLOADER_SETTINGS,
+        files_information: FILES_INFORMATION,
+        properties_information: PROPERTIES_INFORMATION
+      }
+    end
+  
+    # @param [Symbol] setting_name 検索する設定項目名
+    # @param [String] version 検索するバージョン名
+    # @note version==nilの場合、デフォルト値を取得
+    # @param [keys] 検索を行う経路
+    def search(setting_name, version, *keys)
+      if version
+        result = setting_names.dig(setting_name, version.to_sym, *keys)
+        return result if result
+      end
+      setting_names.dig(setting_name, :default, *keys)
+    end
+  
+    # @param [String] version
+    # @return [Pathname]
+    def cache_path(version=nil)
+      search(:downloader_settings, version, :cache_path)
+    end
+  
+    # @param [String] version
+    # @return [Array<String>]
+    def excluded_extensions(version=nil)
+      search(:downloader_settings, version, :excluded_extensions)
+    end
+  
+    # @param [String] version
+    # @return [Array<String>]
+    def excluded_directories(version=nil)
+      search(:downloader_settings, version, :excluded_directories)
+    end
+  
+    # @param [String] version
+    # @return [Array<String>]
+    def excluded_files(version=nil)
+      search(:downloader_settings, version, :excluded_files)
+    end
+  
+    # @param [String] version
+    # @return [Array<String>]
+    def included_files(version=nil)
+      search(:downloader_settings, version, :included_files)
+    end
+  
+    # @param [String] version
+    # @return [Boolean]
+    def unicode_beta(version=nil)
+      search(:downloader_settings, version, :unicode_beta)
+    end
+  
+    # @param [String] version
+    # @param [String] file
+    # @return [Hash<Symbol,String>]
+    def file_format(version, file)
+      # 優先順位
+      # (1) version, fileが両方一致する結果にマッチ
+      result = search(:files_information, version, :file_formats).find { _1[:file_name]==file }
+  
+      # (2) defaultの中でfileが一致する結果にマッチ
+      result ||= search(:files_information, nil, :file_formats).find { _1[:file_name]==file }
+  
+      # (3) default_file_formatを取得
+      result ||= search(:files_information, nil, :default_file_format)
+      result
+    end
+  
+    # @param [String] version
+    # @return [Hash<Symbol,String>]
+    def unihan_file_format(version=nil)
+      search(:files_information, version, :unihan_file_format)
+    end
+  
+    # @param [String] version
+    # @param [String] property
+    # @return [Hash<Symbol,Object>?]
+    def miscellaneous_format(version, property)
+      # 優先順位
+      # (1) version, propertyが両方マッチ
+      result = search(:properties_information, version, :miscellaneous_formats).find { _1[:property_name]==property }
+  
+      # (2) defaultのうち、propertyがマッチ
+      result ||= search(:properties_information, nil, :miscellaneous_formats).find { _1[:property_name]==property }
+      
+      # (2)までにマッチする値が存在しない場合、nilをそのまま返す
+      result
+    end
+  end
+end