schemacop 2.4.6 → 3.0.0.rc3

data/lib/schemacop/v3/array_node.rb

@@ -0,0 +1,218 @@
+module Schemacop
+  module V3
+    class ArrayNode < Node
+      ATTRIBUTES = %i[
+        min_items
+        max_items
+        unique_items
+      ].freeze
+
+      supports_children
+
+      def self.allowed_options
+        super + ATTRIBUTES + %i[additional_items]
+      end
+
+      def self.dsl_methods
+        super + NodeRegistry.dsl_methods(false) + %i[dsl_add dsl_list dsl_cont]
+      end
+
+      attr_reader :items
+      attr_accessor :list_item
+      attr_accessor :cont_item
+
+      def dsl_add(type, **options, &block)
+        if @options[:additional_items].is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "add" once to specify additional items.'
+        end
+
+        @options[:additional_items] = create(type, **options, &block)
+      end
+
+      def dsl_list(type, **options, &block)
+        if list_item.is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "list" once.'
+        end
+
+        @list_item = create(type, **options, &block)
+      end
+
+      def dsl_cont(type, **options, &block)
+        if cont_item.is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "cont" once.'
+        end
+
+        @cont_item = create(type, **options, &block)
+      end
+
+      def add_child(node)
+        @items << node
+      end
+
+      def as_json
+        json = { type: :array }
+
+        if cont_item
+          json[:contains] = cont_item.as_json
+        end
+
+        if list?
+          json[:items] = @list_item.as_json
+        elsif @items.any?
+          json[:items] = @items.map(&:as_json)
+          if options[:additional_items] == true
+            json[:additionalItems] = true
+          elsif options[:additional_items].is_a?(Node)
+            json[:additionalItems] = options[:additional_items].as_json
+          else
+            json[:additionalItems] = false
+          end
+        end
+
+        return process_json(ATTRIBUTES, json)
+      end
+
+      def allowed_types
+        { Array => :array }
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        # Validate length #
+        length = super_data.size
+
+        if options[:min_items] && length < options[:min_items]
+          result.error "Array has #{length} items but needs at least #{options[:min_items]}."
+        end
+
+        if options[:max_items] && length > options[:max_items]
+          result.error "Array has #{length} items but needs at most #{options[:max_items]}."
+        end
+
+        if list?
+          # Validate list
+          super_data.each_with_index do |value, index|
+            result.in_path :"[#{index}]" do
+              list_item._validate(value, result: result)
+            end
+          end
+        elsif items.any?
+          # Validate tuple
+          if length == items.size || (options[:additional_items] != false && length >= items.size)
+            items.each_with_index do |child_node, index|
+              value = super_data[index]
+
+              result.in_path :"[#{index}]" do
+                child_node._validate(value, result: result)
+              end
+            end
+
+            # Validate additional items #
+            if options[:additional_items].is_a?(Node)
+              (items.size..(length - 1)).each do |index|
+                additional_item = super_data[index]
+                result.in_path :"[#{index}]" do
+                  options[:additional_items]._validate(additional_item, result: result)
+                end
+              end
+            end
+          else
+            result.error "Array has #{length} items but must have exactly #{items.size}."
+          end
+        end
+
+        if cont_item.present? && super_data.none? { |obj| item_matches?(cont_item, obj) }
+          result.error "At least one entry must match schema #{cont_item.as_json.inspect}."
+        end
+
+        # Validate uniqueness #
+        if options[:unique_items] && super_data.size != super_data.uniq.size
+          result.error 'Array has duplicate items.'
+        end
+      end
+
+      def children
+        (@items + [@cont_item]).compact
+      end
+
+      def cast(value)
+        return default unless value
+
+        result = []
+
+        value.each_with_index do |value_item, index|
+          if cont_item.present? && item_matches?(cont_item, value_item)
+            result << cont_item.cast(value_item)
+          elsif list?
+            result << list_item.cast(value_item)
+          elsif items.any?
+            if options[:additional_items] != false && index >= items.size
+              if options[:additional_items].is_a?(Node)
+                result << options[:additional_items].cast(value_item)
+              else
+                result << value_item
+              end
+            else
+              item = item_for_data(value_item)
+              result << item.cast(value_item)
+            end
+          else
+            result << value_item
+          end
+        end
+
+        return result
+      end
+
+      protected
+
+      def list?
+        list_item.present?
+      end
+
+      def item_for_data(data)
+        item = children.find { |c| item_matches?(c, data) }
+        return item if item
+
+        fail "Could not find specification for item #{data.inspect}."
+      end
+
+      def init
+        @items = []
+        @cont_item = nil
+
+        if options[:additional_items].nil?
+          options[:additional_items] = false
+        end
+      end
+
+      def validate_self
+        if list? && items.any?
+          fail 'Can\'t use "list" and normal items.'
+        end
+
+        if list? && @options[:additional_items].is_a?(Node)
+          fail 'Can\'t use "list" and additional items.'
+        end
+
+        unless options[:min_items].nil? || options[:min_items].is_a?(Integer)
+          fail 'Option "min_items" must be an "integer"'
+        end
+
+        unless options[:max_items].nil? || options[:max_items].is_a?(Integer)
+          fail 'Option "max_items" must be an "integer"'
+        end
+
+        unless options[:unique_items].nil? || options[:unique_items].is_a?(TrueClass) || options[:unique_items].is_a?(FalseClass)
+          fail 'Option "unique_items" must be a "boolean".'
+        end
+
+        if options[:min_items] && options[:max_items] && options[:min_items] > options[:max_items]
+          fail 'Option "min_items" can\'t be greater than "max_items".'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v3/boolean_node.rb

