obf 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e249a35931e0186e77d7891dd62ea793e590029
-  data.tar.gz: f5ac6ea76ef9258197bdc8668bfdc9eddbf4db6e
+  metadata.gz: e04159aa51fa8c477f23c58a9dc7eda8f1abca98
+  data.tar.gz: 7281b01429f081deb13970741a95b5ef025bb8fa
 SHA512:
-  metadata.gz: 10eaf3229ebf54f38d81524a72729885a8a95645f66179595cd47d1cf5f232f8524b0be4eaad15aaf1efe103c66daf1bfd66d9a009ce0de3490a53b251e41375
-  data.tar.gz: c34e9d79971e8aefba7de989d0bf45a861f37b30b4f796287d99456991d99627b4af4d4a6c98ffeaff56ac84682dc283bcac2d00852524c539e44f5e41111eb0
+  metadata.gz: b3527a3ff96333f841b662008533ff81a4a06ea1429551c604a4d232b61de6d9aa79caca2f735efba04adf178a534574ad50fe504ca30c76583bae8ffd7ed893
+  data.tar.gz: 75ab9ed7797c959ddc16589c302e2b75addb2b7460e91be9299464660198b423ce254fd31cf935ae547fb5821c4616674820f73efcda1b680c3bd7eb109fbb4d

data/lib/obf/utils.rb

@@ -73,9 +73,8 @@ module OBF::Utils
           end
         end
         return type if type
-#         rescue => e
-#           puts e.class.to_s
-#           puts e.message.to_s
+      rescue => e
+        return :unknown
       end
     end
     return :unknown

data/lib/obf/validator.rb

@@ -35,13 +35,46 @@ module OBF
       @warnings || 0
     end
     
-    def self.validate_obf(path)
+    def self.validate_file(path)
+      type = Utils::identify_file(path)
+      fn = File.basename(path)
+      filesize = File.size(path)
+      if type == :obf
+        validate_obf(path)
+      elsif type == :obz
+        validate_obz(path)
+      else
+        {
+          :filename => fn,
+          :filesize => filesize,
+          :valid => false,
+          :errors => 1,
+          :results => [{
+            'type' => 'valid_file',
+            'description' => 'valid .obf or .obz file',
+            'valid' => false,
+            'error' => 'file must be an .obf JSON file or a .obz zip package'
+          }]
+        }
+      end
+    end
+    
+    def self.validate_obf(path, opts={})
       v = self.new
       fn = File.basename(path)
