circuitdata 0.3.5 → 0.5.0

data/lib/circuitdata/bk_comparer.rb

@@ -0,0 +1,106 @@
+def self.compare_files(filehash, validate_origins=false)
+  # Prepare the return
+  ra = {
+      error: false,
+      errormessage: "",
+      summary: {},
+      conflicts: {},
+      product: nil,
+      columns: [],
+      mastercolumn: nil,
+      rows: []
+  }
+
+  #parsedfiles
+  unless filehash.is_a? Hash
+    ra[:error] = true
+    ra[:errormessage] = "You have to feed this function with a hash of names and hashes"
+    return ra
+  end
+
+  # extend the hash that is received
+  nh = {}
+  filehash.each do |fhk, fhv|
+    nh[fhk] = {
+        orig: fhv,
+        parsed: nil,
+        content: nil,
+        has: {}
+    }
+    # READ THE CONTENT
+    ra[:error], ra[:errormessage], nh[fhk][:content] = self.read_json(fhv)
+    ra[:summary] = {} if ra[:error]
+    ra[:conflicts] = {} if ra[:error]
+    return ra if ra[:error]
+    # VALIDATE THE FILES
+    if validate_origins
+      ra[:error], ra[:errormessage], validationserrors = self.validate(nh[fhk][:content])
+      ra[:summary] = {} if ra[:error]
+      ra[:conflicts] = {} if ra[:error]
+      return ra if ra[:error]
+    end
+
+
+    # SET THE PRODUCT NAME
+    nh[fhk][:has][:products], nh[fhk][:has][:stackup], nh[fhk][:has][:profile_default], nh[fhk][:has][:profile_restricted], nh[fhk][:has][:profile_enforced], nh[fhk][:has][:capabilities], nh[fhk][:has][:product] = self.content(nh[fhk][:content])
+    unless nh[fhk][:has][:product].nil?
+      #self.iterate(nh[fhk][:content])
+
+      #root_node = Tree::TreeNode.new("ROOT", "Root Content")
+      #root_node.print_tree
+
+      ra[:product] = nh[fhk][:has][:product] if ra[:product].nil?
+      if nh[fhk][:has][:product] != ra[:product]
+        ra[:error] = true
+        ra[:errormessage] = "Your files contains several different product names"
+        ra[:summary] = {}
+        ra[:conflicts] = {}
+        return ra
+      end
+      ra[:mastercolumn] = fhk if ra[:mastercolumn].nil?
+    end
+
+    # THIS IS WHERE I NEED THINGS TO HAPPEN
+
+  end
+
+  # RETURN IF THERE IS NO PRODUCT
+  if ra[:mastercolumn].nil?
+    ra[:error] = true
+    ra[:errormessage] = "none of the files contains a product"
+    ra[:summary] = {}
+    ra[:conflicts] = {}
+    return ra
+  end
+
+  {
+      current_level: 0,
+      current_key: nil,
+
+  }
+  # Populate the master column
+  #self.iterate(filehash[ra[:mastercolumn].to_sym])
+  #ra[:summary] = productjson[:open_trade_transfer_package][:products][ra[:product]][:printed_circuits_fabrication_data]
+
+  #test = {}
+  #self.save_pair(productjson[:open_trade_transfer_package][:products][ra[:product]][:printed_circuits_fabrication_data], test)
+  #puts test
+  # Populate the product rows
+  #productjson[:open_trade_transfer_package]["products"][ra[:product]]["printed_circuits_fabrication_data"].each do |key, value|
+  #  if value.is_a? Hash
+  #    value.each do |subkey, subvalue|
+  #      ra[:rows][]
+  #end
+
+  # Do comparisons
+  #number = 1
+  #filehash.each do |key, value|
+  #    unless key.to_s == productfile
+  #      #puts self.compatibility_checker( productjson, value, false )
+  #      number += 1
+  #    end
+  #  end
+  #puts JSON.pretty_generate(ra)
+  #puts JSON.pretty_generate(nh)
+  return ra
+end

data/lib/circuitdata/compatibility_checker.rb

