w3c_api 0.1.0 → 0.1.2

data/Rakefile

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/w3c_api/cli.rb

@@ -11,31 +11,31 @@ require_relative 'commands/affiliation'
 require_relative 'commands/participation'
 
 module W3cApi
-    # Main CLI class that registers all subcommands
-    class Cli < Thor
-      # Register subcommands
-      desc 'specification SUBCOMMAND ...ARGS', 'Work with W3C specifications'
-      subcommand 'specification', Commands::Specification
+  # Main CLI class that registers all subcommands
+  class Cli < Thor
+    # Register subcommands
+    desc 'specification SUBCOMMAND ...ARGS', 'Work with W3C specifications'
+    subcommand 'specification', Commands::Specification
 
-      desc 'group SUBCOMMAND ...ARGS', 'Work with W3C groups'
-      subcommand 'group', Commands::Group
+    desc 'group SUBCOMMAND ...ARGS', 'Work with W3C groups'
+    subcommand 'group', Commands::Group
 
-      desc 'user SUBCOMMAND ...ARGS', 'Work with W3C users'
-      subcommand 'user', Commands::User
+    desc 'user SUBCOMMAND ...ARGS', 'Work with W3C users'
+    subcommand 'user', Commands::User
 
-      desc 'translation SUBCOMMAND ...ARGS', 'Work with W3C translations'
-      subcommand 'translation', Commands::Translation
+    desc 'translation SUBCOMMAND ...ARGS', 'Work with W3C translations'
+    subcommand 'translation', Commands::Translation
 
-      desc 'ecosystem SUBCOMMAND ...ARGS', 'Work with W3C ecosystems'
-      subcommand 'ecosystem', Commands::Ecosystem
+    desc 'ecosystem SUBCOMMAND ...ARGS', 'Work with W3C ecosystems'
+    subcommand 'ecosystem', Commands::Ecosystem
 
-      desc 'series SUBCOMMAND ...ARGS', 'Work with W3C specification series'
-      subcommand 'series', Commands::Series
+    desc 'series SUBCOMMAND ...ARGS', 'Work with W3C specification series'
+    subcommand 'series', Commands::Series
 
-      desc 'affiliation SUBCOMMAND ...ARGS', 'Work with W3C affiliations'
-      subcommand 'affiliation', Commands::Affiliation
+    desc 'affiliation SUBCOMMAND ...ARGS', 'Work with W3C affiliations'
+    subcommand 'affiliation', Commands::Affiliation
 
-      desc 'participation SUBCOMMAND ...ARGS', 'Work with W3C participations'
-      subcommand 'participation', Commands::Participation
-    end
+    desc 'participation SUBCOMMAND ...ARGS', 'Work with W3C participations'
+    subcommand 'participation', Commands::Participation
+  end
 end

data/lib/w3c_api/client.rb

@@ -1,320 +1,140 @@
 # frozen_string_literal: true
 
-require 'faraday'
-require 'faraday/follow_redirects'
 require 'json'
+require 'rainbow'
+require 'pp'
+require_relative 'hal'
 
 module W3cApi
-  class Error < StandardError; end
-  class NotFoundError < Error; end
-  class UnauthorizedError < Error; end
-  class BadRequestError < Error; end
-  class ServerError < Error; end
-
   class Client
-    API_ENDPOINT = 'https://api.w3.org'
-
-    attr_reader :last_response
-
-    def initialize(options = {})
-      @api_endpoint = options[:api_endpoint] || API_ENDPOINT
-      @connection = create_connection
-      @params_default = { page: 1, items: 3000 }
-      @debug = !ENV['DEBUG_API'].nil?
-    end
-
     # Specification methods
-
-    def specifications(options = {})
-      response = get('specifications', options.merge(@params_default))
-      Models::Specifications.from_response(response['_links']['specifications'])
+    def specifications(options = nil)
+      fetch_resource(:specification_index, **(options || {}))
     end
 
     def specification(shortname, options = {})
-      response = get("specifications/#{shortname}", options)
-      Models::Specification.from_response(response)
+      fetch_resource(:specification_resource, shortname: shortname, **options)
     end
 
     def specification_versions(shortname, options = {})
