paradocs 1.0.24 → 1.1.0

data/lib/paradocs/extensions/insides.rb

@@ -1,77 +0,0 @@
-module Paradocs
-  module Extensions
-    module Insides
-      def structure(ignore_transparent: true, root: "", &block)
-        flush!
-        fields.each_with_object({meta_keys[:errors] => [], meta_keys[:subschemes] => {}}) do |(_, field), obj|
-          meta, sc = collect_meta(field, root)
-          if sc
-            meta[:structure] = sc.structure(ignore_transparent: ignore_transparent, root: meta[:json_path], &block)
-            obj[meta_keys[:errors]] += meta[:structure].delete(meta_keys[:errors])
-          else
-            obj[meta_keys[:errors]] += field.possible_errors
-          end
-          obj[field.key] = meta unless ignore_transparent && field.transparent?
-          yield(field.key, meta) if block_given?
-
-          next unless field.mutates_schema?
-          subschemes.each do |name, subschema|
-            obj[meta_keys[:subschemes]][name] = subschema.structure(ignore_transparent: ignore_transparent, root: root, &block)
-            obj[meta_keys[:errors]] += obj[meta_keys[:subschemes]][name][meta_keys[:errors]]
-          end
-        end
-      end
-
-      def flatten_structure(ignore_transparent: true, root: "", &block)
-        flush!
-        fields.each_with_object({meta_keys[:errors] => [], meta_keys[:subschemes] => {}}) do |(_, field), obj|
-          meta, sc = collect_meta(field, root)
-          humanized_name = meta.delete(:nested_name)
-          obj[humanized_name] = meta unless ignore_transparent && field.transparent?
-
-          if sc
-            deep_result = sc.flatten_structure(ignore_transparent: ignore_transparent, root: meta[:json_path], &block)
-            obj[meta_keys[:errors]] += deep_result.delete(meta_keys[:errors])
-            obj[meta_keys[:subschemes]].merge!(deep_result.delete(meta_keys[:subschemes]))
-            obj.merge!(deep_result)
-          else
-            obj[meta_keys[:errors]] += field.possible_errors
-          end
-          yield(humanized_name, meta) if block_given?
-          next unless field.mutates_schema?
-          subschemes.each do |name, subschema|
-            obj[meta_keys[:subschemes]][name] ||= subschema.flatten_structure(ignore_transparent: ignore_transparent, root: root, &block)
-            obj[meta_keys[:errors]] += obj[meta_keys[:subschemes]][name][meta_keys[:errors]]
-          end
-        end
-      end
-
-      def walk(meta_key = nil, &visitor)
-        r = visit(meta_key, &visitor)
-        Results.new(r, {}, {})
-      end
-
-      def visit(meta_key = nil, &visitor)
-        fields.each_with_object({}) do |(_, field), m|
-          m[field.key] = field.visit(meta_key, &visitor)
-        end
-      end
-
-      private
-
-      def collect_meta(field, root)
-        json_path = root.empty? ? "$.#{field.key}" : "#{root}.#{field.key}"
-        meta = field.meta_data.merge(json_path: json_path)
-        sc = meta.delete(:schema)
-        meta[:mutates_schema] = true if meta.delete(:mutates_schema)
-        json_path << "[]" if meta[:type] == :array
-        meta[:nested_name] = json_path.gsub("[]", "")[2..-1]
-        [meta, sc]
-      end
-
-      def meta_keys
-        %i(errors subschemes).map! { |key| [key, "#{Paradocs.config.meta_prefix}#{key}".to_sym] }.to_h
-      end
-    end
-  end
-end

