lighthouse-graphql 0.1.0 → 0.2.0

data/lib/lighthouse/schema_generator.rb

@@ -1,244 +1,201 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module SchemaGenerator
-      module_function
-
-      def build(sdl_string, **opts)
-        # Contribute SDL definitions for any registered directive the schema uses
-        # but hasn't declared, so the app doesn't hand-declare every directive.
-        sdl_string = inject_directive_definitions(sdl_string)
-        # Augment SDL: convert list-typed fields with relationship directives
-        # (e.g. `roles: [Role!]! @belongsToMany`) into connection types
-        # (`roles: RoleConnection!`) and generate missing Connection/Edge types.
-        sdl_string = augment_sdl_with_connections(sdl_string)
-        impl =
-          if defined?(::SchemaImplementation)
-            ::SchemaImplementation.new
-          else
-            # Minimal fallback when SchemaImplementation isn't available.
-            # Keep the same dispatch semantics so directive resolvers work.
-            Class.new do
-              attr_accessor :schema
-
-              def call(type, field, obj, args, ctx)
-                field_name = field.respond_to?(:graphql_name) ? field.graphql_name.to_s : field.name.to_s
-                owner = schema && schema.types[type.respond_to?(:graphql_name) ? type.graphql_name : type.name.to_s]
-
-                if owner && owner.respond_to?("resolve_field_#{field_name}")
-                  resolver = owner.method("resolve_field_#{field_name}")
-                  param_count = resolver.parameters.length
-                  return resolver.call(obj, args) if param_count == 2
-
-                  return resolver.call(obj, args, ctx)
-                end
-
-                return field.resolve_proc.call(obj, args, ctx) if field.respond_to?(:resolve_proc) && field.resolve_proc
-
-                obj.respond_to?(field_name) ? obj.public_send(field_name) : nil
-              end
-
-              def resolve_type(_abstract_type, _obj, _ctx)
-                nil
-              end
-
-              def coerce_input(_type, value, _ctx)
-                value
-              end
-
-              def coerce_result(_type, value, _ctx)
-                value
-              end
-            end.new
-          end
-
-        final_sdl = sdl_string
-        base_types = opts.delete(:base_types) || {}
-        using = opts.delete(:using) || {}
-        schema_class = opts.delete(:schema_class) || ::GraphQL::Schema
-
-        # Build using the provided base class so federation / custom schema behavior
-        # is preserved through class hierarchy.
-        schema = schema_class.from_definition(final_sdl, default_resolve: impl, base_types: base_types, using: using)
-
-        # Make to_definition delegate to federation_sdl when available.
-        if schema.respond_to?(:federation_sdl)
-          schema.define_singleton_method(:to_definition) do
-            federation_sdl
-          end
-        end
-        # GraphQL-Ruby caches field resolution procs during schema build; rather
-        # than trying to override per-field `resolve_<field>` methods post-hoc,
-        # we install a single dispatcher here that prefers our generated
-        # `resolve_field_<name>` singletons.
-        if schema.respond_to?(:definition_default_resolve=) && schema.respond_to?(:definition_default_resolve)
-          previous_default = schema.definition_default_resolve
-          schema.definition_default_resolve = proc do |type, field, obj, arguments, ctx|
-            owner =
-              if type.respond_to?(:graphql_name)
-                schema.types[type.graphql_name]
-              elsif type.respond_to?(:name)
-                schema.types[type.name.to_s]
-              end
-
-            field_name = field.respond_to?(:graphql_name) ? field.graphql_name.to_s : field.name.to_s
-
-            if owner && owner.respond_to?("resolve_field_#{field_name}")
-              resolver = owner.method("resolve_field_#{field_name}")
-              source_file, = resolver.source_location
-              # GraphQL-Ruby's SDL builder also defines `resolve_field_*` methods
-              # internally. Only invoke ours (defined under `lib/lighthouse/`),
-              # otherwise we may call an internal resolver with the wrong arity.
-              if source_file && source_file.include?('/lib/lighthouse/')
-                param_count = resolver.parameters.length
-                next resolver.call(obj, arguments) if param_count == 2
-
-                next resolver.call(obj, arguments, ctx)
-              end
-            end
-
-            previous_default.call(type, field, obj, arguments, ctx)
-          end
-        end
-
-        # Give the implementation object access to the built schema so its
-        # runtime dispatcher can look up generated singleton resolvers.
-        begin
-          impl.schema = schema if impl.respond_to?(:schema=)
-        rescue StandardError
-          # ignore
-        end
-
-        post_process(schema, impl, **opts)
-
-        schema
-      end
-
-      def post_process(schema, impl, **_opts)
-        # Inspect types and fields for directives and attach generated resolvers
-        schema.types.each_value do |t|
-          next unless t.kind.object?
-
-          # Apply object-level federation directives to generated types so the
-          # Apollo Federation helper can detect entities and add _entities.
-          if t.ast_node && t.respond_to?(:key)
-            t.ast_node.directives.each do |dnode|
-              case dnode.name
-              when 'key'
-                arg = dnode.arguments.find { |a| a.name == 'fields' }
-                t.key(fields: arg.value) if arg && arg.respond_to?(:value)
-
-                # Setup federation resolve_reference: prefer a custom resolver
-                # registered with ReferenceResolver, but fall back to the base
-                # type's own resolve_reference (e.g. BaseObject's default model
-                # lookup) so direct-model entities resolve without a custom
-                # handler. Capture the inherited implementation before shadowing.
-                default_resolve_reference =
-                  t.respond_to?(:resolve_reference) ? t.method(:resolve_reference) : nil
-
-                t.define_singleton_method(:resolve_reference) do |reference, context|
-                  resolved = ::Lighthouse::ReferenceResolver.resolve(t.graphql_name, reference, context)
-                  next resolved unless resolved.nil?
-
-                  default_resolve_reference ? default_resolve_reference.call(reference, context) : nil
-                end
-              when 'extends'
-                t.extend_type if t.respond_to?(:extend_type)
-              when 'shareable'
-                t.shareable if t.respond_to?(:shareable)
-              when 'inaccessible'
-                t.inaccessible if t.respond_to?(:inaccessible)
-              when 'interfaceObject'
-                t.interface_object if t.respond_to?(:interface_object)
-              end
-            end
-          end
-
-          t.fields.each do |fname, field_def|
-            next unless field_def.ast_node
-
-            directives = field_def.ast_node.directives || []
-            registry = Lighthouse::DirectiveRegistry.default
-            # Apply wrapping directives in resolution order: data resolvers first
-            # (innermost), then @can (wraps to authorize the result), then guards
-            # (outermost, so authentication runs before anything else).
-            sorted = directives.sort_by { |d| registry.resolution_order(d.name) }
-
-            # Dispatch each directive to its registered resolver class. The
-            # registry replaces the previous hardcoded `case dnode.name` so that
-            # adding a directive is "register a class", not "edit the generator".
-            sorted.each do |dnode|
-              resolver_class = registry.resolution_class(dnode.name)
-              next unless resolver_class
-
-              resolver_class.new(field_def, t, dnode).define_resolver(t)
-            end
-
-            # GraphQL-Ruby's SDL builder defines `resolve_<field>` methods that call
-            # the schema's `definition_default_resolve`. Override `resolve_<field>`
-            # to delegate to our generated `resolve_field_<field>` when present, so
-            # runtime resolution consistently reaches our directive resolvers.
-            begin
-              method_name = "resolve_field_#{field_def.name}"
-              runtime_name = "resolve_#{field_def.name}"
-              if t.respond_to?(method_name)
-                t.define_singleton_method(runtime_name) do |obj, arguments, ctx|
-                  public_send(method_name, obj, arguments, ctx)
-                end
-              end
-            rescue StandardError
-              # ignore override failures
-            end
-
-            # Ensure GraphQL-Ruby's ConnectionExtension is applied for SDL-built
-            # connection fields so the runtime will wrap returned values into
-            # Connection objects (populate_connection will be invoked).
-            begin
-              # Avoid adding the ConnectionExtension if pagination args were
-              # already added by SDL augmentation (to prevent duplicate arg
-              # collisions).
-              if field_def.connection? && !(field_def.extensions.any? do |e|
-                e.is_a?(::GraphQL::Schema::Field::ConnectionExtension)
-              end) && !((field_def.arguments || {}).key?(:after) || (field_def.arguments || {}).key?('after'))
-                field_def.extension(::GraphQL::Schema::Field::ConnectionExtension,
-                                    call_after_define: false)
-              end
-            rescue StandardError
-              # ignore failures during post-processing
-            end
-          end
-        end
-
-        # return schema for convenience
-        schema
-      end
-
-      # Scan SDL string for list-typed fields that carry relationship directives
-      # and produce Connection/Edge types where missing. This is a lightweight
-      # transformation that mirrors Lighthouse behavior: clients can declare
-      # `roles: [Role!]! @belongsToMany` and the builder will expose a
-      # `RoleConnection` type and swap the field to return that connection.
-      def augment_sdl_with_connections(sdl)
-        # Drive SDL manipulation through the registry so each directive owns its
-        # manipulation behavior and new manipulators can be added by registering
-        # a class (no edits here).
-        Lighthouse::DirectiveRegistry.default.manipulate_sdl(sdl)
-      end
-
-      # Prepend `directive @name(...) on ...` definitions for registered,
-      # self-describing directives that the SDL uses but has not declared.
-      # Already-declared directives are left untouched (no duplicates).
-      def inject_directive_definitions(sdl)
-        return sdl unless sdl.is_a?(String)
-
-        declared = sdl.scan(/directive\s+@(\w+)/).flatten.to_set
-        missing = Lighthouse::DirectiveRegistry.default.directive_definitions
-                                               .reject { |name, _| declared.include?(name) }
-        return sdl if missing.empty?
-
-        "#{missing.values.join("\n")}\n\n#{sdl}"
-      end
+module Lighthouse::GraphQL::SchemaGenerator
+  # Minimal fallback when SchemaImplementation isn't available.
+  # Keep the same dispatch semantics so directive resolvers work.
+  class FallbackImplementation
+    attr_accessor :schema
+
+    def call(type, field, obj, args, ctx)
+      field_name = Lighthouse::GraphQL::GeneratedResolvers.field_name(field)
+      resolver = generated_resolver(type, field_name)
+      return Lighthouse::GraphQL::GeneratedResolvers.invoke(resolver, obj, args, ctx) if resolver
+      return field.resolve_proc.call(obj, args, ctx) if field.respond_to?(:resolve_proc) && field.resolve_proc
+
+      obj.respond_to?(field_name) ? obj.public_send(field_name) : nil
     end
