grayskull 0.1.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 <Your Name Here>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/grayskull

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "grayskull"
+require "optparse"
+
+Grayskull::CLI.start

data/lib/grayskull.rb

@@ -0,0 +1,8 @@
+require 'grayskull/version'
+
+# Base module for gem.
+module Grayskull
+  autoload :Formats, 'grayskull/formats'
+  autoload :Validator, 'grayskull/validator'
+  autoload :CLI, 'grayskull/cli'
+end

data/lib/grayskull/cli.rb

@@ -0,0 +1,27 @@
+require 'thor'
+
+module Grayskull
+  
+  # The *CLI* class provides an interface for the command line functions 
+  class CLI < Thor
+    
+    desc "validate FILE SCHEMA" ,"Checks TEMPLATE is a valid file and matches SCHEMA."
+    # Creates a new *Validator* and validates the file    
+    def validate(file,schema)
+      validator = Grayskull::Validator.new(file,schema)
+      results = validator.validate
+      
+      if !results['result']
+        puts 'Validation Failed!'
+        results['errors'].each{
+          |error|
+          puts error
+        }
+      else
+        puts 'Validated Successfully!'
+      end
+    end
+    
+  end
+  
+end

data/lib/grayskull/formats.rb

@@ -0,0 +1,29 @@
+module Grayskull
+  
+  module Formats
+    
+    autoload :YAMLHandler, 'grayskull/formats/yaml_handler'
+    autoload :JSONHandler, 'grayskull/formats/json_handler'
+    
+    FILENAME_PATTERN = /(.+)\.([^\/\.]+)/
+    
+    def self.detect_format(filename)
+      matches = FILENAME_PATTERN.match(filename.downcase).to_a
+      if matches
+        ext = matches[2]
+        case ext
+          when 'json'
+            return 'json'
+          when 'yml'
+            return 'yaml'
+          else
+            raise TypeError, "Not a supported file format: " + ext
+        end
+      else
+        raise LoadError, "Not a valid filename: " + filename
+      end
+    end
+    
+  end
+  
+end

data/lib/grayskull/formats/json_handler.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+module Grayskull
+  
+  module Formats
+    
+    class JSONHandler
+      
+       def self.load(file)
+         loaded = File.open(file)
+         content = loaded.gets nil
+        begin
+          return JSON.parse(content)
+        rescue Exception => e
+          raise e.class, 'File could not be parsed as valid JSON'          
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/grayskull/formats/yaml_handler.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+module Grayskull
+  
+  module Formats
+    
+    class YAMLHandler
+      
+      def self.load(file)
+        begin
+          return YAML.load_file(file)
+        rescue Exception => e
+          raise e.class, 'File could not be parsed as valid YAML'          
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/grayskull/validator.rb

