lurker 0.6.2 → 0.6.3

data/lib/lurker/json/reader.rb

@@ -0,0 +1,28 @@
+module Lurker
+  module Json
+    class Reader
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+        @attempts_left = 1
+      end
+
+      def read
+        return YAML.load_file(@path) unless @path.match(/\.erb$/)
+
+        context = Lurker::ErbSchemaContext.new
+        erb = ERB.new(IO.read @path).result(context.get_binding)
+        YAML.load(erb)
+      rescue Errno::ENOENT
+        raise if @attempts_left.zero?
+
+        @path = @path.sub(/\#\/?$/, '').sub(/\.json/, '.json.yml')
+        @attempts_left -= 1
+
+        retry
+      end
+      alias_method :payload, :read
+    end
+  end
+end

data/lib/lurker/json/schema/attribute.rb

@@ -0,0 +1,115 @@
+require 'action_dispatch'
+
+module Lurker
+  module Json
+    class Attribute < Schema
+      URI = 'uri'.freeze
+      TYPE = 'type'.freeze
+      COLOR = 'color'.freeze
+      FORMAT = 'format'.freeze
+      EXAMPLE = 'example'.freeze
+      DATE_TIME = 'date-time'.freeze
+      DESCRIPTION = 'description'.freeze
+
+      TYPE_MAP = {
+        'Time' => 'string',
+        'Hash' => 'object',
+        'Float' => 'number',
+        'Fixnum' => 'integer',
+        'NilClass' => 'null',
+        'TrueClass' => 'boolean',
+        'FalseClass' => 'boolean',
+        'ActionDispatch::Http::UploadedFile' => 'string'
+      }.freeze
+
+      def merge!(schema)
+        return replace!(schema) if @schema[TYPE].blank?
+
+        schema = attributify(schema)
+        return if eql?(schema)
+
+        replace_options = {root_schema: root_schema, parent_schema: parent_schema,
+                           parent_property: parent_property}
+
+        attributes_tuple = Lurker::Json::Tuple::AnyOf.new(
+          [to_hash, schema], replace_options)
+
+        parent_schema.replace!(parent_property, attributes_tuple)
+      end
+
+      def replace!(schema)
+        @schema.clear.merge!(attributify schema)
+      end
+
+      def eql?(schema)
+        @schema[TYPE] == attributify(schema)[TYPE]
+      end
+
+      private
+
+      def parse_schema(schema)
+        @schema = {}
+        initialize_properties
+
+        if schema.is_a?(Hash)
+          @schema.merge!(schema)
+        else
+          @schema = attributify(schema)
+        end
+      end
+
+      def attributify(schema)
+        return schema if schema.is_a?(Hash) || schema.is_a?(Lurker::Json::Schema)
+
+        attribute = {
+          DESCRIPTION => '',
+          TYPE => guess_type(schema),
+          EXAMPLE => serialize_example(schema)
+        }
+
+        if format = guess_format(schema)
+          attribute[FORMAT] = format
+        end
+
+        attribute
+      end
+
+      def initialize_properties
+        @schema[DESCRIPTION] ||= ''
+        @schema[TYPE] ||= ''
+        @schema[EXAMPLE] ||= ''
+      end
+
+      def serialize_example(data)
+        if data.is_a?(ActionDispatch::Http::UploadedFile)
+          data.headers
+        else
+          data
+        end
+      end
+
+      def guess_type(data)
+        data_type = data.class.to_s
+        TYPE_MAP[data_type] || data_type.downcase
+      end
+
+      def guess_format(data)
+        if data.is_a?(Time)
+          DATE_TIME
+        elsif data.is_a?(String)
+          if data.start_with? 'http://'
+            URI
+          elsif data.match(/\#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?\b/)
+            COLOR
+          else
+            begin
+              DATE_TIME if Time.iso8601(data)
+            rescue
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/extensions.rb

@@ -0,0 +1,19 @@
+module Lurker
+  module Json
+    class Extensions < Schema
+      EXTENSIONS = 'extensions'.freeze
+
+      def initialize(schema, options = {})
+        @parent_property = EXTENSIONS
+
+        super
+      end
+
+      def merge!(schema)
+        return unless Lurker.upgrade?
+
+        @schema = @parser.parse_property(parent_property, schema)
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/list.rb

@@ -0,0 +1,51 @@
+module Lurker
+  module Json
+    class List < Schema
+      TYPE = 'type'.freeze
+      ARRAY = 'array'.freeze
+      ITEMS = 'items'.freeze
+
+      def merge!(schema)
+        if schema.is_a?(Array)
+          schema.each { |payload| @schema[ITEMS].merge!(payload) }
+        else
+          @schema[ITEMS].merge!(schema)
+        end
+      end
+
+      def replace!(property, schema)
+        if @schema[ITEMS].is_a?(Lurker::Json::Attribute)
+          @schema[ITEMS] = schema
+        else
+          @schema[ITEMS].replace!(property, schema)
+        end
+      end
+
+      private
+
+      def parse_schema(schema)
+        @schema = {}
+        initialize_properties
+
+        return if schema.empty?
+
+        schema = schema.dup
+        if schema.is_a?(Array)
+          @schema[ITEMS] = @parser.typed.parse(schema.shift)
+
+          schema.each { |payload| @schema[ITEMS].merge!(payload) }
+        else
+          @schema[ITEMS] = @parser.typed.parse(schema.delete ITEMS) if schema.key?(ITEMS)
+          @schema.merge!(schema)
+        end
+
+        @schema
+      end
+
+      def initialize_properties
+        @schema[TYPE] ||= ARRAY
+        @schema[ITEMS] ||= []
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/object.rb

@@ -0,0 +1,67 @@
+module Lurker
+  module Json
+    class Object < Schema
+      TYPE = 'type'.freeze
+      OBJECT = 'object'.freeze
+      REQUIRED = 'required'.freeze
+      PROPERTIES = 'properties'.freeze
+      DESCRIPTION = 'description'.freeze
+      ADDITIONAL_PROPERTIES = 'additionalProperties'.freeze
+
+      def merge!(schema)
+        unless schema.is_a?(Hash)
+          return replace_with_new_type(schema) if @schema[PROPERTIES].blank?
+
+          raise TypeError, "Unable to merge #{schema.class} into JSON object"
+        end
+
+        schema.each do |property, property_schema|
+          if @schema[PROPERTIES].key?(property)
+            @schema[PROPERTIES][property].merge!(property_schema)
+            next
+          end
+
+          replace!(property, property_schema)
+        end
+      end
+
+      def replace!(property, property_schema)
+        @schema[PROPERTIES][property] = Lurker::Json::Parser.typed(subschema_options)
+          .parse_property(property, property_schema)
+      end
+
+      private
+
+      def parse_schema(schema)
+        @schema = {}
+        initialize_properties
+
+        schema = schema.dup
+        merge_required = schema.key?(PROPERTIES)
+
+        (schema.delete(PROPERTIES) || schema).each do |property, property_schema|
+          @schema[PROPERTIES][property] = @parser.typed.parse_property(
+            property, property_schema)
+        end
+
+        @schema.merge!(schema) if merge_required
+      end
+
+      def replace_with_new_type(schema)
+        replace_options = {root_schema: root_schema, parent_schema: parent_schema,
+                           parent_property: parent_property}
+
+        new_schema = Lurker::Json::Parser.typed(replace_options).parse(schema)
+        parent_schema.replace!(parent_property, new_schema)
+      end
+
+      def initialize_properties
+        @schema[DESCRIPTION] ||= ''
+        @schema[TYPE] ||= OBJECT
+        @schema[ADDITIONAL_PROPERTIES] = !!@schema[ADDITIONAL_PROPERTIES]
+        @schema[REQUIRED] ||= []
+        @schema[PROPERTIES] ||= {}
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/reference.rb

@@ -0,0 +1,34 @@
+module Lurker
+  module Json
+    class Reference < Schema
+      REF = '$ref'.freeze
+
+      attr_reader :original_uri
+
+      delegate :merge!, :replace!, :reorder!, to: :@schema
+
+      def to_original_hash(options = {})
+        @original_schema.to_hash
+      end
+
+      private
+
+      def parse_schema(schema)
+        @original_schema = schema.dup
+
+        # NOTE : We decide that reference is relative, so we are using merge
+        # We use first read for correct relative path resolving
+        reader = Lurker::Json::Reader.new(@uri.merge(schema[REF]).path)
+        payload = reader.payload
+
+        @original_uri = parse_uri(reader.path)
+        @schema = @parser.plain(uri: reader.path).parse(payload)
+
+        # NOTE : The easiest way to get schema copy is to parse it again.
+        # It's faster and reliable
+        # @_schema = @parser.plain(uri: reader.path).parse(reader.payload)
+        # @_schema_file = URI.parse(reader.path)
+      end
+    end
+  end
+end

data/lib/lurker/{endpoint → json/schema}/response_codes.rb

@@ -1,24 +1,21 @@
 module Lurker
-  class Endpoint
-    class ResponseCodes
-      RESPONSE_CODES = 'responseCodes'.freeze
-      DESCRIPTION = 'description'.freeze
-      SUCCESSFUL = 'successful'.freeze
+  module Json
+    class ResponseCodes < Schema
       STATUS = 'status'.freeze
+      SUCCESSFUL = 'successful'.freeze
+      DESCRIPTION = 'description'.freeze
+
+      def initialize(schema, options = {})
+        @parent_property = 'responseCodes'
 
-      def initialize(schema)
-        @schema = schema
-        @schema[RESPONSE_CODES] ||= []
+        super
       end
 
-      def add(status_code, successful, options = {})
-        response_code = {
-          STATUS => status_code,
-          SUCCESSFUL => successful,
-          DESCRIPTION => options.fetch(:description, '')
-        }
+      def merge!(status_code, successful)
+        return if exists?(status_code, successful)
 
-        Lurker::SchemaModifier.append!(@schema[RESPONSE_CODES], response_code)
+        payload = {STATUS => status_code, SUCCESSFUL => successful, DESCRIPTION => ''}
+        @schema << Lurker::Json::Parser.plain(root_schema: root_schema).parse(payload)
       end
 
       def validate!(status_code, successful)
@@ -31,7 +28,7 @@ module Lurker
       end
 
       def exists?(status_code, successful)
-        !!@schema[RESPONSE_CODES].detect do |response_code|
+        !!@schema.detect do |response_code|
           response_code[SUCCESSFUL] == successful &&
             (response_code[STATUS] == status_code ||    # 200
              response_code[STATUS].to_i == status_code) # "200 OK"

data/lib/lurker/json/schema/tuple/all_of.rb

@@ -0,0 +1,17 @@
+module Lurker
+  module Json
+    module Tuple
+      class AllOf < Json::Schema
+        include Tuple::InstanceMethods
+
+        ALLOF = 'allOf'.freeze
+
+        private
+
+        def tuple_key
+          ALLOF
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/tuple/any_of.rb

@@ -0,0 +1,17 @@
+module Lurker
+  module Json
+    module Tuple
+      class AnyOf < Json::Schema
+        include Tuple::InstanceMethods
+
+        ANYOF = 'anyOf'.freeze
+
+        private
+
+        def tuple_key
+          ANYOF
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/tuple/one_of.rb

@@ -0,0 +1,17 @@
+module Lurker
+  module Json
+    module Tuple
+      class OneOf < Json::Schema
+        include Tuple::InstanceMethods
+
+        ONEOF = 'oneOf'.freeze
+
+        private
+
+        def tuple_key
+          ONEOF
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/schema/tuple.rb

@@ -0,0 +1,38 @@
+module Lurker
+  module Json
+    module Tuple
+      module InstanceMethods
+        def merge!(schema)
+          return if exists?(schema)
+
+          @schema[tuple_key] << @parser.typed.parse_property(
+            parent_property, schema)
+        end
+
+        def replace!(schema)
+          raise NotImplementedError
+        end
+
+        def exists?(schema)
+          raise NotImplementedError
+        end
+
+        private
+
+        def parse_schema(schema)
+          @schema = {}
+          initialize_properties
+
+          schema = schema.dup
+          @schema[tuple_key] = (schema.delete(tuple_key) || schema).map do |payload|
+            @parser.typed.parse_property(parent_property, payload)
+          end
+        end
+
+        def initialize_properties
+          @schema[tuple_key] ||= []
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/schema.rb

@@ -0,0 +1,122 @@
+module Lurker
+  module Json
+    class Schema
+      include Lurker::Json::Concerns::Validatable
+
+      EXTENSIONS = 'extensions'.freeze
+      RESPONSE_CODES = 'responseCodes'.freeze
+      REQUEST_PARAMETERS = 'requestParameters'.freeze
+      RESPONSE_PARAMETERS = 'responseParameters'.freeze
+
+      attr_reader :uri, :root_schema, :parent_schema, :parent_property
+
+      def initialize(schema, options = {})
+        @root_schema = options[:root_schema]
+        @parent_schema = options[:parent_schema]
+        @parent_property = options[:parent_property]
+        @uri = parse_uri(options[:uri])
+
+        @parser = Lurker::Json::Parser.new(subschema_options)
+
+        parse_schema(schema)
+      end
+
+      def root?
+        root_schema.blank?
+      end
+
+      def merge!(schema)
+        return if schema.blank?
+
+        schema.each do |property, property_schema|
+          if @schema[property].is_a?(Lurker::Json::Schema)
+            @schema[property].merge!(property_schema)
+
+            next
+          end
+
+          replace!(property, property_schema)
+        end
+      end
+
+      def replace!(property, property_schema)
+        @schema[property] = Lurker::Json::Parser.plain(subschema_options)
+          .parse_property(property, property_schema)
+      end
+
+      def reorder!
+        @schema = Hash[@schema.sort]
+        self
+      end
+
+      def to_hash(options = {})
+        hashify(@schema, options)
+      end
+
+      def to_json(options = {})
+        hashify(@schema, options).to_json
+      end
+
+      def to_yaml(options = {})
+        YAML.dump(to_hash(options))
+      end
+
+      def method_missing(method, *args, &block)
+        if @schema.is_a?(Lurker::Json::Schema) || @schema.respond_to?(method)
+          return @schema.send(method, *args, &block)
+        end
+
+        super
+      end
+
+      private
+
+      def hashify(object, options = {})
+        case object
+        when Lurker::Json::Reference
+          options[:reference] == :original ? object.to_original_hash(options)
+            : object.to_hash(options)
+        when Lurker::Json::Schema then object.to_hash(options)
+        when Array then object.map { |x| hashify(x, options) }
+        when Hash
+          object.each_with_object({}) do |(property, property_schema), memo|
+            memo[property] = hashify(property_schema, options)
+          end
+        else object
+        end
+      end
+
+      def parse_uri(uri)
+        return if uri.blank?
+
+        uri = uri.respond_to?(:scheme) ? uri : URI.parse(uri)
+        uri.relative? ? URI.parse("file://#{uri}") : uri
+      end
+
+      def parse_schema(schema)
+        @schema = {}
+
+        unless schema.is_a?(Hash)
+          return @schema = @parser.plain.parse(schema)
+        end
+
+        schema.each do |property, property_schema|
+          @schema[property] = case property
+          when EXTENSIONS
+            Lurker::Json::Extensions.new(property_schema, subschema_options)
+          when RESPONSE_CODES
+            Lurker::Json::ResponseCodes.new(property_schema, subschema_options)
+          when REQUEST_PARAMETERS, RESPONSE_PARAMETERS
+            @parser.typed.parse_property(property, property_schema)
+          else
+            @parser.plain.parse_property(property, property_schema)
+          end
+        end
+      end
+
+      def subschema_options
+        {uri: uri, root_schema: (root? ? self : root_schema), parent_schema: self}
+      end
+    end
+  end
+end

data/lib/lurker/json/writter.rb

@@ -0,0 +1,58 @@
+module Lurker
+  module Json
+    class Writter
+      class << self
+        def write(schema, path)
+          new(path).write(schema)
+        end
+      end
+
+      def initialize(path)
+        @path = path
+        @dirname = File.dirname(path)
+      end
+
+      def write(schema)
+        write_to_file(schema)
+
+        extract_references(schema).each do |reference|
+          Lurker::Json::Writter.write(reference, reference.original_uri.path)
+        end
+      end
+
+      private
+
+      # TODO : Separate schema dumping for JSON & YAML files
+      def write_to_file(schema)
+        FileUtils.mkdir_p(@dirname) unless File.directory?(@dirname)
+        File.open(@path, File::WRONLY | File::TRUNC | File::CREAT) do |file|
+          file.write(present_by_extension schema)
+        end
+      end
+
+      def extract_references(schema, memo = [])
+        case schema
+        when Array
+          schema.each { |payload| extract_references(payload, memo) }
+        when Hash, Lurker::Json::Schema
+          schema.each do |_, payload|
+            memo << payload if payload.is_a?(Lurker::Json::Reference)
+            extract_references(payload, memo)
+          end
+        else
+          # no-op
+        end
+
+        memo
+      end
+
+      def present_by_extension(schema)
+        case File.extname(@path)
+        when '.yml' then schema.to_yaml(reference: :original)
+        when '.json' then JSON.pretty_generate(schema.to_hash reference: :original)
+        else raise TypeError, "Unknown schema file extension '#{File.extname(@path)}'"
+        end
+      end
+    end
+  end
+end

data/lib/lurker/presenters/endpoint_presenter.rb

@@ -115,7 +115,7 @@ class Lurker::EndpointPresenter < Lurker::BasePresenter
   # TODO: remove in favor of named_path
   def path
     return @path if @path
-    unless (@path = @endpoint.schema.extensions.try(:[], 'path_info')).present?
+    unless (@path = @endpoint.schema['extensions'].try(:[], 'path_info')).present?
       @path = @endpoint.path.gsub(/__/, ':')
       @path = @path.gsub(/-#{@end}/) if @endpoint.schema.extensions.try(:[], 'suffix').present?
     end
@@ -127,7 +127,7 @@ class Lurker::EndpointPresenter < Lurker::BasePresenter
   def named_path
     return @named_path if @named_path
     @named_path = base_path.sub(/\/?$/, '/') + endpoint.path.gsub(/__/, ':')
-    if (suffix = endpoint.schema.extensions.try(:[], 'suffix')).present?
+    if (suffix = endpoint.schema['extensions'].try(:[], 'suffix')).present?
       @named_path = @named_path.gsub(/-#{suffix}/, '')
     end
     @named_path

data/lib/lurker/presenters/schema_presenter.rb

@@ -48,7 +48,10 @@ class Lurker::SchemaPresenter < Lurker::BasePresenter
       html << enum_html
 
       (@schema.keys - FORMATTED_KEYS).each do |key|
-        html << '<li>%s: %s</li>' % [key, @schema[key]]
+        value = @schema[key]
+        value = value.to_hash if value.is_a?(Lurker::Json::Schema)
+
+        html << '<li>%s: %s</li>' % [key, value]
       end
 
       html << items_html

data/lib/lurker/presenters/service_presenter.rb

@@ -22,12 +22,12 @@ class Lurker::ServicePresenter < Lurker::BasePresenter
   end
 
   def domains
-    return service.domains if service.domains.present?
+    return service_domains if service_domains.present?
     { '/' => 'Local' }
   end
 
   def default_domain
-    return service.domains.to_a[0][1] if service.domains.present?
+    return service_domains.to_a[0][1] if service_domains.present?
     '/'
   end
 
@@ -87,4 +87,10 @@ class Lurker::ServicePresenter < Lurker::BasePresenter
       hash
     end
   end
+
+  private
+
+  def service_domains
+    service.domains.to_hash
+  end
 end