fictium 0.1.0

data/lib/fictium/exporters/open_api/v3_exporter/content_formatter.rb

@@ -0,0 +1,20 @@
+module Fictium
+  module OpenApi
+    class V3Exporter
+      class ContentFormatter
+        def format(http_object, default = nil)
+          type = (http_object.presence && http_object[:content_type].presence) || default
+          return if type.blank?
+
+          {}.tap do |content|
+            media_type = {
+              example: http_object[:body]
+            }
+            media_type[:schema] = http_object[:schema] if http_object[:schema].present?
+            content[type.to_sym] = media_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fictium/exporters/open_api/v3_exporter/example_formatter.rb

@@ -0,0 +1,46 @@
+module Fictium
+  module OpenApi
+    class V3Exporter
+      class ExampleFormatter
+        def format_default(operation, responses, default_example)
+          responses[:default] = format(default_example)
+          return if default_example.request[:content_type].blank?
+
+          operation[:requestBody] = {
+            content: content_formatter.format(default_example.request)
+          }
+          operation[:requestBody][:required] = true if default_example.request[:required]
+        end
+
+        def format(example)
+          { description: example.summary }.tap do |format|
+            content = content_formatter.format(example.response, default_response_content_type)
+            format[:content] = content if content.present?
+            headers = extract_headers(example)
+            format[:headers] = headers if headers.present?
+          end
+        end
+
+        def default_response_content_type
+          Fictium.configuration.default_response_content_type
+        end
+
+        def extract_headers(example)
+          {}.tap do |headers|
+            example.headers.each do |name, value|
+              headers[name] = header_formatter.format(name, :header, value)
+            end
+          end
+        end
+
+        def content_formatter
+          @content_formatter ||= ContentFormatter.new
+        end
+
+        def header_formatter
+          @header_formatter ||= ParamFormatter.new(ignore_name: true, ignore_in: true)
+        end
+      end
+    end
+  end
+end

data/lib/fictium/exporters/open_api/v3_exporter/param_formatter.rb

@@ -0,0 +1,45 @@
+module Fictium
+  module OpenApi
+    class V3Exporter
+      class ParamFormatter
+        def initialize(ignore_name: false, ignore_in: false)
+          @ignore_name = ignore_name
+          @ignore_in = ignore_in
+        end
+
+        def format(name, section, hash)
+          param = (hash || {})
+          description = param.slice(:description, :required, :deprecated, :schema)
+          description[:allowEmptyValue] = param[:allow_empty] if param[:allow_empty].present?
+          add_required_fields(description)
+          add_optional_fields(name, section, description)
+          description
+        end
+
+        private
+
+        def ignore_in?
+          @ignore_in
+        end
+
+        def ignore_name?
+          @ignore_name
+        end
+
+        def add_required_fields(description)
+          description[:description] ||= ''
+
+          return if description[:schema] || description[:content]
+
+          description[:schema] = {}
+        end
+
+        def add_optional_fields(name, section, description)
+          description[:name] = name unless ignore_name?
+          description[:in] = section unless ignore_in?
+          description[:required] = true if section.to_s == 'path'
+        end
+      end
+    end
+  end
+end

data/lib/fictium/exporters/open_api/v3_exporter/path_formatter.rb

@@ -0,0 +1,60 @@
+module Fictium
+  module OpenApi
+    class V3Exporter
+      class PathFormatter
+        def add_path(paths, action)
+          path_object = paths[action.full_path] || default_path_object
+          path_object[action.method.to_sym] = create_operation(action)
+          paths[action.full_path] = path_object
+        end
+
+        private
+
+        def default_path_object
+          { description: '' }
+        end
+
+        def create_operation(action)
+          {}.tap do |operation|
+            operation[:tags] = action.combined_tags
+            operation[:description] = action.summary
+            operation[:parameters] = format_parameters(action)
+            operation[:responses] = format_responses(operation, action)
+            operation[:deprecated] = action.deprecated?
+          end
+        end
+
+        def format_parameters(action)
+          [].tap do |result|
+            action.params.each do |section, values|
+              values.each do |name, data|
+                result << param_formatter.format(name, section, data)
+              end
+            end
+          end
+        end
+
+        def format_responses(operation, action)
+          {}.tap do |responses|
+            default_example = action.default_example
+            break if default_example.blank?
+
+            example_formatter.format_default(operation, responses, default_example)
+            other_examples = action.examples.reject { |example| example == default_example }
+            other_examples.each do |example|
+              responses[example.response[:status]] = example_formatter.format(example)
+            end
+          end
+        end
+
+        def example_formatter
+          @example_formatter ||= ExampleFormatter.new
+        end
+
+        def param_formatter
+          @param_formatter ||= ParamFormatter.new
+        end
+      end
+    end
+  end
+end