-      response = get("specifications/#{shortname}/versions", options)
-      Models::SpecVersions.from_response(response['_links']['version-history'])
+      fetch_resource(:specification_resource_version_index,
+                     shortname: shortname, **options)
     end
 
     def specification_version(shortname, version, options = {})
-      response = get("specifications/#{shortname}/versions/#{version}", options)
-      Models::SpecVersion.from_response(response)
+      fetch_resource(:specification_resource_version_resource,
+                     shortname: shortname, version: version, **options)
     end
 
     def specifications_by_status(status, options = {})
-      response = get("specifications-by-status/#{status}", options.merge(@params_default))
-      Models::Specifications.from_response(response['_links']['specifications'])
-    end
-
-    def specification_supersedes(shortname, options = {})
-      response = get("specifications/#{shortname}/supersedes", options)
-      Models::Specifications.from_response(response['_links']['specifications'])
+      fetch_resource(:specification_by_status_index, status: status, **options)
     end
 
-    def specification_superseded_by(shortname, options = {})
-      response = get("specifications/#{shortname}/superseded", options)
-      Models::Specifications.from_response(response['_links']['specifications'])
+    %w[supersedes superseded_by editors deliverers].each do |method_suffix|
+      define_method("specification_#{method_suffix}") do |shortname, options = {}|
+        fetch_resource(:"specification_#{method_suffix}_index",
+                       shortname: shortname, **options)
+      end
     end
 
     # Series methods
-
     def series(options = {})
-      response = get('specification-series', options.merge(@params_default))
-      Models::Series.from_response(response['_links']['specification-series'])
+      fetch_resource(:serie_index, **options)
     end
 
     def series_by_shortname(shortname, options = {})
-      response = get("specification-series/#{shortname}", options)
-      Models::Serie.from_response(response)
+      fetch_resource(:serie_resource, shortname: shortname, **options)
     end
 
     def series_specifications(shortname, options = {})
-      response = get("specification-series/#{shortname}/specifications", options.merge(@params_default))
-      Models::Specifications.from_response(response['_links']['specifications'])
+      fetch_resource(:serie_specification_resource,
+                     shortname: shortname, **options)
     end
 
     # Group methods
-
     def groups(options = {})
-      response = get('groups', options)
-      Models::Groups.from_response(response['_links']['groups'])
+      fetch_resource(:group_index, **options)
     end
 
     def group(id, options = {})
-      response = get("groups/#{id}", options)
-      Models::Group.from_response(response)
-    end
-
-    def group_specifications(id, options = {})
-      response = get("groups/#{id}/specifications", options)
-      Models::Specifications.from_response(response['_links']['specifications'])
-    end
-
-    def group_users(id, options = {})
-      response = get("groups/#{id}/users", options)
-      Models::Users.from_response(response['_links']['users'])
+      fetch_resource(:group_resource, id: id, **options)
     end
 
-    def group_charters(id, options = {})
-      response = get("groups/#{id}/charters", options)
-      Models::Charters.from_response(response['_links']['charters'])
-    end
-
-    def group_chairs(id, options = {})
-      response = get("groups/#{id}/chairs", options)
-      Models::Users.from_response(response['_links']['chairs'])
-    rescue NotFoundError
-      # Return empty users collection when endpoint not found
-      Models::Users.from_response([])
-    end
-
-    def group_team_contacts(id, options = {})
-      response = get("groups/#{id}/teamcontacts", options)
-      Models::Users.from_response(response['_links']['team-contacts'])
-    rescue NotFoundError
-      # Return empty users collection when endpoint not found
-      Models::Users.from_response([])
-    end
-
-    def group_participations(id, options = {})
-      response = get("groups/#{id}/participations", options)
-      Models::Participations.from_response(response['_links']['participations'])
+    %w[specifications users charters chairs team_contacts participations].each do |resource|
+      define_method("group_#{resource}") do |id, options = {}|
+        fetch_resource(:"group_#{resource}_index", id: id, **options)
+      end
     end
 
     # User methods
