w3c_api 0.1.0

data/lib/w3c_api/commands/specification.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'output_formatter'
+require_relative '../client'
+
+module W3cApi
+    module Commands
+      # Thor CLI command for specification operations
+      class Specification < Thor
+        include OutputFormatter
+
+        desc 'fetch [OPTIONS]', 'Fetch specifications'
+        option :shortname, type: :string, desc: 'Filter by shortname'
+        option :version, type: :string, desc: 'Specific version of the specification'
+        option :status, type: :string, desc: 'Filter by status'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def fetch
+          client = W3cApi::Client.new
+
+          specifications = if options[:shortname] && options[:version]
+                             # Single specification version
+                             client.specification_version(options[:shortname], options[:version])
+                           elsif options[:shortname]
+                             # Single specification
+                             client.specification(options[:shortname])
+                           elsif options[:status]
+                             # Specifications by status
+                             client.specifications_by_status(options[:status])
+                           else
+                             # All specifications
+                             client.specifications
+                           end
+
+          output_results(specifications, options[:format])
+        end
+
+        desc 'versions', 'Fetch versions of a specification'
+        option :shortname, type: :string, required: true, desc: 'Specification shortname'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def versions
+          client = W3cApi::Client.new
+          versions = client.specification_versions(options[:shortname])
+          output_results(versions, options[:format])
+        end
+
+        desc 'supersedes', 'Fetch specifications that this specification supersedes'
+        option :shortname, type: :string, required: true, desc: 'Specification shortname'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def supersedes
+          # We need to add client.specification_supersedes method in the client
+          client = W3cApi::Client.new
+          specifications = client.specification_supersedes(options[:shortname])
+          output_results(specifications, options[:format])
+        end
+
+        desc 'superseded-by', 'Fetch specifications that supersede this specification'
+        option :shortname, type: :string, required: true, desc: 'Specification shortname'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def superseded_by
+          # We need to add client.specification_superseded_by method in the client
+          client = W3cApi::Client.new
+          specifications = client.specification_superseded_by(options[:shortname])
+          output_results(specifications, options[:format])
+        end
+      end
+    end
+end

data/lib/w3c_api/commands/translation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'output_formatter'
+require_relative '../client'
+
+module W3cApi
+    module Commands
+      # Thor CLI command for translation operations
+      class Translation < Thor
+        include OutputFormatter
+
+        desc 'fetch [OPTIONS]', 'Fetch a translation by ID'
+        option :id, type: :string, desc: 'Translation ID'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def fetch
+          client = W3cApi::Client.new
+
+          translations = if options[:id]
+                           # Single specification version
+                           client.translation(options[:id])
+                         else
+                           # All translations
+                           client.translations
+                         end
+
+          output_results(translations, options[:format])
+        end
+      end
+    end
+end

data/lib/w3c_api/commands/user.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'output_formatter'
+require_relative '../client'
+
+module W3cApi
+    module Commands
+      # Thor CLI command for user operations
+      class User < Thor
+        include OutputFormatter
+
+        desc 'fetch [OPTIONS]', 'Fetch a user by ID'
+        option :id, type: :string, required: true, desc: 'User ID (required)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def fetch
+          client = W3cApi::Client.new
+          user = client.user(options[:id])
+          output_results(user, options[:format])
+        end
+
+        desc 'groups', 'Fetch groups a user is a member of'
+        option :id, type: :string, required: true, desc: 'User ID'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def groups
+          client = W3cApi::Client.new
+          groups = client.user_groups(options[:id])
+          output_results(groups, options[:format])
+        end
+
+        desc 'specifications', 'Fetch specifications a user has contributed to'
+        option :id, type: :string, required: true, desc: 'User ID (string or numeric)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def specifications
+          client = W3cApi::Client.new
+          specifications = client.user_specifications(options[:id])
+          output_results(specifications, options[:format])
+        end
+
+        desc 'affiliations', 'Fetch affiliations of a user'
+        option :id, type: :string, required: true, desc: 'User ID (string or numeric)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def affiliations
+          client = W3cApi::Client.new
+          affiliations = client.user_affiliations(options[:id])
+          output_results(affiliations, options[:format])
+        end
+
+        desc 'participations', 'Fetch participations of a user'
+        option :id, type: :string, required: true, desc: 'User ID (string or numeric)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def participations
+          client = W3cApi::Client.new
+          participations = client.user_participations(options[:id])
+          output_results(participations, options[:format])
+        end
+
+        desc 'chair-of-groups', 'Fetch groups a user chairs'
+        option :id, type: :string, required: true, desc: 'User ID (string or numeric)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def chair_of_groups
+          client = W3cApi::Client.new
+          groups = client.user_chair_of_groups(options[:id])
+          output_results(groups, options[:format])
+        end
+
+        desc 'team-contact-of-groups', 'Fetch groups a user is a team contact of'
+        option :id, type: :string, required: true, desc: 'User ID (string or numeric)'
+        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+        def team_contact_of_groups
+          client = W3cApi::Client.new
+          groups = client.user_team_contact_of_groups(options[:id])
+          output_results(groups, options[:format])
+        end
+      end
+    end
+end

