wikidata-diff-analyzer 0.1.0

data/lib/wikidata/diff/claim_analyzer.rb

@@ -0,0 +1,244 @@
+class ClaimAnalyzer
+    def self.isolate_claim_differences(current_content, parent_content)
+        # Initialize empty arrays to store the added, removed, and changed claims
+        added_claims = []
+        removed_claims = []
+        changed_claims = []
+        added_references = []
+        removed_references = []
+        changed_references = []
+        added_qualifiers = []
+        removed_qualifiers = []
+        changed_qualifiers = []
+
+        if !current_content["claims"].is_a?(Hash) || !parent_content["claims"].is_a?(Hash)
+        return {
+            added_claims: added_claims,
+            removed_claims: removed_claims,
+            changed_claims: changed_claims,
+            added_references: added_references,
+            removed_references: removed_references,
+            changed_references: changed_references,
+            added_qualifiers: added_qualifiers,
+            removed_qualifiers: removed_qualifiers,
+            changed_qualifiers: changed_qualifiers
+        }
+        end
+        # Iterate over each claim key in the current content
+        current_content["claims"].each do |claim_key, current_claims|
+        # Check if the claim key exists in the parent content
+        if parent_content["claims"].key?(claim_key)
+            parent_claims = parent_content["claims"][claim_key]
+            # Iterate over each claim in the current and parent content
+            current_claims.each_with_index do |current_claim, index|
+            parent_claim = parent_claims[index]
+            if parent_claim.nil?
+                # Claim was added
+                added_claims << { key: claim_key, index: index }
+                # check if there's any references or qualifiers in this claim
+                added_references = reference_updates(current_claim, added_references, claim_key, index)
+                added_qualifiers = qualifier_updates(current_claim, added_qualifiers, claim_key, index)
+
+            elsif current_claim != parent_claim
+                # Claim was changed
+                changed_claims << { key: claim_key, index: index }
+                # check if there's any references or qualifiers in this claim
+                changed = handle_changed_references(current_claim, parent_claim, changed_references, added_references, removed_references, claim_key, index)
+                added_references = changed[:added_references]
+                removed_references = changed[:removed_references]
+                changed_references = changed[:changed_references]
+                changed_qualifiers = handle_changed_qualifiers(current_claim, parent_claim, changed_qualifiers, added_qualifiers, removed_qualifiers, claim_key, index)
+                added_qualifiers = changed_qualifiers[:added_qualifiers]
+                removed_qualifiers = changed_qualifiers[:removed_qualifiers]
+                changed_qualifiers = changed_qualifiers[:changed_qualifiers]
+            end
+            end
+            # Check for removed claims
+            parent_claims.each_with_index do |parent_claim, index|
+            current_claim = current_claims[index]
+            if current_claim.nil?
+                # Claim was removed
+                removed_claims << { key: claim_key, index: index }
+
+                # check if there's any references or qualifiers in this claim
+                removed_references = reference_updates(parent_claim, removed_references, claim_key, index)
+                removed_qualifiers = qualifier_updates(parent_claim, removed_qualifiers, claim_key, index)
+            end
+            end
+        else
+            # All claims in current content with this key were added
+            current_claims.each_index do |index|
+            added_claims << { key: claim_key, index: index }
+            # check if there's any references or qualifiers in this claim
+            added_references = reference_updates(current_claims[index], added_references, claim_key, index)
+            added_qualifiers = qualifier_updates(current_claims[index], added_qualifiers, claim_key, index)
+            end
+        end
+        end
+
+        parent_content["claims"].each do |claim_key, parent_claims|
+        # current content[claims] can be nil
+        parent_claims.each_index do |index|
+            if current_content["claims"].nil? || !current_content["claims"].key?(claim_key)
+            removed_claims << { key: claim_key, index: index }
+            # check if there's any references or qualifiers in this claim
+            removed_references = reference_updates(parent_claims[index], removed_references, claim_key, index)
+            removed_qualifiers = qualifier_updates(parent_claims[index], removed_qualifiers, claim_key, index)
+            end
+        end
+        end
+    
+        # puts "Added claims: #{added_claims}"
+        # puts "Removed claims: #{removed_claims}"
+        # puts "Changed claims: #{changed_claims}"
+        # puts "Added references: #{added_references}"
+        # puts "Removed references: #{removed_references}"
+        # puts "Changed references: #{changed_references}"
+        # puts "Added qualifiers: #{added_qualifiers}"
+        # puts "Removed qualifiers: #{removed_qualifiers}"
+        # puts "Changed qualifiers: #{changed_qualifiers}"
+
+
+        {
+        added_claims: added_claims,
+        removed_claims: removed_claims,
+        changed_claims: changed_claims,
+        added_references: added_references,
+        removed_references: removed_references,
+        changed_references: changed_references,
+        added_qualifiers: added_qualifiers,
+        removed_qualifiers: removed_qualifiers,
+        changed_qualifiers: changed_qualifiers
+        }
+    end
+
+    # helper method for adding and removing references
+    def self.reference_updates(claim, updated_references, claim_key, claim_index)
+        if claim["references"]
+        claim["references"].each_with_index do |current_ref, ref_index|
+            updated_references << { claim_key: claim_key, claim_index: claim_index, reference_index: ref_index }
+        end
+        end
+        updated_references
+    end
+
+    # helper method for changed references
+    def self.handle_changed_references(current_claim, parent_claim, changed_references, added_references, removed_references, claim_key, claim_index)
+        current_references = current_claim["references"] ? current_claim["references"] : []
+        parent_references = parent_claim["references"] ? parent_claim["references"] : []
+    
+        current_references.each_with_index do |current_ref, ref_index|
+        if parent_references.empty?
+            added_references << { claim_key: claim_key, claim_index: claim_index, reference_index: ref_index }
+        elsif !parent_references.include?(current_ref)
+            added_references << { claim_key: claim_key, claim_index: claim_index, reference_index: ref_index }
+        elsif ref_modified?(current_ref, parent_references)
+            changed_references << { claim_key: claim_key, claim_index: claim_index, reference_index: ref_index }
+        end
+        end
+    
+        parent_references.each_with_index do |parent_ref, ref_index|
+        if !current_references.include?(parent_ref)
+            removed_references << { claim_key: claim_key, claim_index: claim_index, reference_index: ref_index }
+        end
+        end
+
+        {
+        added_references: added_references,
+        removed_references: removed_references,
+        changed_references: changed_references
+        }
+    end
+
+    # helper method for checking if a reference has been modified
+    def self.ref_modified?(current_reference, parent_references)
+        parent_references.each do |parent_reference|
+        if current_reference["snaks"] != parent_reference["snaks"]
+            return true
+        end
+        end
+        false
+    end
+
+    # helper method for adding qualifiers
+    # handles added and removed qualifiers
+    def self.qualifier_updates(claim, updated_qualifiers, claim_key, claim_index)
+        if claim["qualifiers"]
+        qualifiers = claim["qualifiers"]
+        qualifiers.each do |qualifier_key, qualifier_values|
+            qualifier_values.each_with_index do |qualifier_value, qualifier_index|
+            updated_qualifiers << {
+            claim_key: claim_key,
+            claim_index: claim_index,
+            qualifier_key: qualifier_key,
+            qualifier_index: qualifier_index
+            }
+            end
+        end
+        end
+        updated_qualifiers
+    end
+
+    # helper method for changed qualifiers
+    def self.handle_changed_qualifiers(current_claim, parent_claim, changed_qualifiers, added_qualifiers, removed_qualifiers, claim_key, claim_index)
+        current_qualifiers = current_claim["qualifiers"] ? current_claim["qualifiers"] : {}
+        parent_qualifiers = parent_claim["qualifiers"] ? parent_claim["qualifiers"] : {}
+
+        current_qualifiers.each do |qualifier_key, qualifier_values|
+        qualifier_values.each_with_index do |qualifier_value, qualifier_index|
+            if parent_qualifiers.key?(qualifier_key)
+            parent = parent_qualifiers[qualifier_key]
+            end
+            # Check if the qualifier index exists in the parent content
+            if !parent.nil?
+            parent = parent[qualifier_index]
+            # check if the parent claim was changed by comparing the objects first
+            if parent != qualifier_value
+                # Claim was changed
+                changed_qualifiers << {
+                claim_key: claim_key,
+                claim_index: claim_index,
+                qualifier_key: qualifier_key,
+                qualifier_index: qualifier_index
+                }
+            end
+            else
+            # Claim was added
+            added_qualifiers << {
+                claim_key: claim_key,
+                claim_index: claim_index,
+                qualifier_key: qualifier_key,
+                qualifier_index: qualifier_index
+            }
+            end
+        end
+        end
+        # Check for removed claims
+        parent_qualifiers.each do |qualifier_key, qualifier_values|
+        qualifier_values.each_with_index do |qualifier_value, qualifier_index|
+            if current_qualifiers.key?(qualifier_key)
+            current = current_qualifiers[qualifier_key]
+            end
+            # Check if the qualifier index exists in the current content
+            if !current.nil?
+            current = current[qualifier_index]
+            end
+            if current.nil?
+            # Claim was removed
+            removed_qualifiers << {
+                claim_key: claim_key,
+                claim_index: claim_index,
+                qualifier_key: qualifier_key,
+                qualifier_index: qualifier_index
+            }
+            end
+        end
+        end
+
+        {
+        added_qualifiers: added_qualifiers,
+        removed_qualifiers: removed_qualifiers,
+        changed_qualifiers: changed_qualifiers
+        }
+    end
+end

