circuitdata 0.3.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d1e7837cb1b7ed5d04e2e1dd4ec57ef6b178700
-  data.tar.gz: 03dd4e52e6f4643e0e26b276e5364a1db5383020
+  metadata.gz: aa1f26f00a6e37eddbd191f4c07e20cd6549403d
+  data.tar.gz: 22e2442da385848cb8836ede71d6f747bf8f8cf9
 SHA512:
-  metadata.gz: 4b20ef9d1b10bce4404316914c84fd5e64876d46f40990e57c4cc3fda3af50d99fceb8d2c2b627adafd94aa034b1b24e049cf81afa2cd437944d750f46763f3d
-  data.tar.gz: 0c6656397a1c0b102fddfe341e679fce18c79788ed250112ffdc0325cb8487c7832bdd46f4a845f25294823e65f49e6b935dc84ff1c434cb3db97766771314fd
+  metadata.gz: 2c98b789d6a3299aa7494eefcf0b291be7aa7769015006d9984748f1c8ba39a282fe0ad997913dcb89e89a1f75fa231eac27d242a15ca7e07f8af619e65d16d0
+  data.tar.gz: 8996afcb18cd0c8cd8d26c08dd53f637f12f0dd3932b37a414a1ccfae9915ae2e2d00545cf0598317e4411c371e0f8ff4562887ee17e65f6a9d6586906223870

data/README.md

@@ -40,6 +40,17 @@ require 'circuitdata'
 2.3.0 :009 > # Turn off validation against the schema
 2.3.0 :008 > Circuitdata.compatibility_checker( 'testfile-product.json', 'testfile-profile-restricted.json', false )
  => {:error=>true, :errormessage=>"The product to check did not meet the requirements", :validationserrors=>{}, :restrictederrors=>{"#/open_trade_transfer_package/products/testproduct/printed_circuits_fabrication_data/board/thickness"=>["of type number matched the disallowed schema"]}, :enforcederrors=>{}, :capabilitieserrors=>{}}