@@ -0,0 +1,184 @@
+module Grayskull
+  
+  class Validator
+    
+    def initialize(file,schema)
+      
+      @file = file
+      @schema = schema
+      
+      @loaded_file = self.load(file)
+      @loaded_schema = self.load(schema)
+      @types = @loaded_schema['types'] || {}
+      
+      @errors = []
+    end
+    
+    def load(file)
+     
+      format = Formats::detect_format File.basename(file)
+     
+      case format
+        when 'yaml'
+          return Formats::YAMLHandler.load(file)
+        when 'json'
+          return Formats::JSONHandler.load(file)
+       end
+       
+    end
+    
+    def validate()
+       failed = []
+        
+        @loaded_schema['sections'].each{
+          |section|
+          
+          #check required sections are there
+          if (section['required'] && !@loaded_file.has_key?(section['name']))
+            @errors.push('Error: missing required section - ' + section['name'])
+            failed.push(section['name'])
+          elsif @loaded_file.has_key?(section['name'])
+            node = @loaded_file[section['name']]
+            validated = match_node(node,section,section['name'])
+            if(!validated)
+              failed.push(section['name'])
+            end
+          end
+               
+        }
+        
+        result = {}       
+        result["result"] = failed.empty?
+        
+        if !failed.empty? && !@errors.empty?
+          result["errors"] = @errors
+        end
+        
+        return result
+      end
+      
+      # Checks template node matches the schema.
+      #
+      # Checks type of node against expected type and 
+      # checks any children are of the accepted types.
+      def match_node(node,expected,label)
+        
+        #check type 
+        if !check_type(node,expected['type'],label,expected['ok_empty'])
+          return false
+        end
+        
+        if (node.kind_of?(Hash) || node.kind_of?(Array))
+          
+          if node.empty? && !expected['ok_empty']
+            @errors.push('Error: node ' + label + ' cannot be empty')
+            return false
+          elsif !node.empty? && expected.has_key?('accepts')
+            valid_content = false
+            
+            if node.kind_of?(Hash)
+              matched = []
+              unmatched = []
+              node.each_pair{
+                |key,value|
+                
+                expected['accepts'].each{
+                  |accepts|
+                     
+                  result = check_type(value,accepts,key)
+                  
+                  if result
+                    matched.push(key)
+                    if !unmatched.find_index(key).nil?
+                      unmatched.slice(unmatched.find_index(key))
+                    end
+                    break
+                  else
+                    unmatched.push(key)
+                  end
+                 
+                }
+                
+              }
+                   
+              if(matched.count==node.count)
+                valid_content = true
+               else
+                unmatched.each{
+                  |node|
+                  
+                  @errors.push('Error: node ' + node + ' is not of an accepted type. Should be one of ' + expected['accepts'].join(', '))
+                }
+              end
+              
+            elsif node.kind_of?(Array)
+              matched = []
+              unmatched = []
+              node.each_index{
+                |n|
+                
+                expected['accepts'].each{
+                  |accepts|
+                  
+                  key = label + '[' + n.to_s + ']'
+                  result = check_type(node[n],accepts,key)
+                  
+                  if result
+                    
+                    matched.push(key)
+                    if !unmatched.find_index(key).nil?
+                      unmatched.slice(unmatched.find_index(key))
+                    end
+                    break
+                  else
+                    unmatched.push(key)
+                  end
+                  
+                }
+              }
+              
+              if(matched.count==node.count)
+                valid_content = true
+              else
+                unmatched.each{
+                  |node|
+                  
+                  @errors.push('Error: node ' + node + ' is not of an accepted type. Should be one of ' + expected['accepts'].join(', '))
+                }
+              end
+            
+            end
+            
+            if !valid_content
+              @errors.push('Error: node ' + label + ' contains an unaccepted type.')
+              return false
+            end
+         end
+         
+        end
+       
+        return true
+                
+      end
+      
+      # Checks that the node is of the correct type
+      #
+      # If the expected node is a custom node type as defined in the schema
+      # It will run `match_node` to check that the node schema matches the 
+      # custom type.
+      def check_type(node,expected_type,label,accept_nil = false)
+              
+        valid_type = true;
+        if(@types.has_key?(expected_type))
+          valid_type = match_node(node,@types[expected_type],label)
+        elsif node.class.to_s != expected_type && !(node.kind_of?(NilClass) && (expected_type=='empty' || accept_nil))
+          valid_type = false
+        end
+       
+        return valid_type
+        
+      end
+      
+  end
+  
+end

data/lib/grayskull/version.rb

@@ -0,0 +1,3 @@
+module Grayskull
+  Grayskull::VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: grayskull
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Will McKenzie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-01 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Will validate YAML and JSON files based on a provided schema
+email: 
+- will@oinutter.co.uk
+executables: 
+- grayskull
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- lib/grayskull/cli.rb
+- lib/grayskull/formats/json_handler.rb
+- lib/grayskull/formats/yaml_handler.rb
+- lib/grayskull/formats.rb
+- lib/grayskull/validator.rb
+- lib/grayskull/version.rb
+- lib/grayskull.rb
+- bin/grayskull
+has_rdoc: true
+homepage: http://github.com/OiNutter/grayskull
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: grayskull
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Validates data files based on a provided schema
+test_files: []
+