data/lib/wikidata/diff/description_analyzer.rb

@@ -0,0 +1,49 @@
+class DescriptionAnalyzer
+    def self.isolate_descriptions_differences(current_content, parent_content)
+        return {
+        changed: [],
+        removed: [],
+        added: []
+        } if current_content.nil? && parent_content.nil?
+    
+        current_descriptions = current_content['descriptions'] || {}
+        parent_descriptions = parent_content['descriptions'] || {}
+
+    
+        changed_descriptions = []    # Initialize as an array
+        removed_descriptions = []    # Initialize as an array
+        added_descriptions = []      # Initialize as an array
+    
+        if !current_descriptions.is_a?(Hash) || !parent_descriptions.is_a?(Hash)
+        return{
+            changed: changed_descriptions,
+            removed: removed_descriptions,
+            added: added_descriptions
+        }
+        end
+
+        # Iterate over each language in the current descriptions
+        (current_descriptions || {}).each do |lang, current_description|
+        parent_description = parent_descriptions[lang]
+    
+        if parent_description.nil?
+            added_descriptions << { lang: lang }
+        elsif current_description != parent_description
+            changed_descriptions << { lang: lang }
+        end
+        end
+    
+        # Iterate over each language in the parent descriptions to find removed descriptions
+        (parent_descriptions || {}).each do |lang, parent_description|
+        if current_descriptions[lang].nil?
+            removed_descriptions << { lang: lang }
+        end
+        end
+    
+        {
+        changed: changed_descriptions,
+        removed: removed_descriptions,
+        added: added_descriptions
+        }
+    end
+end

