yes 0.0.1 → 1.3.0

data/lib/yes/constraints/node_constraint.rb

@@ -1,55 +0,0 @@
-module YES
-
-  module Constraints
-
-    # The NodeConstraint class is an abstract class
-    # and used for create constraint subclasses that
-    # apply constraints on a sigle node.
-    #
-    class NodeConstraint < AbstractConstraint
-
-      # Like {Abstract#initialize} but takes a `node` qas well.
-      def initialize(spec, tree, node)
-        super(spec, tree, [node])
-        @node = node
-      end
-
-    public
-
-      # YAML Node.
-      attr :node
-
-      # Get the applicable node's tag.
-      def tag
-        node.type_id
-      end
-
-      # Get the applicable node's value.
-      def value
-        node.value
-      end
-
-#    # Covert a YAML node (Syck) node into a generic representation.
-#    #
-#    # TODO: Should `style` be part of this? Also, is `kind` the proper term?
-#    def catholic_node(node)
-#      n = {}
-#      n['tag']   = node.type_id 
-#      #n['type'] = #base_type_id(node)
-#      n['kind']  = node.kind.to_s
-#      n['value'] = node.value
-#      n['style'] = node.instance_variable_get('@style').to_s
-#      n
-#    end
-
-      #
-      #
-      def self.applicable?(spec)
-        false
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/range.rb

@@ -1,43 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate the a nodes value is within a certain range.
-    # Primarily this works for numeric values, but it can
-    # also work for string in ASCII/UTF-8 order, by using 
-    # a 2-element array for comparison.
-    #
-    #   //note:
-    #     range: ['A','G']
-    #
-    # Valid values for are then only A, B, C, D, E, F and G.
-    class Range < NodeConstraint
-
-      #
-      # @return [Array<Validaiton>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        nodes.map do |node|
-          new(spec, tree, node)
-        end
-      end
-
-      #
-      def self.applicable?(spec)
-        spec['range']
-      end
-
-      # Validate if a node is the only one of it's value in a sequence
-      # or mapping.
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-        range = spec['range']
-        match_delta(range, node.transform) ? true : false
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/regexp.rb

@@ -1,52 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate matching values against a regular expression.
-    # All values are converted to strings (using #to_s) for comparison.
-    #
-    #   //pin:
-    #     regexp: /^\d\s\d\d$/
-    #
-    class Regexp < NodeConstraint
-
-      #
-      # @return [Array<Validaiton>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        nodes.map do |node|
-          new(spec, tree, node)
-        end
-      end
-
-      #
-      def self.applicable?(spec)
-        spec['regexp']
-      end
-
-      # Validate matching values against a regular expression.
-      # All values are converted to strings (using #to_s) for comparison.
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-        regexp = parse_regexp(spec['regexp'])
-        regexp =~ node.value ? true : false
-      end
-
-      # The regular expression from `spec`.
-      #
-      # @return [Regexp] spec's regular expression
-      def parse_regexp(re)
-        case re
-        when /^\/(.*?)\/(\w*)$/
-          ::Regexp.new($1)  # TODO: modifiers
-        else
-          ::Regexp.new(re)
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/required.rb

@@ -1,45 +0,0 @@
-module YES
-
-  module Constraints
-
-    #
-    # TODO: For the moment this is the same as Inclusive.
-    #       It was originall inteded to work like {RequiresValidation}
-    #       but it rpoved hard to work out the validation procedure
-    #       when matching to the subfield. If we can fix it maybe we will
-    #       keep, but for now THIS IS NOT USED.
-    #
-    class Required < TreeConstraint
-
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        [new(spec, tree, nodes)]
-      end
-
-      # Only applicable if `required` field appears in spec.
-      def self.applicable?(spec)
-        spec['required']
-      end
-
-      # Validates whether a matching node must be present within it's parent.
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-        required = spec['required']
-
-        case required
-        when true, false
-          nodes.size > 0
-        else
-          in_nodes = tree.select(required)
-          nodes.size == 0 or in_nodes.size > 0
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/requires.rb

