rails-swagger 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 60dcbcd8c29a1f62409b5a74ada9fe10156d81d3
-  data.tar.gz: 78f746f92e9e12c8b6bd8f5c1f2149d3a4efadfd
+SHA256:
+  metadata.gz: d296e1d1dc96b987c238535613568bdc345e7b8c0fe9eb40559d7aafe6b059ae
+  data.tar.gz: 7e4304f36b6b494878e0a86938757f5cfdbdf811e2af9d1464b6f33a9844546c
 SHA512:
-  metadata.gz: 35344fdc0cc7b480c0f30759657acce83f284b6a3e945be64bb1b4b6010501d0407ba2ed808603d89f0a9d8f724ec44ca9d8a7221b34086f75c7fbd28f7e7461
-  data.tar.gz: 8734547b54976c568bcf36b14c953395943487d6e019a19567c7bbbe1dda14756879965068954110373536c9486462a69249bacda519aed5914fe62d527fb552
+  metadata.gz: c674eb007e4e5b247d97f86a976ef267f336b70a1c3de68425c42bff583c14f0f88c8f549ae821c66eac0c17435cea2112f2dae866e35372a24f8518b0328d09
+  data.tar.gz: 32037a7aaf48446df4c1aeef58d1103622304d4560e2aa22b01936caf3bc14fd0b86105e26bf9a96367a1aa0d9c2770747a8941b282655ecf37ce0dc3ee9adcd

data/lib/rails/swagger.rb

@@ -3,6 +3,6 @@ require "rails/swagger/router"
 require "rails/swagger/engine"
 
 module Rails
-	module Swagger
-	end
+  module Swagger
+  end
 end

data/lib/rails/swagger/controller.rb

@@ -1,39 +1,43 @@
 module Rails
-	module Swagger
-		module Controller
-
-			# METHODS_WITH_BODIES = [
-			# 	:post,
-			# 	:patch,
-			# 	:put
-			# ].freeze
-
-			# Injects swagger-related code into the controller when included
-			def self.included base
-
-				# Add controller hooks
-				# base.class_eval do
-				# 	before_action :swagger_validate_params
-				# end
-
-				# Returns the swagger spec definition for the endpoint serving
-				# the current request.
-				def swagger_endpoint
-					key = "#{params[:controller]}##{params[:action]}"
-					swagger_engine.endpoints[key]
-				end
-
-				# Validates request parameters against the Swagger API spec
-				# associated with this controller.
-				# def swagger_validate_params
-				# 	if METHODS_WITH_BODIES.include? request.method_symbol
-				# 		body = request.POST
-				# 		# TODO: add validation here
-				# 	end
-				# end
-
-			end
-
-		end
-	end
+
+  module Swagger
+
+    module Controller
+
+      # METHODS_WITH_BODIES = [
+      #   :post,
+      #   :patch,
+      #   :put
+      # ].freeze
+
+      # Injects swagger-related code into the controller when included
+      def self.included base
+
+        # Add controller hooks
+        # base.class_eval do
+        #   before_action :swagger_validate_params
+        # end
+
+        # Returns the swagger spec definition for the endpoint serving
+        # the current request.
+        def swagger_endpoint
+          key = "#{params[:controller]}##{params[:action]}"
+          swagger_engine.endpoints[key]
+        end
+
+        # Validates request parameters against the Swagger API spec
+        # associated with this controller.
+        # def swagger_validate_params
+        #   if METHODS_WITH_BODIES.include? request.method_symbol
+        #     body = request.POST
+        #     # TODO: add validation here
+        #   end
+        # end
+
+      end
+
+    end
+
+  end
+
 end

data/lib/rails/swagger/engine.rb

@@ -1,156 +1,158 @@
 module Rails