data/lib/w3c_api/models/affiliation.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'link'
+
+# Example affiliation response:
+# {
+#   "id"=>48830,
+#   "name"=>"Postmedia",
+#   "discr"=>"organization",
+#   "is-member"=>false,
+#   "is-member-association"=>false,
+#   "is-partner-member"=>false,
+#   "_links"=>{
+#     "self"=>{
+#       "href"=>"https://api.w3.org/affiliations/48830"
+#     },
+#     "participants"=>{
+#       "href"=>"https://api.w3.org/affiliations/48830/participants"
+#     },
+#     "participations"=>{
+#       "href"=>"https://api.w3.org/affiliations/48830/participations"
+#     }
+#   }
+# }
+
+# Fetch index response:
+# {
+#   "href"=>"https://api.w3.org/affiliations/1001",
+#   "title"=>"Framkom (Forskningsaktiebolaget Medie-och Kommunikationsteknik)"
+# },
+
+
+module W3cApi
+    module Models
+      class AffiliationLinks < Lutaml::Model::Serializable
+        attribute :self, Link
+        attribute :participants, Link
+        attribute :participations, Link
+      end
+
+      class Affiliation < Base
+        attribute :id, :integer
+        attribute :name, :string
+        attribute :href, :string
+        attribute :title, :string
+        attribute :descr, :string
+        attribute :is_member, :boolean
+        attribute :is_member_association, :boolean
+        attribute :is_partner_member, :boolean
+        attribute :_links, AffiliationLinks
+
+        # Get participants of this affiliation
+        def participants(client = nil)
+          return nil unless client && _links&.participants
+
+          client.affiliation_participants(id)
+        end
+
+        # Get participations of this affiliation
+        def participations(client = nil)
+          return nil unless client && _links&.participations
+
+          client.affiliation_participations(id)
+        end
+
+        def self.from_response(response)
+          transformed_response = transform_keys(response)
+
+          affiliation = new
+          transformed_response.each do |key, value|
+            case key
+            when :_links
+              links = value.each_with_object({}) do |(link_name, link_data), acc|
+                acc[link_name] = Link.new(href: link_data[:href], title: link_data[:title])
+              end
+              affiliation._links = AffiliationLinks.new(links)
+            else
+              affiliation.send("#{key}=", value) if affiliation.respond_to?("#{key}=")
+            end
+          end
+          affiliation
+        end
+      end
+    end
+end

data/lib/w3c_api/models/affiliations.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'affiliation'
+require_relative 'delegate_enumerable'
+require_relative 'collection_base'
+
+# {
+#   "page"=>1,
+#   "limit"=>1000,
+#   "pages"=>16,
+#   "total"=>15918,
+#   "_links"=>{
+#     "affiliations"=>[
+#       {
+#         "href"=>"https://api.w3.org/affiliations/1001",
+#         "title"=>"Framkom (Forskningsaktiebolaget Medie-och Kommunikationsteknik)"
+#       },
+#       {
+#         "href"=>"https://api.w3.org/affiliations/1003",
+#         "title"=>"BackWeb Technologies, Inc."
+#       },
+
+module W3cApi
+    module Models
+      class Affiliations < CollectionBase
+        attribute :affiliations, Affiliation, collection: true
+
+        delegate_enumerable :affiliations
+        collection_instance_class Affiliation, :affiliations
+      end
+    end
+end

