svelte 0.1.1

data/lib/svelte/errors/version_error.rb

@@ -0,0 +1,9 @@
+module Svelte
+  # Svelte error class to represent version errors.
+  # Raised when a Swagger v1 JSON is fed into Svelte
+  class VersionError < StandardError
+    def message
+      'Invalid Swagger version spec supplied. Svelte supports Swagger v2 only'
+    end
+  end
+end

data/lib/svelte/generic_operation.rb

@@ -0,0 +1,63 @@
+module Svelte
+  # Class that handles the actual execution of dynamically generated operations
+  # Each created operation will eventually call this class in order to make the
+  # final HTTP request to the REST endpoint
+  class GenericOperation
+    class << self
+      # Make an HTTP request to a REST resource
+      # @param verb [String] http verb to use, i.e. `'get'`
+      # @param path [Path] Path object containing information about the
+      #   operation to be called
+      # @param configuration [Configuration] Swagger API configuration
+      # @param parameters [Hash] payload of the request, i.e. `{ petId: 1}`
+      # @param options [Hash] request options, i.e. `{ timeout: 10 }`
+      def call(verb:, path:, configuration:, parameters:, options:)
+        url = url_for(configuration: configuration,
+                      path: path,
+                      parameters: parameters)
+        request_parameters = clean_parameters(path: path,
+                                              parameters: parameters)
+        RestClient.call(verb: verb,
+                        url: url,
+                        params: request_parameters,
+                        options: options)
+      end
+
+      private
+
+      def url_for(configuration:, path:, parameters:)
+        url_path =
+          [
+            path.non_parameter_elements,
+            named_parameters(path: path, parameters: parameters)
+          ].flatten.join('/')
+
+        protocol = configuration.protocol
+        host = configuration.host
+        base_path = configuration.base_path
+        if base_path == '/'
+          base_path = ''
+        end
+        "#{protocol}://#{host}#{base_path}/#{url_path}"
+      end
+
+      def named_parameters(path:, parameters:)
+        path.parameter_elements.map do |parameter_element|
+          unless parameters.key?(parameter_element)
+            raise ParameterError,
+                 "Required parameter `#{parameter_element}` missing"
+          end
+          parameters[parameter_element]
+        end
+      end
+
+      def clean_parameters(path:, parameters:)
+        clean_parameters = parameters.dup
+        path.parameter_elements.each do |parameter_element|
+          clean_parameters.delete(parameter_element)
+        end
+        clean_parameters
+      end
+    end
+  end
+end

data/lib/svelte/model_factory.rb