-	module Swagger
-
-		# Defines the Swagger spec file formats that are parsable by this gem.
-		# Currently only the JSON format is supported.
-		ALLOWED_FORMATS = [".json"].freeze
-
-		# Defines a base class from which Swagger API engines can be created.
-		# Uses namespace isolation to ensure routes don't conflict with any
-		# pre-existing routes from the main rails application.
-		class Engine < Rails::Engine
-			isolate_namespace Rails::Swagger
-		end
-
-		# Helper method to create a new engine based on a module namespace
-		# prefix and Swagger spec file. The engine ceated will be a subclass of
-		# Rails::Swagger::Engine, which itself inherits from Rails::Engine.
-		def self.Engine base_module, file
-
-			# Convert the module prefix into a constant if passed in as a string
-			base_module = Object.const_get base_module if String === base_module
-
-			# Ensure the Swagger spec file is in an acceptable format
-			ext = File.extname(file)
-			unless ALLOWED_FORMATS.include? ext
-				raise "Swagger files must end with #{ALLOWED_FORMATS.join(' or ')}. File given: #{file}"
-			end
-
-			# Attempt to read and parse the Swagger spec file
-			document = File.read file
-			case File.extname file
-			when ".json"
-				begin
-					require 'json'
-					document = JSON.parse document
-				rescue JSON::ParserError
-					raise $!, "Problem parsing swagger spec file \"#{file}\": #{$!.message.lines.first.strip}", $@
-				end
-			else
-				raise "Swagger files must end with #{ALLOWED_FORMATS.join(' or ')}. File given: #{file}"
-			end
-
-			# Verify that the swagger version is supported
-			unless document["swagger"] == "2.0"
-				raise "Unsupported swagger version: #{document["swagger"]}. #{self} supports only version 2.0"
-			end
-
-			# Builds a routing tree based on the swagger spec file.
-			# We'll add each endpoint to the routing tree and additionally
-			# store it in an array to be used below.
-			router = Router.new
-			endpoints = []
-			document["paths"].each do |url, actions|
-				actions.each do |verb, definition|
-					route = Endpoint.new(verb.downcase.to_sym, url, definition)
-					router << route
-					endpoints << route
-				end
-			end
-
-			# Creates the engine that will be used to actually route the
-			# contents of the swagger spec file. The engine will eventually be
-			# attached to the base module (argument to this current method).
-			#
-			# Exposes `::router` and `::endpoints` methods to allow other parts
-			# of the code to tie requests back to their spec file definitions.
-			engine = Class.new Engine do
-
-				@router = router
-				@endpoints = Hash.new
-				@schema = document
-
-				class << self
-					def router
-						@router
-					end
-					def endpoints
-						@endpoints
-					end
-					def schema
-						@schema
-					end
-				end
-
-				# Rack app for serving the original swagger file
-				swagger_app = Class.new do
-					def inspect
-						"Rails::Swagger::Engine"
-					end
-					define_method :call do |env|
-						[
-							200,
-							{"Content-Type" => "application/json"},
-							[engine.schema.to_json]
-						]
-					end
-				end
-
-				# Adds routes to the engine by passing the Mapper to the top
-				# of the routing tree. `self` inside the block refers to an
-				# instance of `ActionDispatch::Routing::Mapper`.
-				self.routes.draw do
-					scope module: base_module.name.underscore, format: false do
-						get "swagger.json", to: swagger_app.new
-						router.draw self
-					end
-				end
-
-			end
-
-			# Assign the engine as a class on the base module
-			base_module.const_set :Engine, engine
-
-			# Creates a hash that maps routes back to their swagger spec file
-			# equivalents. This is accomplished by mocking a request for each
-			# swagger spec file endpoint and determining which controller and
-			# action the request is routed to. Swagger spec file definitions
-			# are then attached to that controller/action pair.
-			endpoints.each do |route|
-
-				# Mocks a request using the route's URL
-				url = ::ActionDispatch::Journey::Router::Utils.normalize_path route.path
-				env = ::Rack::MockRequest.env_for url, method: route[:method].upcase
-				req = ::ActionDispatch::Request.new env
-
-				# Maps the swagger spec endpoint to the destination controller
-				# action by routing the request.
-				mapped = engine.routes.router.recognize(req){}.first[1]
-				key = "#{mapped[:controller]}##{mapped[:action]}"
-				engine.endpoints[key] = route
-
-			end
-			engine.endpoints.freeze
-
-			# Defines a helper module on the base module that can be used to
-			# properly generate swagger-aware controllers. Any controllers
-			# referenced from a swagger spec file should include this module.
-			mod = Module.new do
-				@base = base_module
-				def self.included controller
-					base_module = @base
-					controller.include Controller
-					define_method :swagger_engine do
-						base_module.const_get :Engine
-					end
-				end
-			end
-			base_module.const_set :SwaggerController, mod
-
-			# Returns the new engine
-			base_module.const_get :Engine
-
-		end
-
-	end
+
+  module Swagger
+
+    # Defines the Swagger spec file formats that are parsable by this gem.
+    # Currently only the JSON format is supported.
+    ALLOWED_FORMATS = [".json"].freeze
+
+    # Defines a base class from which Swagger API engines can be created.
+    # Uses namespace isolation to ensure routes don't conflict with any
+    # pre-existing routes from the main rails application.
+    class Engine < Rails::Engine
+      isolate_namespace Rails::Swagger
+    end
+
+    # Helper method to create a new engine based on a module namespace
+    # prefix and Swagger spec file. The engine ceated will be a subclass of
+    # Rails::Swagger::Engine, which itself inherits from Rails::Engine.
+    def self.Engine base_module, file
+
+      # Convert the module prefix into a constant if passed in as a string
+      base_module = Object.const_get base_module if String === base_module
+
+      # Ensure the Swagger spec file is in an acceptable format
+      ext = File.extname(file)
+      unless ALLOWED_FORMATS.include? ext
+        raise "Swagger files must end with #{ALLOWED_FORMATS.join(' or ')}. File given: #{file}"
+      end
+
+      # Attempt to read and parse the Swagger spec file
+      document = File.read file
+      case File.extname file
+      when ".json"
+        begin
+          require 'json'
+          document = JSON.parse document
+        rescue JSON::ParserError
+          raise $!, "Problem parsing swagger spec file \"#{file}\": #{$!.message.lines.first.strip}", $@
+        end
+      else
+        raise "Swagger files must end with #{ALLOWED_FORMATS.join(' or ')}. File given: #{file}"
+      end
+
+      # Verify that the swagger version is supported
+      unless document["swagger"] == "2.0"
+        raise "Unsupported swagger version: #{document["swagger"]}. #{self} supports only version 2.0"
+      end
+
+      # Builds a routing tree based on the swagger spec file.
+      # We'll add each endpoint to the routing tree and additionally
+      # store it in an array to be used below.
+      router = Router.new
+      endpoints = []
+      document["paths"].each do |url, actions|
+        actions.each do |verb, definition|
+          route = Endpoint.new(verb.downcase.to_sym, url, definition)
+          router << route
+          endpoints << route
+        end
+      end
+
+      # Creates the engine that will be used to actually route the
+      # contents of the swagger spec file. The engine will eventually be
+      # attached to the base module (argument to this current method).
+      #
+      # Exposes `::router` and `::endpoints` methods to allow other parts
+      # of the code to tie requests back to their spec file definitions.
+      engine = Class.new Engine do
+
+        @router = router
+        @endpoints = Hash.new
+        @schema = document
+
+        class << self
+          def router
+            @router
+          end
+          def endpoints
+            @endpoints
+          end
+          def schema
+            @schema
+          end
+        end
+
+        # Rack app for serving the original swagger file
+        swagger_app = Class.new do
+          def inspect
+            "Rails::Swagger::Engine"
+          end
+          define_method :call do |env|
+            [
+              200,
+              {"Content-Type" => "application/json"},
+              [engine.schema.to_json]
+            ]
+          end
+        end
+
+        # Adds routes to the engine by passing the Mapper to the top
+        # of the routing tree. `self` inside the block refers to an
+        # instance of `ActionDispatch::Routing::Mapper`.
+        self.routes.draw do
+          scope module: base_module.name.underscore, format: false do
+            get "swagger.json", to: swagger_app.new
+            router.draw self
+          end
+        end
+
+      end
+
+      # Assign the engine as a class on the base module
+      base_module.const_set :Engine, engine
+
+      # Creates a hash that maps routes back to their swagger spec file
+      # equivalents. This is accomplished by mocking a request for each
+      # swagger spec file endpoint and determining which controller and
+      # action the request is routed to. Swagger spec file definitions
+      # are then attached to that controller/action pair.
+      endpoints.each do |route|
+
+        # Mocks a request using the route's URL
+        url = ::ActionDispatch::Journey::Router::Utils.normalize_path route.path
+        env = ::Rack::MockRequest.env_for url, method: route[:method].upcase
+        req = ::ActionDispatch::Request.new env
+
+        # Maps the swagger spec endpoint to the destination controller
+        # action by routing the request.
+        mapped = engine.routes.router.recognize(req){}.first[1]
+        key = "#{mapped[:controller]}##{mapped[:action]}"
+        engine.endpoints[key] = route
+
+      end
+      engine.endpoints.freeze
+
+      # Defines a helper module on the base module that can be used to
+      # properly generate swagger-aware controllers. Any controllers
+      # referenced from a swagger spec file should include this module.
+      mod = Module.new do
+        @base = base_module
+        def self.included controller
+          base_module = @base
+          controller.include Controller
+          define_method :swagger_engine do
+            base_module.const_get :Engine
+          end
+        end
+      end
+      base_module.const_set :SwaggerController, mod
+
+      # Returns the new engine
+      base_module.const_get :Engine
+
+    end
+
+  end
+
 end

