circuitdata 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e0f932ee59269f6cc563b1ddd5a85aeaf69d716c
-  data.tar.gz: c93d8bcf99e9a2723e680b902865668089c1420a
+SHA256:
+  metadata.gz: cee57a28b38b2f4e09b6e27af0140b0d6bfe02287ec8e6452519c7f4106e9d84
+  data.tar.gz: 02ed3d0c396aab1df49448c3ee9f78977ff16c7483384240b94729178068710b
 SHA512:
-  metadata.gz: 55325d670241f121a5ac81eff19d641662a3d27429a75615f0f06c6d3bb756f5f6f8cffd3fb1da367daa0069a56d48982eac088f79b862db93bec13f2f8a1cf7
-  data.tar.gz: 79a08cc7a9cfacebbd7af0ff349bfda4c0744a65c13845a23690fa34b16dd08cf1dbcf0854d3a263d781222b797988831fdc5ab54a2ceb122ba8fcd7010ef6a6
+  metadata.gz: acd38a087dcfe90a368ab15d491f272cc00af1b9addc9749723e80cd626e766b5ed01aa92e87df54b38565b25c0ebf73666fd4085f3c8af1f93b7d7a23ddc57a
+  data.tar.gz: 87eb841eb3ab9d350f8e1bc7f7278b450771f278cc9c0713527c16bab3e9097c2c916cfe1e60106e12717b9d26fc00bb9c5f929f9a9a0a4fb09c281c09f84468

data/README.md

@@ -1,7 +1,9 @@
 # Circuitdata
+
 This gem provides helper functions that allows you to do schema checks and control files up against each other according to the [CircuitData Language](https://circuitdata.org)
 
 ## Installation
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -9,153 +11,38 @@ gem 'circuitdata'
 ```
 
 And then execute:
+
 ```bash
 $ bundle
 ```
 
 Or install it yourself as:
+
 ```bash
 $ gem install circuitdata
 ```
 
 ## Usage
+
 If not in rails
+
 ```
 require 'circuitdata'
 ```
 
 ### Commands
 
-#### `Circuitdata.compatibility_checker`
-
-Test one file against the schema
-```ruby
-Circuitdata.compatibility_checker('testfile-product.json')
-```
-When valid gives:
-```ruby
-{
-  :error => false,
-  :errormessage => "",
-  :validationserrors => {},
-  :restrictederrors => {},
-  :enforcederrors => {},
-  :capabilitieserrors => {}
-}
-```
-
-Test two files up against each other (one must be a product file).
-```ruby
-Circuitdata.compatibility_checker('testfile-product.json','testfile-profile-restricted.json')
-```
-
-When invalid results in:
-```ruby
-{
-  :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 => {}
-}
-```
-
-Turn off validation against the schema
-```ruby
-Circuitdata.compatibility_checker( 'testfile-product.json', 'testfile-profile-restricted.json', false )
-```
- Gives:
-```ruby
-{
-  :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 => {}
-}
-
-```
-
-#### `Circuitdata.compare_files`
-
-Run a test with several files against each other and get a complete list of values and conflicts, and a summary
- ```ruby
- product1 = File.join(__dir__, 'test/test_data/test_product1.json')
- profile_restricted = File.join(__dir__, 'test/test_data/testfile-profile-restricted.json')
- profile_default = File.join(__dir__, 'test/test_data/testfile-profile-default.json')
- file_hash = {product1: product1, restricted: profile_restricted, default: profile_default}
-
- Circuitdata.compare_files(file_hash, true)
- ```
-
- Results in:
- ```ruby
- {
-  :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=>[]
-        }
-      }
-      # ...
-    }
-  }
-}
-```
-
 #### `Circuitdata.dereferenced_schema`
 
 This returns the JSON schema used internally to validate the Circuit Data information. It
 returns the schema without any usage of `$ref` so that it can be utilized without any knowledge of the internal paths.
 
-#### `Circuitdata::Profile.schema`
-
-Returns a subset of the Circuit Data schema that relates to profiles. This is a schema without any `$ref`s.
 #### `Circuitdata::Profile.questions`
+
 Returns a list of grouped questions that can be used for populating an input interface related to profiles.
 
 Example output:
+
 ```ruby
 [
   {
@@ -172,7 +59,7 @@ Example output:
             uom: ["um"],
             description: "The roughness of the copper foil."
           },
-          path: "/open_trade_transfer_package/profiles/defaults/printed_circuits_fabrication_data/rigid_conductive_layer/copper_foil_roughness"
+          path: "/open_trade_transfer_package/profiles/default/printed_circuits_fabrication_data/rigid_conductive_layer/copper_foil_roughness"
         }
       },
     ]