@@ -1,57 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Takes a list of relative YPaths and ensures they are present.
-    # This is most useful for ensuring the existance of mapping fields.
-    #
-    #     foo:
-    #       requires:
-    #         - bar
-    #
-    # A valid document would be:
-    #
-    #     foo:
-    #       bar: true
-    #
-    # The literal meaing of this example is "if `foo` exists, the make sure
-    # `foo/bar` also exists.
-    class Requires < NodeConstraint
-
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        nodes.map do |node|
-          new(spec, tree, node)
-        end
-      end
-
-      #
-      def self.applicable?(spec)
-        spec['requires']
-      end
-
-      # Validates whether a matching node must be present within it's parent.
-      #
-      # @return [Boolen] validity
-      def validate(spec)
-        requires = Array(spec['requires'])
-
-        requires.each do |rq|
-          case rq
-          when /^\// # absolute path
-            rq_nodes = tree.select(rq)
-          else
-            rq_nodes = node.select(rq)
-          end
-          return false unless rq_nodes.size > 0
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/tag.rb

@@ -1,55 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate that a node has specific tag.
-    # This ensure all the matching nodes have the given tag.
-    # Be sure to used quotes when starting the tag with `!`.
-    #
-    # NOTE: the tag should honer %TAG directives in the document, but as of 
-    # yet this is not supported. Thus fully qualified tags need to be used
-    # for anything beyond default !! and ! tags.
-    #
-    class Tag < NodeConstraint
-
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        nodes.map do |node|
-          new(spec, tree, node)
-        end
-      end
-
-      #
-      def self.applicable?(spec)
-        spec['tag']
-      end
-
-      # Validate the tag.
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-        tag = spec['tag']
-        match_tag(tag, node)
-      end
-
-      private
-
-      def match_tag(tag, node)
-        node_tag = node.type_id || "tag:yaml.org,2002:#{node.kind}"
-        case node_tag
-        when /^x-private:/
-          tag == $' or tag == '!'+$'
-        when /^tag:yaml.org,2002:/
-          tag == node_tag or tag == '!!'+$'
-        else
-          tag == node_tag
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/tree_constraint.rb

@@ -1,14 +0,0 @@
-module YES
-
-  module Constraints
-
-    # The TreeValidation class is an abstract class
-    # and used for create validation subclasses than
-    # needs access to the complete list of matching nodes.
-    class TreeConstraint < AbstractConstraint
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/type.rb

