atum 0.5.0

data/lib/atum/core/schema/parameter.rb

@@ -0,0 +1,27 @@
+module Atum
+  module Core
+    module Schema
+      class Parameter
+        attr_reader :resource_name
+
+        def initialize(resource_name, name, description)
+          @resource_name = resource_name
+          @name = name
+          @description = description
+        end
+
+        def name
+          [@resource_name, @name].compact.join('_')
+        end
+
+        def description
+          @description || ''
+        end
+
+        def inspect
+          "Parameter(name=#{name}, description=#{description})"
+        end
+      end
+    end
+  end
+end

data/lib/atum/core/schema/parameter_choice.rb

@@ -0,0 +1,28 @@
+module Atum
+  module Core
+    module Schema
+      class ParameterChoice
+        attr_reader :resource_name, :parameters
+
+        def initialize(resource_name, parameters)
+          @resource_name = resource_name
+          @parameters = parameters
+        end
+
+        def description
+          @parameters.map(&:description).join(' or ')
+        end
+
+        def name
+          @parameters.map do |parameter|
+            if parameter.resource_name
+              parameter.name
+            else
+              "#{@resource_name}_#{parameter.name}"
+            end
+          end.join('_or_')
+        end
+      end
+    end
+  end
+end

data/lib/atum/core/schema/resource_schema.rb

