circuitdata 0.6.0 → 0.6.1

data/lib/circuitdata/schema_files/v1/ottp_circuitdata_schema_definitions.json

@@ -29,7 +29,7 @@
             "description": "The name of the manufacturer"
           },
           "ipc-sm-840-class": {
-            "type": "list",
+            "type": "string",
             "enum": ["T", "H"],
             "uom": null,
             "description": "Soldermask to meet IPC SM 840 Class."
@@ -180,12 +180,30 @@
       "thickness_min_micron": {
         "type": "number",
         "uom": ["um"],
-        "description": "The minimum thickness in micrometer."
+        "description": "The minimum thickness."
       },
       "thickness_max_micron": {
         "type": "number",
         "uom": ["um"],
-        "description": "The maximum thickness in micrometer."
+        "description": "The maximum thickness."
+      },
+      "presence_top_boolean": {
+        "type": "boolean",
+        "uom": null,
+        "description": "Indicates presence/capability on top"
+      },
+      "presence_bottom_boolean": {
+        "type": "boolean",
+        "uom": null,
+        "description": "Indicates presence/capability at bottom"
+      },
+      "numeric_single_or_range": {
+        "type": "string",
+        "pattern": "^[-+]?([0-9]*\\.[0-9]+|[0-9]+)$|^([0-9]*|[0-9].[0-9]*)\\.\\.\\.([0-9]|[0-9].[0-9]*)$"
+      },
+      "boolean_true_false_or_both": {
+        "type": "string",
+        "pattern": "^[t,T][r,R][u,U][e,E]$|^[f,F][a,A][l,L][s,S][e,E]$|^[t,T][r,R][u,U][e,E],.[f,F][a,A][l,L][s,S][e,E]$|^[f,F][a,A][l,L][s,S][e,E],.[t,T][r,R][u,U][e,E]$"
       },
       "range": {
         "type": "string",
@@ -201,64 +219,92 @@
     "elements": {
       "conductive_layer": {
         "count": {
-          "type": "integer",
+          "type": "number",
           "uom": null,
-          "description": "The number of conductive layers."
+          "description": "The number of conductive layers.",
+          "minimum": 1,
+          "maximum": 100,
+          "multipleOf": 1.0
         },
         "minimum_internal_track_width": {
           "type": "number",
-          "uom": ["um"],
+          "uom": ["mm"],
           "description": "The minimum nominal width of conductors on internal/unplated layers (minimum track)."
         },
         "minimum_external_track_width": {
           "type": "number",
-          "uom": ["um"],
+          "uom": ["mm"],
           "description": "The minimum nominal width of conductors on external/plated layers (minimum track). If only only one minimum track is present, is should be here."
         },
         "minimum_internal_spacing_width": {
           "type": "number",
-          "uom": ["um"],
+          "uom": ["mm"],
           "description": "The minimum gap between two conductors on the internal layers."
         },
         "minimum_external_spacing_width": {
           "type": "number",
+          "uom": ["mm"],
           "description": "The minimum gap between two conductors on the external layers. If only one minimum gap is present, is should be here."
         },
         "external_base_copper_thickness": {
           "type": "number",
           "enum": [5.1, 8.5, 12, 17.1, 25.7, 34.3, 68.6, 102.9, 137.2, 171.5, 205.7, 240, 342.9, 480.1],
           "uom": ["um"],
-          "description": "Finished base copper thickness following IPC Class on the up to two external layers in micrometer."
+          "description": "Finished base copper thickness following IPC Class on the up to two external layers."
         },
         "internal_base_copper_thickness": {
           "type": "number",
           "enum": [5.1, 8.5, 12, 17.1, 25.7, 34.3, 68.6, 102.9, 137.2, 171.5, 205.7, 240, 342.9, 480.1],
           "uom": ["um"],
-          "description": "Finished base copper thickness following IPC Class on the internal layers in micrometer."
+          "description": "Finished base copper thickness following IPC Class on the internal layers."
         },
         "copper_foil_roughness": {
           "type": "string",
           "enum": ["S", "L", "V"],
-          "uom": ["um"],
+          "enum_description": {
+            "S": "Standard profile",
+            "L": "Low profile",
+            "V": "Very low profile"
+          },
+          "uom": null,
           "description": "The roughness of the copper foil."
         },
         "copper_coverage_average": {
           "type": "number",
           "uom": ["%"],
-          "description": "The average copper coverage of the board. UoM is percentage"
+          "description": "The average copper coverage of the board"
         }
       },
       "final_finish": {
         "finish": {
           "type": "string",
           "enum": ["none", "c_bare_copper", "isn", "iag", "enig", "enepig", "osp", "ht_osp", "g", "GS", "t_fused", "tlu_unfused", "dig", "gwb-1_ultrasonic", "gwb-2-thermosonic", "s_hasl", "b1_lfhasl"],
+          "enum_description": {
+            "none": "No final finish should be used",
+            "c_bare_copper": "AABUS",
+            "isn": "IPC-4554 Immersion Tin",
+            "iag": "IPC-4553 Immersion Silver",
+            "enig": "IPC-4552 Immersion Gold",
+            "enepig": "IPC-4556 ENEPIG",
+            "osp": "J-STD-003 Organic Solderability Preservative",
+            "ht_osp": "J-STD-003 High Temperature OSP",
+            "g": "ASTM-B-488 Gold for edge printed board connectors and areas not to be soldered",
+            "GS": "J-STD-003 Gold Electroplate on areas to be soldered",
+            "t_fused": "J-STD-003 Electrodeposited Tin-Lead (fused)",
+            "tlu_unfused": "J-STD-003 Electrodeposited Tin-Lead Unfused",
+            "dig": "J-STD-003 Direct Immersion Gold (Solderable Surface)",
+            "gwb-1_ultrasonic": "ASTM-B-488 Gold Electroplate for areas to be wire bonded (ultrasonic)",
+            "gwb-2-thermosonic": "ASTM-B-488 Gold Electroplate for areas to be wire bonded (thermosonic)",
+            "s_hasl": "J-STD-003_J-STD-006 Solder Coating over Bare Copper (HASL)",
+            "b1_lfhasl": "J-STD-003_J-STD-006 Lead-Free Solder Coating over Bare Copper (Lead-Free HASL, Lead free HASL)"
+          },
           "uom": null,
           "description": "The material/method/surface to be used in the finish."
         },
         "area": {
           "type": "number",
           "uom": ["dm2"],
-          "description": "The area that the finish will cover, in square decimeter."
+          "description": "The area that the finish will cover"
         }
       },
       "soldermask": {
@@ -273,31 +319,11 @@
           "uom": null,
           "description": "The finish of the soldermask."
         },
-        "min_thickness": {
-          "type": "number",
-          "uom": ["um"],
-          "description": "The minimum thickness of the soldermask."
-        },
-        "max_thickness": {
-          "type": "number",
-          "uom": ["um"],
-          "description": "The maximum thickness of the soldermask."
-        },
         "material": {
           "type": "string",
           "uom": null,
           "description": "The name of a material that appears in the materials section"
         },
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates soldermask presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates soldermask presence/capability at bottom"
-        },
         "allow_touchups": {
           "type": "boolean",
           "uom": null,
@@ -309,16 +335,6 @@
           "type": "string",
           "uom": null,
           "description": "This describes the color based on the name of the color; white, yellow. If a specific color needs to be defined, this can be done custom -> colors section."
-        },
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates legend presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates legend presence/capability at bottom"
         }
       },
       "stiffener": {
@@ -350,16 +366,6 @@
           "uom": null,
           "description": "The total thickness of the coverlay"
         },
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates coverlay presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates coverlay presence/capability at bottom"
-        },
         "material": {
           "type": "string",
           "uom": null,
@@ -371,16 +377,6 @@
           "type": "integer",
           "uom": null,
           "description": ""
-        },
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates peelable mask presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates peelable mask presence/capability at bottom"
         }
       },
       "kapton_tape": {
@@ -388,40 +384,6 @@
           "type": "boolean",
           "uom": null,
           "description": "If alternative to DuPont™ Kapton® HN general-purpose film can be used"
-        },
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates kapton tape presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates kapton tape presence/capability at top"
-        }
-      },
-      "conductive_carbon_print": {
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates Conductive Carbon Print presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates Conductive Carbon Print presence/capability at bottom"
-        }
-      },
-      "silver_print": {
-        "top": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates silver print presence/capability at top"
-        },
-        "bottom": {
-          "type": "boolean",
-          "uom": null,
-          "description": "Indicates silver print presence/capability at bottom"
         }
       },
       "inner_packaging": {
@@ -630,34 +592,6 @@
           "description": "The weight of the array measured in grams."
         }
       },