data/lib/fictium/exporters/open_api/v3_exporter/path_generator.rb

@@ -0,0 +1,37 @@
+module Fictium
+  module OpenApi
+    class V3Exporter
+      class PathGenerator
+        attr_reader :document
+
+        def initialize(document)
+          @document = document
+        end
+
+        def generate
+          {}.tap do |paths|
+            document.resources.each do |resource|
+              generate_from_resource(paths, resource)
+            end
+          end
+        end
+
+        private
+
+        def generate_from_resource(paths, resource)
+          resource.actions.each do |action|
+            generate_from_action(paths, action)
+          end
+        end
+
+        def generate_from_action(paths, action)
+          path_formatter.add_path(paths, action)
+        end
+
+        def path_formatter
+          @path_formatter ||= PathFormatter.new
+        end
+      end
+    end
+  end
+end

data/lib/fictium/exporters/open_api/v3_exporter.rb

@@ -0,0 +1,79 @@
+require_relative 'v3_exporter/content_formatter'
+require_relative 'v3_exporter/example_formatter'
+require_relative 'v3_exporter/param_formatter'
+
+require_relative 'v3_exporter/path_formatter'
+require_relative 'v3_exporter/path_generator'
+
+module Fictium
+  module OpenApi
+    class V3Exporter
+      DEFAULT_PROPERTIES = {
+        openapi: '3.0.0'
+      }.freeze
+      FIXTURE_TYPES = %w[servers security tags].freeze
+      INFO_OPTIONS = %w[title description terms_of_service contract license version].freeze
+
+      def export(document)
+        result = DEFAULT_PROPERTIES
+                 .merge(create_fixtures)
+                 .merge(info: create_info, paths: create_paths(document))
+        validate!(result)
+        FileUtils.mkdir_p(File.dirname(export_file))
+        File.write(export_file, pretty_print? ? JSON.pretty_generate(result) : result.to_json)
+      end
+
+      private
+
+      def export_file
+        @export_file ||=
+          File.join(Fictium.configuration.export_path, 'open_api', '3.0.0', 'swagger.json')
+      end
+
+      def create_fixtures
+        {}.tap do |fixtures|
+          FIXTURE_TYPES.each do |name|
+            result = load_fixtures(name)
+            fixtures[name.camelize(:lower)] = result if result.present?
+          end
+        end
+      end
+
+      def create_info
+        {}.tap do |info|
+          INFO_OPTIONS.each do |option|
+            value = Fictium.configuration.info.public_send(option)
+            info[option.camelize(:lower)] = value if value.present?
+          end
+        end
+      end
+
+      def create_paths(document)
+        V3Exporter::PathGenerator.new(document).generate
+      end
+
+      def load_fixtures(name)
+        fixture_file = File.join(fixture_path, "#{name}.json")
+        return unless File.exist?(fixture_file)
+
+        JSON.parse(File.read(fixture_file))
+      end
+
+      def fixture_path
+        Fictium.configuration.fixture_path
+      end
+
+      def validate!(result)
+        JSON::Validator.validate!(schema, result)
+      end
+
+      def schema
+        @schema ||= JSON.parse(File.read(File.join(__dir__, 'schemas', '3.0.0.json')))
+      end
+
+      def pretty_print?
+        Fictium.configuration.pretty_print
+      end
+    end
+  end
+end

data/lib/fictium/loader.rb

@@ -0,0 +1,15 @@
+require_relative 'configurations/configuration'
+require_relative 'configurations/info'
+
+require_relative 'evaluators/parameter_evaluator'
+require_relative 'evaluators/schema_evaluator'
+
+require_relative 'poros/model'
+
+require_relative 'poros/action'
+require_relative 'poros/document'
+require_relative 'poros/example'
+require_relative 'poros/resource'
+
+# Require default (OpenApi v3) exporter
+require_relative 'exporters/open_api/v3_exporter'

data/lib/fictium/poros/action.rb

