circuitdata 0.6.4 → 0.7.0

data/lib/circuitdata/dereferencer.rb

@@ -1,6 +1,7 @@
+require "net/http"
+
 module Circuitdata
   class Dereferencer
-
     def self.dereference(schema, base_path)
       d = new(base_path)
       d.start(schema)
@@ -11,7 +12,7 @@ module Circuitdata
     end
 
     def start(schema)
-      hash_iterator(schema)
+      hash_iterator(schema, schema)
     end
 
     private
@@ -19,15 +20,35 @@ module Circuitdata
     attr_reader :base_path
 
     def read_file(file_path)
-      full_path = File.expand_path(file_path, base_path)
-      file = File.read(full_path)
+      if file_path.start_with?("https://")
+        file = get_remote_file(file_path)
+      else
+        file = File.read(file_path)
+      end
       JSON.parse(file, symbolize_names: true)
+    rescue => e
+      puts file_path
+      raise e
     end
 
-    def get_ref(ref)
-      file_path, pointer = ref.split('#')
-      data = read_file(file_path)
-      pointer_parts = pointer.split('/').reject(&:blank?)
+    def dereferenced_read_file(file_path)
+      if file_path.start_with?("https://")
+        full_path = file_path
+      else
+        full_path = File.expand_path(file_path, base_path)
+      end
+      file_data = read_file(full_path)
+      self.class.dereference(file_data, File.dirname(full_path))
+    end
+
+    def get_ref(ref, original_schema)
+      file_path, pointer = ref.split("#")
+      if file_path == ""
+        data = original_schema
+      else
+        data = dereferenced_read_file(file_path)
+      end
+      pointer_parts = pointer.split("/").reject(&:blank?)
       result = data.dig(*pointer_parts.map(&:to_sym))
       if result.nil?
         fail "Unable to dereference ref=#{ref}"
@@ -35,23 +56,34 @@ module Circuitdata
       result
     end
 
+    def get_remote_file(url_str)
+      url = URI.parse(url_str)
+      req = Net::HTTP::Get.new(url.to_s)
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true
+      res = http.request(req)
+      if res.code != "200"
+        raise StandardError.new("Expected 200 status got #{res.code.inspect} for #{url_str}")
+      end
+      res.body
+    end
 
-    def hash_iterator(h)
+    def hash_iterator(h, original_schema)
       h = h.clone
-      h.each_pair do |k,v|
+      h.each_pair do |k, v|
         if v.is_a?(Hash)
-          res = hash_iterator(v)
+          res = hash_iterator(v, original_schema)
           if res[:"$ref"]
             h[k] = res[:"$ref"]
           else
             h[k] = res
           end
         elsif v.is_a?(Array)
-          h[k] = array_iterator(v)
+          h[k] = array_iterator(v, original_schema)
         else
           if k == :"$ref"
-            ref_schema = get_ref(v)
-            return hash_iterator(ref_schema)
+            ref_schema = get_ref(v, original_schema)
+            return hash_iterator(ref_schema, original_schema)
           else
             h[k] = v
           end
@@ -60,12 +92,12 @@ module Circuitdata
       h
     end
 
-    def array_iterator(arr)
+    def array_iterator(arr, original_schema)
       arr.map do |v|
         if v.is_a?(Hash)
-          hash_iterator(v)
+          hash_iterator(v, original_schema)
         elsif v.is_a?(Array)
-          array_iterator(arr)
+          array_iterator(arr, original_schema)
         else
           v
         end

data/lib/circuitdata/exposed_area.rb

@@ -0,0 +1,84 @@
+module Circuitdata
+  class ExposedArea
+
+    def initialize(product)
+      @product = product
+    end
+
+    def exposed_copper_area
+      return nil if board_area.nil?
+      exposed_layer_copper_area+barrel_area
+    end
+
+    def barrel_area
+      return 0 if board_thickness.nil?
+      plated_through_holes.map{ |hole|  sum_holes_area(hole)}.sum
+    end
+
+    private
+
+    def exposed_layer_copper_area
+      coverage = []
+      unless top_final_finish.nil?
+        if top_final_finish[:coverage].is_a? Numeric
+          coverage << top_final_finish[:coverage]
+        end
+      end
+      unless bottom_final_finish.nil?
+        if bottom_final_finish[:coverage].is_a? Numeric
+          coverage << bottom_final_finish[:coverage]
+        end
+      end
+      coverage.map{ |percent| percent/100.0*board_area}.sum
+    end
+
+    def sum_holes_area(hole)
+      diameter = hole[:function_attributes][:finished_size]
+      number_of_holes = hole[:function_attributes][:number_of_holes]
+      hole_area(diameter)*number_of_holes
+    end
+
+    def hole_area(finished_size)
+      (finished_size/1000)*Math::PI*board_thickness
+    end
+
+    def board_thickness
+      @product.question_answer([:metrics, :board, :thickness])
+    end
+
+    def board_area
+      @product.question_answer([:metrics, :board, :area])
+    end
+
+    def plated_through_holes
+      @product.processes
+        .select{|process| process[:function] == "holes"}
+        .select{|process| process[:function_attributes][:plated] == true}
+        .select{|process| process[:function_attributes][:hole_type] == "through"}
+        .select{|process| process[:function_attributes][:number_of_holes].present?}
+        .select{|process| process[:function_attributes][:finished_size].present?}
+    end
+
+    def layers
+      @product.layers
+    end
+
+    def top_final_finish
+      return nil if conductive_final_finish_layers.first.nil?
+      return nil if conductive_final_finish_layers.first[:function] != "final_finish"
+      conductive_final_finish_layers.first
+    end
+
+    def bottom_final_finish
+      return nil if conductive_final_finish_layers.last.nil?
+      return nil if conductive_final_finish_layers.last[:function] != "final_finish"
+      conductive_final_finish_layers.last
+    end
+
+    # We are using the knowledge that at least one conductive layer must
+    # be present to separate the top and bottom solder masks from each other.
+    def conductive_final_finish_layers
+      layers.select{ |layer| ["conductive", "final_finish"].include?(layer[:function]) }
+    end
+  end
+end