data/lib/w3c_api/models/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require 'json'
+require 'yaml'
+
+module W3cApi
+  module Models
+    class Base < Lutaml::Model::Serializable
+      # Common methods for all W3C API models
+
+      # Create a model instance from a JSON hash
+      def self.from_response(data)
+        # Convert keys with hyphens to snake_case for Ruby
+        transformed_data = transform_keys(data)
+
+        # Create model instance
+        new(transformed_data)
+      end
+
+      # Utility function to transform kebab-case to snake_case
+      def self.transform_keys(data)
+        case data
+        when Hash
+          result = {}
+          data.each do |key, value|
+            snake_key = key.to_s.tr('-', '_').to_sym
+            result[snake_key] = transform_keys(value)
+          end
+          result
+        when Array
+          data.map { |item| transform_keys(item) }
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/w3c_api/models/call_for_translation.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'link'
+require_relative 'spec_version_ref'
+
+# {
+#     "uri": "https://www.w3.org/WAI/videos/standards-and-benefits/"
+#     "title": "Video Introduction to Web Accessibility and W3C Standards"
+#     "_links": {
+#         "self": {
+#             "href": "https://api.w3.org/callsfortranslation/5"
+#         }
+#         "translations": {
+#             "href": "https://api.w3.org/callsfortranslation/5/translations"
+#         }
+#     }
+# }
+
+module W3cApi
+    module Models
+      class CallForTranslationLinks < Lutaml::Model::Serializable
+        attribute :self, Link
+        attribute :translations, Link
+      end
+
+      class CallForTranslation < Base
+        attribute :uri, :string
+        attribute :title, :string
+        attribute :spec_version, SpecVersionRef
+        attribute :_links, CallForTranslationLinks
+
+        # Get translations for this call for translation
+        def translations(client = nil)
+          return nil unless client && _links&.translations
+
+          client.call_for_translation_translations(uri)
+        end
+
+        def self.from_response(response)
+          transformed_response = transform_keys(response)
+
+          cft = new
+          transformed_response.each do |key, value|
+            case key
+            when :_links
+              links = value.each_with_object({}) do |(link_name, link_data), acc|
+                acc[link_name] = Link.new(href: link_data[:href], title: link_data[:title])
+              end
+              cft._links = CallForTranslationLinks.new(links)
+            else
+              cft.send("#{key}=", value) if cft.respond_to?("#{key}=")
+            end
+          end
+          cft
+        end
+      end
+    end
+end

data/lib/w3c_api/models/call_for_translation_ref.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'spec_version_ref'
+
+module W3cApi
+    module Models
+      class CallForTranslationRef < Lutaml::Model::Serializable
+        attribute :uri, :string
+        attribute :title, :string
+        attribute :comments, :string
+        attribute :spec_version, SpecVersionRef
+      end
+    end
+end

