openapi_contracts 0.8.0 → 0.9.0

data/lib/openapi_contracts/doc/file_parser.rb

@@ -1,85 +0,0 @@
-module OpenapiContracts
-  class Doc::FileParser
-    Result = Struct.new(:data, :path) do
-      def to_mergable_hash
-        d = data
-        path.ascend do |p|
-          d = {p.basename.to_s => d}
-        end
-        d
-      end
-    end
-
-    def self.parse(rootfile, pathname)
-      new(rootfile, pathname).call
-    end
-
-    def initialize(rootfile, pathname)
-      @root = rootfile.parent
-      @rootfile = rootfile
-      @pathname = pathname.relative? ? @root.join(pathname) : pathname
-    end
-
-    def call
-      schema = YAML.safe_load(File.read(@pathname))
-      schema = transform_hash(schema)
-      Result.new(schema, @pathname.relative_path_from(@root).sub_ext(''))
-    end
-
-    private
-
-    def transform_hash(data)
-      data.each_with_object({}) do |(key, val), m|
-        if val.is_a?(Array)
-          m[key] = transform_array(val)
-        elsif val.is_a?(Hash)
-          m[key] = transform_hash(val)
-        elsif key == '$ref'
-          m.merge! transform_pointer(key, val)
-        else
-          m[key] = val
-        end
-      end
-    end
-
-    def transform_array(data)
-      data.each_with_object([]) do |item, m|
-        case item
-        when Hash
-          m.push transform_hash(item)
-        when Array
-          m.push transform_array(item)
-        else
-          m.push item
-        end
-      end
-    end
-
-    def transform_pointer(key, target)
-      if %r{^#/(?<pointer>.*)} =~ target
-        # A JSON Pointer
-        {key => generate_absolute_pointer(pointer)}
-      elsif %r{^(?<relpath>[^#]+)(?:#/(?<pointer>.*))?} =~ target
-        if relpath.start_with?('paths') # path description file pointer
-          # Inline the file contents
-          self.class.parse(@rootfile, Pathname(relpath)).data
-        else # A file pointer with potential JSON sub-pointer
-          tgt = @pathname.parent.relative_path_from(@root).join(relpath).sub_ext('')
-          tgt = tgt.join(pointer) if pointer
-          {key => "#/#{tgt}"}
-        end
-      else
-        {key => target}
-      end
-    end
-
-    # A JSON pointer to the currently parsed file as seen from the root openapi file
-    def generate_absolute_pointer(json_pointer)
-      if @rootfile == @pathname
-        "#/#{json_pointer}"
-      else
-        "#/#{@pathname.relative_path_from(@root).sub_ext('').join(json_pointer)}"
-      end
-    end
-  end
-end

data/lib/openapi_contracts/doc/method.rb

@@ -1,18 +0,0 @@
-module OpenapiContracts
-  class Doc::Method
-    def initialize(schema)
-      @schema = schema
-      @responses = schema['responses'].to_h do |status, _|
-        [status, Doc::Response.new(schema.navigate('responses', status))]
-      end
-    end
-
-    def responses
-      @responses.each_value
-    end
-
-    def with_status(status)
-      @responses[status]
-    end
-  end
-end

data/lib/openapi_contracts/doc/parser.rb

@@ -1,44 +0,0 @@
-module OpenapiContracts
-  class Doc::Parser
-    def self.call(dir, filename)
-      new(dir.join(filename)).parse
-    end
-
-    def initialize(rootfile)
-      @rootfile = rootfile
-    end
-
-    def parse
-      file = Doc::FileParser.parse(@rootfile, @rootfile)
-      data = file.data
-      data.deep_merge! merge_components
-      nullable_to_type!(data)
-      # debugger
-    end
-
-    private
-
-    def merge_components
-      data = {}
-      Dir[File.expand_path('components/**/*.yaml', @rootfile.parent)].each do |file|
-        result = Doc::FileParser.parse(@rootfile, Pathname(file))
-        data.deep_merge!(result.to_mergable_hash)
-      end
-      data
-    end
-
-    def nullable_to_type!(object)
-      case object
-      when Hash
-        if object['type'] && object['nullable']
-          object['type'] = [object['type'], 'null']
-          object.delete 'nullable'
-        else
-          object.each_value { |o| nullable_to_type! o }
-        end
-      when Array
-        object.each { |o| nullable_to_type! o }
-      end
-    end
-  end
-end

data/lib/openapi_contracts/validators/body.rb

@@ -1,38 +0,0 @@
-module OpenapiContracts::Validators
-  class Body < Base
-    private
-
-    def validate
-      if spec.no_content?
-        @errors << 'Expected empty response body' if response.body.present?
-      elsif !spec.supports_content_type?(response_content_type)
-        @errors << "Undocumented response with content-type #{response_content_type.inspect}"
-      else
-        validate_schema
-      end
-    end
-
-    def validate_schema
-      schema = spec.schema_for(response_content_type)
-      # Trick JSONSchemer into validating only against the response schema
-      schemer = JSONSchemer.schema(schema.raw.merge('$ref' => schema.fragment))
-      schemer.validate(JSON(response.body)).each do |err|
-        @errors << error_to_message(err)
-      end
-    end
-
-    def error_to_message(error)
-      if error.key?('details')
-        error['details'].to_a.map { |(key, val)|
-          "#{key.humanize}: #{val} at #{error['data_pointer']}"
-        }.to_sentence
-      else
-        "#{error['data'].inspect} at #{error['data_pointer']} does not match the schema"
-      end
-    end
-
-    def response_content_type
-      response.headers['Content-Type'].split(';').first
-    end
-  end
-end