lurker 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 434f91796b5945b641bb46e3c89a336a3e7e0393
-  data.tar.gz: b1fbb76bebd71b403470dd80dc31f350a53b364d
+  metadata.gz: c59974fdb662a2fbadcb01539d0fe9a1b919da2c
+  data.tar.gz: 476c5cad93b78d96f397fae62ed32ae19ad30c21
 SHA512:
-  metadata.gz: c23242ced7fa8084458d50cc4b8f405c0fa72f5111ff26a7c695a4901d301515199cdebf086fb3a30acf4f32e4f03ae540ec31192fb5f62bcead79e57249d8cb
-  data.tar.gz: ae52d6101d2093832c6b8c1fa44391218589460e0deb98bc9526c900bcf4796660c35f1838c1da51ce70bfd708117841234f1934a457d9cef79293ce804baa4b
+  metadata.gz: a2a7af02fa6d092a639b79f5f903c373c33b40cc3b8ad621aa69eb6ebdd056998b66cfdb57d93be644dff1c0dd2e3cf554aec85a30fd61bc65038b6060a1ace9
+  data.tar.gz: d2afae3c32e2adce210fb74144e0078ea8db8241b7aebeb0afeb474ec67dcf16083ad8153fc405fde8924af7d4986602575078d836be4c5b2c1e5d7a20f28fd3

checksums.yaml.gz.sig