@@ -0,0 +1,171 @@
+require 'svelte/model_factory/parameter'
+
+module Svelte
+  # Bridging the gap between an application and any external service that
+  # publishes its API as a Swagger JSON spec.
+  # @note This module is supposed to be extended not used directly
+  module ModelFactory
+    # Creates typed Ruby objects from JSON definitions. These definitions are
+    # found in the Swagger JSON spec as a top-level key, "definitions".
+    # @param json [Hash] hash of a swagger models definition
+    # @return [Hash] A hash of model names to models created
+    def define_models(json)
+      return unless json
+      models = {}
+      model_definitions = json['definitions']
+      model_definitions.each do |model_name, parameters|
+        attributes = parameters['properties'].keys
+        model = Class.new do
+          attr_reader(*attributes.map(&:to_sym))
+
+          parameters['properties'].each do |attribute, options|
+            define_method("#{attribute}=", lambda do |value|
+              if public_send(attribute).nil? || !public_send(attribute).present?
+                permitted_values = options.fetch('enum', [])
+                required = parameters.fetch('required', []).include?(attribute)
+                instance_variable_set(
+                  "@#{attribute}",
+                  Parameter.new(options['type'],
+                                permitted_values: permitted_values,
+                                required: required)
+                )
+              end
+
+              instance_variable_get("@#{attribute}").value = value
+            end)
+          end
+        end
+
+        define_initialize_on(model: model)
+        define_attributes_on(model: model)
+        define_required_attributes_on(model: model)
+        define_json_for_model_on(model: model)
+        define_nested_models_on(model: model)
+        define_as_json_on(model: model)
+        define_to_json_on(model: model)
+        define_validate_on(model: model)
+        define_valid_on(model: model)
+
+        model.instance_variable_set('@json_for_model', parameters.freeze)
+
+        models[model_name] = model
+      end
+
+      models.each do |model_name, model|
+        const_set(model_name, model)
+      end
+    end
+
+    # Creates typed Ruby objects from JSON String definitions. These definitions
+    # are found in the Swagger JSON spec as a top-level key, "models".
+    # @param string [String] string of json for a swagger models definition
+    # @return [Hash] A hash of model names to models created
+    def define_models_from_json_string(string)
+      define_models(JSON.parse(string)) if string
+    end
+
+    # Creates typed Ruby objects from JSON File definitions. These definitions
+    # are found in the Swagger JSON spec as a top-level key, "models".
+    # @param file [String] path to a json file for a swagger models definition
+    # @return [Hash] A hash of model names to models created
+    def define_models_from_file(file)
+      define_models_from_json_string(File.read(file)) if file
+    end
+
+    private
+
+    def define_initialize_on(model:)
+      model.send(:define_method, :initialize, lambda do
+        (required_attributes - nested_models.keys).each do |required|
+          public_send("#{required}=", Parameter::UNSET)
+        end
+        required_nested_models = nested_models.keys & required_attributes
+        nested_models.each do |nested_model_name, nested_model_info|
+          return unless required_nested_models.include?(nested_model_name)
+          nested_class_name = public_send("#{nested_model_name}=",
+                                          nested_model_info['$ref']
+                                            .split('/').last)
+          nested_class_name = self.class.name.gsub(/::[^:]*\z/, '::') +
+                              nested_class_name
+          public_send("#{nested_model_name}=",
+                      Object.const_get(nested_class_name).new)
+        end
+      end)
+    end
+
+    def define_validate_on(model:)
+      model.send(:define_method, :validate, lambda do
+        invalid_params = {}
+        attributes.each do |attribute|
+          if public_send(attribute).respond_to?(:validate)
+            result = public_send(attribute).validate
+            invalid_params[attribute] = result unless result.empty?
+          end
+        end
+        invalid_params
+      end)
+    end
+
+    def define_valid_on(model:)
+      model.send(:define_method, :valid?, lambda do
+        validate.empty?
+      end)
+    end
+
+    def define_to_json_on(model:)
+      model.send(:define_method, :to_json, lambda do
+        as_json.to_json
+      end)
+    end
+
+    def define_attributes_on(model:)
+      model.send(:define_method, :attributes, lambda do
+        @attributes ||= json_for_model['properties'].keys
+      end)
+    end
+
+    def define_as_json_on(model:)
+      model.send(:define_method, :as_json, lambda do
+        structure = {}
+        attributes.each do |attribute|
+          value = if public_send(attribute).respond_to?(:as_json)
+                    public_send(attribute).as_json
+                  else
+                    public_send(attribute)
+                  end
+
+          structure[attribute] = value unless value.nil?
+        end
+
+        if structure.empty?
+          nil
+        else
+          symbolised_structure = {}
+          structure.each do |key, value|
+            symbolised_structure[key.to_sym] = value
+          end
+          symbolised_structure
+        end
+      end)
+    end
+
+    def define_json_for_model_on(model:)
+      model.send(:define_method, :json_for_model, lambda do
+        self.class.instance_variable_get('@json_for_model')
+      end)
+    end
+
+    def define_nested_models_on(model:)
+      model.send(:define_method, :nested_models, lambda do
+        json_for_model['properties']
+          .select { |_property, sub_properties| sub_properties.key?('$ref') }
+      end)
+    end
+
+    def define_required_attributes_on(model:)
+      model.send(:define_method, :required_attributes, lambda do
+        @required_attributes ||= json_for_model.fetch('required', [])
+      end)
+    end
+  end
+end

data/lib/svelte/model_factory/parameter.rb