-      "inner_packaging": {
-        "type_of_bag": {
-          "type": "string",
-          "enum": ["a", "b", "c", "d"],
-          "uom": null,
-          "description": "The material of the bag to be used"
-        },
-        "hic": {
-          "type": "boolean",
-          "uom": null,
-          "description": "True to include a Humidity Indicator Card (HIC), False to not"
-        },
-        "esd": {
-          "type": "boolean",
-          "uom": null,
-          "description": "True to indicate that packaging for ESD-sensitive required."
-        },
-        "desiccant": {
-          "type": "boolean",
-          "uom": null,
-          "description": "True to indicate that a desiccant material is required."
-        },
-        "vacuum": {
-          "type": "boolean",
-          "uom": null,
-          "description": "True to indicate that vacuum is needed for shrinkage - no heat rap or shrink rap allowed."
-        }
-      },
       "mechanical": {
         "edge_bevelling": {
           "type": "boolean",
@@ -779,6 +713,9 @@
         },
         "standards": {
           "type": "array",
+          "items": {
+            "type": "string"
+          },
           "uom": null,
           "description": "Possible values are the ones listed in the subelement \"standards\" but typical will be \"ul\" and \"rohs\". Separate by comma."
         },
@@ -925,35 +862,35 @@
           "type": "string",
           "enum": ["1", "2", "3", "3A", "3S", "3M"],
           "uom": null,
-          "description": "Requirements according to IPC 6012 class."
+          "description": "Requirements according to IPC 6012 class"
         },
         "ipc_6013_class": {
           "type": "string",
           "enum": ["1", "2", "3"],
           "uom": null,
-          "description": "Requirements according to IPC 6013 for flexible or rigid-flex boards."
+          "description": "Requirements according to IPC 6013 for flexible or rigid-flex boards"
         },