@@ -0,0 +1,119 @@
+class Circuitdata::CompatibilityChecker
+  def initialize(product_file, check_file, validate_origins)
+    require 'json'
+    require 'json-schema'
+
+    @product_file = product_file
+    @check_file = check_file
+    @validate_origins = validate_origins
+    # Final hash
+    @fh = {error: false, message: nil, errors: {validation: {}, restricted: {}, enforced: {}, capabilities: {}}}
+  end
+
+  def start_check
+    # Initialize & validate
+    @fh[:error], @fh[:message], product_data = Circuitdata.read_json(@product_file)
+    return @fh if @fh[:error]
+    @fh[:error], @fh[:message], @fh[:errors][:validation] = Circuitdata.validate(product_data)
+    return @fh if @fh[:error]
+    if @check_file.present?
+      @fh[:error], @fh[:message], check_data = Circuitdata.read_json(@check_file)
+      return @fh if @fh[:error]
+      @fh[:error], @fh[:message], @fh[:errors][:validation] = Circuitdata.validate(check_data)
+      return @fh if @fh[:error]
+      f2_types = Circuitdata.get_data_summary(check_data)[1]
+      # read the schema
+      schema_path = File.join(File.dirname(__FILE__), 'schema_files/v1/ottp_circuitdata_skeleton_schema.json')
+      restricted_schema = enforced_schema = capability_schema = Circuitdata.read_json(schema_path)[2]
+      # Compare the content
+      perform_comparison(product_data, check_data, restricted_schema, 'restricted') if f2_types.include? 'profile_restricted'
+      perform_comparison(product_data, check_data, enforced_schema, 'enforced') if f2_types.include? 'profile_enforced'
+      perform_comparison(product_data, check_data, capability_schema, 'capabilities') if f2_types.include? 'capabilities'
+    end
+
+    @fh
+  end
+
+  def perform_comparison(product_data, check_data, schema, type)
+    case type
+      when 'restricted'
+        check_hash = check_data.dig(:open_trade_transfer_package, :profiles, :restricted, :printed_circuits_fabrication_data)
+      when 'enforced'
+        check_hash = check_data.dig(:open_trade_transfer_package, :profiles, :enforced, :printed_circuits_fabrication_data)
+      when 'capabilities'
+        check_hash = check_data.dig(:open_trade_transfer_package, :capabilities, :printed_circuits_fabrication_data)
+      else
+        check_hash = {}
+    end
+    # binding.pry
+
+    check_hash.each do |k, v|
+      v.each do |kl1, vl1| # level 1
+        common_hash = schema.dig(:properties, :open_trade_transfer_package, :properties, :products, :patternProperties, :'^(?!generic$).*', :properties, :printed_circuits_fabrication_data, :properties)
+        # binding.pry
+        common_hash[k.to_sym]||= {:type => 'object', :properties => {}}
+        common_hash[:stackup][:properties][:specified][:properties][k.to_sym] ||= {:type => 'object', :properties => {}}
+
+        case vl1.class.name
+          when 'String'
+            if vl1.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$") #This is a value range
+              from, too = vl1.match("^(\\d*|\\d*.\\d*)\\.\\.\\.(\\d*|\\d*.\\d*)$").captures
+              case type
+                when 'restricted'
+                  new_hash = {:not => {:allOf => [{:minimum => from.to_f},{:maximum => too.to_f}]}}
+                else
+                  new_hash = eval("{:minimum => #{from}, :maximum => #{too}}")
+              end
+            else # This is a normal string - check for commas
+              enum = []
+              vl1.split(',').each {|enumvalue| enum << enumvalue.strip}
+              case type
+                when 'restricted'
+                  new_hash = {:not => {:anyOf => [{ :enum => ''}]}}
+                  new_hash[:not][:anyOf][0][:enum] = enum
+                else
+                  new_hash = eval("{:enum => #{enum}}")
+              end
+            end
+          when 'Numeric' # This is a normal string
+            case type
+              when 'restricted'
+                new_hash = {:not => {:allOf => [{:minimum => vl1.to_f},{:maximum => vl1.to_f}]}}
+              else
+                new_hash = eval("{:enum => [#{vl1.to_s}]}")
+            end
+        end
+        common_hash[k.to_sym][:properties][kl1.to_sym] = new_hash
+        common_hash[:stackup][:properties][:specified][:properties][k.to_sym][:properties][kl1.to_sym] = new_hash
+      end if v.is_a? Hash
+    end
+
+    # perform validations
+    begin
+      validation_errors = JSON::Validator.fully_validate(schema.to_json, product_data, :errors_as_objects => true)
+
+      if validation_errors.any?
+        @fh[:error] = true
+        @fh[:message] = 'The product to check did not meet the requirements'
+
+        # format the errors well here
+
+        validation_errors.each do |error|
+          error_array = []
+          begin
+            error_array << error[:message].match("^(The\\sproperty\\s\\'[\\s\\S]*\\'\\s)([\\s\\S]*)(\\sin\\sschema[\\s\\S]*)$").captures[1]
+          rescue
+            error_array << error[:message]
+          end
+          @fh[:errors][type.to_sym][error[:fragment]] = error_array
+        end
+      end
+    rescue JSON::Schema::ReadFailed
+      @fh[:error] = true
+      @fh[:message] = "Could not read the submitted `#{type}` schema" # enforced_schema
+    rescue JSON::Schema::SchemaError
+      @fh[:error] = true
+      @fh[:message] = "Something was wrong with the submitted `#{type}` schema" # enforced_schema
+    end
+  end
+end