+2.3.0 :005 > # Run a test with several files against each other and get a complete list of values and conflicts, and a summary
+2.3.0 :006 > product1 = File.join(File.dirname(__FILE__), 'test/test_data/test_product1.json')
+ => "./test/test_data/test_product1.json"
+2.3.0 :007 > profile_restricted = File.join(File.dirname(__FILE__), 'test/test_data/testfile-profile-restricted.json')
+ => "./test/test_data/testfile-profile-restricted.json"
+2.3.0 :008 > profile_default = File.join(File.dirname(__FILE__), 'test/test_data/testfile-profile-default.json')
+ => "./test/test_data/testfile-profile-default.json"
+2.3.0 :009 > file_hash = {product1: product1, restricted: profile_restricted, default: profile_default}
+ => {:product1=>"./test/test_data/test_product1.json", :restricted=>"./test/test_data/testfile-profile-restricted.json", :default=>"./test/test_data/testfile-profile-default.json"}
+2.3.0 :010 > Circuitdata.compare_files(file_hash, true)
+ => {:error=>false, :message=>nil, :conflict=>false, :product_name=>"testproduct", :columns=>[:summary, :product1, :restricted, :default], :master_column=>nil, :rows=>{:rigid_conductive_layer=>{:count=>{:product1=>{:value=>11, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>11, :conflict=>false, :conflicts_with=>[:product1], :conflict_message=>[]}}, :minimum_external_track_width=>{:product1=>{:value=>0.14, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>0.14, :conflict=>false, :conflicts_with=>[:product1], :conflict_message=>[]}}, :minimum_external_spacing_width=>{:product1=>{:value=>0.14, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>0.14, :conflict=>false, :conflicts_with=>[:product1], :conflict_message=>[]}}, :copper_foil_roughness=>{:product1=>{:value=>"L", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>"L", :conflict=>false, :conflicts_with=>[:product1], :conflict_message=>[]}}}, :legend=>{:color=>{:product1=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>"white", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>"white", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}}}, :array=>{:fiducials_number=>{:product1=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>3, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>3, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}}, :fiducials_shape=>{:product1=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>"circle", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>"circle", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}}, :breakaway_method=>{:product1=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>"routing", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>"routing", :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}}, :mouse_bites=>{:product1=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :restricted=>{:value=>nil, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :default=>{:value=>true, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}, :summary=>{:value=>true, :conflict=>false, :conflicts_with=>[], :conflict_message=>[]}}}}} 
 ```
 
 ## License

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/circuitdata.rb

@@ -1,432 +1,120 @@
 module Circuitdata
-
-
-  def self.content(checksjson)
-    number_of_products = 0
-    stackup =  false
-    profile_defaults = false
-    profile_enforced = false
-    profile_restricted = false
-    capabilities = false
-    if checksjson.has_key? "open_trade_transfer_package"
-      if checksjson["open_trade_transfer_package"].has_key? "products"
-        if checksjson["open_trade_transfer_package"]["products"].length > 0
-          number_of_products = checksjson["open_trade_transfer_package"]["products"].length
-          checksjson["open_trade_transfer_package"]["products"].each do |key, value|
-            if checksjson["open_trade_transfer_package"]["products"][key].has_key? "stackup"
-              if checksjson["open_trade_transfer_package"]["products"][key]["stackup"].has_key? "specification_level"
-                if checksjson["open_trade_transfer_package"]["products"][key]["stackup"]["specification_level"] == "specified"
-                  if checksjson["open_trade_transfer_package"]["products"][key]["stackup"].has_key? "specified"
-                    if checksjson["open_trade_transfer_package"]["products"][key]["stackup"]["specified"].length > 0
-                      stackup = true
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-      if checksjson["open_trade_transfer_package"].has_key? "profiles"
-        if checksjson["open_trade_transfer_package"]["profiles"].has_key? "enforced"
-          if checksjson["open_trade_transfer_package"]["profiles"]["enforced"].length > 0
-            profile_enforced = true
-          end
-        end
-        if checksjson["open_trade_transfer_package"]["profiles"].has_key? "restricted"
-          if checksjson["open_trade_transfer_package"]["profiles"]["restricted"].length > 0
-            profile_restricted = true
-          end
-        end
-        if checksjson["open_trade_transfer_package"]["profiles"].has_key? "defaults"
-          if checksjson["open_trade_transfer_package"]["profiles"]["defaults"].length > 0
-            profile_defaults = true
-          end
-        end
+  # SHOULD ONLY HOUSE COMMON FUNCTIONS ONLY
+  require 'active_support/all'
+  require 'circuitdata/file_comparer'
+  require 'circuitdata/compatibility_checker'
+
+  def self.get_data_summary(data)
+    types = []
+    wrapper = data&.dig(:open_trade_transfer_package)
+    types << 'profile_restricted' unless wrapper&.dig(:profiles, :restricted).nil?
+    types << 'profile_enforced' unless wrapper&.dig(:profiles, :enforced).nil?
+    types << 'profile_defaults' unless wrapper&.dig(:profiles, :defaults).nil?
+    types << 'capabilities' unless wrapper&.dig(:capabilities).nil?
+
+    products = wrapper&.dig(:products)
+    product_names = products.nil? ? [] : products.keys# this will return all the product names
+    types << 'product' if product_names.any?
+    # loop through the products
+    products.each do |k, v|
+      if v&.dig(:stackup, :specification_level) == 'specified' && !v&.dig(:stackup, :specification_level, :specified).nil?
+        types << 'stackup'
       end
-      if checksjson["open_trade_transfer_package"].has_key? "capabilities"
-        if checksjson["open_trade_transfer_package"]["capabilities"].length > 0
-          capabilities = true
-        end
-      end
-    end
-    return number_of_products, stackup, profile_defaults, profile_restricted, profile_enforced, capabilities
-  end
+    end unless products.nil?
 
-  def self.read_json(content)
+    return product_names, types
+  end
 
-    require 'open-uri'
+  def self.read_json(file)
     require 'json'
+    error, message, data = false, nil, nil
 
-    error = false
-    message = ""
-    returncontent = nil
-    if content.is_a? Hash
+    if file.is_a? Hash
       begin
-        returncontent = content
+        data = file
+        data.deep_symbolize_keys!
       rescue
         error = true
         message = "Could not convert the Hash into JSON"
       end
     else
       begin
-        open(content) do |f|
-          returncontent = JSON.parse(f.read)
+        open(file) do |f|
+          data = JSON.parse(f.read, symbolize_names: true)
         end
       rescue
         error = true
         message = "Could not read the file"
       end
     end
-    return error, message, returncontent
+    return error, message, data
   end
 
   def self.validate(content)
     require 'json-schema'
-    $jsonschema_v1 = 'http://schema.circuitdata.org/v1/ottp_circuitdata_schema.json'
-
-    error = false
-    message = ""
-    validationserrors = {}
+    error, message, validations_errors = false, nil, {}
+    schema = File.join(File.dirname(__FILE__), 'circuitdata/schema_files/v1/ottp_circuitdata_schema.json')
+    # schema = 'http://schema.circuitdata.org/v1/ottp_circuitdata_schema.json'
 
     begin
-      validated = JSON::Validator.fully_validate($jsonschema_v1, content, :errors_as_objects => true)
+      validated = JSON::Validator.fully_validate(schema, content, :errors_as_objects => true)
     rescue JSON::Schema::ReadFailed
-      errors = true
-      message = "Could not read the schema #{$jsonschema_v1}"
+      error = true
+      message = "Could not read the validating schema"
     rescue JSON::Schema::SchemaError
-      errors = true
-      message = "Something was wrong with the schema #{$jsonschema_v1}"
+      error = true
+      message = "There is something was wrong with the validating schema"
     end
-    unless errors
+    unless error
       if validated.count > 0
         error = true
         message = "Could not validate the file against the CircuitData json schema"
-        validated.each do |valerror|
-          validationserrors[valerror[:fragment]] = [] unless validationserrors.has_key? valerror[:fragment]
+        validated.each do |val_error|
+          validations_errors[val_error[:fragment]] = [] unless validations_errors.has_key? val_error[:fragment]
           begin
-            scrap, keep, scrap2 = valerror[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema\\sfile[\\s\\S]*)$").captures
+            keep = val_error[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema\\sfile[\\s\\S]*)$").captures[1]
           rescue
-            keep = valerror[:message]
+            keep = val_error[:message]
           end
-          validationserrors[valerror[:fragment]] << keep
+          validations_errors[val_error[:fragment]] << keep
         end
       end
     end
-    return error, message, validationserrors
+    return error, message, validations_errors
   end
 
-  def self.compare_files(list)
-    # Will presume that the files are validated
-    # Prepare the return
-    ra = {
-      error: false,
-      errormessage: "",
-      summary: {},
-      conflicts: {},
-      files: []
-    }
-    if not list.is_a? Array
-      ra[:error] = true
-      ra[:errormessage] = "You have to feed this function with a list of files or hashes"
-      return ra
-    end
-    list.each do |totest|
-      error, message, returncontent = self.read_json(totest)
-      #puts returncontent
-      ra[:summary] = ra[:summary].merge(returncontent)
-      ra[:files] << totest
-    end
-    return ra
+  def self.compare_files(file_hash, validate_origins=false)
+    comparer = FileComparer.new(file_hash, validate_origins)
+    comparer.compare
   end
 
-  def self.compatibility_checker( productfile, checksfile=nil, validate_origins=true )
-
-    require 'open-uri'
-    require 'json'
-    require 'json-schema'
-
-    $jsonschema_v1 = 'http://schema.circuitdata.org/v1/ottp_circuitdata_schema.json'
-
-    # prepare the return
-    returnarray = {
-      error: false,
-      errormessage: "",
-      validationserrors: {},
-      restrictederrors: {},
-      enforcederrors: {},
-      capabilitieserrors: {},
-      contains: {
-        file1: {
-          products: 0,
-          stackup: false,
-          profile_defaults: false,
-          profile_enforced: false,
-          profile_restricted: false,
-          capabilities: false
-        },
-        file2: {
-          products: 0,
-          stackup: false,
-          profile_defaults: false,
-          profile_enforced: false,
-          profile_restricted: false,
-          capabilities: false
-        }
-      }
-    }
-
-    # Check the files or hashes
-    #
-    returnarray[:error], returnarray[:errormessage], json_productfile = self.read_json(productfile)
-    return returnarray if returnarray[:error]
-    if not checksfile.nil?
-      returnarray[:error], returnarray[:errormessage], json_checksfile = self.read_json(checksfile)
-      return returnarray if returnarray[:error]
-    end
-
-    # Validate the original files against the CircuitData schema
-    if validate_origins
-      returnarray[:error], returnarray[:errormessage], returnarray[:validationserrors] = self.validate(json_productfile)
-      return returnarray if returnarray[:error]
-      if not checksfile.nil?
-        returnarray[:error], returnarray[:errormessage], returnarray[:validationserrors] = self.validate(json_checksfile)
-        return returnarray if returnarray[:error]
-      end
-    end
-
-    # Check against the content
-    returnarray[:contains][:file1][:products], returnarray[:contains][:file1][:stackup], returnarray[:contains][:file1][:profile_defaults], returnarray[:contains][:file1][:profile_restricted], returnarray[:contains][:file1][:profile_enforced], returnarray[:contains][:file1][:capabilities] = self.content(json_productfile)
-    if not checksfile.nil?
-      returnarray[:contains][:file2][:products], returnarray[:contains][:file2][:stackup], returnarray[:contains][:file2][:profile_defaults], returnarray[:contains][:file2][:profile_restricted], returnarray[:contains][:file2][:profile_enforced], returnarray[:contains][:file2][:capabilities] = self.content(json_checksfile)
-    end
-
-    if not checksfile.nil?
-
-      # Create the JSON
-      restrictedschema = enforcedschema = capabilityschema = {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["open_trade_transfer_package"],
-        "properties": {
-          "open_trade_transfer_package": {
-            "type": "object",
-            "properties": {
-              "version": {
-                "type": "string",
-                "pattern": "^1.0$"
-              },
-              "information": {
-                "$ref": "https://raw.githubusercontent.com/elmatica/Open-Trade-Transfer-Package/master/v1/ottp_schema_definitions.json#/definitions/information"
-              },
-              "products": {
-                "type": "object",
-                "properties": {
-                  "generic": {
-                    "type": "object",
-                    "properties": {},
-                    "id": "generic",
-                    "description": "this should validate any element under generic to be valid"
-                  }
-                },
-                "patternProperties": {
-                  "^(?!generic$).*": {
-                    "type": "object",
-                    "required": ["printed_circuits_fabrication_data"],
-                    "properties": {
-                      "printed_circuits_fabrication_data": {
-                        "type": "object",
-                        "required": ["version"],
-                        "properties": {
-                          "stackup": {
-                            "type": "object",
-                            "properties": {
-                              "specified": {
-                                "type": "object",
-                                "properties": {
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      if returnarray[:contains][:file1][:product] or returnarray[:contains][:file1][:stackup]
-        # RUN THROUGH THE ENFORCED
-        if returnarray[:contains][:file2][:profile_enforced]
-          json_checksfile["open_trade_transfer_package"]["profiles"]["enforced"]["printed_circuits_fabrication_data"].each do |key, value|
-            if json_checksfile["open_trade_transfer_package"]["profiles"]["enforced"]["printed_circuits_fabrication_data"][key].is_a? Hash
-              json_checksfile["open_trade_transfer_package"]["profiles"]["enforced"]["printed_circuits_fabrication_data"][key].each do |subkey, subvalue|
-                enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym] = {:type => "object", :properties => {} } unless enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties].has_key? key.to_sym
-                enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym] = {:type => "object", :properties => {} } unless enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties].has_key? key.to_sym
-                if subvalue.is_a? String
-                  if subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$") #This is a value range
-                    from, too = subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$").captures
-                    newhash = eval("{:minimum => #{from}, :maximum => #{too}}")
-                    enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                    enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                  else # This is a normal string - check for commas
-                    enum = []
-                    subvalue.split(',').each { |enumvalue| enum << enumvalue.strip }
-                    enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => #{enum}}")
-                    enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => #{enum}}")
-                  end
-                elsif subvalue.is_a? Numeric # This is a normal string
-                  enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => [#{subvalue.to_s}]}")
-                  enforcedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => [#{subvalue.to_s}]}")
-                end
-              end
-            end
-          end
-          begin
-            enforcedvalidate = JSON::Validator.fully_validate(enforcedschema.to_json, json_productfile, :errors_as_objects => true)
-          rescue JSON::Schema::ReadFailed
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Could not read the schema #{$jsonschema_v1}"
-          rescue JSON::Schema::SchemaError
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Something was wrong with the schema #{$jsonschema_v1}"
-          end
-          unless $errors
-            if enforcedvalidate.count > 0
-              returnarray[:error] = true
-              returnarray[:errormessage] = "The product to check did not meet the requirements"
-              enforcedvalidate.each do |valerror|
-                returnarray[:enforcederrors][valerror[:fragment]] = [] unless returnarray[:enforcederrors].has_key? valerror[:fragment]
-                begin
-                  scrap, keep, scrap2 = valerror[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema[\\s\\S]*)$").captures
-                rescue
-                  keep = valerror[:message]
-                end
-                returnarray[:enforcederrors][valerror[:fragment]] << keep
-              end
-            end
-          end
-        end
-        # RUN THROUGH THE RESTRICTED
-        if returnarray[:contains][:file2][:profile_restricted]
-          json_checksfile["open_trade_transfer_package"]["profiles"]["restricted"]["printed_circuits_fabrication_data"].each do |key, value|
-            if json_checksfile["open_trade_transfer_package"]["profiles"]["restricted"]["printed_circuits_fabrication_data"][key].is_a? Hash
-              json_checksfile["open_trade_transfer_package"]["profiles"]["restricted"]["printed_circuits_fabrication_data"][key].each do |subkey, subvalue|
-                restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym] = {:type => "object", :properties => {} } unless restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties].has_key? key.to_sym
-                restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym] = {:type => "object", :properties => {} } unless restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties].has_key? key.to_sym
-                if subvalue.is_a? String
-                  if subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$") #This is a value range
-                    from, too = subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$").captures
-                    newhash = {:not => {:allOf => [{:minimum => from.to_f},{:maximum => too.to_f}]}}
-                    restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                    restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                  else # This is a normal string - check for commas
-                    newhash = {:not => {:anyOf => [{ :enum => ""}]}}
-                    enum = []
-                    subvalue.split(',').each { |enumvalue| enum << enumvalue.strip }
-                    newhash[:not][:anyOf][0][:enum] = enum
-                    restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                    restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                  end
-                elsif subvalue.is_a? Numeric # This is a normal string
-                  newhash = {:not => {:allOf => [{:minimum => subvalue.to_f},{:maximum => subvalue.to_f}]}}
-                  restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                  restrictedschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                end
-              end
-            end
-          end
-          begin
-            restrictedvalidate = JSON::Validator.fully_validate(restrictedschema.to_json, json_productfile, :errors_as_objects => true)
-          rescue JSON::Schema::ReadFailed
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Could not read the schema #{$jsonschema_v1}"
-          rescue JSON::Schema::SchemaError
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Something was wrong with the schema #{$jsonschema_v1}"
-          end
-          unless $errors
-            if restrictedvalidate.count > 0
-              returnarray[:error] = true
-              returnarray[:errormessage] = "The product to check did not meet the requirements"
-              restrictedvalidate.each do |valerror|
-                returnarray[:restrictederrors][valerror[:fragment]] = [] unless returnarray[:restrictederrors].has_key? valerror[:fragment]
-                begin
-                  scrap, keep, scrap2 = valerror[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema[\\s\\S]*)$").captures
-                rescue
-                  keep = valerror[:message]
-                end
-                returnarray[:restrictederrors][valerror[:fragment]] << keep
-              end
-            end
-          end
-        end
-        # RUN THROUGH THE CAPABILITIES
-        if returnarray[:contains][:file2][:capabilities]
-          json_checksfile["open_trade_transfer_package"]["capabilities"]["printed_circuits_fabrication_data"].each do |key, value|
-            if json_checksfile["open_trade_transfer_package"]["capabilities"]["printed_circuits_fabrication_data"][key].is_a? Hash
-              json_checksfile["open_trade_transfer_package"]["capabilities"]["printed_circuits_fabrication_data"][key].each do |subkey, subvalue|
-                capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym] = {:type => "object", :properties => {} } unless capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties].has_key? key.to_sym
-                capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym] = {:type => "object", :properties => {} } unless capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties].has_key? key.to_sym
-                if subvalue.is_a? String
-                  if subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$") #This is a value range
-                    from, too = subvalue.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$").captures
-                    newhash = eval("{:minimum => #{from}, :maximum => #{too}}")
-                    capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                    capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = newhash
-                  else # This is a normal string - check for commas
-                    enum = []
-                    subvalue.split(',').each { |enumvalue| enum << enumvalue.strip }
-                    capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => #{enum}}")
-                    capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => #{enum}}")
-                  end
-                elsif subvalue.is_a? Numeric # This is a normal string
-                  capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => [#{subvalue.to_s}]}")
-                  capabilityschema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties][:"^(?!generic$).*"][:properties][:printed_circuits_fabrication_data][:properties][:stackup][:properties][:specified][:properties][key.to_sym][:properties][subkey.to_sym] = eval("{:enum => [#{subvalue.to_s}]}")
-                end
-              end
-            end
-          end
-          begin
-            capabilitiesvalidate = JSON::Validator.fully_validate(capabilityschema.to_json, json_productfile, :errors_as_objects => true)
-          rescue JSON::Schema::ReadFailed
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Could not read the schema #{$jsonschema_v1}"
-          rescue JSON::Schema::SchemaError
-            $errors = true
-            returnarray[:error] = true
-            returnarray[:errormessage] = "Something was wrong with the schema #{$jsonschema_v1}"
-          end
-          unless $errors
-            if capabilitiesvalidate.count > 0
-              returnarray[:error] = true
-              returnarray[:errormessage] = "The product to check did not meet the requirements"
-              capabilitiesvalidate.each do |valerror|
-                returnarray[:capabilitieserrors][valerror[:fragment]] = [] unless returnarray[:capabilitieserrors].has_key? valerror[:fragment]
-                begin
-                  scrap, keep, scrap2 = valerror[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema[\\s\\S]*)$").captures
-                rescue
-                  keep = valerror[:message]
-                end
-                returnarray[:capabilitieserrors][valerror[:fragment]] << keep
-              end
-            end
-          end
-        end
-      end
-    end
-
-    return returnarray
+  def self.compatibility_checker(product_file, check_file=nil, validate_origins=false)
+    checker = CompatibilityChecker.new(product_file, check_file, validate_origins)
+    checker.start_check
+  end
 
+  def self.test
+    product1 = File.join(File.dirname(__FILE__), '../test/test_data/test_product1.json')
+    product2 = File.join(File.dirname(__FILE__), '../test/test_data/test_product2.json')
+    profile_restricted = File.join(File.dirname(__FILE__), '../test/test_data/testfile-profile-restricted.json')
+    profile_enforced = File.join(File.dirname(__FILE__), '../test/test_data/testfile-profile-enforced.json')
+    profile_default = File.join(File.dirname(__FILE__), '../test/test_data/testfile-profile-default.json')
+    capabilities = File.join(File.dirname(__FILE__), '../test/test_data/testfile-capability.json')
+
+    # TEST WITH NON SCHEMA COMPATIBLE JSON
+    # puts 'testing validation with non schema compatible json'
+    # puts Circuitdata.compatibility_checker(fail_product)
+    # puts "\n"
+
+    # TEST THE COMPATIBILITY CHECKER FUNCTION FIRST:
+    puts "\nTesting compatibility_checker: - the capabilities"
+    puts Circuitdata.compatibility_checker(product1, capabilities)
+    puts "\n"
+
+    # THEN TEST THE COMPARE FILES:
+    puts "Testing file comparison"
+    # file_hash = {product1: product1, product2: product2, restricted: profile_restricted, enforced: profile_enforced, default: profile_default, capability: capabilities}
+    file_hash = {product1: product1, product2: product2, restricted: profile_restricted, enforced: profile_enforced, default: profile_default}
+    Circuitdata.compare_files(file_hash, true)
   end
 end