@@ -0,0 +1,51 @@
+module Atum
+  module Core
+    module Schema
+      class ResourceSchema
+        attr_reader :name
+
+        # Instantiate a resource schema.
+        #
+        # @param schema [ApiSchema] The whole document's schema
+        # @param name [String] The name of the resource to identify in the schema.
+        def initialize(schema, definition, name)
+          @schema = schema
+          @name = name
+          @definition = definition
+        end
+
+        %w(description definitions properties).each do |key|
+          define_method(key) { @definition[key] }
+        end
+
+        # Get a schema for a named link.
+        #
+        # @param name [String] The name of the link.
+        # @raise [SchemaError] Raised if an unknown link name is provided.
+        def link_schema_for(name)
+          link_schema = link_schema_hash[name]
+          raise SchemaError, "Unknown link '#{name}'." unless link_schema
+          link_schema
+        end
+
+        # The link schema children that are part of this resource schema.
+        #
+        # @return [Array<LinkSchema>] The link schema children.
+        def link_schemas
+          link_schema_hash.values
+        end
+
+        private
+
+        def link_schema_hash
+          @link_schema_hash ||= Hash[
+            @definition['links'].map do |link|
+              [link['title'].downcase.gsub(' ', '_'),
+               LinkSchema.new(@schema, self, link)]
+            end
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/atum/generation.rb

@@ -0,0 +1,15 @@
+module Atum
+  module Generation
+  end
+end
+
+require 'atum/generation/errors'
+require 'atum/generation/erb_context'
+require 'atum/generation/options_parameter'
+require 'atum/generation/generator_link'
+require 'atum/generation/generator_resource'
+require 'atum/generation/generator_service'
+require 'atum/generation/generators/base_generator'
+require 'atum/generation/generators/module_generator'
+require 'atum/generation/generators/client_generator'
+require 'atum/generation/generators/resource_generator'

data/lib/atum/generation/erb_context.rb

@@ -0,0 +1,17 @@
+module Atum
+  module Generation
+    class ErbContext < Erubis::Context
+      def commentify(comment, tabs)
+        starter = ('  ' * tabs) + '# '
+        max_line_length = 78 - (tabs * 2)
+        comment.split("\n")
+          .map { |l| l.scan(/.{1,#{max_line_length}}/) }
+          .flatten.map { |l| starter + l.strip }.join("\n")
+      end
+
+      def method(name, params)
+        "#{name}" + (params.length > 0 ? "(#{params})" : '')
+      end
+    end
+  end
+end

data/lib/atum/generation/errors.rb

@@ -0,0 +1,6 @@
+module Atum
+  module Generation
+    class GeneratorError < StandardError
+    end
+  end
+end

data/lib/atum/generation/generator_link.rb

@@ -0,0 +1,39 @@
+module Atum
+  module Generation
+    class GeneratorLink
+      def initialize(link_schema)
+        @link_schema = link_schema
+      end
+
+      def name
+        @link_schema.name
+      end
+
+      def description
+        @link_schema.description
+      end
+
+      def parameters
+        @parameters ||= begin
+          params = @link_schema.parameters
+          params << OptionsParameter.new
+          params
+        end
+      end
+
+      # The list of parameters to render in generated source code for the method
+      # signature for the link.
+      def parameter_names_with_defaults
+        parameters.map do |param|
+          s = param.name
+          s += " = #{param.default}" if param.respond_to?(:default)
+          s
+        end.join(', ')
+      end
+
+      def parameter_names
+        parameters.map(&:name).join(', ')
+      end
+    end
+  end
+end

data/lib/atum/generation/generator_resource.rb

@@ -0,0 +1,31 @@
+module Atum
+  module Generation
+    class GeneratorResource
+      def initialize(resource_schema)
+        @resource_schema = resource_schema
+      end
+
+      # The name of the resource, in snake case.
+      def name
+        @resource_schema.name.gsub('-', '_')
+      end
+
+      # Description of the resource.
+      def description
+        @resource_schema.description
+      end
+
+      # Links available on this resource.
+      def links
+        @links ||= @resource_schema.link_schemas.map do |link_schema|
+          GeneratorLink.new(link_schema)
+        end
+      end
+
+      # The name of the resource class in generated code.
+      def class_name
+        name.camelcase
+      end
+    end
+  end
+end

data/lib/atum/generation/generator_service.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+
+module Atum
+  module Generation
+    class GeneratorService
+      def initialize(module_name, schema_file, url, options)
+        @module_name = module_name
+        @schema = schema_from_file(schema_file)
+        @url = url
+        @options = options
+      end
+
+      def generate_files
+        generate_namespace_folder
+        generated_files.each do |gf|
+          File.open("#{gf.path}.rb", 'w') do |f|
+            f.write(gf.generator.generate)
+          end
+        end
+      end
+
+      private
+
+      def schema_from_file(file)
+        Atum::Core::Schema::ApiSchema.new(JSON.parse(File.read(file)))
+      end
+
+      def generate_namespace_folder
+        FileUtils.mkdir_p namespace_path
+        FileUtils.mkdir_p File.join(namespace_path, 'resources')
+      end
+
+      def resources
+        @schema.resource_schemas.map { |r| GeneratorResource.new(r) }
+      end
+
+      def generated_files
+        files = []
+
+        files << GeneratedFile.new(namespace_path,
+                                   Generators::ModuleGenerator.new(*generator_args))
+
+        files << GeneratedFile.new(File.join(namespace_path, 'client'),
+                                   Generators::ClientGenerator.new(*generator_args))
+
+        resources.each do |resource|
+          files << GeneratedFile.new(
+            File.join(namespace_path, 'resources', resource.name.underscore),
+            Generators::ResourceGenerator.new(resource, *generator_args))
+        end
+
+        files
+      end
+
+      def namespace
+        @module_name.downcase.underscore
+      end
+
+      def namespace_path
+        s = []
+        s << @options[:path] if @options.key?(:path)
+        s << namespace
+        File.join(*s)
+      end
+
+      def generator_args
+        [@module_name, @schema, @url, @options]
+      end
+
+      class GeneratedFile < Struct.new(:path, :generator); end
+    end
+  end
+end

data/lib/atum/generation/generators/base_generator.rb

@@ -0,0 +1,57 @@
+module Atum
+  module Generation
+    module Generators
+      class BaseGenerator
+        TEMPLATE_NAME = nil
+
+        # Generate a static client that uses Atum under the hood.  This is a good
+        # option if you want to ship a gem or generate API documentation using Yard.
+        #
+        # @param module_name [String] The name of the module, as rendered in a Ruby
+        #   source file, to use for the generated client.
+        # @param schema [Schema] The schema instance to generate the client from.
+        # @param url [String] The URL for the API service.
+        # @param options [Hash] Configuration for links.  Possible keys include:
+        #   - default_headers: Optionally, a set of headers to include in every
+        #     request made by the client.  Default is no custom headers.
+        def initialize(module_name, schema, url, options)
+          @module_name = module_name
+          @schema = schema
+          @url = url
+          @options = options
+        end
+
+        def context
+          ErbContext.new(context_hash.merge(module_name: @module_name))
+        end
+
+        def context_hash
+          raise NotImplementedError, 'Subclasses must define context_hash'
+        end
+
+        def template
+          @template ||= Erubis::Eruby.new(File.read(template_path))
+        end
+
+        def generate
+          template.evaluate(context)
+        end
+
+        def resources
+          @schema.resource_schemas.map { |r| GeneratorResource.new(r) }
+        end
+
+        private
+
+        def template_path
+          File.expand_path(File.join(File.dirname(__FILE__), 'views',
+                                     "#{template_name}.erb"))
+        end
+
+        def template_name
+          raise NotImplementedError, 'Subclasses must define template_name'
+        end
+      end
+    end
+  end
+end

data/lib/atum/generation/generators/client_generator.rb

@@ -0,0 +1,16 @@
+module Atum
+  module Generation
+    module Generators
+      class ClientGenerator < BaseGenerator
+        def context_hash
+          { description: @schema.description,
+            resources: resources }
+        end
+
+        def template_name
+          'client'
+        end
+      end
+    end
+  end
+end

data/lib/atum/generation/generators/module_generator.rb

@@ -0,0 +1,17 @@
+module Atum
+  module Generation
+    module Generators
+      class ModuleGenerator < BaseGenerator
+        def context_hash
+          { default_headers: @options.fetch(:default_headers, {}),
+            schema: JSON.dump(@schema.schema),
+            resources: resources }
+        end
+
+        def template_name
+          'module'
+        end
+      end
+    end
+  end
+end

data/lib/atum/generation/generators/resource_generator.rb

@@ -0,0 +1,23 @@
+module Atum
+  module Generation
+    module Generators
+      class ResourceGenerator < BaseGenerator
+        def initialize(resource, *args)
+          super(*args)
+          @resource = resource
+        end
+
+        def context_hash
+          { description: @resource.description,
+            class_name: @resource.class_name,
+            links: @resource.links,
+            resource_name: @resource.name }
+        end
+
+        def template_name
+          'resource'
+        end
+      end
+    end
+  end
+end

data/lib/atum/generation/generators/views/client.erb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+#
+# WARNING: Do not edit by hand, this file was generated by Atum:
+#
+#   https://github.com/gocardless/atum
+#
+require 'atum'
+require 'uri'
+
+module <%= @module_name %>
+<%= commentify(@description, 1) %>
+  class Client
+    def initialize(client)
+      @client = client
+    end
+    <% @resources.each do |resource| %>
+
+<%= commentify(resource.description, 2) %>
+    #
+<%= commentify("@return [" +resource.class_name + "]", 2) %>
+    def <%= resource.name %>
+      @<%= resource.name %>_resource ||= <%= resource.class_name %>.new(@client)
+    end
+    <% end %>
+  end
+end