data/lib/wikidata/diff/label_analyzer.rb

@@ -0,0 +1,53 @@
+class LabelAnalyzer
+    def self.isolate_labels_differences(current_content, parent_content)
+        return {
+        changed: [],
+        removed: [],
+        added: []
+        } if current_content.nil? && parent_content.nil?
+    
+        current_labels = current_content['labels'] || {}
+        parent_labels = parent_content['labels'] || {}
+
+        changed_labels = []
+        removed_labels = []
+        added_labels = []
+
+        if current_labels.is_a?(Array) || parent_labels.is_a?(Array)
+        return {
+        changed: changed_labels,
+        removed: removed_labels,
+        added: added_labels
+        }
+        end
+
+    
+        # Iterate over each language in the current labels
+        (current_labels || {}).each do |lang, current_label|
+        parent_label = parent_labels[lang]
+    
+        if parent_label.nil?
+            added_labels << { lang: lang }
+        elsif current_label != parent_label
+            changed_labels << { lang: lang }
+        end
+        end
+    
+        # Iterate over each language in the parent labels to find removed labels
+        (parent_labels || {}).each do |lang, parent_label|
+        if current_labels[lang].nil?
+            removed_labels << { lang: lang }
+        end
+        end
+
+        # puts "Changed labels: #{changed_labels}"
+        # puts "Removed labels: #{removed_labels}"
+        # puts "Added labels: #{added_labels}"
+    
+        {
+        changed: changed_labels,
+        removed: removed_labels,
+        added: added_labels
+        }
+    end
+end