data/lib/w3c_api/models/charter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'extension'
+require_relative 'link'
+
+# Example charter response format - specific fields may vary by group:
+# {
+#     "end": "2025-10-31"
+#     "title": "Accessibility Guidelines Working Group Charter"
+#     "start": "1997-10-06"
+#     "initial_end": "1999-10-06"
+#     "uri": "https://www.w3.org/2022/05/accessibility-guidelines-wg-charter.html"
+#     "cfp_uri": "https://lists.w3.org/Archives/Member/w3c-ac-members/..."
+#     "extensions": [...]
+#     "required_new_commitments": false
+#     "patent_policy": "pre-2020"
+#     "_links": {
+#         "self": {
+#             "href": "https://api.w3.org/groups/wg/ag/charters/492"
+#         },
+#         "group": {
+#             "href": "https://api.w3.org/groups/wg/ag"
+#         }
+#     }
+# }
+
+module W3cApi
+    module Models
+      class CharterLinks < Lutaml::Model::Serializable
+        attribute :self, Link
+        attribute :group, Link
+      end
+
+      class Charter < Base
+        attribute :end, :string # Date-time format
+        attribute :href, :string
+        attribute :title, :string
+        attribute :start, :string # Date-time format
+        attribute :initial_end, :string # Date-time format
+        attribute :uri, :string, pattern: %r{https?://www\.w3\.org.*}
+        attribute :cfp_uri, :string, pattern: %r{https://lists\.w3\.org/Archives/Member/w3c-ac-members/.*}
+        attribute :extensions, Extension, collection: true
+        attribute :required_new_commitments, :boolean
+        attribute :patent_policy, :string
+        attribute :_links, CharterLinks
+
+        # Return the group this charter belongs to
+        def group(client = nil)
+          return nil unless client && _links&.group
+
+          group_href = _links.group.href
+          group_id = group_href.split('/').last
+
+          client.group(group_id)
+        end
+
+        # Parse date strings to Date objects
+        def end_date
+          Date.parse(self.end) if self.end
+        rescue Date::Error
+          nil
+        end
+
+        def start_date
+          Date.parse(start) if start
+        rescue Date::Error
+          nil
+        end
+
+        def initial_end_date
+          Date.parse(initial_end) if initial_end
+        rescue Date::Error
+          nil
+        end
+
+        # Check if this charter is active
+        def active?
+          start_date &&
+            (end_date.nil? || end_date >= Date.today) &&
+            start_date <= Date.today
+        rescue Date::Error
+          false
+        end
+
+        # Check if this charter has been extended
+        def extended?
+          !extensions.nil? && !extensions.empty?
+        end
+
+        def self.from_response(response)
+          transformed_response = transform_keys(response)
+
+          charter = new
+          transformed_response.each do |key, value|
+            case key
+            when :_links
+              links = value.each_with_object({}) do |(link_name, link_data), acc|
+                acc[link_name] = Link.new(href: link_data[:href], title: link_data[:title])
+              end
+              charter._links = CharterLinks.new(links)
+            else
+              charter.send("#{key}=", value) if charter.respond_to?("#{key}=")
+            end
+          end
+          charter
+        end
+      end
+    end
+end

data/lib/w3c_api/models/charters.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'charter'
+require_relative 'delegate_enumerable'
+require_relative 'collection_base'
+
+module W3cApi
+    module Models
+      class Charters < CollectionBase
+        attribute :charters, Charter, collection: true
+
+        delegate_enumerable :charters
+        collection_instance_class Charter, :charters
+      end
+    end
+end

data/lib/w3c_api/models/collection_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require 'json'
+require 'yaml'
+
+module W3cApi
+  module Models
+    class CollectionBase < Lutaml::Model::Serializable
+      # Common methods for all W3C API model collections
+      extend DelegateEnumerable
+
+      def self.collection_instance_class(klass, attribute)
+        @collection_instance_class ||= klass
+        @collection_attribute = attribute
+      end
+
+      # Create a model instance from a hash response
+      def self.from_response(data)
+        return new({ @collection_attribute => [] }) if data.nil?
+
+        # Handle the case where data is expected to have 'items' key
+        if data.is_a?(Hash)
+          return new({ @collection_attribute => [] }) unless data.key?(:items) || data.key?('items')
+
+          items_key = data.key?(:items) ? :items : 'items'
+          items = data[items_key] || []
+
+          # Set pagination metadata
+          result = new
+          data.each do |key, value|
+            next if key == items_key
+
+            result.send("#{key}=", value) if result.respond_to?("#{key}=")
+          end
+
+          # Process items array
+          transformed_items = items.map do |item|
+            @collection_instance_class.new(transform_keys(item))
+          end
+
+          result.send("#{@collection_attribute}=", transformed_items)
+          return result
+
+          # Handle case where response is a hash but doesn't contain 'items'
+
+        end
+
+        # Handle case where data is directly the items array
+        if data.is_a?(Array)
+          transformed_data = data.map do |item|
+            @collection_instance_class.new(transform_keys(item))
+          end
+          return new({ @collection_attribute => transformed_data })
+        end
+
+        # For backward compatibility, try to create a model instance anyway
+        new({ @collection_attribute => [] })
+      end
+
+      # Utility function to transform kebab-case to snake_case
+      def self.transform_keys(data)
+        case data
+        when Hash
+          result = {}
+          data.each do |key, value|
+            snake_key = key.to_s.tr('-', '_').to_sym
+            result[snake_key] = transform_keys(value)
+          end
+          result
+        when Array
+          data.map { |item| transform_keys(item) }
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/w3c_api/models/connected_account.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+# {
+#   "created"=>"2019-07-18T21:28:31+00:00",
+#   "updated"=>"2021-01-21T10:49:57+00:00",
+#   "service"=>"github",
+#   "identifier"=>"1801875",
+#   "nickname"=>"davidsgrogan",
+#   "profile-picture"=>"https://avatars.githubusercontent.com/u/1801875?v=4",
+#   "href"=>"https://github.com/davidsgrogan",
+#   "_links"=>{
+#     "user"=>{
+#       "href"=>"https://api.w3.org/users/c2yerd5euz48gcw08s44oww8g4oo8w8"
+#     }
+#   }
+# }
+
+module W3cApi
+    module Models
+      class ConnectedAccountLinks < Lutaml::Model::Serializable
+        attribute :user, Link
+      end
+
+      class ConnectedAccount < Base
+        attribute :created, :date_time
+        attribute :updated, :date_time
+        attribute :service, :string
+        attribute :identifier, :string
+        attribute :nickname, :string
+        attribute :profile_picture, :string
+        attribute :href, :string
+        attribute :_links, ConnectedAccountLinks
+
+        def self.from_response(response)
+          transformed_response = transform_keys(response)
+          account = new
+          transformed_response.each do |key, value|
+            case key
+            when :_links
+              links = value.each_with_object({}) do |(link_name, link_data), acc|
+                acc[link_name] = Link.new(href: link_data[:href], title: link_data[:title])
+              end
+              account._links = ConnectedAccountLinks.new(links)
+            else
+              account.send("#{key}=", value) if account.respond_to?("#{key}=")
+            end
+          end
+          account
+        end
+      end
+    end
+end