data/spec/schema_structures_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-describe "Schema structures generation" do
-  Paradocs.policy :policy_with_error do
-    register_error ArgumentError
-
-    validate do |*|
-      raise ArgumentError
-    end
-  end
-
-  Paradocs.policy :policy_with_silent_error do
-    register_silent_error RuntimeError
-  end
-
-  let(:schema) do
-    Paradocs::Schema.new do
-      subschema(:highest_level) { field(:test).present } # no mutations on this level -> subschema ignored
-
-      field(:data).type(:object).present.schema do
-        field(:id).type(:integer).present.policy(:policy_with_error)
-        field(:name).type(:string).meta(label: "very important staff")
-        field(:role).type(:string).declared.options(["admin", "user"]).default("user").mutates_schema! do |*|
-          :test_subschema
-        end
-        field(:extra).type(:array).required.schema do
-          field(:extra).declared.default(false).policy(:policy_with_silent_error)
-        end
-
-        mutation_by!(:name) { :subschema }
-
-        subschema(:subschema) do
-          field(:test_field).present
-        end
-        subschema(:test_subschema) do
-          field(:test1).present
-        end
-      end
-    end
-  end
-
-
-  it "generates nested data for documentation generation" do
-    result = schema.structure { |k, meta| meta[:block_works] = true unless meta[:present] }
-    expect(result[:_subschemes]).to eq({})
-    expect(result[:_errors]).to eq([ArgumentError])
-    data_structure = result[:data].delete(:structure)
-    expect(result[:data]).to eq({
-      type: :object,
-      required: true,
-      present: true,
-      json_path: "$.data",
-      nested_name: "data",
-    })
-    expect(data_structure[:_subschemes]).to eq({
-      test_subschema: {
-        _errors: [],
-        _subschemes: {},
-        test1: {required: true, present: true, json_path: "$.data.test1", nested_name: "data.test1"}
-      },
-      subschema: {
-        _errors: [],
-        _subschemes: {},
-        test_field: {required: true, present: true, json_path: "$.data.test_field", nested_name: "data.test_field"}
-      }
-    })
-    expect(data_structure[:id]).to eq({
-      type: :integer,
-      required: true,
-      present: true,
-      policy_with_error: {errors: [ArgumentError]},
-      json_path: "$.data.id",
-      nested_name: "data.id"
-    })
-    expect(data_structure[:name]).to eq({
-      type: :string,
-      label: "very important staff",
-      mutates_schema: true,
-      block_works: true,
-      json_path: "$.data.name",
-      nested_name: "data.name"
-    })
-    expect(data_structure[:role]).to eq({
-      type: :string,
-      options: ["admin", "user"],
-      default: "user",
-      mutates_schema: true,
-      block_works: true,
-      json_path: "$.data.role",
-      nested_name: "data.role"
-    })
-    expect(data_structure[:extra]).to eq({
-      type: :array,
-      required: true,
-      block_works: true,
-      json_path: "$.data.extra[]",
-      nested_name: "data.extra",
-      structure: {
-        extra: {
-          default: false,
-          block_works: true,
-          json_path: "$.data.extra[].extra",
-          nested_name: "data.extra.extra",
-          policy_with_silent_error: {errors: []}
-        },
-        _subschemes: {}
-      }
-    })
-  end
-
-  it "generates flatten data for documentation generation" do
-    expect(schema.flatten_structure { |key, meta| meta[:block_works] = true if key.split(".").size == 1 }).to eq({
-      "data" => {
-        type: :object,
-        required: true,
-        present: true,
-        block_works: true,
-        json_path: "$.data"
-      },
-      "data.extra" => {
-        type: :array,
-        required: true,
-        json_path: "$.data.extra[]"
-      },
-      "data.extra.extra" => {
-        default: false,
-        json_path: "$.data.extra[].extra",
-        policy_with_silent_error: {errors: []}
-      },
-      "data.id" => {
-        type: :integer,
-        required: true,
-        present: true,
-        json_path: "$.data.id",
-        policy_with_error: {errors: [ArgumentError]}
-      },
-      "data.name" => {
-        type: :string,
-        json_path: "$.data.name",
-        label: "very important staff",
-        mutates_schema: true
-      },
-      "data.role" => {
-        type: :string,
-        options: ["admin", "user"],
-        default: "user",
-        json_path: "$.data.role",
-        mutates_schema: true
-      },
-      _errors: [ArgumentError],
-      _subschemes: {
-        test_subschema: {
-          _errors: [],
-          _subschemes: {},
-          "data.test1"=>{
-            required: true,
-            present: true,
-            json_path: "$.data.test1"
-          }
-        },
-        subschema: {
-          _errors: [],
-          _subschemes: {},
-          "data.test_field" => {required: true, present: true, json_path: "$.data.test_field"}
-        }
-      }
-    })
-  end
-end