data/lib/circuitdata/json_schema.rb

@@ -0,0 +1,14 @@
+require "json-schema"
+
+module Circuitdata
+  class UuidChecker
+    UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+    def self.call(value)
+      unless UUID_REGEX.match?(value)
+        raise JSON::Schema::CustomFormatError.new("is not a uuid")
+      end
+    end
+  end
+end
+
+JSON::Validator.register_format_validator("uuid", Circuitdata::UuidChecker)

data/lib/circuitdata/json_validator.rb

@@ -0,0 +1,56 @@
+require_relative "./json_validator/json_schema_error_parser"
+
+module Circuitdata
+  class JsonValidator
+    def self.validate(schema, data)
+      errors = JSON::Validator.fully_validate(
+        schema, data, errors_as_objects: true,
+      )
+      simple_errors = errors.select { |e| error_is_simple?(e) }
+      complex_errors = errors - simple_errors
+      convert_simple_errors(simple_errors) +
+        convert_complex_errors(complex_errors, schema, data)
+    end
+
+    private
+
+    def self.convert_simple_errors(schema_errors)
+      JsonSchemaErrorParser.translate_all(schema_errors)
+    end
+
+    def self.error_is_simple?(error)
+      path = error[:fragment]
+      !path.include?("circuitdata/layers") && !path.include?("circuitdata/processes")
+    end
+
+    def self.convert_complex_errors(errors, schema, data)
+      errors.flat_map do |error|
+        path = error[:fragment].slice(2..-1)
+        parts = path.split("/")
+
+        schema_element, data_element = get_element(parts, schema, data)
+        func = data_element.fetch(:function)
+        actual_schema = schema_element.fetch(:oneOf).find { |s| s.dig(:properties, :function, :enum).first == func }
+        simpler_errors = JSON::Validator.fully_validate(
+          actual_schema, data_element, errors_as_objects: true,
+        )
+        convert_simple_errors(simpler_errors).map do |err|
+          err[:source_path] = "/#{path}#{err[:source_path]}"
+          err
+        end
+      end
+    end
+
+    def self.get_element(parts, schema, data)
+      return [schema, data] if parts.empty?
+      part = parts.first
+      if data.is_a?(Hash)
+        sub_schema = schema.dig(:properties, part.to_sym)
+        sub_schema ||= schema.dig(:patternProperties).values.first
+        get_element(parts[1..-1], sub_schema, data[part.to_sym])
+      else
+        get_element(parts[1..-1], schema.dig(:items), data[part.to_i])
+      end
+    end
+  end
+end

data/lib/circuitdata/json_validator/json_schema_error_parser.rb

@@ -0,0 +1,57 @@
+module Circuitdata
+  class JsonValidator
+    class JsonSchemaErrorParser
+      class << self
+        def translate_all(errors)
+          errors.map(&method(:translate)).reject do |error|
+            error[:problem] == "pattern_mismatch" &&
+              error[:pattern] == "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+          end
+        end
+
+        def translate(error)
+          additional_data = extract_data(error[:message], error[:failed_attribute])
+          if additional_data.nil?
+            fail "Unhandled error: #{error.inspect}"
+          end
+
+          path = error[:fragment].gsub("#", "")
+          {
+            source_path: path,
+            field: path.split("/").last,
+          }.merge(additional_data)
+        end
+
+        def extract_data(message, failed_attribute)
+          case failed_attribute
+          when "Required"
+            field = message.match(/of '(.*)'/)[1]
+            if !field
+              fail "Unable to extract field from #{message.inspect}"
+            end
+            return {field: field, problem: "required_property_missing"}
+          when "TypeV4"
+            if message.include?("did not match the following type")
+              matches = message.match(/of type (\S*) did not match the following type: (\S*)/)
+              actual, expected = matches[1..2]
+              return {actual: actual, expected: expected, problem: "type_mismatch"}
+            end
+          when "AdditionalProperties"
+            matches = message.match(/contains additional properties (\[.*\]) outside/)
+            additional_properties = JSON.parse(matches[1])
+            return {additional_properties: additional_properties, problem: "additional_properties"}
+          when "Enum"
+            return {problem: "not_in_enum"}
+          when "Pattern"
+            regex = message.match(/did not match the regex '(\S*)' /)[1]
+            return {problem: "pattern_mismatch", pattern: regex}
+          else
+            if message.match?(/is not a uuid/)
+              return {problem: "format_mismatch", expected: "uuid"}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuitdata/material_validator.rb

