breadkit 0.1.0

data/lib/breadkit/dsl.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Breadkit
+  module DSL
+    METHODS = %w[title board use_parts use_boards supply net part wire offboard expect lint_disable resistor capacitor electrolytic diode led transistor pot button ic connected isolated].freeze
+
+    class Builder
+      attr_reader :document
+
+      def initialize(base_dir: Dir.pwd)
+        @document = Document.new
+        @expected = nil
+        @base_dir = base_dir
+      end
+
+      def title(value)
+        document.title = value.to_s
+      end
+
+      def board(type, **options)
+        raise DSLError, "board may only be declared once" if @board_declared
+        unknown = options.keys - [:split_rails]
+        raise DSLError, "unknown board option #{unknown.first}" unless unknown.empty?
+        if options.key?(:split_rails) && ![true, false].include?(options[:split_rails])
+          raise DSLError, "split_rails must be boolean"
+        end
+
+        @board_declared = true
+        document.board = { type: type.to_s, options: options }
+      end
+
+      def use_parts(path)
+        document.part_paths.concat(Dir.glob(resolve_path(path)))
+      end
+
+      def use_boards(path)
+        document.board_paths.concat(Dir.glob(resolve_path(path)))
+      end
+
+      def supply(name, voltage:, plus:, minus:)
+        document.supplies << { name: name.to_s, voltage: Value.parse(voltage), plus: plus.to_s,
+                               minus: minus.to_s, location: source_location }
+      end
+
+      def net(name, *refs, at: nil, **options)
+        if @expected
+          @expected << { kind: "net", name: name.to_s, refs: (refs + [at] + options.values).compact.map(&:to_s), location: source_location }
+        else
+          raise DSLError, "net requires at: outside expect" if at.nil? || !refs.empty? || !options.empty?
+
+          document.labels << { name: name.to_s, at: at.to_s, location: source_location }
+        end
+      end
+
+      def part(ref, type, value = nil, pins: nil, at: nil, **attrs)
+        unsupported = attrs.keys.find { |key| %i[rotate wire_layer].include?(key.to_sym) }
+        raise DSLError, "unsupported component option #{unsupported}" if unsupported
+
+        document.components << { ref: ref.to_s, type: type.to_s, value: value, pins: pins, at: at,
+                                 attrs: attrs, unused: Array(attrs.delete(:unused)), location: source_location }
+      end
+
+      def resistor(ref, value, **options)
+        part(ref, :resistor, value, **options)
+      end
+
+      def capacitor(ref, value, **options)
+        part(ref, :capacitor, value, **options)
+      end
+
+      def electrolytic(ref, value, **options)
+        part(ref, :electrolytic, value, **options)
+      end
+
+      def diode(ref, value = nil, **options)
+        part(ref, :diode, value, **options)
+      end
+
+      def led(ref, **options)
+        part(ref, :led, nil, **options)
+      end
+
+      def transistor(ref, value = nil, **options)
+        part(ref, :transistor, value, **options)
+      end
+
+      def pot(ref, value = nil, **options)
+        part(ref, :pot, value, **options)
+      end
+
+      def button(ref, **options)
+        part(ref, :button, nil, **options)
+      end
+
+      def ic(ref, value, **options)
+        part(ref, value.to_s.downcase == "dip" ? :dip : value, nil, **options)
+      end
+
+      def wire(from, to, color: nil, id: nil, route: :straight, layer: nil, electrical: true, dashed: false)
+        document.wires << { id: id&.to_s, from: from.to_s, to: to.to_s, color: color&.to_s,
+                            route: route.to_s, layer: layer_names(layer), electrical: electrical != false,
+                            dashed: !!dashed, location: source_location }
+      end
+
+      def offboard(name, type, side: :left, at: nil, unused: [], **attrs)
+        unsupported = attrs.keys.find { |key| %i[rotate wire_layer].include?(key.to_sym) }
+        raise DSLError, "unsupported component option #{unsupported}" if unsupported
+
+        attrs[:at] = at if at
+        document.components << { ref: name.to_s, type: type.to_s, attrs: attrs.merge(side: side.to_s),
+                                 pins: nil, unused: Array(unused), location: source_location, offboard: true }
+      end
+
+      def expect(strict: false, &block)
+        entries = []
+        previous = @expected
+        @expected = entries
+        instance_eval(&block)
+        document.expectations << { strict: strict, entries: entries, location: source_location }
+      ensure
+        @expected = previous
+      end
+
+      def connected(*refs)
+        raise DSLError, "connected must be inside expect" unless @expected
+
+        @expected << { kind: "connected", refs: refs.map(&:to_s), location: source_location }
+      end
+
+      def isolated(*refs)
+        raise DSLError, "isolated must be inside expect" unless @expected
+
+        @expected << { kind: "isolated", refs: refs.map(&:to_s), location: source_location }
+      end
+
+      def lint_disable(rule_id, on: nil, reason: nil)
+        document.lint_disables << { rule: rule_id.to_s, on: on&.to_s, reason: reason, location: source_location }
+      end
+
+      def method_missing(name, *_args, **_kwargs, &_block)
+        suggestions = DidYouMean::SpellChecker.new(dictionary: METHODS).correct(name.to_s)
+        hint = suggestions.empty? ? "" : "; did you mean #{suggestions.first.inspect}?"
+        raise DSLError, "unknown DSL method #{name}#{hint}"
+      end
+
+      def respond_to_missing?(name, _include_private = false)
+        METHODS.include?(name.to_s)
+      end
+
+      private
+
+      def source_location
+        loc = caller_locations(2, 12).find { |item| item.path && File.expand_path(item.path) != __FILE__ }
+        SourceLocation.new(path: loc&.path, line: loc&.lineno)
+      end
+
+      def resolve_path(path)
+        value = path.to_s
+        File.expand_path(value, @base_dir)
+      end
+
+      def layer_names(value)
+        return if value.nil?
+
+        Array(value).map(&:to_s)
+      end
+    end
+
+    def self.load_file(path)
+      absolute = File.expand_path(path)
+      builder = Builder.new(base_dir: File.dirname(absolute))
+      builder.instance_eval(File.read(absolute, encoding: "UTF-8"), absolute, 1)
+      builder.document
+    rescue DSLError
+      raise
+    rescue ScriptError, StandardError => e
+      line = e.backtrace_locations&.find { |frame| frame.path == absolute }&.lineno
+      location = line ? "#{path}:#{line}" : path
+      raise DSLError, "#{location}: #{e.message}"
+    end
+  end
+end

