artemis 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67885289ab96c6ee04586b1c448bfa3832ecdb6b8ce2b28726d988a24801aee4
-  data.tar.gz: 788127f71e696536fd2f6e2076f97f2bb8af6d9374af5760782da12c85005660
+  metadata.gz: 48a7d1c38990ead32932786f4a3981d3e7a8db1914ffac704bd14fec1511e9a6
+  data.tar.gz: 6a3150492d60d3f94baff965a514b2392c0bdfc9c34d51cca540b7156cf4b1ba
 SHA512:
-  metadata.gz: e4099922005bf7f838d9e6147253b8403b9381fa5ea7c29a1317045b64c8cbe08e2bcc8ea0060ff60da41b7fba9325f47cce079ae1c8d217d0d47dcfee437c5f
-  data.tar.gz: f633c25ba1ddbe8bcec167425f4f48b9ed8d6f94bac6048dc75c9a68bb13745af76b4572bb1b4e3a869bbf542a0928c8a0235e9ee835726e52325085e089d42b
+  metadata.gz: 594a2346bfc01cf7d8ca53c7359693f4e43e38dea0a5e65d36faf51851a55665839436078b7d1aaf6a20441edb949e24f0f406c0612928f00c850e552d4e829d
+  data.tar.gz: 9a19609908348342985afa0ef74e40133b1ea647fed58279b8c11efbc27e257e1086290932c3af2c0083c40cd0d5baa8b746929533c3d8f2a58d05ce1de4c0ab

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## v1.0.2
+
+#### 🐞 Bug Fixes
+
+- Fixes a bug where abstract client classes are not loaded correctly (#93, `494d30b`)
+
+## v1.0.1
+
+> Yanked due to inconsistent commit history.
+
 ## v1.0.0
 
 #### 🚨 Breaking Changes

data/Rakefile

@@ -1,6 +1,5 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require 'rspec/core/rake_task'
 
 TESTS_IN_ISOLATION = ['test/railtie_test.rb', 'test/rake_tasks_test.rb']
 
@@ -16,6 +15,4 @@ Rake::TestTask.new('test:isolated') do |t|
   t.warning    = false
 end
 
-RSpec::Core::RakeTask.new(:spec)
-
-task default: ['spec', 'test', 'test:isolated']
+task default: ['test', 'test:isolated']

data/artemis.gemspec

@@ -24,5 +24,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.16"
   spec.add_development_dependency "net-http-persistent", ">= 3.0"
   spec.add_development_dependency "rake", ">= 10.0"
-  spec.add_development_dependency "rspec", ">= 3.8"
 end

data/lib/artemis/railtie.rb

@@ -31,7 +31,9 @@ module Artemis
     end
 
     initializer 'graphql.client.set_reloader', after: 'graphql.client.set_query_paths' do |app|
-      if !config.respond_to?(:autoloader) || config.autoloader != :zeitwerk
+      not_on_zeitwerk = !defined?(Zeitwerk) || (app.config.respond_to?(:autoloader) && app.config.autoloader != :zeitwerk)
+
+      if not_on_zeitwerk
         files_to_watch = Artemis::Client.query_paths.map {|path| [path, config.artemis.graphql_extentions] }.to_h
 
         app.reloaders << ActiveSupport::FileUpdateChecker.new([], files_to_watch) do
@@ -58,14 +60,10 @@ module Artemis
     end
 
     initializer 'graphql.client.preload', after: 'graphql.client.load_config' do |app|
-      if app.config.eager_load && app.config.cache_classes
-        Artemis::GraphQLEndpoint.registered_services.each do |endpoint_name|
-          begin
-            require_dependency endpoint_name # Rails 7.0+ requires this.
-          rescue LoadError
-            # no-op...
-          end
+      not_on_zeitwerk = !defined?(Zeitwerk) || (app.config.respond_to?(:autoloader) && app.config.autoloader != :zeitwerk)
 
+      if app.config.eager_load && app.config.cache_classes && not_on_zeitwerk
+        Artemis::GraphQLEndpoint.registered_services.each do |endpoint_name|
           endpoint_name.camelize.constantize.preload!
         end
       end

data/lib/artemis/version.rb

@@ -1,3 +1,3 @@
 module Artemis
-  VERSION = "1.0.0"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: artemis
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Jon Allured
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-05 00:00:00.000000000 Z
+date: 2024-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -123,20 +123,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.8'
 description: GraphQL client on Rails + Convention over Configuration = ❤️
 email:
 - jon.allured@gmail.com
@@ -198,22 +184,6 @@ files:
 - lib/generators/artemis/query/templates/fixture.yml
 - lib/generators/artemis/query/templates/query.graphql
 - lib/tasks/artemis.rake
-- spec/adapters_spec.rb
-- spec/autoloading_spec.rb
-- spec/callbacks_spec.rb
-- spec/client_spec.rb
-- spec/endpoint_spec.rb
-- spec/fixtures/github.rb
-- spec/fixtures/github/_repository_fields.graphql
-- spec/fixtures/github/repository.graphql
-- spec/fixtures/github/schema.json
-- spec/fixtures/github/user.graphql
-- spec/fixtures/github/user_repositories.graphql
-- spec/fixtures/responses/github/repository.yml
-- spec/fixtures/responses/github/user.json
-- spec/fixtures/responses/spotify_client/artist.yml
-- spec/spec_helper.rb
-- spec/test_helper_spec.rb
 - tmp/.gitkeep
 homepage: https://github.com/yuki24/artemis
 licenses:
@@ -234,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: GraphQL on Rails

data/spec/adapters_spec.rb

@@ -1,278 +0,0 @@
-require 'json'
-require 'rack'
-require 'webrick'
-
-RACK_SERVER = begin
-                require 'rackup/handler/webrick'
-                Rackup::Handler::WEBrick
-              rescue LoadError
-                Rack::Handler::WEBrick
-              end
-
-describe 'Adapters' do
-  FakeServer = ->(env) {
-    case env['PATH_INFO']
-    when '/slow_server'
-      sleep 2.1
-
-      [200, {}, ['{}']]
-    when '/500'
-      [500, {}, ['Server error']]
-    when '/test_multi_domain'
-      body = {
-        data: {
-          body: "Endpoint switched.",
-          headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
-                      .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
-                      .to_h,
-        },
-        errors: [],
-        extensions: {}
-      }.to_json
-
-      [200, {}, [body]]
-    else
-      request_body = JSON.parse(env['rack.input'].read)
-
-      response_body = if request_body['_json']
-                        request_body['_json'].map do |query|
-                          {
-                            data: {
-                              body: query,
-                              headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
-                                          .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
-                                          .to_h,
-                            },
-                            errors: [],
-                            extensions: {}
-                          }
-                        end.to_json
-                      else
-                        {
-                          data: {
-                            body: request_body,
-                            headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
-                                        .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
-                                        .to_h,
-                          },
-                          errors: [],
-                          extensions: {}
-                        }.to_json
-                      end
-
-      [200, {}, [response_body]]
-    end
-  }
-
-  before :all do
-    Artemis::Adapters::AbstractAdapter.send(:attr_writer, :uri, :timeout)
-
-    @server_thread = Thread.new do
-      RACK_SERVER.run(FakeServer, Port: 8000, Logger: WEBrick::Log.new('/dev/null'), AccessLog: [])
-    end
-
-    loop do
-      begin
-        TCPSocket.open('localhost', 8000)
-        break
-      rescue Errno::ECONNREFUSED
-        # no-op
-      end
-    end
-  end
-
-  after :all do
-    RACK_SERVER.shutdown
-    @server_thread.terminate
-  end
-
-  shared_examples 'an adapter' do
-    describe '#initialize' do
-      it 'requires an url' do
-        expect do
-          adapter.class.new(nil, service_name: nil, timeout: 2, pool_size: 5)
-        end.to raise_error(ArgumentError, "url is required (given `nil')")
-      end
-    end
-
-    describe '#execute' do
-      it 'makes an actual HTTP request' do
-        response = adapter.execute(
-          document: GraphQL::Client::IntrospectionDocument,
-          operation_name: 'IntrospectionQuery',
-          variables: { id: 'yayoi-kusama' },
-          context: { user_id: 1 }
-        )
-
-        expect(response['data']['body']['query']).to eq(GraphQL::Client::IntrospectionDocument.to_query_string)
-        expect(response['data']['body']['variables']).to eq('id' => 'yayoi-kusama')
-        expect(response['data']['body']['operationName']).to eq('IntrospectionQuery')
-        expect(response['data']['headers']['CONTENT_TYPE']).to eq('application/json')
-        expect(response['data']['headers']['ACCEPT']).to eq('application/json')
-        expect(response['errors']).to eq([])
-        expect(response['extensions']).to eq({})
-      end
-
-      it 'raises an error when it receives a server error' do
-        adapter.uri = URI.parse('http://localhost:8000/500')
-
-        expect do
-          adapter.execute(document: GraphQL::Client::IntrospectionDocument, operation_name: 'IntrospectionQuery')
-        end.to raise_error(Artemis::GraphQLServerError, "Received server error status 500: Server error")
-      end
-
-      it 'allows for overriding timeout' do
-        adapter.uri = URI.parse('http://localhost:8000/slow_server')
-
-        expect do
-          adapter.execute(document: GraphQL::Client::IntrospectionDocument, operation_name: 'IntrospectionQuery')
-        end.to raise_error(timeout_error)
-      end
-    end
-
-    describe '#multiplex' do
-      it 'makes an HTTP request with multiple queries' do
-        response = adapter.multiplex(
-          [
-            {
-              query: GraphQL::Client::IntrospectionDocument.to_query_string,
-              operationName: 'IntrospectionQuery',
-              variables: {
-                id: 'yayoi-kusama'
-              },
-            },
-          ],
-          context: {
-            user_id: 1
-          }
-        )
-
-        introspection_query = response[0]
-
-        expect(introspection_query['data']['body']['query']).to eq(GraphQL::Client::IntrospectionDocument.to_query_string)
-        expect(introspection_query['data']['body']['variables']).to eq('id' => 'yayoi-kusama')
-        expect(introspection_query['data']['body']['operationName']).to eq('IntrospectionQuery')
-        expect(introspection_query['data']['headers']['CONTENT_TYPE']).to eq('application/json')
-        expect(introspection_query['data']['headers']['ACCEPT']).to eq('application/json')
-        expect(introspection_query['errors']).to eq([])
-        expect(introspection_query['extensions']).to eq({})
-      end
-
-      it 'raises an error when it receives a server error' do
-        adapter.uri = URI.parse('http://localhost:8000/500')
-
-        expect do
-          adapter.multiplex([])
-        end.to raise_error(Artemis::GraphQLServerError, "Received server error status 500: Server error")
-      end
-
-      it 'allows for overriding timeout' do
-        adapter.uri = URI.parse('http://localhost:8000/slow_server')
-
-        expect do
-          adapter.multiplex([])
-        end.to raise_error(timeout_error)
-      end
-    end
-  end
-
-  describe Artemis::Adapters::NetHttpAdapter do
-    let(:adapter) { Artemis::Adapters::NetHttpAdapter.new('http://localhost:8000', service_name: nil, timeout: 0.5, pool_size: 5) }
-    let(:timeout_error) { Net::ReadTimeout }
-
-    it_behaves_like 'an adapter'
-  end
-
-  describe Artemis::Adapters::NetHttpPersistentAdapter do
-    let(:adapter) { Artemis::Adapters::NetHttpPersistentAdapter.new('http://localhost:8000', service_name: nil, timeout: 0.5, pool_size: 5) }
-    let(:timeout_error) { Net::ReadTimeout }
-
-    it_behaves_like 'an adapter'
-  end
-
-  describe Artemis::Adapters::MultiDomainAdapter do
-    let(:adapter) { Artemis::Adapters::MultiDomainAdapter.new('ignored', service_name: nil, timeout: 0.5, pool_size: 5, adapter_options: { adapter: :net_http }) }
-
-    it 'makes an actual HTTP request' do
-      response = adapter.execute(document: GraphQL::Client::IntrospectionDocument, context: { url: 'http://localhost:8000/test_multi_domain' })
-
-      expect(response['data']['body']).to eq("Endpoint switched.")
-      expect(response['errors']).to eq([])
-      expect(response['extensions']).to eq({})
-    end
-
-    it 'can make a multiplex (the graphql feature, not HTTP/2) request' do
-      response = adapter.multiplex(
-        [
-          {
-            query: GraphQL::Client::IntrospectionDocument.to_query_string,
-            operationName: 'IntrospectionQuery',
-            variables: {
-              id: 'yayoi-kusama'
-            },
-          },
-        ],
-        context: {
-          url: 'http://localhost:8000/test_multi_domain'
-        }
-      )
-
-      expect(response['data']['body']).to eq("Endpoint switched.")
-      expect(response['errors']).to eq([])
-      expect(response['extensions']).to eq({})
-    end
-
-    it 'can make a multiplex request with custom HTTP headers' do
-      response = adapter.multiplex(
-        [
-          {
-            query: GraphQL::Client::IntrospectionDocument.to_query_string,
-            operationName: 'IntrospectionQuery',
-          },
-        ],
-        context: {
-          headers: {
-            Authorization: "Token token",
-          },
-          url: 'http://localhost:8000/test_multi_domain'
-        }
-      )
-
-      expect(response['data']['headers']['AUTHORIZATION']).to eq("token token")
-    end
-
-    it 'raises an error when adapter_options.adapter is set to :multi domain' do
-      expect do
-        Artemis::Adapters::MultiDomainAdapter.new('ignored', service_name: nil, timeout: 0.5, pool_size: 5, adapter_options: { adapter: :multi_domain })
-      end.to raise_error(ArgumentError, 'You can not use the :multi_domain adapter with the :multi_domain adapter.')
-    end
-
-    it 'raises an error when context.url is not specified' do
-      expect do
-        adapter.execute(document: GraphQL::Client::IntrospectionDocument)
-      end.to raise_error(ArgumentError, 'The MultiDomain adapter requires a url on every request. Please specify a ' \
-                                        'url with a context: Client.with_context(url: "https://awesomeshop.domain.conm")')
-    end
-
-    it 'raises an error when it receives a server error' do
-      expect do
-        adapter.execute(document: GraphQL::Client::IntrospectionDocument, context: { url: 'http://localhost:8000/500' })
-      end.to raise_error(Artemis::GraphQLServerError, "Received server error status 500: Server error")
-    end
-
-    it 'allows for overriding timeout' do
-      expect do
-        adapter.execute(document: GraphQL::Client::IntrospectionDocument, context: { url: 'http://localhost:8000/slow_server' })
-      end.to raise_error(Net::ReadTimeout)
-    end
-  end
-
-  if RUBY_ENGINE == 'ruby'
-    describe Artemis::Adapters::CurbAdapter do
-      let(:adapter) { Artemis::Adapters::CurbAdapter.new('http://localhost:8000', service_name: nil, timeout: 2, pool_size: 5) }
-      let(:timeout_error) { Curl::Err::TimeoutError }
-
-      it_behaves_like 'an adapter'
-    end
-  end
-end

data/spec/autoloading_spec.rb

@@ -1,152 +0,0 @@
-describe "#{GraphQL::Client} Autoloading" do
-  describe ".load_constant" do
-    it "loads the specified constant if there is a matching graphql file" do
-      Github.send(:remove_const, :User) if Github.constants.include?(:User)
-
-      Github.load_constant(:User)
-
-      expect(defined?(Github::User)).to eq('constant')
-    end
-
-    it "does nothing and returns nil if there is no matching file" do
-      expect(Github.load_constant(:DoesNotExist)).to be_nil
-    end
-  end
-
-  describe ".preload!" do
-    it "preloads all the graphQL files in the query paths" do
-      %i(User UserRepositories Repository RepositoryFields)
-        .select {|const_name| Github.constants.include?(const_name) }
-        .each {|const_name| Github.send(:remove_const, const_name) }
-
-      Github.preload!
-
-      expect(defined?(Github::User)).to eq('constant')
-      expect(defined?(Github::Repository)).to eq('constant')
-    end
-  end
-
-  it "dynamically loads the matching GraphQL query and sets it to a constant" do
-    Github.send(:remove_const, :User) if Github.constants.include?(:User)
-
-    query = Github::User
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  it "dynamically loads the matching GraphQL fragment and sets it to a constant" do
-    Github.send(:remove_const, :RepositoryFields) if Github.constants.include?(:RepositoryFields)
-
-    query = Github::RepositoryFields
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      fragment Github__RepositoryFields on Repository {
-        name
-        nameWithOwner
-        url
-        updatedAt
-        languages(first: 1) {
-          nodes {
-            name
-            color
-          }
-        }
-      }
-    GRAPHQL
-  end
-
-  it "correctly loads the matching GraphQL query even when the top-level constant with the same name exists" do
-    # In Ruby <= 2.4 top-level constants can be looked up through a namespace, which turned out to be a bad practice.
-    # This has been removed in 2.5, but in earlier versions still suffer from this behaviour.
-    Github.send(:remove_const, :User) if Github.constants.include?(:User)
-    Object.send(:remove_const, :User) if Object.constants.include?(:User)
-
-    begin
-      Object.send(:const_set, :User, 1)
-
-      Github.user
-    ensure
-      Object.send(:remove_const, :User)
-    end
-
-    query = Github::User
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  it "raises an exception when the path was resolved but the file does not exist" do
-    begin
-      Github.graphql_file_paths << "github/removed.graphql"
-
-      expect { Github::Removed }.to raise_error(Errno::ENOENT)
-    ensure
-      Github.graphql_file_paths.delete("github/removed.graphql")
-    end
-  end
-
-  it "raises an NameError when there is no graphql file that matches the const name" do
-    expect { Github::DoesNotExist }.to raise_error(NameError)
-  end
-
-  xit "defines the query method when the matching class method gets called for the first time" do
-    Github.undef_method(:user) if Github.public_instance_methods.include?(:user)
-
-    Github.user
-
-    expect(Github.public_instance_methods).to include(:user)
-  end
-
-  it "raises an NameError when there is no graphql file that matches the class method name" do
-    expect { Github.does_not_exist }.to raise_error(NameError)
-  end
-
-  it "raises an NameError when the class method name matches a fragment name" do
-    expect { Github.repository_fields_fragment }.to raise_error(NameError)
-  end
-
-  it "responds to a class method that has a matching graphQL file" do
-    expect(Github).to respond_to(:user)
-  end
-
-  it "does not respond to class methods that do not have a matching graphQL file" do
-    expect(Github).not_to respond_to(:does_not_exist)
-  end
-
-  xit "defines the query method when the matching instance method gets called for the first time" do
-    Github.undef_method(:user) if Github.public_instance_methods.include?(:user)
-
-    Github.new.user
-
-    expect(Github.public_instance_methods).to include(:user)
-  end
-
-  it "raises an NameError when there is no graphql file that matches the instance method name" do
-    expect { Github.new.does_not_exist }.to raise_error(NameError)
-  end
-
-  it "raises an NameError when the instance method name matches a fragment name" do
-    expect { Github.new.repository_fields_fragment }.to raise_error(NameError)
-  end
-
-  it "responds to the method that has a matching graphQL file" do
-    expect(Github.new).to respond_to(:user)
-  end
-
-  it "does not respond to methods that do not have a matching graphQL file" do
-    expect(Github.new).not_to respond_to(:does_not_exist)
-  end
-end

data/spec/callbacks_spec.rb

@@ -1,60 +0,0 @@
-require 'active_support/core_ext/module/attribute_accessors'
-
-describe "#{GraphQL::Client} Callbacks" do
-  Client = Class.new(Artemis::Client) do
-    def self.name
-      'Github'
-    end
-
-    mattr_accessor :before_callback, :after_callback
-    self.before_callback = nil
-    self.after_callback = nil
-
-    before_execute do |document, operation_name, variables, context|
-      self.before_callback = document, operation_name, variables, context
-    end
-
-    after_execute do |data, errors, extensions|
-      self.after_callback = data, errors, extensions
-    end
-  end
-
-  Spotify = Class.new(Artemis::Client) do
-    def self.name
-      'Spotify'
-    end
-
-    before_execute do
-      raise "this callback should not get invoked"
-    end
-
-    after_execute do
-      raise "this callback should not get invoked"
-    end
-  end
-
-  describe ".before_execute" do
-    it "gets invoked before executing" do
-      Client.repository(owner: "yuki24", name: "artemis", context: { user_id: 'yuki24' })
-
-      document, operation_name, variables, context = Client.before_callback
-
-      expect(document).to eq(Client::Repository.document)
-      expect(operation_name).to eq('Client__Repository')
-      expect(variables).to eq("name" => "artemis", "owner" => "yuki24")
-      expect(context).to eq(user_id: 'yuki24')
-    end
-  end
-
-  describe ".after_execute" do
-    it "gets invoked after executing" do
-      Client.user
-
-      data, errors, extensions = Client.after_callback
-
-      expect(data).to eq("test" => "data")
-      expect(errors).to eq([])
-      expect(extensions).to eq({})
-    end
-  end
-end