@@ -0,0 +1,16 @@
+module Schemacop
+  module V3
+    class BooleanNode < Node
+      def as_json
+        process_json([], type: :boolean)
+      end
+
+      def allowed_types
+        {
+          TrueClass  => :boolean,
+          FalseClass => :boolean
+        }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/combination_node.rb

@@ -0,0 +1,45 @@
+module Schemacop
+  module V3
+    # @abstract
+    class CombinationNode < Node
+      def self.dsl_methods
+        super + NodeRegistry.dsl_methods(false)
+      end
+
+      supports_children
+
+      def init
+        @items = []
+      end
+
+      def as_json
+        process_json([], type => @items.map(&:as_json))
+      end
+
+      def cast(value)
+        item = match(value)
+        return value unless item
+
+        return item.cast(value)
+      end
+
+      def add_child(node)
+        @items << node
+      end
+
+      protected
+
+      def type
+        fail NotImplementedError
+      end
+
+      def match(data)
+        matches(data).first
+      end
+
+      def matches(data)
+        @items.filter { |i| item_matches?(i, data) }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/context.rb

@@ -0,0 +1,17 @@
+module Schemacop
+  module V3
+    class Context
+      attr_accessor :schemas
+
+      def initialize
+        @schemas = {}.with_indifferent_access.freeze
+      end
+
+      def schema(name, type = :hash, **options, &block)
+        @schemas = @schemas.merge(
+          name => Node.create(type, **options, &block)
+        ).freeze
+      end
+    end
+  end
+end

data/lib/schemacop/v3/dsl_scope.rb

@@ -0,0 +1,46 @@
+module Schemacop
+  module V3
+    class DslScope
+      EXP_NAME = /^dsl_([a-z_]+)([?!])?$/.freeze
+
+      def initialize(node)
+        @node = node
+        @with_name = @node.class.supports_children_options[:name]
+      end
+
+      def method_missing(name, *args, **options, &block)
+        match = EXP_NAME.match(name)
+        return super unless match
+
+        base_name, req_optional = match.captures
+
+        if req_optional == '!'
+          options[:required] = true
+        elsif req_optional == '?'
+          options[:required] = false
+        end
+
+        options[:parent] = @node
+
+        if (klass = NodeRegistry.by_short_name(base_name))
+          if @with_name
+            options[:name] = args.shift
+          end
+          node = klass.create(*args, **options, &block)
+          @node.add_child node
+          return node
+        else
+          return super
+        end
+      end
+
+      def respond_to_missing?(name, *args)
+        match = EXP_NAME.match(name)
+        return super unless match
+
+        base_name, _req_optional = match.captures
+        return NodeRegistry.by_short_name(base_name).present? || super
+      end
+    end
+  end
+end

data/lib/schemacop/v3/global_context.rb

@@ -0,0 +1,114 @@
+module Schemacop
+  module V3
+    class GlobalContext < Context
+      DSL_METHODS = %i[schema].freeze
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def self.eager_load!
+        instance.eager_load!
+      end
+
+      def self.schemas
+        instance.schemas
+      end
+
+      def self.schema_for(path)
+        instance.schema_for(path)
+      end
+
+      def schema(type = :hash, **options, &block)
+        @current_schemas << Node.create(type, **options, &block)
+      end
+
+      def schema_for(path)
+        path = path.to_sym
+        load_schema(path) unless @eager_loaded
+        @schemas[path]
+      end
+
+      def eager_load!
+        @schemas = {}
+
+        fail "Global context can't be eager loaded more than once." if @eager_loaded
+
+        Schemacop.load_paths.each do |load_path|
+          Dir.glob(File.join(load_path, '**', '*.rb')).sort.each do |file|
+            load_file(file, load_path)
+          end
+        end
+
+        @eager_loaded = true
+      end
+
+      private
+
+      def initialize
+        super
+        @schemas = {}
+        @load_paths_by_schemas = {}
+        @eager_loaded = false
+        @current_virtual_path = nil
+      end
+
+      def path_for(virtual_path)
+        "#{virtual_path.to_s.underscore}.rb"
+      end
+
+      def virtual_path_for(path, load_path)
+        Pathname.new(path).relative_path_from(load_path).to_s.underscore.gsub(/\.rb$/, '').to_sym
+      end
+
+      def load_schema(virtual_path)
+        path = path_for(virtual_path)
+
+        @schemas = schemas.except(virtual_path).freeze
+        @load_paths_by_schemas = @load_paths_by_schemas.except(virtual_path)
+
+        Schemacop.load_paths.each do |load_path|
+          path_in_load_path = File.join(load_path, path)
+
+          if File.exist?(path_in_load_path)
+            load_file(path_in_load_path, load_path)
+          end
+        end
+      end
+
+      def load_file(path, load_path)
+        return false unless File.exist?(path)
+
+        # Determine virtual path
+        virtual_path = virtual_path_for(path, load_path)
+
+        # Run file and collect schemas
+        begin
+          @current_schemas = []
+          env = ScopedEnv.new(self, DSL_METHODS)
+          env.instance_eval IO.read(path)
+        rescue StandardError => e
+          fail "Could not load schema #{path.inspect}: #{e.message}"
+        end
+
+        # Load schemas
+        case @current_schemas.size
+        when 0
+          fail "Schema #{path.inspect} does not define any schema."
+        when 1
+          if @schemas.include?(virtual_path)
+            fail "Schema #{virtual_path.to_s.inspect} is defined in both load paths "\
+                 "#{@load_paths_by_schemas[virtual_path].inspect} and #{load_path.inspect}."
+          end
+
+          @load_paths_by_schemas[virtual_path] = load_path
+          @schemas = @schemas.merge(virtual_path => @current_schemas.first)
+        else
+          fail "Schema #{path.inspect} defines multiple schemas."
+        end
+
+        return true
+      end
+    end
+  end
+end