@@ -1,91 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate the <i>tag type</i>. This ensure all the matching nodes
-    # have the same base type specified. The tag type is the portion
-    # of the tag the occcurs after the last non-alphanumeric character,
-    # usually a `:`. In essence the tag type is the tag regardless of namespace.
-    # 
-    # Also, `#` is treated specially as a subset fo they type, so it will
-    # be used if given in the type comparison.
-    #
-    # @example
-    #   'foo' =~ '!!foo'
-    #   'foo' =~ '!<tag:foo.org/bar:foo>'
-    #   'foo' =~ '!<tag:foo.org/bar:foo>'
-    #   'foo' =~ '!!foo#alt'
-    #   'foo#alt' =~ '!!foo#alt'
-    #
-    class Type < NodeConstraint
-
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-        nodes.map do |node|
-          new(spec, tree, node)
-        end
-      end  
-
-      #
-      def self.applicable?(spec)
-        spec['type']
-      end
-
-      # Validate type.
-      #
-      def validate(spec)
-        type_match(node, spec['type'])
-      end
-
-      private
-
-      # Get the nodes base type see if matches the given type.
-      # The {TYPE_MATCH} chart is used to map a node base types
-      # to a given type.
-      #
-      # @return [Boolean] node's type matches given type
-      def type_match(node, type)
-        node_type, node_subtype = base_type_id(node).split('#')
-        want_type, want_subtype = type.split('#')
-
-        return false if want_subtype && want_subtype != node_subtype
-
-        pick_type = TYPE_MATCH[want_type] || [want_type]
-        pick_type.any?{ |t| t == node_type }
-      end
-
-      # Get the base of the node's type tag, i.e. the part after the last
-      # non-alphanumeric characeter plus `#`.
-      #
-      # @return [String] base type
-      def base_type_id(node)
-        fixed_type_id(node).split(/[^#A-Za-z0-9_-]/).last
-      end
-
-      # Return the `type_id` of a node. If the type_id is `nil` then
-      # returns the `kind`.
-      #
-      # @return [String] type_id or kind of node
-      def fixed_type_id(node)
-        type_id = node.type_id
-        if type_id
-          type_id
-        else
-          node.kind.to_s
-        end
-      end
-
-      #
-      TYPE_MATCH = {
-        'date'   => ['timestamp'],
-        'bool'   => ['bool'],
-        'number' => ['int', 'float']
-      }
-
-    end
-
-  end
-
-end

data/lib/yes/constraints/value.rb

@@ -1,62 +0,0 @@
-module YES
-
-  module Constraints
-
-    # Validate if a node's _value_ conforms to a constraint, where a 
-    # value is either an sequence element or a mapping value.
-    #
-    #   //authors:
-    #     type: seq
-    #     value:
-    #       type: str
-    #
-    # A valid code value could then have no more than three characters.
-    class Value < NodeConstraint
-
-      # For value constraint, the work is all handled by the
-      # checklist method.
-      #
-      # @return [Array<Constraint>]
-      def self.checklist(spec, tree, nodes)
-        return [] unless applicable?(spec)
-
-        vspec = spec['value']
-        list  = []
-
-        nodes.each do |node|
-          case node.kind
-          when :seq
-            YES.constraints.each do |c|
-              list.concat(c.checklist(vspec, tree, node.children))
-            end
-          when :map
-            YES.constraints.each do |c|
-              list.concat(c.checklist(vspec, tree, node.value.values))
-            end
-          else
-            # TODO: might value for scalars have a useful meaning?
-            raise "value constraint does not apply to scalars"
-          end
-        end
-
-        list
-      end
-
-      #
-      #
-      def self.applicable?(spec)
-        spec['value']
-      end
-
-      #
-      # no-op
-      #
-      # @return [Boolean] validity
-      def validate(spec)
-      end
-
-    end
-
-  end
-
-end

data/lib/yes/genclass.rb

@@ -1,2 +0,0 @@
-# TODO: Idea from Kwalify, to use the scheam to grenerate a validating RUby class.
-

data/lib/yes/lint.rb

@@ -1,101 +0,0 @@
-module YES
-
-  # YAML Easy Schema - Constrain Validator ("Lint")
-  #
-  # Issues
-  #
-  # * Matching fully-quaified tags.
-  # * Handling namespaces.
-  # * Handling YAML version directive.
-  #
-  class Lint
-
-    # The schema document.
-    attr :schema
-
-    # The tree, which is populate when #validate is called.
-    #attr :tree
-
-    # The constraint checklist.
-    attr :checklist
-
-    #
-    def initialize(schema)
-      @schema    = YAML.load(schema)
-      @checklist = []
-    end
-
-    #
-    # @param [String] yaml
-    #   A YAML document.
-    #
-    # @return [Array]
-    #   List of constraints that were invalid.
-    #
-    def validate(yaml)
-      @checklist = []
-
-      tree = YAML.parse(yaml)
-
-      @schema.each do |ypath, spec|
-        validate_ypath(ypath, spec, tree)
-      end
-
-      @checklist.reject{ |v| v.valid? }
-    end
-
-    #
-    def validate_ypath(ypath, spec, tree)
-      validate_spec(ypath, spec, tree)
-
-      ## handle sub-paths
-      if spec['map']
-        spec['map'].each do |sub_path, sub_spec|
-          sub_ypath = ypath + '/' + sub_path
-          validate_ypath(sub_ypath, sub_spec, tree)
-        end
-      end
-    end
-
-    # Process all validations.
-    #
-    # FIXME: Add logic handling.
-    def validate_spec(ypath, spec, tree)
-      nodes = select_nodes(ypath, tree)
-
-      YES.constraints.each do |c|
-        @checklist.concat(c.checklist(spec, tree, nodes))
-      end
-    end
-
-    # TODO: Maybe this should be a class method, too ?
-    def select_nodes(ypath, tree)
-      case ypath
-      when Hash
-        if path = ypath['path'] || ypath['ypath']
-          nodes = tree.select(path)
-        else
-          nodes = tree.select('*') # all nodes
-        end
-        YES.constraints.each do |c|
-          next unless Constraints::NodeConstraint === c
-          checklist = c.checklist(spec, tree, nodes)
-          selection = checklist.select{ |v| v.valid? }
-          nodes.concat(selection.map{ |s| s.node })
-        end
-        nodes
-      else
-        tree.select(ypath)
-      end
-    end
-
-    ## Validate if a node is the only one of it's value in a sequence
-    ## or mapping.
-    #def validate_unique(spec, nodes)
-    #  return unless unique = spec['unique']
-    #  # TODO: how to do?
-    #end
-
-  end
-
-end

data/lib/yes/logical_and.rb

@@ -1,13 +0,0 @@
-module YES
-
-  class And < Array
-    def intialize(data)
-      concat(data)
-    end
-  end
-
-  YAML.add_domain_type('http://rubyworks.github.com/yes', 'and') do |data|
-    And.new(data)
-  end
-
-end