@@ -180,5 +67,21 @@ Example output:
   # ...
 ]
 ```
+
+### Validation
+
+To validate a CircuitData JSON file the `Validator` can be used. This will check that a file matches the schema defined in the CircuitData language as well as logical issues. An example of a logical issue is missing layers in the layers list for a product.
+
+The following is an example of using the `Validator`:
+
+```
+validator = Circuitdata::Validator.new(json_file_contents)
+if !validator.valid?
+  puts validator.errors.inspect
+end
+# ...
+```
+
 ## License
+
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,8 +1,6 @@
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-end
+RSpec::Core::RakeTask.new(:spec)
 
-desc "Run tests"
-task :default => :test
+task :default => :spec

data/lib/circuitdata.rb

@@ -1,132 +1,44 @@
 module Circuitdata
   # SHOULD ONLY HOUSE COMMON FUNCTIONS ONLY
-  require 'active_support/all'
-  require 'json-schema'
-  require_relative './circuitdata/file_comparer'
-  require_relative './circuitdata/compatibility_checker'
-  require_relative './circuitdata/dereferencer'
-  require_relative './circuitdata/profile'
-  require_relative './circuitdata/tools'
 
-  SCHEMA_PATH = 'circuitdata/schema_files/v1/ottp_circuitdata_schema.json'
-  SCHEMA_FULL_PATH = File.join(__dir__, SCHEMA_PATH)
-
-  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
-    end unless products.nil?
-
-    return product_names, types
-  end
-
-  def self.read_json(file)
-    error, message, data = false, nil, nil
-
-    if file.is_a? Hash
-      begin
-        data = file
-        data.deep_symbolize_keys!
-      rescue
-        error = true
-        message = "Could not convert the Hash into JSON"
-      end
-    else
-      begin
-        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, data
+  require "active_support/all"
+  require_relative "./circuitdata/version"
+  require_relative "./circuitdata/json_schema"
+  require_relative "./circuitdata/dereferencer"
+  require_relative "./circuitdata/profile"
+  require_relative "./circuitdata/schema"
+  require_relative "./circuitdata/product"
+  require_relative "./circuitdata/validator"
+  require_relative "./circuitdata/json_validator"
+  require_relative "./circuitdata/material_validator"
+  require_relative "./circuitdata/product_id_validator"
+  require_relative "./circuitdata/bury/bury"
+  require_relative "./circuitdata/product_id_validator"
+  require_relative "./circuitdata/exposed_area"
+  require_relative "./circuitdata/summary"
+
+  SCHEMA_BASE_PATH = File.join(__dir__, "circuitdata/schema_files/v1")
+  SCHEMA_FULL_PATH = File.join(SCHEMA_BASE_PATH, "..", "schema_v1_dereferenced.json")
+  DEFINITIONS_FULL_PATH = File.join(
+    SCHEMA_BASE_PATH, "ottp_circuitdata_schema_definitions.json"
+  )
+  def self.dereferenced_schema(schema_file_path: SCHEMA_FULL_PATH)
+    schema_cache[schema_file_path] ||= Dereferencer.dereference(
+      schema(schema_file_path: schema_file_path),
+      File.dirname(schema_file_path)
+    )
   end
 
-  def self.validate(content)
-    error, message, validations_errors = false, nil, {}
+  private
 
-    begin
-      validated = JSON::Validator.fully_validate(SCHEMA_FULL_PATH, content, :errors_as_objects => true)
-    rescue JSON::Schema::ReadFailed
-      error = true
-      message = "Could not read the validating schema"
-    rescue JSON::Schema::SchemaError
-      error = true
-      message = "There is something was wrong with the validating schema"
-    end
-    unless error
-      if validated.count > 0
-        error = true
-        message = "Could not validate the file against the CircuitData json schema"
-        validated.each do |val_error|
-          validations_errors[val_error[:fragment]] = [] unless validations_errors.has_key? val_error[:fragment]
-          begin
-            keep = val_error[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema\\sfile[\\s\\S]*)$").captures[1]
-          rescue
-            keep = val_error[:message]
-          end
-          validations_errors[val_error[:fragment]] << keep
-        end
-      end
-    end
-    return error, message, validations_errors
-  end
-
-  def self.schema
+  def self.schema(schema_file_path: SCHEMA_FULL_PATH)
     JSON.parse(
-      File.read(SCHEMA_FULL_PATH),
-      symbolize_names: true
+      File.read(schema_file_path),
+      symbolize_names: true,
     )
   end
 
-  def self.dereferenced_schema
-    Dereferencer.dereference(
-      schema,
-      File.dirname(Circuitdata::SCHEMA_FULL_PATH)
-    )
-  end
-
-  def self.compare_files(file_hash, validate_origins=false)
-    comparer = FileComparer.new(file_hash, validate_origins)
-    comparer.compare
-  end
-
-  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.create_documentation()
-    docu = Tools.new()
-    ra = docu.create_structure
-    docu.create_documentation(ra)
-  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')
-
-    # 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}
-    Circuitdata.compare_files(file_hash, true)
+  def self.schema_cache
+    @schema_cache ||= {}
   end
 end

data/lib/circuitdata/bury/bury.rb

@@ -0,0 +1,61 @@
+module Circuitdata
+  module Bury
+    class InvalidDataError < StandardError; end
+
+    class << self
+      def bury(data, *path, value)
+        current_data = data
+        path[0..-2].each_with_index do |part, i|
+          current_data = next_level(part, path[i + 1], current_data)
+        end
+        if !value.nil?
+          current_data[path.last] = value
+        else
+          current_data.delete(path.last)
+        end
+        data
+      end
+
+      def dig(data, *path)
+        current_data = data
+        path.each do |part|
+          current_data = next_level(part, nil, current_data, initialize_missing: false)
+          return nil if current_data.nil?
+        end
+        current_data
+      end
+
+      private
+
+      def find_matching_hash(data, partial_hash)
+        unless data.is_a?(Array)
+          fail InvalidDataError, "parent of #{partial_hash} is not an array"
+        end
+        data.find do |el|
+          partial_hash.all? { |k, v| el[k] == v }
+        end
+      end
+
+      def next_level(part, next_part, current_data, initialize_missing: true)
+        if part.is_a?(Hash)
+          existing_hash = find_matching_hash(current_data, part)
+          if !existing_hash
+            return nil unless initialize_missing
+            new_data = part.dup
+            current_data.push(new_data)
+            new_data
+          else
+            existing_hash
+          end
+        elsif current_data[part].nil?
+          return nil unless initialize_missing
+          next_is_array = next_part.is_a?(Integer) || next_part.is_a?(Hash)
+          current_data[part] = next_is_array ? [] : {}
+          current_data[part]
+        else
+          current_data[part]
+        end
+      end
+    end
+  end
+end