data/lib/rails/swagger/router.rb

@@ -1,188 +1,195 @@
 module Rails
-	module Swagger
-
-		# Internally represents individual routes
-		Endpoint = Struct.new(:method, :url, :definition, :_path) do
-			def initialize *opts
-				super
-				self[:_path] = self.path
-			end
-			# Translates path params from {bracket} syntax to :symbol syntax
-			def path
-				self[:url].gsub(/\{(.+)\}/, ':\\1')
-			end
-		end
-
-		# Defines RESTful routing conventions
-		RESOURCE_ROUTES = {
-			get: :index,
-			post: :create
-		}.freeze
-		PARAM_ROUTES = {
-			get: :show,
-			patch: :update,
-			put: :update,
-			delete: :destroy
-		}.freeze
-
-		class Router
-
-			attr_accessor :endpoints
-
-			def initialize prefix = [], parent = nil
-				@parent = parent
-				@prefix = prefix.freeze
-				@endpoints = []
-				@subroutes = Hash.new do |hash, k|
-					hash[k] = Router.new(@prefix + [k], self)
-				end
-			end
-
-			# Adds an individual endpoint to the routing tree
-			def << route
-				raise "Argument must be an Endpoint" unless Endpoint === route
-				_base, *subroute = route[:_path].split '/' # Split out first element
-				if subroute.count == 0
-					route[:_path] = ""
-					@endpoints << route
-				else
-					route[:_path] = subroute.join '/'
-					self[subroute[0]] << route
-				end
-			end
-
-			# Returns a specific branch of the routing tree
-			def [] path
-				@subroutes[path]
-			end
-
-			# Returns the routing path
-			def path
-				"/" + @prefix.join("/")
-			end
-
-			# Returns the mode used for collecting routes
-			def route_mode
-				mode = :resource
-				mode = :namespace if @endpoints.count == 0
-				mode = :action if @subroutes.count == 0 && @parent && @parent.route_mode == :resource
-				mode
-			end
-
-			# Returns the mode used for actions in this router
-			def action_mode
-				if /^:/ === @prefix[-2]
-					:member
-				elsif /^:/ === @prefix[-1]
-					:param
-				else
-					:collection
-				end
-			end
-
-			# Determines the action for a specific route
-			def action_for route
-				raise "Argument must be an Endpoint" unless Endpoint === route
-				action = @prefix[-1]
-				action = PARAM_ROUTES[route[:method]] if self.action_mode == :param
-				action = RESOURCE_ROUTES[route[:method]] if self.route_mode == :resource && self.action_mode == :collection
-				action
-			end
-
-			# Draws the routes for this router
-			def draw map
-				case self.route_mode
-				when :resource
-
-					# Find collection-level resource actions
-					actions = @endpoints.map{ |r| self.action_for r }.select{ |a| Symbol === a }
-
-					# Find parameter-level resource actions
-					@subroutes.select{ |k, _| /^:/ === k }.values.each do |subroute|
-						actions += subroute.endpoints.map{ |r| subroute.action_for r }.select{ |a| Symbol === a }
-					end
-
-					# Draw a resource
-					map.resources @prefix.last.to_sym, only: actions do
-						draw_actions! map
-						draw_subroutes! map
-					end
-
-				when :namespace
-
-					# Draw a namespace (unless at the top)
-					if @prefix.join("/").blank?
-						draw_subroutes! map
-					else
-						map.namespace @prefix.last do
-							draw_subroutes! map
-						end
-					end
-
-				when :action
-
-					# Draw actions directly
-					draw_actions! map
-
-				end
-
-			end
-
-			# Returns the routing tree in text format
-			def to_s
-
-				output = ""
-
-				path = "/" + @prefix.join('/')
-				@endpoints.each do |route|
-					output += "#{route[:method].to_s.upcase} #{path}\n"
-				end
-				@subroutes.each do |k, subroute|
-					output += subroute.to_s
-				end
-
-				output
-
-			end
-
-			# Outputs a visual representation of the routing tree
-			def _debug_routing_tree
 