-
-    def users(options = {})
-      raise ArgumentError,
-            'The W3C API does not support fetching all users. You must provide a specific user ID with the user method.'
-    end
-
-    def user(id, options = {})
-      response = get("users/#{id}", options)
-      Models::User.from_response(response)
-    end
-
-    def user_specifications(id, options = {})
-      response = get("users/#{id}/specifications", options)
-      Models::Specifications.from_response(response['_links']['specifications'])
-    rescue NotFoundError
-      # Return empty specifications collection when endpoint not found
-      Models::Specifications.from_response([])
-    end
-
-    def user_groups(id, options = {})
-      response = get("users/#{id}/groups", options)
-      Models::Groups.from_response(response['_links']['groups'])
-    end
-
-    def user_affiliations(id, options = {})
-      response = get("users/#{id}/affiliations", options)
-      Models::Affiliations.from_response(response['_links']['affiliations'])
-    rescue NotFoundError
-      # Return empty affiliations collection when endpoint not found
-      Models::Affiliations.from_response([])
+    def user(hash, options = {})
+      fetch_resource(:user_resource, hash: hash, **options)
     end
 
-    def user_participations(id, options = {})
-      response = get("users/#{id}/participations", options)
-      Models::Participations.from_response(response['_links']['participations'])
-    rescue NotFoundError
-      # Return empty participations collection when endpoint not found
-      Models::Participations.from_response([])
-    end
-
-    def user_chair_of_groups(id, options = {})
-      response = get("users/#{id}/chair-of-groups", options)
-      Models::Groups.from_response(response['_links']['groups'])
-    rescue NotFoundError
-      # Return empty groups collection when endpoint not found
-      Models::Groups.from_response([])
-    end
-
-    def user_team_contact_of_groups(id, options = {})
-      response = get("users/#{id}/team-contact-of-groups", options)
-      Models::Groups.from_response(response['_links']['groups'])
-    rescue NotFoundError
-      # Return empty groups collection when endpoint not found
-      Models::Groups.from_response([])
+    %w[groups affiliations participations chair_of_groups
+       team_contact_of_groups specifications].each do |resource|
+      define_method("user_#{resource}") do |hash, options = {}|
+        fetch_resource(:"user_#{resource}_index", hash: hash, **options)
+      end
     end
 
     # Translation methods
-
     def translations(options = {})
-      response = get('translations', options.merge(embed: true))
-      Models::Translations.from_response(response['_links']['translations'])
+      fetch_resource(:translation_index, **options)
     end
 
     def translation(id, options = {})
-      response = get("translations/#{id}", options)
-      Models::Translation.from_response(response)
+      fetch_resource(:translation_resource, id: id, **options)
     end
 
     # Affiliation methods
-
     def affiliations(options = {})
-      response = get('affiliations', options.merge(@params_default))
-      Models::Affiliations.from_response(response['_links']['affiliations'])
+      fetch_resource(:affiliation_index, **options)
     end
 
     def affiliation(id, options = {})
-      response = get("affiliations/#{id}", options)
-      Models::Affiliation.from_response(response)
-    end
-
-    def affiliation_participants(id, options = {})
-      response = get("affiliations/#{id}/participants", options)
-      Models::Users.from_response(response['_links']['participants'])
+      fetch_resource(:affiliation_resource, id: id, **options)
     end
 
-    def affiliation_participations(id, options = {})
-      response = get("affiliations/#{id}/participations", options)
-      Models::Participations.from_response(response['_links']['participations'])
+    %w[participants participations].each do |resource|
+      define_method("affiliation_#{resource}") do |id, options = {}|
+        fetch_resource(:"affiliation_#{resource}_index", id: id, **options)
+      end
     end
 
     # Ecosystem methods
-
     def ecosystems(options = {})
-      response = get('ecosystems', options)
-      Models::Ecosystems.from_response(response['_links']['ecosystems'])
-    end
-
-    def ecosystem(shortname, options = {})
-      response = get("ecosystems/#{shortname}", options)
-      Models::Ecosystem.from_response(response)
-    end
-
-    def ecosystem_groups(shortname, options = {})
-      response = get("ecosystems/#{shortname}/groups", options)
-      Models::Groups.from_response(response['_links']['groups'])
+      fetch_resource(:ecosystem_index, **options)
     end
 
-    def ecosystem_evangelists(shortname, options = {})
-      response = get("ecosystems/#{shortname}/evangelists", options)
-      Models::Users.from_response(response['_links']['users'])
+    def ecosystem(id, options = {})
+      fetch_resource(:ecosystem_resource, id: id, **options)
     end
 