-      results = v.validate_obf(path)
+      filesize = 0
+      content = nil
+      if opts['zipper']
+        content = opts['zipper'].read(path)
+        filesize = opts['zipper'].glob(path)[0].size
+      else
+        content = File.read(path)
+        filesize = File.size(path)
+      end
+      results = v.validate_obf(content, fn, opts)
       {
         :filename => fn,
-        :filesize => File.size(path),
+        :filesize => filesize,
         :valid => v.errors == 0,
         :errors => v.errors,
         :warnings => v.warnings,
@@ -50,39 +83,176 @@ module OBF
     end
     
     def self.validate_obz(path)
+      v = self.new
+      fn = File.basename(path)
+      results, sub_results = v.validate_obz(path, fn)
+      errors = ([v.errors] + sub_results.map{|r| r[:errors] }).inject(:+)
+      warnings = ([v.warnings] + sub_results.map{|r| r[:warnings] }).inject(:+)
+      {
+        :filename => fn,
+        :filesize => File.size(path),
+        :valid => errors == 0,
+        :errors => errors,
+        :warnings => warnings,
+        :results => results,
+        :sub_results => sub_results
+      }
     end
-  
-    def validate_obf(path, opts={})
+    
+    def setup
       @blocked = nil
       @errored = false
       @warnings = 0
       @errors = 0
       @checks = []
+      @sub_checks = []
+    end
+    
+    def validate_obz(path, filename)
+      setup
+      
+      add_check('filename', "file name") do
+        if !filename.match(/\.obz$/)
+          warn "filename should end with .obz"
+        end
+      end
+      
+      valid_zip = false
+      add_check('zip', 'valid zip') do
+        begin
+          Utils::load_zip(path) do |zipper|
+          end
+          valid_zip = true
+        rescue Zip::Error => e
+          err "file is not a valid zip package"
+        end
+      end
+      if valid_zip
+        Utils::load_zip(path) do |zipper|
+          json = nil
+          add_check('manifest', 'manifest.json') do
+            if zipper.glob('manifest.json').length == 0
+              err "manifest.json is required in the zip package"
+            end
+            json = JSON.parse(zipper.read('manifest.json')) rescue nil
+            if !json
+              err "manifest.json must contain a valid JSON structure"
+            end
+          end
+          if json
+            add_check('manifest_format', 'manifest.json format version') do
+              if !json['format']
+                err "format attribute is required, set to #{OBF::FORMAT}"
+              end
+              version = json['format'].split(/-/, 3)[-1].to_f
+              if version > OBF::FORMAT_CURRENT_VERSION
+                err "format version (#{version}) is invalid, current version is #{OBF::FORMAT_CURRENT_VERSION}"
+              elsif version < OBF::FORMAT_CURRENT_VERSION
+                warn "format version (#{version}) is old, consider updating to #{OBF::FORMAT_CURRENT_VERSION}"
+              end
+            end
+            
+            add_check('manifest_root', 'manifest.json root attribute') do
+              if !json['root']
+                err "root attribute is required"
+              end
+              if zipper.glob(json['root']).length == 0
+                err "root attribute must reference a file in the package"
+              end
+            end
+            
+            paths = nil
+            add_check('manifest_paths', 'manifest.json paths attribute') do
+              if !json['paths'] || !json['paths'].is_a?(Hash)
+                err "paths attribute must be a valid hash"
+              end
+              if !json['paths']['boards'] || !json['paths']['boards'].is_a?(Hash)
+                err "paths.boards must be a valid hash"
+              end
+              if json['paths']['images'] && !json['paths']['images'].is_a?(Hash)
+                err "paths.images must be a valid hash if defined"
+              end
+              if json['paths']['sounds'] && !json['paths']['sounds'].is_a?(Hash)
+                err "paths.sounds must be a valid hash if defined"
+              end
+            end
+            add_check('manifest_extras', 'manifest.json extra attributes') do
+              attrs = ['format', 'root', 'paths']
+              json.keys.each do |key|
+                if !attrs.include?(key) && !key.match(/^ext_/)
+                  warn "#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
+                end
+              end
+
+              attrs = ['boards', 'images', 'sounds']
+              json['paths'].keys.each do |key|
+                if !attrs.include?(key) && !key.match(/^ext_/)
+                  warn "paths.#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
+                end
+              end
+            end
+            add_check('manifest_boards', 'manifest.json referenced boards') do
+            end
+            
+            add_check('manifest_images', 'manifest.json referenced images') do
+            end
+
+            add_check('manifest_sounds', 'manifest.json referenced sounds') do
+            end
+            
+            sub_results = []
+            if json['paths']['boards'] && json['paths']['boards'].is_a?(Hash)
+              json['paths']['boards'].each do |key, path|
+                sub = Validator.validate_obf(path, {'zipper' => zipper})
+                sub_results << sub
+              end
+            end
+            @sub_checks = sub_results
+          end
+          if zipper.glob('manifest.json').length > 0
+            json = JSON.parse(zipper.read('manifest.json')) rescue nil
+            if json['root'] && json['format'] && json['format'].match(/^open-board-/)
+              type = :obz
+            end
+          end
+        end
+      end
+      return [@checks, @sub_checks]
+    end
+  
+    def validate_obf(content, filename, opts={})
+      setup
       
       # TODO enforce extra attributes being defined with ext_
 
+      add_check('filename', "file name") do
+        if !filename.match(/\.obf$/)
+          warn "filename should end with .obf"
+        end
+      end
+      
       json = nil
-      add_check('valid_json', "JSON File") do
+      add_check('valid_json', "JSON file") do
         begin
-          json = JSON.parse(File.read(path))
+          json = JSON.parse(content)
         rescue => e
           err "Couldn't parse as JSON", true
         end
       end
     
       ext = nil
-      add_check('to_external', "OBF Structure") do
+      add_check('to_external', "OBF structure") do
         begin
-          ext = External.from_obf(path, {})
+          External.from_obf(json, {})
+          ext = JSON.parse(content)
         rescue External::StructureError => e
           err "Couldn't parse structure: #{e.message}", true
         end
       end
-      ext = json
-    
+      
       add_check('format_version', "format version") do
         if !ext['format']
-          err "format attribute is required, set to #{FORMAT}"
+          err "format attribute is required, set to #{OBF::FORMAT}"
         end
         version = ext['format'].split(/-/, 3)[-1].to_f
         if version > OBF::FORMAT_CURRENT_VERSION
@@ -188,89 +358,95 @@ module OBF
         warn("not all defined buttons were included in the grid order (#{(button_ids - used_button_ids).join(',')})") if (button_ids - used_button_ids).length > 0
       end
       
-      unless opts['obz']
-        button_image_ids = []
-        if ext['buttons'] && ext['buttons'].is_a?(Array)
-          ext['buttons'].each{|b| button_image_ids << b['image_id'] if b.is_a?(Hash) && b['image_id'] }
-        end
-        add_check('images', "images attribute") do
-          
-          if !ext['images']
-            err "images attribute is required"
-          elsif !ext['images'].is_a?(Array)
-            err "images attribute must be an array"
-          end
-        end
+      button_image_ids = []
+      if ext && ext['buttons'] && ext['buttons'].is_a?(Array)
+        ext['buttons'].each{|b| button_image_ids << b['image_id'] if b.is_a?(Hash) && b['image_id'] }
+      end
+      add_check('images', "images attribute") do
         
-        if ext['images'] && ext['images'].is_a?(Array)
-          ext['images'].each_with_index do |image, idx|
-            add_check("image[#{idx}]", "image at images[#{idx}]") do
-              if !image.is_a?(Hash)
-                err "image must be a hash"
-              elsif !image['id']
-                err "image.id is required"
-              elsif !image['width'] || !image['width'].is_a?(Fixnum)
-                err "image.width must be a valid positive number"
-              elsif !image['height'] || !image['height'].is_a?(Fixnum)
-                err "image.height must be a valid positive number"
-              elsif !image['content_type'] || !image['content_type'].match(/^image\/.+$/)
-                err "image.content_type must be a valid image mime type"
-              elsif !image['url'] && !image['data'] && !image['symbol']
-                err "image must have data, url or symbol attribute defined"
-              elsif image['data'] && !image['data'].match(/^data:image\/.+;base64,.+$/)
-                err "image.data must be a valid data URI if defined"
-              elsif image['symbol'] && !image['symbol'].is_a?(Hash)
-                err "image.symbol must be a hash if defined"
-              end
-              
-              attrs = ['id', 'width', 'height', 'content_type', 'data', 'url', 'symbol', 'path', 'data_url', 'license']
-              image.keys.each do |key|
-                if !attrs.include?(key) && !key.match(/^ext_/)
-                  warn "image.#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
+        if !ext['images']
+          err "images attribute is required"
+        elsif !ext['images'].is_a?(Array)
+          err "images attribute must be an array"
+        end
+      end
+      
+      if ext && ext['images'] && ext['images'].is_a?(Array)
+        ext['images'].each_with_index do |image, idx|
+          add_check("image[#{idx}]", "image at images[#{idx}]") do
+            if !image.is_a?(Hash)
+              err "image must be a hash"
+            elsif !image['id']
+              err "image.id is required"
+            elsif !image['width'] || !image['width'].is_a?(Fixnum)
+              err "image.width must be a valid positive number"
+            elsif !image['height'] || !image['height'].is_a?(Fixnum)
+              err "image.height must be a valid positive number"
+            elsif !image['content_type'] || !image['content_type'].match(/^image\/.+$/)
+              err "image.content_type must be a valid image mime type"
+            elsif !image['url'] && !image['data'] && !image['symbol']
+              err "image must have data, url or symbol attribute defined"
+            elsif image['data'] && !image['data'].match(/^data:image\/.+;base64,.+$/)
+              err "image.data must be a valid data URI if defined"
+            elsif image['symbol'] && !image['symbol'].is_a?(Hash)
+              err "image.symbol must be a hash if defined"
+            end
+            if image['path']
+              if opts['zipper']
+                if opts['zipper'].glob(image['path']).length == 0
+                  err "image.path \"#{image['path']}\" not found in .obz package"
                 end
+              else
+                err "image.path should not be defined outside of an .obz package"
+              end
+            end
+            
+            attrs = ['id', 'width', 'height', 'content_type', 'data', 'url', 'symbol', 'path', 'data_url', 'license']
+            image.keys.each do |key|
+              if !attrs.include?(key) && !key.match(/^ext_/)
+                warn "image.#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
               end
             end
           end
         end
+      end
 
-        add_check('sounds', "sounds attribute") do
-          
-          if !ext['sounds']
-            err "sounds attribute is required"
-          elsif !ext['sounds'].is_a?(Array)
-            err "sounds attribute must be an array"
-          end
+      add_check('sounds', "sounds attribute") do
+        if !ext['sounds']
+          err "sounds attribute is required"
+        elsif !ext['sounds'].is_a?(Array)
+          err "sounds attribute must be an array"
         end
-        
-        if ext['sounds'] && ext['sounds'].is_a?(Array)
-          ext['sounds'].each_with_index do |sound, idx|
-            add_check("sounds[#{idx}]", "sound at sounds[#{idx}]") do
-              if !sound.is_a?(Hash)
-                err "sound must be a hash"
-              elsif !sound['id']
-                err "sound.id is required"
-              elsif !sound['duration'] || !sound['duration'].is_a?(Fixnum)
-                err "sound.duration must be a valid positive number"
-              elsif !sound['content_type'] || !sound['content_type'].match(/^audio\/.+$/)
-                err "sound.content_type must be a valid audio mime type"
-              elsif !sound['url'] && !sound['data'] && !sound['symbol']
-                err "sound must have data, url or symbol attribute defined"
-              elsif sound['data'] && !sound['data'].match(/^data:audio\/.+;base64,.+$/)
-                err "sound.data must be a valid data URI if defined"
-              end
-              
-              attrs = ['id', 'duration', 'content_type', 'data', 'url', 'path', 'data_url', 'license']
-              sound.keys.each do |key|
-                if !attrs.include?(key) && !key.match(/^ext_/)
-                  warn "sound.#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
-                end
+      end
+      
+      if ext && ext['sounds'] && ext['sounds'].is_a?(Array)
+        ext['sounds'].each_with_index do |sound, idx|
+          add_check("sounds[#{idx}]", "sound at sounds[#{idx}]") do
+            if !sound.is_a?(Hash)
+              err "sound must be a hash"
+            elsif !sound['id']
+              err "sound.id is required"
+            elsif !sound['duration'] || !sound['duration'].is_a?(Fixnum)
+              err "sound.duration must be a valid positive number"
+            elsif !sound['content_type'] || !sound['content_type'].match(/^audio\/.+$/)
+              err "sound.content_type must be a valid audio mime type"
+            elsif !sound['url'] && !sound['data'] && !sound['symbol']
+              err "sound must have data, url or symbol attribute defined"
+            elsif sound['data'] && !sound['data'].match(/^data:audio\/.+;base64,.+$/)
+              err "sound.data must be a valid data URI if defined"
+            end
+            
+            attrs = ['id', 'duration', 'content_type', 'data', 'url', 'path', 'data_url', 'license']
+            sound.keys.each do |key|
+              if !attrs.include?(key) && !key.match(/^ext_/)
+                warn "sound.#{key} attribute is not defined in the spec, should be prefixed with ext_yourapp_"
               end
             end
           end
         end
       end
       
-      if ext['buttons'] && ext['buttons'].is_a?(Array)
+      if ext && ext['buttons'] && ext['buttons'].is_a?(Array)
         ext['buttons'].each_with_index do |button, idx|
           add_check("buttons[#{idx}]", "button at buttons[#{idx}]") do
             if !button.is_a?(Hash)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: obf
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Brian Whitmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-04 00:00:00.000000000 Z
+date: 2014-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json