-				puts self.path + " - #{self.route_mode}"
-				@endpoints.each do |route|
-					puts "\t#{route[:method].to_s.upcase} to ##{self.action_for route} (#{self.action_mode})"
-				end
-				@subroutes.each do |k, subroute| subroute._debug_routing_tree end
+  module Swagger
+
+    # Internally represents individual routes
+    Endpoint = Struct.new(:method, :url, :definition, :_path) do
+      def initialize *opts
+        super
+        self[:_path] = self.path
+      end
+      # Translates path params from {bracket} syntax to :symbol syntax
+      def path
+        self[:url].gsub(/\{([^}]+)\}/, ':\\1')
+      end
+    end
+
+    # Defines RESTful routing conventions
+    RESOURCE_ROUTES = {
+      get: :index,
+      post: :create
+    }.freeze
+    PARAM_ROUTES = {
+      get: :show,
+      patch: :update,
+      put: :update,
+      delete: :destroy
+    }.freeze
+
+    class Router
+
+      attr_accessor :endpoints
+
+      def initialize prefix = [], parent = nil
+        @parent = parent
+        @prefix = prefix.freeze
+        @endpoints = []
+        @subroutes = Hash.new do |hash, k|
+          hash[k] = Router.new(@prefix + [k], self)
+        end
+      end
+
+      # Adds an individual endpoint to the routing tree
+      def << route
+        raise "Argument must be an Endpoint" unless Endpoint === route
+        _base, *subroute = route[:_path].split '/' # Split out first element
+        if subroute.count == 0
+          route[:_path] = ""
+          @endpoints << route
+        else
+          route[:_path] = subroute.join '/'
+          self[subroute[0]] << route
+        end
+      end
+
+      # Returns a specific branch of the routing tree
+      def [] path
+        @subroutes[path]
+      end
+
+      # Returns the routing path
+      def path
+        "/" + @prefix.join("/")
+      end
+
+      # Returns the mode used for collecting routes
+      def route_mode
+        mode = :resource
+        mode = :namespace if @endpoints.count == 0
+        mode = :action if @subroutes.count == 0 && @parent && @parent.route_mode == :resource
+        mode = :param if /^:/ === @prefix.last
+        mode
+      end
+
+      # Returns the mode used for actions in this router
+      def action_mode
+        if /^:/ === @prefix[-1]
+          :param
+        else
+          :collection
+        end
+      end
+
+      # Determines the action for a specific route
+      def action_for route
+        raise "Argument must be an Endpoint" unless Endpoint === route
+        action = @prefix[-1]
+        action = PARAM_ROUTES[route[:method]] if self.action_mode == :param
+        action = RESOURCE_ROUTES[route[:method]] if self.route_mode == :resource && self.action_mode == :collection
+        action
+      end
+
+      # Draws the routes for this router
+      def draw map
+
+        case self.route_mode
+        when :resource
+
+          # Find collection-level resource actions
+          actions = @endpoints.map{ |r| self.action_for r }.select{ |a| Symbol === a }
+
+          # Find parameter-level resource actions
+          @subroutes.select{ |k, _| /^:/ === k }.values.each do |subroute|
+            actions += subroute.endpoints.map{ |r| subroute.action_for r }.select{ |a| Symbol === a }
+          end
+
+          # Draw a resource
+          map.resources @prefix.last.to_sym, only: actions do
+            draw_actions! map
+            draw_subroutes! map
+          end
+
+        when :namespace
+
+          # Draw a namespace (unless at the top)
+          if @prefix.join("/").blank?
+            draw_subroutes! map
+          else
+            map.namespace @prefix.last do
+              draw_subroutes! map
+            end
+          end
+
+        when :param
 