@@ -0,0 +1,40 @@
+module Circuitdata
+  class MaterialValidator
+    attr_reader :errors
+
+    MATERIAL_SCHEMA_PATH = [
+      :properties,
+      :open_trade_transfer_package,
+      :properties,
+      :custom,
+      :properties,
+      :materials,
+      :properties,
+      :circuitdata,
+      :patternProperties,
+      :".*",
+    ]
+
+    def initialize(data)
+      @data = data
+    end
+
+    def valid?
+      return @valid if defined? @valid
+      @valid = run_checks
+    end
+
+    private
+
+    attr_reader :data
+
+    def run_checks
+      @errors = JsonValidator.validate(schema, data)
+      @errors.empty?
+    end
+
+    def schema
+      Circuitdata.dereferenced_schema.dig(*MATERIAL_SCHEMA_PATH)
+    end
+  end
+end

data/lib/circuitdata/product.rb

@@ -0,0 +1,125 @@
+module Circuitdata
+  class Product
+    BASIC_PRODUCT_STRUCTURE = {
+      open_trade_transfer_package: {
+        version: SCHEMA_VERSION,
+        products: {},
+        custom: {
+          materials: {
+            circuitdata: {},
+          },
+        },
+      },
+    }
+    BASE_PATH = [:open_trade_transfer_package, :products]
+    attr_accessor :id
+
+    def self.from_data(data)
+      products_hash = data.dig(*BASE_PATH)
+      return [] if products_hash.nil?
+      products_hash.keys.map do |k|
+        self.new(id: k, data: data)
+      end
+    end
+
+    def initialize(id:, data:)
+      @id = id
+      @data = data
+    end
+
+    def update_id(new_id)
+      product_map = data.dig(*BASE_PATH)
+      current_data = product_data
+      product_map.delete(id.to_sym)
+      product_map[new_id.to_sym] = {
+        circuitdata: current_data,
+      }
+      @id = new_id
+    end
+
+    def product_data
+      data.dig(*product_data_path)
+    end
+
+    def product_data=(new_data)
+      Bury.bury(data, *product_data_path, new_data)
+      product_data.merge!(version: SCHEMA_VERSION)
+    end
+
+    def materials_data
+      data.dig(*materials_data_path)
+    end
+
+    def materials_data=(new_data)
+      Bury.bury(data, *materials_data_path, new_data)
+    end
+
+    def data=(new_data)
+      @data = new_data
+    end
+
+    def data
+      @data ||= setup_basic_data
+    end
+
+    def question_answer(path)
+      return nil if path.empty?
+      path = path.map { |p| p.is_a?(String) ? p.to_sym : p }
+      value = Bury.dig(product_data, *path)
+      value
+    end
+
+    def set_question_answer(*path, value)
+      return if value.nil? && question_answer(path).nil?
+      Bury.bury(product_data, *path, value)
+    end
+
+    def layers
+      product_data.fetch(:layers, [])
+    end
+
+    def processes
+      product_data.fetch(:processes, [])
+    end
+
+    def sections
+      product_data.fetch(:sections, [])
+    end
+
+    def metrics
+      product_data.fetch(:metrics, {})
+    end
+
+    def exposed_copper
+      exposed_area.exposed_copper_area
+    end
+    
+    def product_data_path
+      [:open_trade_transfer_package, :products, id.to_sym, :circuitdata]
+    end
+
+    def layer_name(uuid)
+      layers.find { |l| l[:uuid] == uuid }&.fetch(:name, nil)
+    end
+
+    private
+
+    def exposed_area
+      @exposed_area ||= ExposedArea.new(self)
+    end
+
+    def materials_data_path
+      [:open_trade_transfer_package, :custom, :materials, :circuitdata]
+    end
+
+    def setup_basic_data
+      new_data = BASIC_PRODUCT_STRUCTURE.deep_dup
+      new_data.dig(:open_trade_transfer_package, :products)[id.to_sym] = {
+        circuitdata: {
+          version: SCHEMA_VERSION,
+        },
+      }
+      new_data
+    end
+  end
+end