@@ -1 +1 @@
-r����A!A����oAڡ�Ҧ	�]-x���G��':�$�$D�M
���T̜K���gޭ�6:U��r�%�]����_���G���d3'�]ޒK�����|ڲ��T�?'�@�%��3���X��$�ЎKqvX�0��D�
+�ƴs���:�vsT�\�k���Ȑj<Dk�9�s:d�������L��{o�z���W�_�W���aA�za�G��q#Mz^)8K㊥����r_~����%��Մ��H���'�0���51rÝRy�NW��ݧm�FZ��#��a൥� I9�g��b�:Kj��,i|�g\C�}��F
��Ѥs��A�;��*���P�iM7�
5aܶ��/ ����U���7A�>/K���Sh�Ņm; 5;��P�oX�3��

data/Gemfile

@@ -6,6 +6,7 @@ group :development do
   # tools
   gem 'pry-byebug'
   gem 'pry-stack_explorer'
+  gem 'pry-session'
   # rspec --format fuubar
   gem 'fuubar'
   # cucumber --format fuubar

data/features/dereferencing_through_inlining.feature

@@ -0,0 +1,102 @@
+Feature: $ref defererencing through inlining
+  Background:
+    Given a checked file "lurker/api/v3/users/__id-PATCH.json.yml" with:
+      """yml
+      ---
+      description: user updating
+      prefix: users management
+      requestParameters:
+        description: ''
+        type: object
+        additionalProperties: false
+        required: []
+        properties:
+          user:
+            "$ref": "../../../definitions/user_request_parameters.json#/"
+      responseCodes:
+      - status: 200
+        successful: true
+        description: ''
+      responseParameters:
+        "$ref": "../../../definitions/user.json#/"
+      extensions:
+        method: PATCH
+        path_info: "/api/v3/users/1"
+        path_params:
+          id: '1'
+          controller: api/v3/users
+          action: update
+
+      """
+    And a file named "lurker/definitions/user_request_parameters.json" with:
+      """json
+      {
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Bob"
+          }
+        }
+      }
+      """
+    And a file named "lurker/definitions/user.json.yml" with:
+      """yml
+      ---
+      properties:
+        id:
+          type: integer
+          example: 1
+        name:
+          type: string
+          example: razum2um
+        surname:
+          type: string
+          example: Unknown
+      """
+    And a file named "spec/controllers/api/v3/users_controller_spec.rb" with:
+      """ruby
+        require "spec_helper"
+
+        describe Api::V3::UsersController, :lurker do
+          render_views
+
+          let(:user) do
+            User.where(name: 'razum2um', surname: 'Unknown').first_or_create!
+          end
+
+          it "updates a user surname as string" do
+            patch :update, id: user.id, user: { surname: 'Marley' }
+            expect(response).to be_success
+          end
+        end
+      """
+
+  Scenario: json schema left $ref keyword as is using "users/update"
+    When I run `bin/rspec spec/controllers/api/v3/users_controller_spec.rb`
+    Then the example should pass
+    Then a file named "lurker/api/v3/users/__id-PATCH.json.yml" should exist
+    Then the checked file "lurker/api/v3/users/__id-PATCH.json.yml" should not change
+    Then a file named "lurker/definitions/user_request_parameters.json" should exist
+    Then the file "lurker/definitions/user_request_parameters.json" should contain exactly:
+      """json
+      {
+        "description": "",
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+
+        ],
+        "properties": {
+          "name": {
+            "description": "",
+            "type": "string",
+            "example": "Bob"
+          },
+          "surname": {
+            "description": "",
+            "type": "string",
+            "example": "Marley"
+          }
+        }
+      }
+      """

data/features/partials.feature

@@ -20,6 +20,9 @@ Feature: partials
         name:
           type: string
           example: razum2um
+        surname:
+          type: string
+          example: Unknown
       """
     And a file named "lurker/definitions/repo.json.yml" with:
       """yml
@@ -94,4 +97,3 @@ Feature: partials
     create  index.html
     create  api/v1/users/__user_id/repos-POST.html
     """
-

data/features/step_definitions/additional_cli_steps.rb

@@ -1,3 +1,10 @@
+Given /^a checked file "([^"]*)" with:$/ do |file_name, file_content|
+  write_file(file_name, file_content)
+
+  @files ||= {}
+  in_current_dir { @files[md5(file_name)] = checksum(file_name) }
+end
+
 Given /^an empty directory named "([^"]*)"$/ do |dir_name|
   FileUtils.rm_rf File.expand_path("../../../tmp/lurker_app/#{dir_name}", __FILE__)
   create_dir(dir_name)
@@ -83,3 +90,15 @@ Then(/^I should see JSON response with "([^"]*)"$/) do |name|
     expect(page).to have_content name
   end
 end
+
+Then /(?:a|the) checked file "([^"]*)" should not change$/ do |file_name|
+  in_current_dir do
+    expect(@files.try(:[], md5(file_name))).to eq checksum(file_name)
+  end
+end
+
+Then /(?:a|the) checked file "([^"]*)" should change$/ do |file_name|
+  in_current_dir do
+    expect(@files.try(:[], md5(file_name))).not_to eq checksum(file_name)
+  end
+end

data/features/support/files_helper.rb

@@ -0,0 +1,7 @@
+def md5(file_name)
+  Digest::MD5.hexdigest(file_name)
+end
+
+def checksum(file_name)
+  Digest::SHA2.hexdigest(File.read file_name)
+end

data/lib/lurker/endpoint.rb

@@ -8,24 +8,43 @@ module Lurker
   class Endpoint
     include Lurker::Utils
 
+    PREFIX = 'prefix'.freeze
+    ACTION = 'action'.freeze
+    CONTROLLER = 'controller'.freeze
+    EXTENSIONS = 'extensions'.freeze
+    PATH_PARAMS = 'path_params'.freeze
+    QUERY_PARAMS = 'query_params'.freeze
+    DEPRECATED = 'deprecated'.freeze
+    DESCRIPTION = 'description'.freeze
+    RESPONSE_CODES = 'responseCodes'.freeze
+    REQUEST_PARAMETERS = 'requestParameters'.freeze
+    RESPONSE_PARAMETERS = 'responseParameters'.freeze
+    DESCRPTIONS = {
+      'index' => 'listing',
+      'show' => '',
+      'edit' => 'editing',
+      'create' => 'creation',
+      'update' => 'updating',
+      'destroy' => 'descruction'
+    }.freeze
+
     attr_reader :schema, :service, :endpoint_path, :extensions
-    attr_reader :request_parameters, :response_parameters, :response_codes
-    attr_accessor :errors
 
     def initialize(endpoint_path, extensions = {}, service = Lurker::Service.default_service)
       @endpoint_path = endpoint_path
       @extensions = extensions
       @service = service
-      @errors = []
       @persisted = false
       @schema = File.exist?(endpoint_path) ? load_schema : build_schema
-
-      initialize_schema_properties
+      @request_errors = []
+      @response_errors = []
     end
 
     def persist!
-      schema.ordered! unless persisted?
-      schema.write_to(endpoint_path)
+      finalize_schema!
+
+      Lurker::Json::Orderer.reorder(schema) unless persisted?
+      Lurker::Json::Writter.write(schema, endpoint_path)
 
       @persisted = true
     end
@@ -42,21 +61,30 @@ module Lurker
     end
 
     def consume_request(params, successful = true)
-      request_parameters.validate(params) if persisted?
-      request_parameters.add(params) if successful
+      parameters = stringify_keys(params)
+
+      if persisted?
+        @request_errors = request_parameters.validate(parameters)
+        @request_errors.unshift('Request') unless @request_errors.empty?
+      end
+
+      request_parameters.merge!(parameters) if successful
     end
 
     def consume_response(params, status_code, successful = true)
+      parameters = stringify_keys(params)
+
       if persisted?
         response_codes.validate!(status_code, successful)
-        response_parameters.validate(params) if successful
+
+        @response_errors = response_parameters.validate(parameters)
+        @response_errors.unshift('Response') unless @response_errors.empty?
 
         return
       end
 
-      response_parameters.add(params) if successful
-      response_codes.add(status_code, successful) unless response_codes.exists?(
-        status_code, successful)
+      response_parameters.merge!(parameters) if successful
+      response_codes.merge!(status_code, successful)
     end
 
     def verb
@@ -65,44 +93,46 @@ module Lurker
 
     def path
       @path ||= endpoint_path.
-                  gsub(service.service_dir, "").
+                  gsub(service.service_dir, '').
                   match(/\/?(.*)[-\/][A-Z]+\.json(\.yml)?(\.erb)?$/)[1]
     end
 
     # properties
 
     def deprecated?
-      @schema["deprecated"]
+      @schema[DEPRECATED]
     end
 
     def prefix
-      @schema["prefix"]
+      @schema[PREFIX]
     end
 
     def description
-      @schema["description"]
+      @schema[DESCRIPTION]
     end
 
     def url_params
-      (schema.extensions['path_params'] || {}).reject { |k, _| %w(action controller format).include? k }
+      (@schema[EXTENSIONS][PATH_PARAMS] || {}).reject { |k, _| %w(action controller format).include? k }
     end
 
     def query_params
-      (schema.extensions['query_params'] || {})
+      (@schema[EXTENSIONS][QUERY_PARAMS] || {})
     end
 
-    protected
-
-    def initialize_schema_properties
-      @response_codes = ResponseCodes.new(schema)
+    def request_parameters
+      @schema[REQUEST_PARAMETERS]
+    end
 
-      @response_parameters = HttpParameters.new(schema,
-        schema_key: 'responseParameters', schema_id: endpoint_path, human_name: 'Response')
+    def response_parameters
+      @schema[RESPONSE_PARAMETERS]
+    end
 
-      @request_parameters = HttpParameters.new(schema,
-        schema_key: 'requestParameters', schema_id: endpoint_path, human_name: 'Request')
+    def response_codes
+      @schema[RESPONSE_CODES]
     end
 
+    protected
+
     def persisted?
       !!@persisted
     end
@@ -110,43 +140,48 @@ module Lurker
     def load_schema
       @persisted = true
 
-      Lurker::Schema.new(
-        load_file(endpoint_path),
-        stringify_keys(extensions)
-      )
+      reader = Lurker::Json::Reader.new(endpoint_path)
+      schemify(reader.payload)
     end
 
     def build_schema
       @persisted = false
 
-      Lurker::Schema.new(
-        {
-          "prefix" => "",
-          "description" => "",
-          "responseCodes" => []
-        },
-        stringify_keys(extensions)
-      )
-    end
-
-    def load_file(fname)
-      if fname.match(/\.erb$/)
-        context = Lurker::ErbSchemaContext.new
-        erb = ERB.new(IO.read(fname)).result(context.get_binding)
-        YAML.load(erb)
-      else
-        YAML.load_file(fname)
+      payload = {
+        DESCRIPTION => '',
+        PREFIX => '',
+        REQUEST_PARAMETERS => {},
+        RESPONSE_CODES => [],
+        RESPONSE_PARAMETERS => {}
+      }
+      schemify(payload)
+    end
+
+    def schemify(payload)
+      Lurker::Json::Parser.plain(uri: endpoint_path).parse(payload).tap do |schm|
+        ext = Lurker::Json::Extensions.new(stringify_keys extensions)
+        schm.merge!(EXTENSIONS => ext)
       end
     end
 
+    def finalize_schema!
+      path_params = schema[EXTENSIONS][PATH_PARAMS] || {}
+      subject = path_params[CONTROLLER].to_s.split(/\//).last.to_s
+      description = DESCRPTIONS[path_params[ACTION]]
+
+      schema[DESCRIPTION] = "#{subject.singularize} #{description}".strip if schema[DESCRIPTION].blank?
+      schema[PREFIX] = "#{subject} management" if schema[PREFIX].blank?
+    end
+
     def raise_errors!
-      return if response_parameters.errors.empty?
+      return if @response_errors.empty?
 
-      errors = (request_parameters.errors | response_parameters.errors) * "\n"
+      errors = (@request_errors | @response_errors) * "\n"
       exception = Lurker::ValidationError.new(word_wrap errors)
       if (example = Lurker::Spy.current.block).respond_to?(:metadata) && (metadata = example.metadata).respond_to?(:location, true)
         exception.set_backtrace [metadata.send(:location)]
       end
+
       raise exception
     end
 

data/lib/lurker/json/concerns/validatable.rb

@@ -0,0 +1,47 @@
+module Lurker
+  module Json
+    module Concerns
+      module Validatable
+        ID = 'id'.freeze
+        TYPE = 'type'.freeze
+        OBJECT = 'object'.freeze
+        PROPERTIES = 'properties'.freeze
+        ADDITIONAL_PROPERTIES = 'additionalProperties'.freeze
+
+        def validate(data)
+          Lurker::Validator.new(to_validation_schema, data,
+            record_errors: true).validate.map { |error| "- #{error}" }
+        end
+
+        def to_validation_schema
+          set_additional_properties_false_on(to_hash).tap do |schema|
+            schema[ID] = "file://#{uri}"
+          end
+        end
+
+        private
+
+        def set_additional_properties_false_on(object)
+          case object
+          when Hash
+            copy = object.dup
+
+            if object[TYPE] == OBJECT || object.key?(PROPERTIES)
+              copy[ADDITIONAL_PROPERTIES] ||= false
+            end
+
+            object.each do |key, value|
+              next if key == ADDITIONAL_PROPERTIES
+              copy[key] = set_additional_properties_false_on(value)
+            end
+
+            copy
+          when Array
+            copy = object.map { |value| set_additional_properties_false_on(value) }
+          else object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/orderer.rb

@@ -0,0 +1,19 @@
+module Lurker
+  module Json
+    class Orderer
+      EXTENSIONS = 'extensions'.freeze
+
+      class << self
+        def reorder(schema)
+          new.reorder(schema)
+        end
+      end
+
+      def reorder(schema)
+        extensions = schema.delete(EXTENSIONS).try(:reorder!)
+        schema.reorder!
+        schema[EXTENSIONS] = extensions
+      end
+    end
+  end
+end

data/lib/lurker/json/parser/expertise.rb

@@ -0,0 +1,30 @@
+module Lurker
+  module Json
+    class Parser
+      module Expertise
+        REF = '$ref'.freeze
+        TYPE = 'type'.freeze
+        ANYOF = 'anyOf'.freeze
+        ALLOF = 'allOf'.freeze
+        ONEOF = 'oneOf'.freeze
+        ITEMS = 'items'.freeze
+        PROPERTIES = 'properties'.freeze
+
+        module_function
+
+        def type_defined?(hash)
+          return false unless hash.is_a?(Hash)
+
+          hash.key? TYPE
+        end
+
+        def type_supposed?(hash)
+          return false unless hash.is_a?(Hash)
+
+          hash.key?(ANYOF) || hash.key?(ALLOF) || hash.key?(ONEOF) ||
+          hash.key?(ITEMS) || hash.key?(PROPERTIES) || hash.key?(REF)
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/parser/plain_strategy.rb

@@ -0,0 +1,39 @@
+module Lurker
+  module Json
+    class Parser
+      class PlainStrategy
+        include Lurker::Json::Parser::Expertise
+
+        attr_reader :schema_options
+
+        def initialize(options)
+          @schema_options = options.dup
+        end
+
+        def parse(payload)
+          case payload
+          when Lurker::Json::Schema
+            payload
+          when Hash
+            return parse_as_typed(payload) if type_defined?(payload) ||
+              type_supposed?(payload)
+
+            Lurker::Json::Schema.new(payload, schema_options)
+          when Array
+            payload.map do |schema|
+              Lurker::Json::Parser.plain(schema_options).parse(schema)
+            end
+          else
+            payload
+          end
+        end
+
+        private
+
+        def parse_as_typed(payload)
+          Lurker::Json::Parser.typed(schema_options).parse(payload)
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/parser/typed_strategy.rb

@@ -0,0 +1,71 @@
+module Lurker
+  module Json
+    class Parser
+      class TypedStrategy
+        include Lurker::Json::Parser::Expertise
+
+        ANYOF = 'anyOf'.freeze
+        ALLOF = 'allOf'.freeze
+        ONEOF = 'oneOf'.freeze
+        ITEMS = 'items'.freeze
+        TYPE  = 'type'.freeze
+        ARRAY = 'array'.freeze
+        OBJECT = 'object'.freeze
+        PROPERTIES = 'properties'.freeze
+
+        attr_reader :schema_options
+
+        def initialize(options)
+          @schema_options = options.dup
+        end
+
+        def parse(payload)
+          case payload
+          when Lurker::Json::Schema
+            payload
+          when Hash
+            return create_by_type(payload) if type_defined?(payload)
+            return create_by_supposition(payload) if type_supposed?(payload)
+
+            Lurker::Json::Object.new(payload, schema_options)
+          when Array
+            Lurker::Json::List.new(payload, schema_options)
+          else
+            Lurker::Json::Attribute.new(payload, schema_options)
+          end
+        end
+
+        private
+
+        def create_by_supposition(payload)
+          if payload.key?(ITEMS)
+            Lurker::Json::List.new(payload, schema_options)
+          elsif payload.key?(PROPERTIES)
+            Lurker::Json::Object.new(payload, schema_options)
+          elsif payload.key?(ANYOF)
+            Lurker::Json::Tuple::AnyOf.new(payload, schema_options)
+          elsif payload.key?(ALLOF)
+            Lurker::Json::Tuple::AllOf.new(payload, schema_options)
+          elsif payload.key?(ONEOF)
+            Lurker::Json::Tuple::OneOf.new(payload, schema_options)
+          elsif payload.key?(REF)
+            Lurker::Json::Reference.new(payload, schema_options)
+          else
+            raise "Unknown type supposition for #{payload}"
+          end
+        end
+
+        def create_by_type(payload)
+          case payload[TYPE]
+          when OBJECT
+            Lurker::Json::Object.new(payload, schema_options)
+          when ARRAY
+            Lurker::Json::List.new(payload, schema_options)
+          else
+            Lurker::Json::Attribute.new(payload, schema_options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lurker/json/parser.rb

@@ -0,0 +1,73 @@
+module Lurker
+  module Json
+    class Parser
+      class << self
+        def plain(options = {})
+          new(options).plain
+        end
+
+        def typed(options = {})
+          new(options).typed
+        end
+      end
+
+      def initialize(options = {})
+        @root_schema = options[:root_schema]
+        @parent_schema = options[:parent_schema]
+        @parent_property = options[:parent_property]
+        @uri = options[:uri] || @parent_schema.try(:uri)
+        @strategy = nil
+      end
+
+      def parse(payload)
+        parse_once { @strategy.new(schema_options_once).parse(payload) }
+      end
+
+      def parse_property(property, payload)
+        options = schema_options_once.merge!(parent_property: property)
+        parse_once { @strategy.new(options).parse(payload) }
+      end
+
+      def plain(options = {})
+        @options = schema_options.merge!(options)
+        @strategy = strategy_klass(:plain)
+        self
+      end
+
+      def typed(options = {})
+        @options = schema_options.merge!(options)
+        @strategy = strategy_klass(:typed)
+        self
+      end
+
+      private
+
+      def parse_once(&block)
+        raise 'Define parsing strategy [plain|typed] before using' unless @strategy.present?
+
+        result = block.call
+        @strategy = nil
+
+        result
+      end
+
+      def schema_options_once
+        options = @options.present? ? @options.dup : schema_options
+        @options = {}
+
+        options
+      end
+
+      def strategy_klass(name)
+        "lurker/json/parser/#{name}_strategy".camelize.constantize
+      end
+
+      def schema_options
+        {
+          uri: @uri, root_schema: @root_schema,
+          parent_schema: @parent_schema, parent_property: @parent_property
+        }
+      end
+    end
+  end
+end