data/lib/wikidata/diff/large_batches_analyzer.rb

@@ -0,0 +1,39 @@
+require_relative 'api'
+
+class LargeBatchesAnalyzer
+    # returns revision contents and parent contents for whole revision_ids array
+    def self.handle_large_batches(revision_ids, batch_size)
+        revision_contents = {}
+        parent_contents = {}
+    
+    
+        revision_ids_batches = revision_ids.each_slice(batch_size).to_a
+        puts "Handling revision_ids_batches: #{revision_ids_batches.length}"
+        revision_ids_batches.each do |batch|
+            parsed_contents = Api.get_revision_contents(batch)
+            if parsed_contents
+                parent_ids = []
+                revision_contents.merge!(parsed_contents) if parsed_contents
+                parsed_contents.values.each do |data|
+                    parent_id = data[:parentid]
+                    
+                    if parent_id != 0 && !parent_id.nil?
+                        parent_ids << parent_id
+                    end
+                end
+                parent_contents_batch = Api.get_revision_contents(parent_ids)
+                parent_contents.merge!(parent_contents_batch) if parent_contents_batch
+            end
+        end
+    
+        result = {}
+        revision_contents.each do |revid, data|
+            parentid = data[:parentid]
+            parent_content = parent_contents[parentid] if parentid
+            current = data ? data[:content] : nil
+            parent = parent_content ? parent_content[:content] : nil
+            result[revid] = { current_content: current, parent_content: parent }    
+        end
+        result
+    end
+end

data/lib/wikidata/diff/mediawiki_login.rb

@@ -0,0 +1,12 @@
+require 'mediawiki_api'
+# to load env variable
+require 'dotenv/load'
+
+# THIS IS NOT WORKING YET
+class MediawikiLogin
+    def self.mediawiki_login
+        client = MediawikiApi::Client.new('https://www.mediawiki.org/w/api.php')
+        client.log_in(ENV['MEDIAWIKI_USERNAME'], ENV['MEDIAWIKI_PASSWORD'])
+        client.logged_in?  # Return whether login was successful
+    end
+end

data/lib/wikidata/diff/revision_analyzer.rb