-        "ipc_6018":{
+        "ipc_6018": {
           "type": "boolean",
           "uom": null,
-          "description": "IPC-6018 Microwave End Product Board Inspection and Test."
+          "description": "IPC-6018 Microwave End Product Board Inspection and Test"
         }
       },
       "testing": {
         "netlist": {
           "type": "boolean",
           "uom": null,
-          "description": "100% Netlist testing according to IPC-D-356, ODB++ or IPC2581."
+          "description": "100% Netlist testing according to IPC-D-356, ODB++ or IPC2581"
         },
         "allow_generate_netlist": {
           "type": "boolean",
           "uom": null,
-          "description": "Allow Netlist to be generated from Gerber or other file format if needed."
+          "description": "Allow Netlist to be generated from Gerber or other file format if needed"
         },
         "hipot": {
           "type": "boolean",
           "uom": null,
-          "description": " HiPot Test (Dielectric Withstanding Voltage Test)."
+          "description": "HiPot Test (Dielectric Withstanding Voltage Test)"
         },
         "4_wire": {
           "type": "boolean",
@@ -1136,4 +1073,4 @@
       }
     }
   }
-}
+}

data/lib/circuitdata/tools.rb

@@ -0,0 +1,176 @@
+class Circuitdata::Tools
+  def initialize()
+    require 'json'
+    @schema_path = File.join(File.dirname(__FILE__), 'schema_files/v1/ottp_circuitdata_schema.json')
+    @definitions_path = File.join(File.dirname(__FILE__), 'schema_files/v1/ottp_circuitdata_schema_definitions.json')
+    @ra = {}
+  end
+
+  def update_ra(type, key, value)
+    parsed_elements = Circuitdata.read_json(@definitions_path)[2]
+    unless @ra[:structured].has_key? key
+      @ra[:structured][key] = {
+        :type => value[:type],
+        :elements => {},
+        :name => nil,
+        :description => nil,
+        :aliases => nil
+      }
+      @ra[:structured][key][:name] = value[:name] if value.has_key? :name
+      @ra[:structured][key][:description] = value[:decription] if value.has_key? :decription
+      if value.has_key? :aliases
+        @ra[:structured][key][:aliases] = value[:aliases] unless value[:aliases] == ""
+      end
+    end
+    if value.has_key? :properties
+      value[:properties].each do |skey, svalue|
+        unless @ra[:structured][key][:elements].has_key? skey
+          @ra[:structured][key][:elements][skey] = {
+            :in_product_generic => false,
+            :in_product_stackup => false,
+            :in_profile_default => false,
+            :in_profile_enforced => false,
+            :in_profile_restricted => false,
+            :in_capabilities => false,
+            :type => nil,
+            :arrayitems => nil,
+            :enum => nil,
+            :description => nil,
+            :uom => nil,
+            :minimum => nil,
+            :maximum => nil,
+            :in_profile_restricted_regex => nil,
+            :in_capabilities_regex => nil
+          }
+          if svalue.has_key? :$ref
+            elements = svalue[:$ref].split('/')
+            if elements.length < 5
+              element = parsed_elements[elements[1].to_sym][elements[2].to_sym][elements[3].to_sym]
+            else
+              element = parsed_elements[elements[1].to_sym][elements[2].to_sym][elements[3].to_sym][elements[4].to_sym]
+            end
+          else
+            element = nil
+            [:rigid_conductive_layer, :flexible_conductive_layer].include? key.to_sym ? newkey = :conductive_layer : newkey = key.to_sym
+            if parsed_elements[:definitions][:elements].has_key? newkey
+              element = parsed_elements[:definitions][:elements][newkey][skey.to_sym] if parsed_elements[:definitions][:elements][newkey].has_key? skey.to_sym
+            end
+          end
+          unless element.nil?
+            if element.has_key? :type
+              @ra[:structured][key][:elements][skey][:type] = element[:type]
+              if element[:type] == "array"
+                if element.has_key? :items and element[:items].has_key? :type
+                  @ra[:structured][key][:elements][skey][:arrayitems] == element[:items][:type]
+                end
+              end
+            end
+            @ra[:structured][key][:elements][skey][:enum] = element[:enum] if element.has_key? :enum
+            @ra[:structured][key][:elements][skey][:description] = element[:description] if element.has_key? :description
+            @ra[:structured][key][:elements][skey][:uom] = element[:uom] if element.has_key? :uom
+            @ra[:structured][key][:elements][skey][:minimum] = element[:minimum] if element.has_key? :minimum
+            @ra[:structured][key][:elements][skey][:maximum] = element[:maximum] if element.has_key? :maximum
+          end
+        else
+          if [:in_profile_restricted, :in_capabilities].include? type
+            case @ra[:structured][key][:elements][skey][:type]
+            when *["number", "integer", "boolean", "string"]
+              @ra[:structured][key][:elements][skey][:type] = "number" if @ra[:structured][key][:elements][skey][:type] == "integer"
+              unless ( svalue.has_key? :type and svalue[:type] == "array" ) and ( svalue.has_key? :items and svalue[:items].has_key? :type and svalue[:items][:type] == @ra[:structured][key][:elements][skey][:type])
+                (@ra[:errors][type][key] ||= {})[skey] = "Type is #{@ra[:structured][key][:elements][skey][:type]}, wrong check"
+              end
+            when "array"
+              unless svalue.has_key? :type and svalue[:type] == "array"
+                (@ra[:errors][type][key] ||= {})[skey] = "Type is #{@ra[:structured][key][:elements][skey][:type]}, wrong check"
+              end
+            else
+              puts "unknown type #{@ra[:structured][key][:elements][skey][:type]} in #{key}, #{skey}"
+            end
+          end
+        end
+        @ra[:structured][key][:elements][skey][type] = true
+      end
+    end
+  end
+
+  def create_structure
+    @ra[:structured] = {}
+    @ra[:errors] = {:in_profile_restricted => {}, :in_capabilities => {}}
+    parsed_schema = Circuitdata.read_json(@schema_path)[2]
+    parsed_schema[:properties][:open_trade_transfer_package][:properties][:products][:patternProperties]["^(?!generic$).*".to_sym][:properties][:printed_circuits_fabrication_data][:properties].each do |key, value|
+      self.update_ra(:in_product_generic, key, value)
+    end
+    ["defaults", "restricted", "enforced"].each do |sym|
+      parsed_schema[:properties][:open_trade_transfer_package][:properties][:profiles][:properties][sym.to_sym][:properties][:printed_circuits_fabrication_data][:properties].each do |key, value|
+        case sym
+        when "defaults"
+          t = :in_profile_default
+        when "restricted"
+          t = :in_profile_restricted
+        when "enforced"
+          t = :in_profile_enforced
+        end
+        self.update_ra(t, key, value)
+      end
+    end
+    parsed_schema[:properties][:open_trade_transfer_package][:properties][:capabilities][:properties][:printed_circuits_fabrication_data][:properties].each do |key, value|
+      self.update_ra(:in_capabilities, key, value)
+    end
+    @ra[:structured].sort.to_h
+    @ra[:structured].delete(:version)
+    return @ra
+  end
+
+  def create_documentation(ra)
+    ra[:documentation] = "## Elements and tags\n"
+    ra[:structured].each do |element_key, element_value|
+      ra[:documentation] += "[#{element_key}](##{element_key.to_s.downcase.tr(" ", "-")})\n"
+      element_value[:elements].each do |e_key, e_value|
+        ra[:documentation] += "* #{e_key}\n"
+      end
+      ra[:documentation] += "\n"
+    end
+    ra[:structured].each do |element_key, element_value|
+      ra[:documentation] += "### #{element_key}\n"
+      ra[:documentation] += "Name: #{element_value[:name]}\n" unless element_value[:name].nil?
+      ra[:documentation] += "Aliases: #{element_value[:aliases]}\n" unless element_value[:aliases].nil?
+      ra[:documentation] += "#{element_value[:description]}\n" unless element_value[:description].nil?
+      ra[:documentation] += "\n"
+      element_value[:elements].each do |e_key, e_value|
+        ra[:documentation] += "#### #{e_key}\n"
+        ra[:documentation] += "Aliases: #{e_value[:aliases]}\n" unless e_value[:aliases].nil?
+        ra[:documentation] += "#{e_value[:description]}\n" unless e_value[:description].nil?
+        ra[:documentation] += "Unit of Measure: #{e_value[:uom][0]}\n" unless e_value[:uom].nil?
+        unless e_value[:type].nil?
+          if e_value[:type] == "array"
+            if e_value[:arrayitems].nil?
+              ra[:documentation] += "Type: #{e_value[:type].capitalize} of unknown type\n"
+            else
+              ra[:documentation] += "Type: #{e_value[:type].capitalize} of #{e_value[:arrayitems].capitalize}\n"
+            end
+          else
+            ra[:documentation] += "Type: #{e_value[:type].capitalize}\n"
+          end
+        end
+        if e_value.has_key? :enum and not e_value[:enum].nil?
+          ra[:documentation] += "Use one of these values:\n"
+          e_value[:enum].each do |ev|
+            ra[:documentation] += "* #{ev}\n"
+          end
+        end
+        ra[:documentation] += "Use in:\n"
+        e_value[:in_product_generic] ? ra[:documentation] += "* *Generic product section: Allowed*\n" :  ra[:documentation] += "* *Generic product section: Disallowed*\n"
+        e_value[:in_product_stackup] ? ra[:documentation] += "* *Stackup product section: Allowed*\n" :  ra[:documentation] += "* *Gtackup product section: Disallowed*\n"
+        e_value[:in_profile_default] ? ra[:documentation] += "* *Profile defaults section: Allowed*\n" :  ra[:documentation] += "* *Profile defaults section: Disallowed*\n"
+        e_value[:in_profile_enforced] ? ra[:documentation] += "* *Profile enforced section: Allowed*\n" :  ra[:documentation] += "* *Profile enforced section: Disallowed*\n"
+        e_value[:in_profile_restricted] ? ra[:documentation] += "* *Profile restricted section: Allowed*\n" :  ra[:documentation] += "* *Profile restricted section: Disallowed*\n"
+        ra[:documentation] += "*  - Value in restricted section must match regex #{e_value[:in_profile_restricted_regex]}\n" unless e_value[:in_profile_restricted_regex].nil?
+        e_value[:in_capabilities] ? ra[:documentation] += "* *Capabilites section: Allowed*\n" :  ra[:documentation] += "* *Capabilities section: Disallowed*\n"
+        ra[:documentation] += "*  - Value in capabilites section must match regex #{e_value[:in_capabilities_regex]}\n" unless e_value[:in_capabilities_regex].nil?
+        ra[:documentation] += "\n"
+      end
+    end
+    puts ra[:documentation]
+  end
+
+end