adf_builder 0.4.0 → 1.1.0

data/lib/adf_builder/nodes/node.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Node
+      include AdfBuilder::Validations
+
+      attr_reader :children, :attributes, :value, :tag_name
+
+      def initialize
+        @children = []
+        @attributes = {}
+        @value = nil
+        @tag_name = nil
+      end
+
+      def add_child(node)
+        @children << node
+      end
+
+      def remove_children(tag_name)
+        @children.reject! { |c| c.tag_name == tag_name }
+      end
+
+      def to_xml
+        Serializer.to_xml(self)
+      end
+
+      def method_missing(method_name, *args, &block)
+        # Support for dynamic/custom tags
+        # usage: custom_tag "value", attr: "val"
+        # usage: custom_tag { ... }
+
+        tag_name = method_name
+        attributes = args.last.is_a?(Hash) ? args.last : {}
+        value = args.first unless args.first == attributes
+
+        # If it's a block, it's a structural node
+        if block_given?
+          node = GenericNode.new(tag_name, attributes)
+          node.instance_eval(&block)
+          add_child(node)
+        # If it has a value, it's a leaf node/element
+        elsif value
+          node = GenericNode.new(tag_name, attributes, value)
+          add_child(node)
+        else
+          # Just a tag with attributes? e.g. <flag active="true"/>
+          node = GenericNode.new(tag_name, attributes)
+          add_child(node)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+
+    class GenericNode < Node
+      def initialize(tag_name, attributes = {}, value = nil)
+        super()
+        @tag_name = tag_name
+        @attributes = attributes
+        @value = value
+      end
+    end
+
+    class Root < Node
+      # The root context of the builder
+      def prospect(&block)
+        prospect = Prospect.new
+        prospect.instance_eval(&block) if block_given?
+        add_child(prospect)
+      end
+
+      def first_prospect
+        @children.find { |c| c.is_a?(Prospect) }
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/prospect.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Prospect < Node
+      def request_date(date)
+        @attributes[:requestdate] = date
+      end
+
+      def vehicle(&block)
+        vehicle = Vehicle.new
+        vehicle.instance_eval(&block) if block_given?
+        add_child(vehicle)
+      end
+
+      def customer(&block)
+        customer = Customer.new
+        customer.instance_eval(&block) if block_given?
+        add_child(customer)
+      end
+
+      def vendor(&block)
+        vendor = Vendor.new
+        vendor.instance_eval(&block) if block_given?
+        add_child(vendor)
+      end
+
+      def provider(&block)
+        provider = Provider.new
+        provider.instance_eval(&block) if block_given?
+        add_child(provider)
+      end
+
+      # Helpers for Editing
+      def vehicles
+        @children.select { |c| c.is_a?(Vehicle) }
+      end
+
+      def customers
+        @children.select { |c| c.is_a?(Customer) }
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/provider.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Provider < Node
+      def initialize
+        super
+        @tag_name = :provider
+      end
+
+      def id(value, sequence: nil, source: nil)
+        add_child(Id.new(value, sequence: sequence, source: source))
+      end
+
+      def name(value, part: nil, type: nil)
+        remove_children(:name)
+        add_child(Name.new(value, part: part, type: type))
+      end
+
+      def service(value)
+        remove_children(:service)
+        add_child(GenericNode.new(:service, {}, value))
+      end
+
+      def url(value)
+        remove_children(:url)
+        add_child(GenericNode.new(:url, {}, value))
+      end
+
+      def email(value, preferredcontact: nil)
+        remove_children(:email)
+        add_child(Email.new(value, preferredcontact: preferredcontact))
+      end
+
+      def phone(value, type: nil, time: nil, preferredcontact: nil)
+        remove_children(:phone)
+        add_child(Phone.new(value, type: type, time: time, preferredcontact: preferredcontact))
+      end
+
+      def contact(primary_contact: false, &block)
+        remove_children(:contact)
+        contact = Contact.new(primary_contact: primary_contact)
+        contact.instance_eval(&block) if block_given?
+        add_child(contact)
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/shared.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Id < Node
+      def initialize(value, sequence: nil, source: nil)
+        super()
+        @tag_name = :id
+        @value = value
+        @attributes[:sequence] = sequence if sequence
+        @attributes[:source] = source if source
+      end
+    end
+
+    class Phone < Node
+      def initialize(value, type: nil, time: nil, preferredcontact: nil)
+        super()
+        @tag_name = :phone
+        @value = value
+        @attributes[:type] = type if type
+        @attributes[:time] = time if time
+        @attributes[:preferredcontact] = preferredcontact if preferredcontact
+      end
+    end
+
+    class Email < Node
+      def initialize(value, preferredcontact: nil)
+        super()
+        @tag_name = :email
+        @value = value
+        @attributes[:preferredcontact] = preferredcontact if preferredcontact
+      end
+    end
+
+    class Name < Node
+      def initialize(value, part: nil, type: nil)
+        super()
+        @tag_name = :name
+        @value = value
+        @attributes[:part] = part if part
+        @attributes[:type] = type if type
+      end
+    end
+
+    class Address < Node
+      def initialize(type: nil)
+        super()
+        @tag_name = :address
+        @attributes[:type] = type if type
+      end
+
+      def street(value, line: nil)
+        node = GenericNode.new(:street, { line: line }.compact, value)
+        add_child(node)
+      end
+
+      # Simple elements
+      %i[apartment city regioncode postalcode country].each do |tag|
+        define_method(tag) do |value|
+          add_child(GenericNode.new(tag, {}, value))
+        end
+      end
+    end
+
+    class Contact < Node
+      def initialize(primary_contact: false)
+        super()
+        @tag_name = :contact
+        # primary_contact might be useful for logic but not an attribute
+      end
+
+      def name(value, part: nil, type: nil)
+        add_child(Name.new(value, part: part, type: type))
+      end
+
+      def email(value, preferredcontact: nil)
+        add_child(Email.new(value, preferredcontact: preferredcontact))
+      end
+
+      def phone(value, type: nil, time: nil, preferredcontact: nil)
+        add_child(Phone.new(value, type: type, time: time, preferredcontact: preferredcontact))
+      end
+
+      def address(type: nil, &block)
+        addr = Address.new(type: type)
+        addr.instance_eval(&block) if block_given?
+        add_child(addr)
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/vehicle.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Vehicle < Node
+      validates_inclusion_of :status, in: %i[new used]
+      validates_inclusion_of :interest, in: %i[buy lease sell trade-in test-drive]
+
+      def initialize
+        super
+        @tag_name = :vehicle
+        @attributes[:status] = :new
+        @attributes[:interest] = :buy
+      end
+
+      # Simple Text Elements (Singular)
+      %i[year make model vin stock trim doors bodystyle transmission condition pricecomments comments].each do |tag|
+        define_method(tag) do |value|
+          remove_children(tag)
+          add_child(GenericNode.new(tag, {}, value))
+        end
+      end
+
+      def interest(value)
+        @attributes[:interest] = value
+      end
+
+      def status(value)
+        @attributes[:status] = value
+      end
+
+      # Complex Elements
+      def id(value, sequence: nil, source: nil)
+        # id* is multiple, so just add
+        add_child(Id.new(value, sequence: sequence, source: source))
+      end
+
+      def odometer(value, status: nil, units: nil)
+        remove_children(:odometer)
+        add_child(Odometer.new(value, status: status, units: units))
+      end
+
+      def imagetag(value, width: nil, height: nil, alttext: nil)
+        remove_children(:imagetag)
+        add_child(ImageTag.new(value, width: width, height: height, alttext: alttext))
+      end
+
+      def price(value, **attrs)
+        remove_children(:price)
+        add_child(Price.new(value, **attrs))
+      end
+
+      def option(&block)
+        # option* is multiple
+        opt = Option.new
+        opt.instance_eval(&block) if block_given?
+        add_child(opt)
+      end
+
+      def finance(&block)
+        remove_children(:finance)
+        fin = Finance.new
+        fin.instance_eval(&block) if block_given?
+        add_child(fin)
+      end
+
+      def colorcombination(&block)
+        # colorcombination* is multiple
+        cc = ColorCombination.new
+        cc.instance_eval(&block) if block_given?
+        add_child(cc)
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/vehicle_nodes.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Odometer < Node
+      validates_inclusion_of :status, in: %i[unknown rolledover replaced original]
+      validates_inclusion_of :units, in: %i[km mi]
+
+      def initialize(value, status: nil, units: nil)
+        super()
+        @tag_name = :odometer
+        @value = value
+        @attributes[:status] = status if status
+        @attributes[:units] = units if units
+      end
+    end
+
+    class ImageTag < Node
+      def initialize(value, width: nil, height: nil, alttext: nil)
+        super()
+        @tag_name = :imagetag
+        @value = value
+        @attributes[:width] = width if width
+        @attributes[:height] = height if height
+        @attributes[:alttext] = alttext if alttext
+      end
+    end
+
+    class Price < Node
+      validates_inclusion_of :type, in: %i[quote offer msrp invoice call appraisal asking]
+      validates_inclusion_of :delta, in: %i[absolute relative percentage]
+      validates_inclusion_of :relativeto, in: %i[msrp invoice]
+
+      def initialize(value, type: :quote, currency: nil, delta: nil, relativeto: nil, source: nil)
+        super()
+        @tag_name = :price
+        @value = value
+        @attributes[:type] = type
+        @attributes[:currency] = currency if currency
+        @attributes[:delta] = delta if delta
+        @attributes[:relativeto] = relativeto if relativeto
+        @attributes[:source] = source if source
+      end
+    end
+
+    class Amount < Node
+      validates_inclusion_of :type, in: %i[downpayment monthly total]
+      validates_inclusion_of :limit, in: %i[maximum minimum exact]
+
+      def initialize(value, type: :total, limit: :maximum, currency: nil)
+        super()
+        @tag_name = :amount
+        @value = value
+        @attributes[:type] = type
+        @attributes[:limit] = limit
+        @attributes[:currency] = currency if currency
+      end
+    end
+
+    class Balance < Node
+      validates_inclusion_of :type, in: %i[finance residual]
+
+      def initialize(value, type: :finance, currency: nil)
+        super()
+        @tag_name = :balance
+        @value = value
+        @attributes[:type] = type
+        @attributes[:currency] = currency if currency
+      end
+    end
+
+    class Finance < Node
+      def initialize
+        super
+        @tag_name = :finance
+      end
+
+      def method(value)
+        add_child(GenericNode.new(:method, {}, value))
+      end
+
+      def amount(value, type: :total, limit: :maximum, currency: nil)
+        add_child(Amount.new(value, type: type, limit: limit, currency: currency))
+      end
+
+      def balance(value, type: :finance, currency: nil)
+        add_child(Balance.new(value, type: type, currency: currency))
+      end
+    end
+
+    class Option < Node
+      def initialize
+        super
+        @tag_name = :option
+      end
+
+      def optionname(value)
+        add_child(GenericNode.new(:optionname, {}, value))
+      end
+
+      def manufacturercode(value)
+        add_child(GenericNode.new(:manufacturercode, {}, value))
+      end
+
+      def stock(value)
+        add_child(GenericNode.new(:stock, {}, value))
+      end
+
+      def weighting(value)
+        add_child(GenericNode.new(:weighting, {}, value))
+      end
+
+      def price(value, **attrs)
+        add_child(Price.new(value, **attrs))
+      end
+    end
+
+    class ColorCombination < Node
+      def initialize
+        super
+        @tag_name = :colorcombination
+      end
+
+      def interiorcolor(value)
+        add_child(GenericNode.new(:interiorcolor, {}, value))
+      end
+
+      def exteriorcolor(value)
+        add_child(GenericNode.new(:exteriorcolor, {}, value))
+      end
+
+      def preference(value)
+        add_child(GenericNode.new(:preference, {}, value))
+      end
+    end
+  end
+end