data/lib/circuitdata/file_comparer.rb

@@ -0,0 +1,243 @@
+class Circuitdata::FileComparer
+  def initialize(file_hash, validate_origins)
+    @file_hash = file_hash
+    @validate_origins = validate_origins
+    @rows = {}
+    @nh = {} # a new_hash to combine all the data
+    @columns = []
+    @default_column = nil
+    @master_column = nil
+    # Final hash
+    @fh = {error: false, message: nil, conflict: false, product_name: nil, columns: nil, master_column: nil, rows: nil}
+  end
+
+  def compare
+    # Initial check
+    unless @file_hash.is_a? Hash
+      @fh[:error] = true
+      @fh[:message] = 'You have to feed this function with a hash of names and hashes'
+      return @fh
+    end
+
+    # Process the hashes
+    products_array = []
+    @file_hash.each do |k, v|
+      # read content
+      @fh[:error], @fh[:message], file_content = Circuitdata.read_json(v)
+      return @fh if @fh[:error]
+      products, types = Circuitdata.get_data_summary(file_content)
+      products_array.push(*products) # add products to tracking array
+      # populate the new_hash to be used later
+      @nh[k] = {types: types, products: products, data: file_content}
+    end
+
+    # check if the files content meet the requirements
+    if valid_product?(products_array)
+      @fh[:product_name] = products_array.first.to_s
+      @columns = @nh.keys
+      # get all data with products in it
+      product_hashes = @nh.select{|k, v| v[:products].any?}
+      product_columns = product_hashes.keys
+
+      # Add conflicts into the new_hash
+      product_hashes.each do |column_k, column_v|
+        master_json = column_v.dig(:data)
+        @nh.each do |file_k, file_v|
+          products, data = file_v[:products], file_v[:data]
+          check_results = Circuitdata.compatibility_checker(master_json, data, false)
+          # format the conflicts correctly here
+          file_v[:conflicts] ||= {}
+          file_v[:conflicts][column_k] = get_validation_summary(check_results, file_k)
+          # initialize the rows format - for all the product items
+          product_hash = data.dig(:open_trade_transfer_package, :products, @fh[:product_name].to_sym, :printed_circuits_fabrication_data)
+          if products.any?
+            init_row_format(product_hash)
+          end
+        end
+        # Initialize the rows format - for all default profile items
+        @default_column, file_v = @nh.select{|k, v| v[:types].include?("profile_defaults")}.first # this should only be a single file
+        data = file_v[:data]
+        product_hash = data.dig(:open_trade_transfer_package, :profiles, :defaults, :printed_circuits_fabrication_data)
+        init_row_format(product_hash)
+      end
+
+      # populate the @rows
+      product_columns.each do |column|
+        @master_column = column
+        process_row_hash('populate')
+      end
+      # populate the @rows summary
+      product_columns.each do |column|
+        @master_column = column
+        process_row_hash('get_summary')
+      end
+      process_row_hash('populate_defaults')
+    end
+
+    @fh[:columns] = @columns.unshift(:summary)
+    @fh[:rows] = @rows
+    @fh
+  end
+
+  def init_row_format(product_hash)
+    product_hash.each do |k, v|
+      if v.is_a?(Hash)
+        @rows[k] ||= {}
+        v.each do |kl1, vl1|
+          @rows[k][kl1] ||= get_l1_hash(@columns)
+        end
+      else
+        @rows[k] ||= []
+        # if array functionality eg Holes
+      end if ['Hash', 'Array'].include?(v.class.name)
+    end
+  end
+
+  def process_row_hash(action)
+    @rows.each do |k, v| # product elements level
+      if v.is_a?(Hash)
+        v.each do |kl1, vl1| # specification level
+          value, conflict, conflicts_with, conflict_message = [], false, [], []
+          vl1.each do |kl2, vl2| # the specification column level - call the function from here
+            conflicts = @nh.dig(kl2, :conflicts, @master_column)
+            case action
+              when 'populate'
+                check = conflicts.any? && conflicts.dig(:rows, k, kl1).present?
+                vl2[:value] = @nh.dig(kl2, :data, :open_trade_transfer_package, :products, @fh[:product_name].to_sym, :printed_circuits_fabrication_data, k, kl1)
+                vl2[:conflict] = check unless vl2[:conflict] # update only when the status is false
+                vl2[:conflicts_with] = check ? vl2[:conflicts_with] << @master_column : []
+                vl2[:conflict_message] = check ? vl2[:conflict_message] + conflicts&.dig(:rows, k, kl1) : []
+
+                # update master_column conflicts with
+                if check
+                  master_row = @rows.dig(k, kl1, @master_column)
+                  master_row[:conflicts_with] = master_row[:conflicts_with] + conflicts.dig(:master_conflicts)
+                  master_row[:conflict] = true
+                  master_row[:conflict_message] = (master_row[:conflict_message] + vl2[:conflict_message]).uniq
+                end
+              when 'get_summary'
+                # get the summary items
+                if kl2 != :summary
+                  items_v = vl2[:value]
+                  master_value = vl1.dig(@master_column, :value)
+                  # dont test if the @master_column value is also nil
+                  if value.empty? || !value.include?(items_v)
+                    value << items_v
+                    conflicts_with << kl2
+                    # jump the default column
+                    if kl2 != @master_column # Add errors to the specific rows items
+                      # get the item type
+                      col_type = get_column_type(@nh.dig(kl2, :types))
+                      vl2[:conflict] = true
+                      vl2[:conflicts_with] = (vl2[:conflicts_with] << @master_column).uniq
+                      vl2[:conflict_message] = (vl2[:conflict_message] << customize_conflict_message(col_type, kl2, @master_column)).uniq
+                      # update the master row
+                      master_row = @rows.dig(k, kl1, @master_column)
+                      master_row[:conflicts_with] = master_row[:conflicts_with] << kl2
+                      master_row[:conflict] = true
+                      # get a customized error message here
+                      master_row[:conflict_message] = (master_row[:conflict_message] << customize_conflict_message(col_type, @master_column, kl2)).uniq
+                    end
+                  end unless items_v.nil? || master_value.nil?
+                  conflict = true if vl2[:conflict]
+                  conflicts_with = conflicts_with + vl2[:conflicts_with]
+                  conflict_message = conflict_message + vl2[:conflict_message]
+                end
+              when 'populate_defaults'
+                if kl2 == @default_column
+                  vl2[:value] = @nh.dig(kl2, :data, :open_trade_transfer_package, :profiles, :defaults, :printed_circuits_fabrication_data, k, kl1)
+                  vl2[:conflict] = false
+                  vl2[:conflicts_with] = []
+                  vl2[:conflict_message] = []
+                end
+            end
+          end
+          case action
+            when 'get_summary'
+              if value.count > 1
+                conflict = true
+              else
+                value = value.first
+              end
+              vl1[:summary] = {value: value, conflict: conflict, conflicts_with: conflicts_with.uniq, conflict_message: conflict_message.uniq}
+            when 'populate_defaults'
+              # if all the values are blank, use the default value
+              vl1[:summary][:value] ||= vl1.dig(@default_column, :value)
+          end
+          if action == 'get_summary'
+          end
+          @fh[:conflict] = true if conflict
+        end
+      else
+        # if array functionality eg Holes
+      end
+    end
+  end
+
+  def customize_conflict_message(type, col, conflicting_col)
+    case type
+      when :product
+        "#{col.to_s} value conflicts with value from #{conflicting_col.to_s}"
+      when :restricted
+        "#{col.to_s} value is restricted in #{conflicting_col.to_s}"
+      when :enforced
+        "#{col.to_s} value conflicts with the enforced value from #{conflicting_col.to_s}"
+      when :capability
+        "#{col.to_s} value is outside the capabilities of #{conflicting_col.to_s}"
+      else
+        "There were some value conflicts"
+    end
+  end
+
+  def get_column_type(types)
+    types ||= []
+    if types.include? "product"
+      :product
+    elsif types.include? "profile_restricted"
+      :restricted
+    elsif types.include? "profile_enforced"
+      :enforced
+    elsif types.include? "capabilities"
+      :capability
+    end
+  end
+
+  def get_validation_summary(validation, column)
+    summary = {}
+    if validation[:error]
+      summary[:master_conflicts] ||= []
+      summary[:master_conflicts] << column
+      summary[:conflicts], summary[:rows] = true, {}
+      validation[:errors].each do |type, errors| # validation, restricted, enforced, capabilities
+        errors.each do |k, v|
+          folders_stack = k.split('/')
+          folder, spec = folders_stack[5], folders_stack[6]
+          summary[:rows][folder.to_sym] ||= {}
+          spec_message = summary[:rows][folder.to_sym][spec.to_sym] || []
+          summary[:rows][folder.to_sym][spec.to_sym] = spec_message+v
+        end if errors.any?
+      end
+    end
+    summary
+  end
+
+  def get_l1_hash(columns)
+    l1_hash = {}
+    columns.each{|c| l1_hash[c]={} }
+    l1_hash
+  end
+
+  def valid_product?(products_array)
+    if products_array.uniq.count > 1
+      @fh[:error] = true
+      @fh[:message] = 'Your files contains several different product names'
+      return false # validation fails because of different product names
+    end
+    if products_array.empty?
+      @fh[:error] = true
+      @fh[:message] = 'None of the files contains a product'
+      return false # c=validation fails because there are no products
+    end
+    true
+  end
+end