data/lib/breadkit/hole_id.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Breadkit
+  class HoleId
+    attr_reader :kind, :row, :col, :rail, :index, :ref, :pin
+
+    def initialize(kind:, row: nil, col: nil, rail: nil, index: nil, ref: nil, pin: nil)
+      @kind, @row, @col, @rail, @index, @ref, @pin = kind, row, col, rail, index, ref, pin
+      freeze
+    end
+
+    def self.parse(value, board: nil)
+      text = value.to_s.strip
+      rows = board ? board.terminal_rows : ('a'..'j').to_a
+      rails = board ? board.rail_ids : %w[T+ T- B+ B-]
+      rows.sort_by { |row| -row.length }.each do |row|
+        m = /\A(#{Regexp.escape(row)})(\d+)\z/i.match(text)
+        next unless m
+
+        col = m[2].to_i
+        raise ArgumentError, "invalid hole: #{value}" unless col.positive?
+        return new(kind: :terminal, row: row, col: col)
+      end
+      rails.sort_by { |rail| -rail.length }.each do |rail|
+        m = /\A(#{Regexp.escape(rail)})(\d*)\z/i.match(text)
+        next unless m
+
+        index = m[2].empty? ? nil : m[2].to_i
+        raise ArgumentError, "invalid hole: #{value}" if index == 0
+        return new(kind: :rail, rail: rail, index: index)
+      end
+      if (m = /\A([A-Za-z][\w-]*)\.([A-Za-z0-9_+-]+)\z/.match(text))
+        return new(kind: :pin, ref: m[1], pin: m[2])
+      end
+      raise ArgumentError, "invalid hole or pin reference: #{value.inspect}"
+    end
+
+    def to_s
+      case kind
+      when :terminal then "#{row}#{col}"
+      when :rail then "#{rail}#{index}"
+      else "#{ref}.#{pin}"
+      end
+    end
+  end
+end

data/lib/breadkit/ir.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Breadkit
+  module IR
+    class Writer
+      def write(circuit)
+        library = PartLibrary.new
+        part_definitions = circuit.components.values.map(&:part).uniq.filter_map do |part|
+          standard = library.find(part.id, pin_count: part.pins.length)
+          part.data unless standard&.data == part.data
+        end
+        result = {
+          schema_version: 1,
+          title: circuit.title,
+          board: { type: circuit.board.definition.id, options: { split_rails: circuit.board.split_rails } },
+          board_definition: circuit.board.definition.data,
+          supplies: circuit.supplies.map { |item| { name: item.name, voltage: item.voltage, plus: item.plus, minus: item.minus, source: source(item.location) } },
+          labels: circuit.labels.map { |item| { net: item.name, at: item.at, source: source(item.location) } },
+          components: circuit.components.values.map do |component|
+            { ref: component.ref, part: component.part.id, value: component.value,
+              attrs: stringify(component.attrs), pins: component.pins.transform_values(&:hole_id),
+              unused: component.unused, source: source(component.location) }
+          end,
+          wires: circuit.wires.map { |wire| { id: wire.id, from: wire.from, to: wire.to, color: wire.color, route: wire.route,
+                                               layer: wire.layer, electrical: wire.electrical, dashed: wire.dashed,
+                                               source: source(wire.location) } },
+          expectations: stringify(circuit.expectations),
+          lint_disables: stringify(circuit.lint_disables),
+          analysis: { nets: circuit.nets.map { |net| { name: net.name, members: net.members, holes: net.holes, potential: circuit.potentials.values[net.name] } } }
+        }
+        result[:part_definitions] = part_definitions unless part_definitions.empty?
+        result
+      end
+
+      private
+
+      def source(location)
+        return nil unless location && location.path && location.line
+
+        path = Pathname.new(location.path)
+        path = path.relative_path_from(Pathname.pwd) if path.absolute?
+        { path: path.to_s, line: location.line }
+      end
+
+      def stringify(value)
+        case value
+        when Hash then value.each_with_object({}) { |(key, item), result| result[key.to_s] = stringify(item) }
+        when Array then value.map { |item| stringify(item) }
+        when SourceLocation then source(value).transform_keys(&:to_s)
+        when Struct then value.each_pair.each_with_object({}) { |(key, item), result| result[key.to_s] = stringify(item) }
+        when Symbol then value.to_s
+        else value
+        end
+      end
+    end
+
+    class Reader
+      def read_file(path)
+        read(JSON.parse(File.read(path, encoding: "UTF-8")))
+      rescue JSON::ParserError => e
+        raise DSLError, "#{path}: invalid IR JSON: #{e.message}"
+      end
+
+      def read(data)
+        data = stringify_keys(data)
+        validate!(data)
+        doc = Document.new
+        doc.title = data["title"]
+        doc.board = { type: data.dig("board", "type") || "full", options: (data.dig("board", "options") || {}).transform_keys(&:to_sym) }
+        doc.board_definitions = [data["board_definition"]] if data["board_definition"]
+        doc.supplies = Array(data["supplies"]).map do |item|
+          { name: item.fetch("name"), voltage: Value.parse(item.fetch("voltage")), plus: item.fetch("plus"), minus: item.fetch("minus"), location: location(item["source"]) }
+        end
+        doc.labels = Array(data["labels"]).map do |item|
+          { name: item.fetch("net"), at: item.fetch("at"), location: location(item["source"]) }
+        end
+        doc.components = Array(data["components"]).map do |item|
+          { ref: item.fetch("ref"), type: item.fetch("part"), value: item["value"],
+            pins: item["pins"] || {}, at: nil, attrs: (item["attrs"] || {}).transform_keys(&:to_sym),
+            unused: item["unused"] || [], location: location(item["source"]) }
+        end
+        doc.part_definitions = Array(data["part_definitions"])
+        doc.wires = Array(data["wires"]).map do |item|
+          { id: item["id"], from: item.fetch("from"), to: item.fetch("to"), color: item["color"],
+            route: item["route"] || "straight", layer: item["layer"], electrical: item["electrical"] != false,
+            dashed: item["dashed"] == true, location: location(item["source"]) }
+        end
+        doc.expectations = Array(data["expectations"])
+        doc.lint_disables = Array(data["lint_disables"]).map do |item|
+          { rule: item.fetch("rule"), on: item["on"], reason: item["reason"], location: location(item["location"]) }
+        end
+        Resolver.new.call(doc)
+      rescue KeyError => e
+        raise DSLError, "invalid IR: missing #{e.key}"
+      end
+
+      private
+
+      def validate!(data)
+        require_hash(data, "root")
+        raise DSLError, "unsupported IR schema_version" unless data["schema_version"] == 1
+        raise DSLError, "invalid IR: title must be text or null" unless data["title"].nil? || data["title"].is_a?(String)
+
+        board = require_hash(data["board"], "board")
+        require_string(board["type"], "board.type")
+        options = require_hash(board["options"], "board.options")
+        unless !options.key?("split_rails") || [true, false].include?(options["split_rails"])
+          raise DSLError, "invalid IR: board.options.split_rails must be boolean"
+        end
+        validate_board_definition(data["board_definition"]) if data.key?("board_definition")
+        validate_records(data, "supplies", %w[name plus minus], %w[voltage])
+        validate_records(data, "labels", %w[net at])
+        validate_records(data, "components", %w[ref part])
+        validate_records(data, "wires", %w[id from to])
+        validate_records(data, "expectations")
+        validate_records(data, "part_definitions") if data.key?("part_definitions")
+        validate_records(data, "lint_disables", %w[rule]) if data.key?("lint_disables")
+        Array(data["part_definitions"]).each_with_index do |item, index|
+          require_string(item["id"], "part_definitions[#{index}].id")
+          require_array(item["pins"], "part_definitions[#{index}].pins").each do |pin|
+            require_hash(pin, "part_definitions[#{index}].pins item")
+          end
+        end
+        Array(data["lint_disables"]).each_with_index do |item, index|
+          require_source(item["location"], "lint_disables[#{index}].location") if item.key?("location")
+        end
+        data.fetch("components").each_with_index do |item, index|
+          require_hash(item["pins"], "components[#{index}].pins").each_value do |hole|
+            raise DSLError, "invalid IR: components[#{index}].pins values must be text or null" unless hole.nil? || hole.is_a?(String)
+          end
+          require_hash(item["attrs"], "components[#{index}].attrs")
+          require_array(item["unused"], "components[#{index}].unused")
+        end
+        data.fetch("expectations").each_with_index do |item, index|
+          require_source(item["location"], "expectations[#{index}].location")
+          require_array(item["entries"], "expectations[#{index}].entries")
+          item["entries"].each_with_index do |entry, entry_index|
+            require_hash(entry, "expectations[#{index}].entries[#{entry_index}]")
+            unless %w[connected isolated net].include?(entry["kind"])
+              raise DSLError, "invalid IR: expectations[#{index}].entries[#{entry_index}].kind is unknown"
+            end
+            require_array(entry["refs"], "expectations[#{index}].entries[#{entry_index}].refs")
+            require_source(entry["location"], "expectations[#{index}].entries[#{entry_index}].location")
+          end
+        end
+        require_array(require_hash(data["analysis"], "analysis")["nets"], "analysis.nets") if data.key?("analysis")
+      end
+
+      def validate_board_definition(value)
+        board = require_hash(value, "board_definition")
+        require_string(board["id"], "board_definition.id")
+        terminal = require_hash(board["terminal"], "board_definition.terminal")
+        unless terminal["columns"].is_a?(Integer) && terminal["columns"].positive?
+          raise DSLError, "invalid IR: board_definition.terminal.columns must be a positive integer"
+        end
+        require_array(terminal["rows"], "board_definition.terminal.rows").each do |row|
+          require_string(row, "board_definition.terminal.rows item")
+        end
+        require_array(terminal["groups"], "board_definition.terminal.groups").each do |group|
+          require_array(group, "board_definition.terminal.groups item")
+        end
+      end
+
+      def validate_records(data, key, strings = [], numbers = [])
+        require_array(data[key], key).each_with_index do |item, index|
+          require_hash(item, "#{key}[#{index}]")
+          strings.each { |field| require_string(item[field], "#{key}[#{index}].#{field}") }
+          numbers.each do |field|
+            raise DSLError, "invalid IR: #{key}[#{index}].#{field} must be a number" unless item[field].is_a?(Numeric)
+          end
+          require_source(item["source"], "#{key}[#{index}].source") if item.key?("source")
+        end
+      end
+
+      def require_source(value, path)
+        return if value.nil?
+
+        require_hash(value, path)
+        require_string(value["path"], "#{path}.path")
+        raise DSLError, "invalid IR: #{path}.line must be a positive integer" unless value["line"].is_a?(Integer) && value["line"].positive?
+      end
+
+      def require_hash(value, path)
+        raise DSLError, "invalid IR: #{path} must be an object" unless value.is_a?(Hash)
+
+        value
+      end
+
+      def require_array(value, path)
+        raise DSLError, "invalid IR: #{path} must be an array" unless value.is_a?(Array)
+
+        value
+      end
+
+      def require_string(value, path)
+        raise DSLError, "invalid IR: #{path} must be text" unless value.is_a?(String)
+      end
+
+      def location(source)
+        return nil unless source
+        SourceLocation.new(path: source["path"], line: source["line"])
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash then value.each_with_object({}) { |(key, item), result| result[key.to_s] = stringify_keys(item) }
+        when Array then value.map { |item| stringify_keys(item) }
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/breadkit/model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Breadkit
+  SourceLocation = Struct.new(:path, :line, keyword_init: true)
+  Diagnostic = Data.define(:code, :severity, :message, :location, :targets)
+  Hole = Struct.new(:id, :kind, :row, :col, :rail, :x, :y, :strip_id, keyword_init: true)
+  Strip = Struct.new(:id, :hole_ids, keyword_init: true)
+  Pin = Struct.new(:name, :number, :hole_id, :node_id, :role, keyword_init: true)
+  Component = Struct.new(:ref, :part, :value, :attrs, :pins, :unused, :location, keyword_init: true) do
+    def pin(reference)
+      definition = part.pin(reference)
+      pins[(definition["name"] || definition["num"]).to_s] if definition
+    end
+  end
+  Wire = Struct.new(:id, :from, :to, :color, :route, :layer, :electrical, :dashed, :location, keyword_init: true)
+  Supply = Struct.new(:name, :voltage, :plus, :minus, :location, keyword_init: true)
+  Label = Struct.new(:name, :at, :location, keyword_init: true)
+  Net = Struct.new(:name, :members, :holes, :labels, :potential, keyword_init: true)
+
+  class Document
+    attr_accessor :title, :board, :supplies, :labels, :components, :wires, :expectations,
+                  :lint_disables, :part_paths, :part_definitions, :board_paths, :board_definitions
+
+    def initialize
+      @title = nil
+      @board = { type: "full", options: {} }
+      @supplies, @labels, @components, @wires = [], [], [], []
+      @expectations, @lint_disables, @part_paths, @part_definitions, @board_paths, @board_definitions = [], [], [], [], [], []
+    end
+  end
+end

data/lib/breadkit/part_library.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Breadkit
+  class PartDef
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+      raise ArgumentError, "part definition needs an id" unless data["id"]
+      raise ArgumentError, "part #{data['id']} needs pins" unless data["pins"].is_a?(Array)
+      identities = {}
+      pins.each_with_index do |pin, index|
+        raise ArgumentError, "part #{id} has invalid pin" unless pin.is_a?(Hash) && pin["num"]
+
+        ([pin["num"], pin["name"]] + Array(pin["aliases"])).compact.each do |identity|
+          key = identity.to_s.downcase
+          raise ArgumentError, "part #{id} has duplicate pin identity #{identity}" if identities.key?(key) && identities[key] != index
+
+          identities[key] = index
+        end
+      end
+      valid_pins = pins.flat_map { |pin| [pin["num"], pin["name"], *Array(pin["aliases"])].compact.map(&:to_s) }
+      %w[internal switch same_strip_ok].each do |key|
+        Array(data[key]).each do |pair|
+          raise ArgumentError, "part #{id} has invalid #{key} pin pair #{pair.inspect}" unless pair.length == 2 && pair.all? { |pin| valid_pins.include?(pin.to_s) }
+        end
+      end
+      raise ArgumentError, "part #{id} has invalid placement" unless %w[leads dip footprint offboard].include?(placement)
+      if data["polarity"]
+        unless data["polarity"].is_a?(Hash) && data["polarity"].values.all? { |name| identities.key?(name.to_s.downcase) }
+          raise ArgumentError, "part #{id} has invalid polarity pin reference"
+        end
+      end
+      if data["footprint"]
+        numbers = pins.map { |pin| pin.fetch("num").to_s }
+        unless data["footprint"].is_a?(Hash) && data["footprint"].all? { |key, offset| numbers.include?(key.to_s) && offset.is_a?(Array) && offset.length == 2 && offset.all? { |value| value.is_a?(Integer) } }
+          raise ArgumentError, "part #{id} has invalid footprint pin reference or offset"
+        end
+      end
+      if data.dig("render", "shape") == "module"
+        size_mm = data.dig("render", "size_mm")
+        raise ArgumentError, "part #{id} module rendering needs positive size_mm [width, height]" unless valid_mm_pair?(size_mm, positive: true)
+        offset_mm = data.dig("render", "body_offset_mm")
+        if offset_mm && !valid_mm_pair?(offset_mm, positive: false)
+          raise ArgumentError, "part #{id} module rendering needs finite body_offset_mm [x, y]"
+        end
+      end
+    end
+
+    def id
+      data.fetch("id")
+    end
+
+    def pins
+      data.fetch("pins")
+    end
+
+    def placement
+      data.fetch("placement", "leads")
+    end
+
+    def pin(value)
+      key = value.to_s.downcase
+      pins.find do |pin|
+        ([pin["num"], pin["name"]] + Array(pin["aliases"])).compact.any? { |item| item.to_s.downcase == key }
+      end
+    end
+
+    private
+
+    def valid_mm_pair?(values, positive:)
+      values.is_a?(Array) && values.length == 2 && values.all? do |value|
+        number = Float(value)
+        number.finite? && (!positive || number.positive?)
+      rescue ArgumentError, TypeError
+        false
+      end
+    end
+  end
+
+  class PartLibrary
+    def initialize(extra_paths: [], extra_definitions: [])
+      paths = Dir.glob(File.expand_path("../../data/parts/*.yml", __dir__))
+      paths.concat(extra_paths.flat_map { |path| Dir.glob(path) })
+      definitions = paths.uniq.map { |path| YAML.safe_load(File.read(path, encoding: "UTF-8"), aliases: false) }
+      definitions.concat(extra_definitions)
+      @parts = {}
+      definitions.each do |data|
+        part = PartDef.new(data)
+        ([part.id] + Array(data["aliases"])).each do |name|
+          key = name.to_s.downcase
+          raise ArgumentError, "part alias #{name} conflicts with #{@parts[key].id}" if @parts[key] && @parts[key] != part
+
+          @parts[key] = part
+        end
+      end
+    end
+
+    def find(name, pin_count: nil)
+      key = name.to_s.downcase
+      return @parts[key] if @parts[key]
+      return unless %w[dip pin_header].include?(key) && pin_count
+
+      count = Integer(pin_count)
+      return unless count.between?(key == "dip" ? 2 : 1, 64) && (key != "dip" || count.even?)
+      generic(key, count)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def all
+      (@parts.values.uniq + %w[dip pin_header].map { |id| generic(id, 2) }).sort_by(&:id)
+    end
+
+    private
+
+    def generic(id, count)
+      pins = (1..count).map { |number| { "num" => number, "name" => number.to_s } }
+      data = { "id" => id, "placement" => id == "dip" ? "dip" : "footprint", "pins" => pins,
+               "package" => { "pins" => count }, "render" => { "shape" => id == "dip" ? "dip" : "generic" } }
+      data["footprint"] = (1..count).to_h { |number| [number.to_s, [number - 1, 0]] } if id == "pin_header"
+      PartDef.new(data)
+    end
+  end
+end