data/lib/adf_builder/nodes/vendor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Vendor < Node
+      def initialize
+        super
+        @tag_name = :vendor
+      end
+
+      def id(value, sequence: nil, source: nil)
+        add_child(Id.new(value, sequence: sequence, source: source))
+      end
+
+      def vendorname(value)
+        remove_children(:vendorname)
+        add_child(GenericNode.new(:vendorname, {}, value))
+      end
+
+      def url(value)
+        remove_children(:url)
+        add_child(GenericNode.new(:url, {}, value))
+      end
+
+      def contact(primary_contact: false, &block)
+        remove_children(:contact)
+        contact = Contact.new(primary_contact: primary_contact)
+        contact.instance_eval(&block) if block_given?
+        add_child(contact)
+      end
+    end
+  end
+end

data/lib/adf_builder/serializer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "ox"
+
+module AdfBuilder
+  class Serializer
+    def self.to_xml(node)
+      new(node).to_xml
+    end
+
+    def initialize(root_node)
+      @root_node = root_node
+    end
+
+    def to_xml
+      doc = Ox::Document.new
+
+      # XML Instruction
+      instruct = Ox::Instruct.new(:xml)
+      instruct[:version] = "1.0"
+      doc << instruct
+
+      # ADF Instruction
+      adf_instruct = Ox::Instruct.new("ADF")
+      adf_instruct[:version] = "1.0"
+      doc << adf_instruct
+
+      # ADF Root Element
+      adf = Ox::Element.new("adf")
+      doc << adf
+
+      @root_node.children.each do |child|
+        serialize_node(child, adf)
+      end
+
+      Ox.dump(doc)
+    end
+
+    private
+
+    def serialize_node(node, parent_element)
+      # Determine element name using tag_name to avoid conflict with DSL methods like 'name'
+      # Safest check: Does it have the instance variable set?
+      element_name = if node.instance_variable_defined?(:@tag_name) && node.instance_variable_get(:@tag_name)
+                       node.instance_variable_get(:@tag_name).to_s
+                     else
+                       node.class.name.split("::").last.downcase
+                     end
+
+      # puts "DEBUG: Serializing #{node.class} as <#{element_name}>"
+
+      element = Ox::Element.new(element_name)
+
+      # Add attributes (XML attributes) or Simple Child Elements
+      node.attributes.each do |key, value|
+        if attribute?(key)
+          element[key] = value.to_s
+        else
+          # It's a simple child element
+          child_el = Ox::Element.new(key.to_s)
+          child_el << value.to_s
+          element << child_el
+        end
+      end
+
+      # Add Node-level Text Content (e.g. <name>John</name>)
+      element << node.value.to_s if node.respond_to?(:value) && node.value
+
+      # Recursively add children nodes
+      node.children.each do |child|
+        serialize_node(child, element)
+      end
+
+      parent_element << element
+    end
+
+    def attribute?(key)
+      %i[
+        part type status sequence source id valid preferredcontact time
+        interest units width height alttext limit currency delta relativeto line
+      ].include?(key)
+    end
+  end
+end

data/lib/adf_builder/validations.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Validations
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def validates_inclusion_of(attribute, in:)
+        @validations ||= []
+        @validations << { type: :inclusion, attribute: attribute, in: binding.local_variable_get(:in) }
+      end
+
+      def validations
+        @validations || []
+      end
+    end
+
+    def validate!
+      self.class.validations.each do |validation|
+        value = @attributes[validation[:attribute]]
+        next if value.nil? # Allow nil unless presence validation is added
+
+        next unless validation[:type] == :inclusion
+
+        allowed = validation[:in]
+        unless allowed.include?(value)
+          raise AdfBuilder::Error,
+                "Invalid value for #{validation[:attribute]}: #{value}. Allowed: #{allowed.join(", ")}"
+        end
+      end
+
+      # Recursively validate children
+      @children.each(&:validate!)
+    end
+  end
+end

data/lib/adf_builder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AdfBuilder
-  VERSION = "0.4.0"
+  VERSION = "1.1.0"
 end