@@ -0,0 +1,43 @@
+module Fictium
+  class Action < Fictium::Model
+    attr_reader :resource, :examples, :params
+    attr_accessor :path, :summary, :description, :method, :tags, :deprecated, :docs
+
+    def initialize(resource)
+      @resource = resource
+      @params = ActiveSupport::HashWithIndifferentAccess.new
+      @examples = []
+      @tags = []
+      @deprecated = false
+    end
+
+    def full_path
+      "#{resource.base_path}#{path}"
+    end
+
+    def [](section)
+      @params[section] ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def add_params_in(section, &block)
+      self[section].merge!(Fictium::ParameterEvaluator.new.evaluate_params(&block))
+      nil
+    end
+
+    def add_example
+      Fictium::Example.new(self).tap { |example| examples << example }
+    end
+
+    def combined_tags
+      resource.tags + tags
+    end
+
+    def deprecated?
+      deprecated
+    end
+
+    def default_example
+      examples.find(&:default?).presence || examples.first
+    end
+  end
+end

data/lib/fictium/poros/document.rb

@@ -0,0 +1,19 @@
+module Fictium
+  class Document < Fictium::Model
+    attr_reader :resources
+
+    def initialize
+      @resources = []
+    end
+
+    def create_resource
+      Fictium::Resource.new(self).tap { |resource| resources << resource }
+    end
+
+    def export
+      Fictium.configuration.exporters.each do |exporter|
+        exporter.export(self)
+      end
+    end
+  end
+end

data/lib/fictium/poros/example.rb

@@ -0,0 +1,15 @@
+module Fictium
+  class Example < Fictium::Model
+    attr_reader :action
+    attr_accessor :summary, :description, :response, :request, :default, :headers
+
+    def initialize(action)
+      @action = action
+      @headers = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def default?
+      default
+    end
+  end
+end

data/lib/fictium/poros/model.rb

@@ -0,0 +1,4 @@
+module Fictium
+  class Model
+  end
+end

data/lib/fictium/poros/resource.rb

@@ -0,0 +1,16 @@
+module Fictium
+  class Resource < Fictium::Model
+    attr_reader :document, :actions
+    attr_accessor :name, :base_path, :summary, :description, :tags
+
+    def initialize(document)
+      @document = document
+      @actions = []
+      @tags = []
+    end
+
+    def create_action
+      Fictium::Action.new(self).tap { |action| actions << action }
+    end
+  end
+end

data/lib/fictium/railtie.rb

@@ -0,0 +1,4 @@
+module Fictium
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/fictium/rspec/actions.rb

@@ -0,0 +1,40 @@
+module Fictium
+  module RSpec
+    module Actions
+      extend ActiveSupport::Concern
+
+      included do
+        metadata[:fictium_action] = metadata[:fictium_resource].create_action
+        Fictium::RSpec::Autocomplete::Action.description_attributes(
+          metadata[:fictium_action],
+          metadata[:description]
+        )
+      end
+
+      class_methods do
+        def path(path)
+          metadata[:fictium_action].path = path
+        end
+
+        def params_in(section, &block)
+          metadata[:fictium_action].add_params_in(section, &block)
+        end
+
+        def example(*args, **kwargs)
+          Fictium::RSpec::Proxies::Example.new(self, args, kwargs)
+        end
+
+        def deprecate!
+          metadata[:fictium_action].deprecated = true
+        end
+
+        def action_docs(description: nil, url:)
+          metadata[:fictium_action].docs = {}.tap do |docs|
+            docs[:url] = url
+            docs[:description] = description if description.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fictium/rspec/autocomplete/action.rb