@@ -0,0 +1,50 @@
+require_relative 'claim_analyzer'
+require_relative 'alias_analyzer'
+require_relative 'label_analyzer'
+require_relative 'description_analyzer'
+require_relative 'sitelink_analyzer'
+
+class RevisionAnalyzer
+  # This method takes two revisions as input and returns the differences between them.
+  def self.analyze_diff(current_content, parent_content)
+      diff = {}
+      # Calculate claim differences includes references and qualifiers
+      claim_diff = ClaimAnalyzer.isolate_claim_differences(current_content, parent_content)
+      diff[:added_claims] = claim_diff[:added_claims].length
+      diff[:removed_claims] = claim_diff[:removed_claims].length
+      diff[:changed_claims] = claim_diff[:changed_claims].length
+      diff[:added_references] = claim_diff[:added_references].length
+      diff[:removed_references] = claim_diff[:removed_references].length
+      diff[:changed_references] = claim_diff[:changed_references].length
+      diff[:added_qualifiers] = claim_diff[:added_qualifiers].length
+      diff[:removed_qualifiers] = claim_diff[:removed_qualifiers].length
+      diff[:changed_qualifiers] = claim_diff[:changed_qualifiers].length
+    
+      # Calculate alias differences
+      alias_diff = AliasAnalyzer.isolate_aliases_differences(current_content, parent_content)
+      diff[:added_aliases] = alias_diff[:added].length
+      diff[:removed_aliases] = alias_diff[:removed].length
+      diff[:changed_aliases] = alias_diff[:changed].length
+
+
+      # Calculate label differences
+      label_diff = LabelAnalyzer.isolate_labels_differences(current_content, parent_content)
+      diff[:added_labels] = label_diff[:added].length
+      diff[:removed_labels] = label_diff[:removed].length
+      diff[:changed_labels] = label_diff[:changed].length
+
+      # Calculate description differences
+      description_diff = DescriptionAnalyzer.isolate_descriptions_differences(current_content, parent_content)
+      diff[:added_descriptions] = description_diff[:added].length
+      diff[:removed_descriptions] = description_diff[:removed].length
+      diff[:changed_descriptions] = description_diff[:changed].length
+
+      # Calculate sitelink differences
+      sitelink_diff = SitelinkAnalyzer.isolate_sitelinks_differences(current_content, parent_content)
+      diff[:added_sitelinks] = sitelink_diff[:added].length
+      diff[:removed_sitelinks] = sitelink_diff[:removed].length
+      diff[:changed_sitelinks] = sitelink_diff[:changed].length
+
+      diff
+  end
+end

data/lib/wikidata/diff/sitelink_analyzer.rb

@@ -0,0 +1,61 @@
+class SitelinkAnalyzer
+    def self.isolate_sitelinks_differences(current_content, parent_content)
+        added_sitelinks = {}
+        removed_sitelinks = {}
+        changed_sitelinks = {}
+      
+        # Check if both current and parent content exist
+        if current_content && parent_content
+          current_sitelinks = current_content['sitelinks']
+          parent_sitelinks = parent_content['sitelinks']
+      
+          # Check added sitelinks
+          if current_sitelinks.respond_to?(:each)
+            current_sitelinks.each do |site_key, current_sitelink|
+              unless parent_sitelinks.respond_to?(:key?) && parent_sitelinks.key?(site_key)
+                added_sitelinks[site_key] = current_sitelink
+              end
+            end
+          end
+    
+          # Check removed sitelinks
+          if parent_sitelinks.respond_to?(:each)
+            parent_sitelinks.each do |site_key, parent_sitelink|
+              unless current_sitelinks.respond_to?(:key?) && current_sitelinks.key?(site_key)
+                removed_sitelinks[site_key] = parent_sitelink
+              end
+            end
+          end
+          # Check changed sitelinks
+          if current_sitelinks && parent_sitelinks
+            current_sitelinks.each do |site_key, current_sitelink|
+              if parent_sitelinks.respond_to?(:key?) && parent_sitelinks.key?(site_key)
+                parent_sitelink = parent_sitelinks[site_key]
+                if current_sitelink != parent_sitelink
+                  changed_sitelinks[site_key] = {
+                    current: current_sitelink,
+                    parent: parent_sitelink
+                  }
+                end
+              end
+            end
+          end
+        elsif current_content
+          # All sitelinks are added if parent content is nil
+          added_sitelinks = current_content['sitelinks']
+        elsif parent_content
+          # All sitelinks are removed if current content is nil
+          removed_sitelinks = parent_content['sitelinks']
+        end
+      
+        # puts "Added sitelinks: #{added_sitelinks}"
+        # puts "Removed sitelinks: #{removed_sitelinks}"
+        # puts "Changed sitelinks: #{changed_sitelinks}"
+    
+        {
+          added: added_sitelinks,
+          removed: removed_sitelinks,
+          changed: changed_sitelinks
+        }
+    end
+end 

data/lib/wikidata/diff/total.rb

