r2-oas 0.4.0

data/lib/r2-oas/schema/v3/object/from_routes/public.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'info_object'
+require_relative 'paths_object'
+require_relative 'path_item_object'
+require_relative 'external_document_object'
+require_relative 'components_object'
+require_relative 'components/schema_object'
+require_relative 'components/request_body_object'

data/lib/r2-oas/schema/v3/object/from_routes/server_object.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class ServerObject < BaseObject
+        def to_doc
+          server.data.each_with_object([]) do |server, result|
+            result.push(
+              'url' => (server[:url]).to_s,
+              'description' => (server[:description]).to_s
+            )
+            # Do not Server Variable Object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/from_routes/tag_object.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'path_item_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class TagObject < BaseObject
+        def initialize(tags_data, opts = {})
+          super(opts)
+          @tags_data = tags_data
+        end
+
+        def to_doc
+          @tags_data.each_with_object([]) do |tag_name, result|
+            result.push(create_doc(tag_name))
+          end
+        end
+
+        private
+
+        def create_doc(tag_name)
+          {
+            'name' => tag_name,
+            'description' => "#{tag_name} description",
+            # External Docs Object
+            'externalDocs' => {
+              'description' => 'description',
+              'url' => 'url'
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/store.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Schema
+    module V3
+      class Store
+        attr_accessor :root_doc
+        attr_accessor :components_schema_name_list, :appended_components_schema_name_list
+        attr_accessor :components_request_body_name_list, :appended_components_request_body_name_list
+
+        def initialize(type = :obj)
+          @data = {}
+          @data['type'] = type
+          @data['data'] = {}
+          @root_doc = {}
+          @components_schema_name_list = []
+          @appended_components_schema_name_list = []
+          @components_request_body_name_list = []
+          @appended_components_request_body_name_list = []
+        end
+
+        def add(obj_type, key, value)
+          @data['data'][obj_type] ||= {}
+          # MEMO:
+          # Do not save the same thing in store by using unique contents for schema name
+          @data['data'][obj_type][key] ||= value
+        end
+
+        def gets(obj_type)
+          (@data['data'][obj_type] || {}).values.present? ? @data['data'][obj_type].values : []
+        end
+
+        class << self
+          extend Forwardable
+
+          def_delegators :instance, :add, :gets, :root_doc
+          def_delegators :instance, :components_schema_name_list, :appended_components_schema_name_list
+          def_delegators :instance, :components_request_body_name_list, :appended_components_request_body_name_list
+
+          def create(type = :obj)
+            instance(type)
+          end
+
+          private
+
+          def instance(type)
+            @instance ||= {}
+            @instance[type] ||= new(type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/squeezer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'squeezer/base_squeezer'
+require_relative 'squeezer/tag_squeezer'
+require_relative 'squeezer/path_squeezer'
+
+module R2OAS
+  module Schema
+    module V3
+      class Squeezer < BaseSqueezer
+        def squeeze_docs
+          except_paths_schema = @schema_data.except('paths', 'tags', 'components')
+          components_schemas = @schema_data.slice('components')
+
+          path_squeezer = PathSqueezer.new(@schema_data, many_paths_file_paths: many_paths_file_paths)
+          tag_squeezer = TagSqueezer.new(@schema_data, many_paths_file_paths: many_paths_file_paths)
+
+          # To make components merge after paths
+          slice_schemas = [
+            tag_squeezer.squeeze_docs,
+            path_squeezer.squeeze_docs,
+            components_schemas
+          ]
+          slice_schemas.each_with_object(except_paths_schema) { |slice_schema, result| result.deep_merge!(slice_schema) }
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/squeezer/base_squeezer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Schema
+    module V3
+      class BaseSqueezer < Base
+        def initialize(schema_data, options = {})
+          super(options)
+          @schema_data = schema_data
+          @tag_names = create_tag_names
+        end
+
+        def squeeze_docs
+          raise NoImplementError, 'Please implement in inherited class.'
+        end
+
+        private
+
+        attr_accessor :many_paths_file_paths
+
+        def create_tag_names
+          many_paths_file_paths.each_with_object([]) do |unit_paths_path, result|
+            paths_from_local = YAML.load_file(unit_paths_path)
+
+            tag_name_from_path = if paths_from_local['paths'].values[0].values[0].is_a?(Array)
+                                   'unknown'
+                                 else
+                                   paths_from_local['paths'].values[0].values[0]['tags'][0]
+                                 end
+
+            result.push(tag_name_from_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/squeezer/path_squeezer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base_squeezer'
+
+module R2OAS
+  module Schema
+    module V3
+      class PathSqueezer < BaseSqueezer
+        VERB = %w[get put post delete options head patch trace].freeze
+        NOT_VERB = %w[$ref summary description servers parameters].freeze
+
+        def squeeze_docs
+          slice_paths_schema = @schema_data['paths'].each_with_object({}) do |(path, data_when_path), result|
+            data_when_path.each do |verb_or_not, data_when_verb_or_not|
+              if VERB.include?(verb_or_not)
+                include_tag_name = data_when_verb_or_not['tags'].first.in? @tag_names
+                result.deep_merge!(path.to_s => data_when_path) if include_tag_name
+              elsif NOT_VERB.include?(verb_or_not)
+                result.deep_merge!(path.to_s => data_when_path)
+              end
+            end
+          end
+          { 'paths' => slice_paths_schema }
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/squeezer/tag_squeezer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base_squeezer'
+
+module R2OAS
+  module Schema
+    module V3
+      class TagSqueezer < BaseSqueezer
+        def squeeze_docs
+          slice_tags_schema = @schema_data['tags'].each_with_object([]) do |tag, result|
+            eql_tag_name = tag['name'].in? @tag_names
+            result.push(tag) if eql_tag_name
+          end
+          { 'tags' => slice_tags_schema }
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/shared/all.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'sortable'
+require_relative 'callable'

data/lib/r2-oas/shared/callable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Callable
+    def deep_call(data, target, callback)
+      return data unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        if key.eql? target
+          data[key] = callback.call(value)
+        else
+          data[key] = deep_call(value, target, callback)
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/shared/sortable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Sortable
+    def deep_sort(data, target)
+      if data.is_a?(Hash)
+        data.each_with_object({}) do |(key, value), result|
+          result[key] = if key.eql? target
+                          if value.is_a?(Hash)
+                            Hash[value.sort]
+                          else
+                            value
+                                        end
+                        else
+                          deep_sort(value, target)
+                        end
+        end
+      else
+        data
+      end
+    end
+  end
+end

data/lib/r2-oas/store.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+require 'zlib'
+
+require 'r2-oas/schema/manager/file_manager'
+
+module R2OAS
+  class Store
+    attr_accessor :data
+
+    def initialize(type, data = {})
+      if data.empty?
+        @data = {}
+        @type = type
+        @data['type'] = type
+        @data['data'] = {}
+      else
+        @type = type
+        @data = data
+      end
+    end
+
+    def add(key, value)
+      case @type
+      when :schema
+        sha1 = calc_sha1(key, value)
+
+        @data['data'][sha1] ||= {}
+        @data['data'][sha1]['key'] = key
+        @data['data'][sha1]['value'] = Zlib::Deflate.deflate(value)
+      end
+    end
+
+    def save
+      @data['data'].values.each do |value|
+        case @type
+        when :schema
+          save_path = value['key']
+          save_data = Zlib::Inflate.inflate(value['value'])
+          manager = Schema::FileManager.new(save_path, :full)
+          manager.save(save_data)
+          yield save_path
+        end
+      end
+    end
+
+    def dup_slice(*sha1s)
+      dup_store = Store.new(@type, @data.dup)
+      dup_data = dup_store.data['data']
+      dup_store.data['data'] = sha1s.each_with_object({}) { |sha1, data| data[sha1] = dup_data[sha1] if dup_store.key?(sha1) }
+      dup_store
+    end
+
+    def checksum?
+      @data['data'].each_with_object([]) do |(sha1, value), arr|
+        child_key = value['key']
+        child_value = Zlib::Inflate.inflate(value['value'])
+        arr.push(sha1.eql? calc_sha1(child_key, child_value))
+      end.all?
+    end
+
+    def key?(key)
+      @data['data']&.key?(key)
+    end
+
+    def exists?
+      !@data['data']&.empty?
+    end
+
+    def diff_from(local_store)
+      to_hash = adjust(values.to_h, 'after')
+      from_hash = adjust(local_store.send(:values).to_h, 'before')
+      analyze_data = to_hash.deep_merge(from_hash)
+      if block_given?
+        yield analyze_data
+      else
+        analyze_data
+      end
+    end
+
+    private
+
+    def calc_sha1(key, value)
+      Digest::SHA1.hexdigest("#{key}\0#{value}")
+    end
+
+    def values
+      arr = @data['data'].values
+      arr.each_with_object([]) do |el, result|
+        key = el['key']
+        value = el['value']
+        result.push([key, value])
+      end
+    end
+
+    def adjust(hash, direct)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key] = { direct => {} }
+        result[key][direct] = YAML.safe_load(Zlib::Inflate.inflate(value))
+        result
+      end
+    end
+
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :add, :save, :dup_slice, :checksum?, :key?, :exists?, :diff_from
+
+      def create(type = :schema)
+        instance(type)
+      end
+
+      private
+
+      def instance(type)
+        @instance ||= {}
+        @instance[type] ||= new(type)
+      end
+    end
+  end
+end

data/lib/r2-oas/support/deprecation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'deprecation/instance_delegator'
+require_relative 'deprecation/reporting'
+require_relative 'deprecation/behavior'
+
+module R2OAS
+  class Deprecation
+    include Singleton
+    # Be sure to follow the Singleton module
+    include InstanceDelegator
+    include Behavior
+    include Reporting
+
+    # The version number in which the deprecated behavior will be removed, by default.
+    attr_accessor :deprecation_horizon
+
+    def initialize(deprecation_horizon = '0.4.2', gem_name = 'r2-oas')
+      self.gem_name = gem_name
+      self.deprecation_horizon = deprecation_horizon
+      self.silenced = false
+    end
+  end
+end

data/lib/r2-oas/support/deprecation/behavior.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# MEMO:
+# copy from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/deprecation/behaviors.rb
+module R2OAS
+  class Deprecation
+    class DeprecationError < StandardError; end
+
+    DEFAULT_BEHAVIORS = {
+      stderr: lambda { |message, _callstack, _deprecation_horizon, _gem_name|
+        $stderr.puts(message)
+      }
+    }.freeze
+
+    module Behavior
+      def behavior
+        @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
+      end
+    end
+  end
+end