-			end
+          # Draw subroutes directly
+          draw_subroutes! map
 
-		protected
+        when :action
 
-			def draw_actions! map
+          # Draw actions directly
+          draw_actions! map
 
-				@endpoints.each do |route|
+        end
+
+      end
 
-					# Params hash for the route to be added
-					params = Hash.new
-					params[:via] = route[:method]
-					params[:on] = self.action_mode unless self.action_mode == :param
-					params[:action] = self.action_for route
+      # Returns the routing tree in text format
+      def to_s
 
-					# These are handled in the resource
-					next if Symbol === params[:action]
+        output = ""
 
-					# Add this individual route
-					map.match @prefix.last, params
+        path = "/" + @prefix.join('/')
+        @endpoints.each do |route|
+          output += "#{route[:method].to_s.upcase} #{path}\n"
+        end
+        @subroutes.each do |k, subroute|
+          output += subroute.to_s
+        end
 
-				end
+        output
 
-			end
+      end
 
-			def draw_subroutes! map
-				@subroutes.values.each { |r| r.draw map }
-			end
+      # Outputs a visual representation of the routing tree
+      def _debug_routing_tree
 
-		end
+        puts self.path + " - #{self.route_mode}"
+        @endpoints.each do |route|
+          puts "\t#{route[:method].to_s.upcase} to ##{self.action_for route} (#{self.action_mode})"
+        end
+        @subroutes.each do |k, subroute| subroute._debug_routing_tree end
+
+      end
+
+    protected
+
+      def draw_actions! map
+
+        @endpoints.each do |route|
+
+          # Params hash for the route to be added
+          params = Hash.new
+          params[:via] = route[:method]
+          params[:on] = self.action_mode unless self.action_mode == :param
+          params[:action] = self.action_for route
+
+          # These are handled in the resource
+          next if Symbol === params[:action]
+
+          # Add this individual route
+          map.match @prefix.last, params
+
+        end
+
+      end
+
+      def draw_subroutes! map
+        @subroutes.values.each { |r| r.draw map }
+      end
+
+    end
+
+  end
 
-	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-swagger
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kenaniah Cerny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-29 00:00:00.000000000 Z
+date: 2019-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Turns Swagger API schemas into mountable Rails engines