@@ -0,0 +1,25 @@
+class Total
+    def self.accumulate_totals(diff_data, total)
+        total[:claims_added] += diff_data[:added_claims]
+        total[:claims_removed] += diff_data[:removed_claims]
+        total[:claims_changed] += diff_data[:changed_claims]
+        total[:qualifiers_added] += diff_data[:added_qualifiers]
+        total[:qualifiers_removed] += diff_data[:removed_qualifiers]
+        total[:qualifiers_changed] += diff_data[:changed_qualifiers]
+        total[:references_added] += diff_data[:added_references]
+        total[:references_removed] += diff_data[:removed_references]
+        total[:references_changed] += diff_data[:changed_references]
+        total[:aliases_added] += diff_data[:added_aliases]
+        total[:aliases_removed] += diff_data[:removed_aliases]
+        total[:aliases_changed] += diff_data[:changed_aliases]
+        total[:labels_added] += diff_data[:added_labels]
+        total[:labels_removed] += diff_data[:removed_labels]
+        total[:labels_changed] += diff_data[:changed_labels]
+        total[:descriptions_added] += diff_data[:added_descriptions]
+        total[:descriptions_removed] += diff_data[:removed_descriptions]
+        total[:descriptions_changed] += diff_data[:changed_descriptions]
+        total[:sitelinks_added] += diff_data[:added_sitelinks]
+        total[:sitelinks_removed] += diff_data[:removed_sitelinks]
+        total[:sitelinks_changed] += diff_data[:changed_sitelinks]
+    end
+end

data/sig/wikidata/diff/analyzer.rbs

@@ -0,0 +1,8 @@
+module Wikidata
+  module Diff
+    module Analyzer
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

data/wikidata-diff-analyzer.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/wikidata/diff/analyzer/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "wikidata-diff-analyzer"
+  spec.version = Wikidata::Diff::Analyzer::VERSION
+  spec.authors = ["Sulagna Saha"]
+  spec.email = ["saha23s@mtholyoke.edu"]
+
+  spec.summary = "A Ruby gem for analyzing diffs between Wikidata items."
+  spec.description = "This gem provides tools for analyzing diffs between Wikidata items, including retrieving the JSON representation of an item for a specific revision."
+  spec.homepage = "https://github.com/WikiEducationFoundation/wikidata-diff-analyzer"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/WikiEducationFoundation/wikidata-diff-analyzer"
+  spec.metadata["changelog_uri"] = "https://github.com/WikiEducationFoundation/wikidata-diff-analyzer/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Adding the dependencies
+  spec.add_dependency 'json', '~> 2.1'
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: wikidata-diff-analyzer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sulagna Saha
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: This gem provides tools for analyzing diffs between Wikidata items, including
+  retrieving the JSON representation of an item for a specific revision.
+email:
+- saha23s@mtholyoke.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/wikidata/diff/alias_analyzer.rb
+- lib/wikidata/diff/analyzer.rb
+- lib/wikidata/diff/analyzer/version.rb
+- lib/wikidata/diff/api.rb
+- lib/wikidata/diff/claim_analyzer.rb
+- lib/wikidata/diff/description_analyzer.rb
+- lib/wikidata/diff/label_analyzer.rb
+- lib/wikidata/diff/large_batches_analyzer.rb
+- lib/wikidata/diff/mediawiki_login.rb
+- lib/wikidata/diff/revision_analyzer.rb
+- lib/wikidata/diff/sitelink_analyzer.rb
+- lib/wikidata/diff/total.rb
+- sig/wikidata/diff/analyzer.rbs
+- wikidata-diff-analyzer.gemspec
+homepage: https://github.com/WikiEducationFoundation/wikidata-diff-analyzer
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/WikiEducationFoundation/wikidata-diff-analyzer
+  source_code_uri: https://github.com/WikiEducationFoundation/wikidata-diff-analyzer
+  changelog_uri: https://github.com/WikiEducationFoundation/wikidata-diff-analyzer/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: A Ruby gem for analyzing diffs between Wikidata items.
+test_files: []