-    def ecosystem_member_organizations(shortname, options = {})
-      response = get("ecosystems/#{shortname}/member-organizations", options)
-      Models::Affiliations.from_response(response['_links']['affiliations'])
+    %w[groups evangelists member_organizations].each do |resource|
+      define_method("ecosystem_#{resource}") do |shortname, options = {}|
+        fetch_resource(:"ecosystem_#{resource}_index",
+                       shortname: shortname, **options)
+      end
     end
 
     # Participation methods
-
     def participation(id, options = {})
-      response = get("participations/#{id}", options)
-      Models::Participation.from_response(response)
+      fetch_resource(:participation_resource, id: id, **options)
     end
 
     def participation_participants(id, options = {})
-      response = get("participations/#{id}/participants", options)
-      Models::Users.from_response(response['_links']['users'])
-    end
-
-    # Make the get method public for testing
-    def get(url, params = {})
-      @last_response = @connection.get(url, params)
-      handle_response(@last_response, url)
+      fetch_resource(:participation_participants_index, id: id, **options)
     end
 
     private
 
-    def create_connection
-      Faraday.new(url: @api_endpoint) do |conn|
-        conn.use Faraday::FollowRedirects::Middleware
-        conn.request :json
-        conn.response :json, content_type: /\bjson$/
-        conn.adapter Faraday.default_adapter
-      end
-    end
-
-    def handle_response(response, url)
-      debug_log(response, url) if @debug
-
-      case response.status
-      when 200..299
-        response.body
-      when 400
-        raise W3cApi::BadRequestError, response_message(response)
-      when 401
-        raise W3cApi::UnauthorizedError, response_message(response)
-      when 404
-        raise W3cApi::NotFoundError, response_message(response)
-      when 500..599
-        raise W3cApi::ServerError, response_message(response)
+    def fetch_resource(resource_key, **params)
+      if params.any?
+        Hal.instance.register.fetch(resource_key, **params)
       else
-        raise W3cApi::Error, response_message(response)
+        Hal.instance.register.fetch(resource_key)
       end
     end
-
-    def debug_log(response, url)
-      puts "\n===== DEBUG: W3C API REQUEST =====".blue if defined?(Rainbow)
-      puts "\n===== DEBUG: W3C API REQUEST =====" unless defined?(Rainbow)
-      puts "URL: #{url}"
-      puts "Status: #{response.status}"
-
-      # Format headers as JSON
-      puts "\nHeaders:"
-      headers_hash = response.headers.to_h
-      puts JSON.pretty_generate(headers_hash)
-
-      puts "\nResponse body:"
-      if response.body.is_a?(Hash) || response.body.is_a?(Array)
-        puts JSON.pretty_generate(response.body)
-      else
-        puts response.body.inspect
-      end
-      puts "===== END DEBUG OUTPUT =====\n"
-    end
-
-    def response_message(response)
-      message = "Status: #{response.status}"
-      message += ", Error: #{response.body['error']}" if response.body.is_a?(Hash) && response.body['error']
-      message
-    end
-  end # End of Client class
-end # End of W3c module
+  end
+end

data/lib/w3c_api/commands/affiliation.rb

@@ -5,44 +5,44 @@ require_relative 'output_formatter'
 require_relative '../client'
 
 module W3cApi
-    module Commands
-      # Thor CLI command for affiliation operations
-      class Affiliation < Thor
-        include OutputFormatter
+  module Commands
+    # Thor CLI command for affiliation operations
+    class Affiliation < Thor
+      include OutputFormatter
 
-        desc 'fetch [OPTIONS]', 'Fetch affiliations'
-        option :id, type: :numeric, desc: 'Affiliation ID'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def fetch
-          client = W3cApi::Client.new
+      desc 'fetch [OPTIONS]', 'Fetch affiliations'
+      option :id, type: :numeric, desc: 'Affiliation ID'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def fetch
+        client = W3cApi::Client.new
 
-          affiliations = if options[:id]
-                           # Single affiliation
-                           client.affiliation(options[:id])
-                         else
-                           client.affiliations
-                         end
+        affiliations = if options[:id]
+                         # Single affiliation
+                         client.affiliation(options[:id])
+                       else
+                         client.affiliations
+                       end
 
-          output_results(affiliations, options[:format])
-        end
+        output_results(affiliations, options[:format])
+      end
 