@@ -0,0 +1,154 @@
+module Svelte
+  module ModelFactory
+    # Helper class to wrap around all parameters
+    class Parameter
+
+      # Constant to represent an unset parameter
+      UNSET = Class.new
+
+      # Override of the `inspect` method to return a string representation
+      # of the class
+      def UNSET.inspect
+        'unset'
+      end
+
+      attr_reader :type
+      attr_accessor :value
+
+      # Creates a new Parameter
+      # @param type [String]: Type of the parameter, i.e. `'integer'`
+      # @param permitted_values [Array]: array of allowed values
+      #  for the parameter
+      # @param required [Boolean]: is the parameter required?
+      def initialize(type, permitted_values: [], required: false)
+        @type = type
+        @permitted_values = permitted_values
+        @required = required
+        @value = UNSET
+      end
+
+      # @return [Boolean] true if and only if the parameter is valid
+      def valid?
+        validate.empty?
+      end
+
+      # @return [String] String representing
+      #   the validation errors of the parameter
+      def validate
+        # We are not a required parameter, so being unset is fine.
+        return '' if validate_blank
+
+        # if we have a nested model
+        return value.validate if value.respond_to?(:validate)
+
+        messages = validate_messages
+        messages.any? ? 'Invalid parameter: ' + messages.join(', ') : ''
+      end
+
+      # @return [Boolean] true if and only if the parameter has been set
+      def present?
+        !unset?
+      end
+
+      # @return [Hash] json representation of the parameter
+      def as_json
+        value.respond_to?(:as_json) ? value.as_json : value if present?
+      end
+
+      private
+
+      def validate_messages
+        messages = []
+
+        validate_type(messages)
+
+        messages << invalid_type_enum_message unless validate_value_in_enum
+        messages << required_parameter_missing_message unless validate_required
+
+        messages
+      end
+
+      def unset?
+        value == UNSET
+      end
+
+      def validate_blank
+        if @required
+          false
+        else
+          unset?
+        end
+      end
+
+      def validate_required
+        return true unless @required
+        return false if unset?
+        true
+      end
+
+      def validate_value_in_enum
+        return true if @permitted_values.empty?
+        @permitted_values.include?(value)
+      end
+
+      def validate_type(messages)
+        return true if unset? || not_required_but_nil?
+
+        # TODO: this smells, should we have a duck type that responds
+        # to .validate?
+        valid = case type
+                when 'string'
+                  validate_string
+                when 'boolean'
+                  validate_boolean
+                when 'number', 'integer'
+                  validate_number
+                when 'array'
+                  validate_array
+                when 'object'
+                  # Objects cannot be validated
+                  true
+                else
+                  false
+                end
+        messages << invalid_type_message unless valid
+      end
+
+      def invalid_type_message
+        "Expected valid #{type}, but was #{value.inspect}"
+      end
+
+      def invalid_type_enum_message
+        "Expected one of #{@permitted_values.inspect}, but was #{value.inspect}"
+      end
+
+      def required_parameter_missing_message
+        'Missing required parameter'
+      end
+
+      def not_required_but_nil?
+        !@required && value.nil?
+      end
+
+      def validate_string
+        value.is_a?(String)
+      end
+
+      def validate_array_contents
+        value.all? { |v| !v.respond_to?(:valid?) || v.valid? }
+      end
+
+      def validate_array
+        value.is_a?(Array) && validate_array_contents
+      end
+
+      def validate_boolean
+        value == !!value
+      end
+
+      def validate_number
+        value.is_a?(Numeric)
+      end
+    end
+  end
+end

data/lib/svelte/operation.rb

@@ -0,0 +1,31 @@
+module Svelte
+  # Describes a Swagger API Operation
+  class Operation
+    attr_reader :verb, :properties, :path
+
+    # Creates a new Operation.
+    # @param verb [String] operation verb i.e. `'get'`
+    # @param properties [Hash] definition
+    # @param path [Path] Path the operation belongs to
+    def initialize(verb:, properties:, path:)
+      @verb = verb
+      @properties = properties
+      @path = path
+      validate
+    end
+
+    # Operation identifier
+    # @return [String] unique Swagger API operation identifier
+    def id
+      properties['operationId']
+    end
+
+    private
+
+    def validate
+      unless id.is_a?(String)
+        raise JSONError, 'Operation is missing mandatory `operationId` field'
+      end
+    end
+  end
+end

data/lib/svelte/operation_builder.rb

@@ -0,0 +1,47 @@
+module Svelte
+  # Dynamically builds Swagger API operations on top of a given module
+  class OperationBuilder
+    class << self
+      # Builds an operation on top of `module_constant`
+      # @param operation [Svete::Operation] operation to build
+      # @param module_constant [Module] operation to build
+      # @param configuration [Configuration] Swagger API configuration
+      def build(operation:, module_constant:, configuration:)
+        builder = self
+        method_name = StringManipulator.method_name_for(operation.id)
+        module_constant.define_singleton_method(method_name) do |*parameters|
+          GenericOperation.call(
+            verb: operation.verb,
+            path: operation.path,
+            configuration: configuration,
+            parameters: builder.request_parameters(full_parameters: parameters),
+            options: builder.options(full_parameters: parameters))
+        end
+      end
+
+      # Returns the parameters that are to be sent as part of the request
+      # to the API endpoint.
+      # @param full_parameters [Array] array with the arguments passed into the
+      #   method call
+      # @return [Hash] Hash with all the parameters to be sent as part of the
+      #   request
+      # @note All keys will be transformed from `Symbol` to `String`
+      def request_parameters(full_parameters:)
+        return {} if full_parameters.compact.empty?
+        full_parameters.first.inject({}) do |memo, (k, v)|
+          memo.merge!(k.to_s => v)
+        end
+      end
+
+      # Returns the options that are to be sent as part of the request
+      # to the API endpoint.
+      # @param full_parameters [Array] array with the arguments passed into the
+      #   method call
+      # @return [Hash] Hash with all the options to be sent as part of the
+      #   request
+      def options(full_parameters:)
+        full_parameters[1] || {}
+      end
+    end
+  end
+end