+
+    def resolve_type(_abstract_type, _obj, _ctx)
+      nil
+    end
+
+    def coerce_input(_type, value, _ctx)
+      value
+    end
+
+    def coerce_result(_type, value, _ctx)
+      value
+    end
+
+    private
+
+    def generated_resolver(type, field_name)
+      owner = schema && schema.types[type.respond_to?(:graphql_name) ? type.graphql_name : type.name.to_s]
+      method_name = Lighthouse::GraphQL::GeneratedResolvers.method_name(field_name)
+      owner.method(method_name) if owner.respond_to?(method_name)
+    end
+  end
+
+  module_function
+
+  def build(sdl_string, **opts)
+    # Decided on the app's SDL: once definitions are injected, every schema mentions it.
+    uses_cache_control = sdl_string.to_s.gsub(/directive\s+@cacheControl/, '').include?('@cacheControl')
+    # The manipulated document — from the schema cache when it is enabled
+    # and fresh (see SchemaCache), else built now.
+    document = Lighthouse::GraphQL::SchemaCache.document(sdl_string) { |sdl| manipulate(sdl) }
+    impl = default_implementation
+    schema = from_document(document, impl, opts)
+
+    delegate_to_federation_sdl(schema)
+    Lighthouse::GraphQL::GeneratedResolvers.install_dispatcher(schema)
+    attach_schema(impl, schema)
+    post_process(schema, impl, **opts)
+
+    # @cacheControl hints become the response's Cache-Control header,
+    # computed per query from the fields it selects.
+    schema.query_analyzer(Lighthouse::GraphQL::CacheControl::Analyzer) if uses_cache_control
+
+    schema
+  end
+
+  # The runtime resolver graphql-ruby calls for every field: SchemaImplementation
+  # (the library's, or the app's own) when loaded, else the minimal fallback.
+  def default_implementation
+    defined?(::SchemaImplementation) ? ::SchemaImplementation.new : FallbackImplementation.new
+  end
+
+  # Build using the provided base class so federation / custom schema behavior
+  # is preserved through class hierarchy.
+  # The document is handed over through `parser:`, graphql-ruby's public
+  # hook, so it is not parsed again. Takes the options it uses out of `opts`;
+  # the rest are post_process's.
+  def from_document(document, impl, opts)
+    base_types = opts.delete(:base_types) || {}
+    using = opts.delete(:using) || {}
+    schema_class = opts.delete(:schema_class) || ::GraphQL::Schema
+
+    schema_class.from_definition('', parser: prebuilt_parser(document), default_resolve: impl,
+                                     base_types: base_types, using: using)
+  end
+
+  # Make to_definition delegate to federation_sdl when available.
+  def delegate_to_federation_sdl(schema)
+    return unless schema.respond_to?(:federation_sdl)
+
+    schema.define_singleton_method(:to_definition) do
+      federation_sdl
+    end
+  end
+
+  # Give the implementation object access to the built schema so its
+  # runtime dispatcher can look up generated singleton resolvers.
+  def attach_schema(impl, schema)
+    impl.schema = schema if impl.respond_to?(:schema=)
+  rescue StandardError
+    # ignore
+  end
+
+  # A "parser" returning a document that is already parsed. A module, not
+  # an object: graphql-ruby checks `defined?(parser::SchemaParser)`, which on
+  # a plain object builds a TypeError message by inspecting it — the whole
+  # document, quadratically slow on a large schema.
+  def prebuilt_parser(document)
+    Module.new { define_singleton_method(:parse) { |*| document } }
+  end
+
+  # The SDL as the schema is built from it: directive definitions injected
+  # (so apps don't hand-declare Lighthouse's directives), then every
+  # registered manipulator run (pagination types, whereConditions inputs, ...).
+  def manipulate(sdl)
+    augment_sdl_with_connections(inject_directive_definitions(sdl))
+  end
+
+  def post_process(schema, _impl, **_opts)
+    root_kinds = { schema.query&.graphql_name => :queries, schema.mutation&.graphql_name => :mutations }.reject { |name, _| name.nil? }
+
+    # Inspect types and fields for directives and attach generated resolvers
+    schema.types.each_value do |type|
+      next unless type.kind.object?
+
+      # Apply object-level federation directives to generated types so the
+      # Apollo Federation helper can detect entities and add _entities.
+      Lighthouse::GraphQL::FederationDirectives.apply(type)
+      type.fields.each_value { |field_def| process_field(type, field_def, root_kinds[type.graphql_name]) }
+    end
+
+    # return schema for convenience
+    schema
+  end
+
+  # A field's generated resolvers, then the runtime hooks that make
+  # graphql-ruby reach them.
+  def process_field(type, field_def, root_kind)
+    return unless field_def.ast_node
+
+    apply_field_resolvers(type, field_def, field_def.ast_node.directives || [], root_kind)
+    Lighthouse::GraphQL::GeneratedResolvers.route_runtime_resolver(type, field_def)
+    ensure_connection_extension(field_def)
+  end
+
+  # Ensure GraphQL-Ruby's ConnectionExtension is applied for SDL-built
+  # connection fields so the runtime will wrap returned values into
+  # Connection objects (populate_connection will be invoked).
+  def ensure_connection_extension(field_def)
+    return unless field_def.connection? && field_def.extensions.none?(::GraphQL::Schema::Field::ConnectionExtension)
+
+    # Avoid adding the ConnectionExtension if pagination args were
+    # already added by SDL augmentation (to prevent duplicate arg
+    # collisions).
+    return if (field_def.arguments || {}).then { |arguments| arguments.key?(:after) || arguments.key?('after') }
+
+    field_def.extension(::GraphQL::Schema::Field::ConnectionExtension, call_after_define: false)
+  rescue StandardError
+    # ignore failures during post-processing
+  end
+
+  # A field's resolvers, installed in resolution order (see FieldResolverStack).
+  def apply_field_resolvers(type, field_def, directives, root_kind)
+    Lighthouse::GraphQL::FieldResolverStack.apply(type, field_def, directives, root_kind)
+  end
+
+  # Scan SDL string for list-typed fields that carry relationship directives
+  # and produce Connection/Edge types where missing. This is a lightweight
+  # transformation that mirrors Lighthouse behavior: clients can declare
+  # `roles: [Role!]! @belongsToMany` and the builder will expose a
+  # `RoleConnection` type and swap the field to return that connection.
+  def augment_sdl_with_connections(sdl)
+    # Drive SDL manipulation through the registry so each directive owns its
+    # manipulation behavior and new manipulators can be added by registering
+    # a class (no edits here).
+    Lighthouse::DirectiveRegistry.default.manipulate_sdl(sdl)
+  end
+
+  # Prepend `directive @name(...) on ...` definitions for registered,
+  # self-describing directives that the SDL uses but has not declared.
+  # Already-declared directives are left untouched (no duplicates).
+  def inject_directive_definitions(sdl)
+    return sdl unless sdl.is_a?(String)
+
+    missing = missing_directive_definitions(sdl)
+    return sdl if missing.empty?
+
+    definitions = missing.values + missing_type_definitions(sdl, missing.values).values
+    "#{definitions.join("\n")}\n\n#{sdl}"
+  end
+
+  # Types the given directive definitions refer to (`CanAction`,
+  # `ClearCacheIdSource`, ...) that the SDL does not define itself.
+  def missing_type_definitions(sdl, directive_definitions, registry: Lighthouse::DirectiveRegistry.default)
+    declared = sdl.to_s.scan(/^\s*(?:scalar|enum|input|type|interface|union)\s+(\w+)/).flatten.to_set
+    text = directive_definitions.join("\n")
+    registry.type_definitions.select { |name, _| declared.exclude?(name) && text.match?(/\b#{name}\b/) }
+  end
+
+  # The registry's directive definitions minus those the SDL declares itself.
+  # Returns { "name" => "directive @name(...) on ..." }.
+  def missing_directive_definitions(sdl, registry: Lighthouse::DirectiveRegistry.default)
+    declared = sdl.to_s.scan(/directive\s+@(\w+)/).flatten.to_set
+    registry.directive_definitions.except(*declared)
   end
 end

data/lib/lighthouse/schema_implementation.rb

@@ -16,57 +16,18 @@ class SchemaImplementation
   def call(type, field, obj, args, ctx)
     field_name = extract_field_name(field)
 
-    # Prefer singleton resolver methods attached during post_process
-    owner_candidates = [type]
-    if type.respond_to?(:metadata) && type.metadata.is_a?(Hash) && type.metadata[:type_class]
-      owner_candidates << type.metadata[:type_class]
-    end
-    owner_candidates << lookup_owner_type(type)
-
-    resolver_method_name = "resolve_field_#{field_name}"
-    owner = owner_candidates.compact.find do |cand|
-      next false unless cand.respond_to?(resolver_method_name)
-      m = cand.method(resolver_method_name)
-      source_file, = m.source_location
-      source_file && source_file.include?('/lib/lighthouse/')
-    end
-
-    if owner
-      resolver = owner.method(resolver_method_name)
-      param_count = resolver.parameters.length
-      return resolver.call(obj, args) if param_count == 2
-      resolver.call(obj, args, ctx)
-    end
+    # Prefer singleton resolver methods attached during post_process.
+    resolver = generated_resolver(type, field_name)
+    return Lighthouse::GraphQL::GeneratedResolvers.invoke(resolver, obj, args, ctx) if resolver
 
     # Use field-level resolve proc if available
-    if field.respond_to?(:resolve_proc) && field.resolve_proc
-      return field.resolve_proc.call(obj, args, ctx)
-    end
-
-    if obj.is_a?(Hash)
-      return obj[field_name.to_s] if obj.key?(field_name.to_s)
-      return obj[field_name.to_sym] if obj.key?(field_name.to_sym)
-
-      snake = naming_attribute(field_name)
-      return obj[snake] if obj.key?(snake)
-      return obj[snake.to_sym] if obj.key?(snake.to_sym)
-
-      return nil
-    end
+    return field.resolve_proc.call(obj, args, ctx) if field.respond_to?(:resolve_proc) && field.resolve_proc
+    return read_hash(obj, field_name) if obj.is_a?(Hash)
 
-    # Fallback to reading the attribute off the Ruby object. Map the GraphQL
-    # field name (camelCase) to the Rails attribute (snake_case) when the object
-    # does not respond to the literal name, so e.g. `customAttributes` resolves
-    # to `custom_attributes` without a per-field resolver.
-    return obj.public_send(field_name) if obj.respond_to?(field_name)
-
-    snake = naming_attribute(field_name)
-    return obj.public_send(snake) if snake != field_name.to_s && obj.respond_to?(snake)
-
-    nil
+    read_attribute(obj, field_name)
   end
 
-  def resolve_type(abstract_type, obj, ctx)
+  def resolve_type(abstract_type, _obj, _ctx)
     # Try to resolve to a Ruby type class under Types::<Name>Type
     type_name = abstract_type.respond_to?(:name) ? abstract_type.name : abstract_type.to_s
     begin
@@ -76,16 +37,57 @@ class SchemaImplementation
     end
   end
 
-  def coerce_input(type, value, ctx)
+  def coerce_input(_type, value, _ctx)
     value
   end
 
-  def coerce_result(type, value, ctx)
+  def coerce_result(_type, value, _ctx)
     value
   end
 
   private
 
+  # Our generated `resolve_field_<name>` on the first owner that has one: the
+  # type itself, its type class, or the schema's type of the same name.
+  def generated_resolver(type, field_name)
+    method_name = Lighthouse::GraphQL::GeneratedResolvers.method_name(field_name)
+    owner_candidates(type).each do |candidate|
+      next unless candidate.respond_to?(method_name)
+
+      resolver = candidate.method(method_name)
+      return resolver if Lighthouse::GraphQL::GeneratedResolvers.generated?(resolver)
+    end
+    nil
+  end
+
+  def owner_candidates(type)
+    candidates = [type]
+    candidates << type.metadata[:type_class] if type.respond_to?(:metadata) && type.metadata.is_a?(Hash) && type.metadata[:type_class]
+    candidates << lookup_owner_type(type)
+    candidates.compact
+  end
+
+  # A Hash result is read by the field name as given, then in snake_case,
+  # each as a String or Symbol key.
+  def read_hash(hash, field_name)
+    snake = naming_attribute(field_name)
+    key = [field_name.to_s, field_name.to_sym, snake, snake.to_sym].find { |candidate| hash.key?(candidate) }
+    key.nil? ? nil : hash[key]
+  end
+
+  # Fallback to reading the attribute off the Ruby object. Map the GraphQL
+  # field name (camelCase) to the Rails attribute (snake_case) when the object
+  # does not respond to the literal name, so e.g. `customAttributes` resolves
+  # to `custom_attributes` without a per-field resolver.
+  def read_attribute(obj, field_name)
+    return obj.public_send(field_name) if obj.respond_to?(field_name)
+
+    snake = naming_attribute(field_name)
+    return obj.public_send(snake) if snake != field_name.to_s && obj.respond_to?(snake)
+
+    nil
+  end
+
   def naming_attribute(field_name)
     if defined?(Lighthouse::Support::Naming)
       Lighthouse::Support::Naming.attribute(field_name)
@@ -106,6 +108,7 @@ class SchemaImplementation
 
   def lookup_owner_type(type)
     return nil unless @schema
+
     type_name = if type.respond_to?(:graphql_name)
                   type.graphql_name
                 elsif type.respond_to?(:name)

data/lib/lighthouse/sdl_loader.rb

@@ -1,27 +1,24 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module SDLLoader
-      module_function
+module Lighthouse::GraphQL::SDLLoader
+  module_function
 
-      def load_from_folder(folder)
-        files = Dir[File.join(folder, '**', '*.graphql')].sort
-        if files.empty?
-          # fallback to the monolithic schema.graphql in apps/chatwoot
-          # schema.graphql is located at apps/chatwoot/schema.graphql
-          default = File.expand_path('../../..//schema.graphql', __dir__)
-          return File.read(default) if File.exist?(default)
-          return ''
-        end
+  def load_from_folder(folder)
+    files = Dir[File.join(folder, '**', '*.graphql')]
+    if files.empty?
+      # fallback to the monolithic schema.graphql in apps/chatwoot
+      # schema.graphql is located at apps/chatwoot/schema.graphql
+      default = File.expand_path('../../..//schema.graphql', __dir__)
+      return File.read(default) if File.exist?(default)
 
-        files.map! { |f| File.read(f) }
-        files.join("\n\n")
-      end
-
-      def load_from_file(path)
-        File.read(path)
-      end
+      return ''
     end
+
+    files.map! { |f| File.read(f) }
+    files.join("\n\n")
+  end
+
+  def load_from_file(path)
+    File.read(path)
   end
 end