@@ -0,0 +1,52 @@
+module Fictium
+  module RSpec
+    module Autocomplete
+      module Action
+        ACTION_NAME = /#([A-Z_]+)/i.freeze
+        DEFAULT_PATHS = {
+          index: '',
+          create: '',
+          new: '/new',
+          show: '/{id}',
+          update: '/{id}',
+          destroy: '/{id}'
+        }.freeze
+        class << self
+          def description_attributes(action, description)
+            name = find_action_name(description)&.downcase
+            find_summary(action, name)
+            find_path(action, name)
+          end
+
+          private
+
+          def find_summary(action, name)
+            return if name.blank?
+
+            key = :"default_summary_for_#{name}"
+            summary_method = descriptors[key] || Fictium.configuration.unknown_action_descriptor
+            one_argument = summary_method.arity == 1
+            action.summary =
+              one_argument ? summary_method.call(action) : summary_method.call(action, name)
+          end
+
+          def descriptors
+            @descriptors ||= Fictium.configuration.default_action_descriptors || {}
+          end
+
+          def find_path(action, name)
+            return if name.blank?
+
+            key = name.to_sym
+            action.path = DEFAULT_PATHS[key] || "/{id}/#{name}"
+          end
+
+          def find_action_name(description)
+            match = description.match(ACTION_NAME)
+            match.presence && match[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fictium/rspec/autocomplete/example.rb

@@ -0,0 +1,45 @@
+module Fictium
+  module RSpec
+    module Autocomplete
+      module Example
+        class << self
+          def process_http_response(example, response)
+            example.response ||= {}
+            example.response.merge!(
+              status: response.status,
+              body: response.body,
+              content_type: response.content_type
+            )
+            process_http_request(example, response.request)
+            return unless example.default?
+
+            autocomplete_params.extract_from_response(example, response)
+          end
+
+          private
+
+          def autocomplete_params
+            Fictium::RSpec::Autocomplete::Params
+          end
+
+          def process_http_request(example, request)
+            example.request ||= {}
+            example.request.merge!(
+              content_type: request.content_type,
+              body: request.body.string
+            )
+            extract_method(example, request)
+            return unless example.default?
+
+            autocomplete_params.extract_from_request(example.action, request)
+          end
+
+          def extract_method(example, request)
+            action = example.action
+            action.method = request.method.downcase.to_sym if action.method.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fictium/rspec/autocomplete/params.rb

@@ -0,0 +1,79 @@
+module Fictium
+  module RSpec
+    module Autocomplete
+      module Params
+        REQUEST_SECTIONS = %i[query header path cookie].freeze
+        PATH_TEMPLATE = /{([A-Z_\-][A-Z0-9_\-]*)}/i.freeze
+
+        class << self
+          def extract_from_request(action, request)
+            REQUEST_SECTIONS.each do |section|
+              action.params[section] ||= ActiveSupport::HashWithIndifferentAccess.new
+              send(:"parse_request_#{section}", action.params[section], action, request)
+            end
+          end
+
+          def extract_from_response(example, response)
+            example.headers ||= ActiveSupport::HashWithIndifferentAccess.new
+            response.headers.each do |name, value|
+              next unless valid_header?(name)
+
+              example.headers[name] ||= {}
+              example.headers[name].merge!(
+                example: value
+              )
+            end
+          end
+
+          private
+
+          def parse_request_query(params, _action, request)
+            request.query_parameters.each do |key, value|
+              params[key] ||= {}
+              params[key].merge!(
+                example: value
+              )
+            end
+          end
+
+          def parse_request_header(params, _action, request)
+            request.headers.to_h.each do |name, value|
+              next unless valid_header?(name)
+
+              params[name] ||= {}
+              params[name].merge!(
+                example: value
+              )
+            end
+          end
+
+          def parse_request_path(params, action, _request)
+            action.full_path.scan(PATH_TEMPLATE).flatten.each do |name|
+              params[name] ||= {}
+              # TODO: Extract example from request
+            end
+          end
+
+          def parse_request_cookie(params, _action, request)
+            request.cookies.each do |key, value|
+              params[key] ||= {}
+              params[key].merge!(
+                example: value
+              )
+            end
+          end
+
+          def valid_header?(name)
+            return false if ignored_header_groups.any? { |group| name.downcase.start_with?(group) }
+
+            !Fictium.configuration.ignored_header_values.include?(name.downcase)
+          end
+
+          def ignored_header_groups
+            Fictium.configuration.ignored_header_groups
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fictium/rspec/autocomplete/resource.rb

@@ -0,0 +1,20 @@
+module Fictium
+  module RSpec
+    module Autocomplete
+      module Resource
+        CONTROLLER_TERMINATION = /Controller$/.freeze
+
+        class << self
+          def name_attributes(resource, controller_name)
+            resource_path = controller_name.sub(CONTROLLER_TERMINATION, '').underscore
+            resource.base_path = "/#{resource_path}"
+            path_sections = resource_path.split('/')
+            plural = path_sections.last
+            resource.name = plural.singularize.humanize(capitalize: false)
+            resource.summary = Fictium.configuration.summary_format.call(plural)
+          end
+        end
+      end
+    end
+  end
+end