-        desc 'participants', 'Fetch participants of an affiliation'
-        option :id, type: :numeric, required: true, desc: 'Affiliation ID'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def participants
-          client = W3cApi::Client.new
-          participants = client.affiliation_participants(options[:id])
-          output_results(participants, options[:format])
-        end
+      desc 'participants', 'Fetch participants of an affiliation'
+      option :id, type: :numeric, required: true, desc: 'Affiliation ID'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def participants
+        client = W3cApi::Client.new
+        participants = client.affiliation_participants(options[:id])
+        output_results(participants, options[:format])
+      end
 
-        desc 'participations', 'Fetch participations of an affiliation'
-        option :id, type: :numeric, required: true, desc: 'Affiliation ID'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def participations
-          client = W3cApi::Client.new
-          participations = client.affiliation_participations(options[:id])
-          output_results(participations, options[:format])
-        end
+      desc 'participations', 'Fetch participations of an affiliation'
+      option :id, type: :numeric, required: true, desc: 'Affiliation ID'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def participations
+        client = W3cApi::Client.new
+        participations = client.affiliation_participations(options[:id])
+        output_results(participations, options[:format])
       end
     end
+  end
 end

data/lib/w3c_api/commands/ecosystem.rb

@@ -5,53 +5,53 @@ require_relative 'output_formatter'
 require_relative '../client'
 
 module W3cApi
-    module Commands
-      # Thor CLI command for ecosystem operations
-      class Ecosystem < Thor
-        include OutputFormatter
-
-        desc 'fetch [OPTIONS]', 'Fetch ecosystems'
-        option :shortname, type: :string, desc: 'Ecosystem shortname'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def fetch
-          client = W3cApi::Client.new
-
-          ecosystems = if options[:shortname]
-                         # Single ecosystem
-                         client.ecosystem(options[:shortname])
-                       else
-                         client.ecosystems
-                       end
-
-          output_results(ecosystems, options[:format])
-        end
-
-        desc 'groups', 'Fetch groups in an ecosystem'
-        option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def groups
-          client = W3cApi::Client.new
-          groups = client.ecosystem_groups(options[:shortname])
-          output_results(groups, options[:format])
-        end
-
-        desc 'evangelists', 'Fetch evangelists of an ecosystem'
-        option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def evangelists
-          client = W3cApi::Client.new
-          evangelists = client.ecosystem_evangelists(options[:shortname])
-          output_results(evangelists, options[:format])
-        end
-
-        desc 'member-organizations', 'Fetch member organizations of an ecosystem'
-        option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
-        option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
-        def member_organizations
-          client = W3cApi::Client.new
-          organizations = client.ecosystem_member_organizations(options[:shortname])
-          output_results(organizations, options[:format])
-        end
+  module Commands
+    # Thor CLI command for ecosystem operations
+    class Ecosystem < Thor
+      include OutputFormatter
+
+      desc 'fetch [OPTIONS]', 'Fetch ecosystems'
+      option :shortname, type: :string, desc: 'Ecosystem shortname'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def fetch
+        client = W3cApi::Client.new
+
+        ecosystems = if options[:shortname]
+                       # Single ecosystem
+                       client.ecosystem(options[:shortname])
+                     else
+                       client.ecosystems
+                     end
+
+        output_results(ecosystems, options[:format])
+      end
+
+      desc 'groups', 'Fetch groups in an ecosystem'
+      option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def groups
+        client = W3cApi::Client.new
+        groups = client.ecosystem_groups(options[:shortname])
+        output_results(groups, options[:format])
+      end
+
+      desc 'evangelists', 'Fetch evangelists of an ecosystem'
+      option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def evangelists
+        client = W3cApi::Client.new
+        evangelists = client.ecosystem_evangelists(options[:shortname])
+        output_results(evangelists, options[:format])
+      end
+
+      desc 'member-organizations', 'Fetch member organizations of an ecosystem'
+      option :shortname, type: :string, required: true, desc: 'Ecosystem shortname'
+      option :format, type: :string, default: 'yaml', enum: %w[json yaml], desc: 'Output format'
+      def member_organizations
+        client = W3cApi::Client.new
+        organizations = client.ecosystem_member_organizations(options[:shortname])
+        output_results(organizations, options[:format])
       end
     end
+  end
 end