yes 0.0.1

data/lib/yes/constraints/tag.rb

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,62 @@
+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

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

data/lib/yes/lint.rb

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,13 @@
+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

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: "yes"
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: qed
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: detroit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: YAML Easy Schemas it a straight-foward but powerful YPath-based schema format and validation program for YAML documents.
+email: transfire@gmail.com
+executables: 
+- yes-lint
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .ruby
+- .yardopts
+- bin/yes-lint
+- data/yes/yes.yes
+- lib/yes/cli.rb
+- lib/yes/constraints/abstract_constraint.rb
+- lib/yes/constraints/choice.rb
+- lib/yes/constraints/count.rb
+- lib/yes/constraints/exclusive.rb
+- lib/yes/constraints/fnmatch.rb
+- lib/yes/constraints/inclusive.rb
+- lib/yes/constraints/key.rb
+- lib/yes/constraints/kind.rb
+- lib/yes/constraints/length.rb
+- lib/yes/constraints/node_constraint.rb
+- lib/yes/constraints/range.rb
+- lib/yes/constraints/regexp.rb
+- lib/yes/constraints/required.rb
+- lib/yes/constraints/requires.rb
+- lib/yes/constraints/tag.rb
+- lib/yes/constraints/tree_constraint.rb
+- lib/yes/constraints/type.rb
+- lib/yes/constraints/value.rb
+- lib/yes/genclass.rb
+- lib/yes/lint.rb
+- lib/yes/logical_and.rb
+- lib/yes.rb
+- HISTORY.rdoc
+- README.rdoc
+- QED.rdoc
+- LICENSE.rdoc
+- THANKS.rdoc
+homepage: http://rubyworks.github.com/yes
+licenses: 
+- BSD-2-Clause
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: 
+- --title
+- YES API
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: "yes"
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: YAML Easy Schema
+test_files: []
+