adf_builder 0.3.0 → 1.0.0

data/lib/adf_builder/base/prospect.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Prospect
     STATUSES = {
       new: :new,
       resend: :resend
-    }
+    }.freeze
 
     def initialize(doc)
       @doc = doc
@@ -11,7 +13,6 @@ module AdfBuilder
       @prospect = @doc.adf.prospect
       @prospect[:status] = STATUSES[:new]
 
-
       @request_date = RequestDate.new(@prospect)
       @vehicles = Vehicles.new(@prospect)
       @customer = Customer.new(@prospect)
@@ -19,33 +20,15 @@ module AdfBuilder
       @provider = Provider.new(@prospect)
     end
 
-    def request_date
-      @request_date
-    end
-
-    def vehicles
-      @vehicles
-    end
-
-    def customer
-      @customer
-    end
-
-    def vendor
-      @vendor
-    end
-
-    def provider
-      @provider
-    end
+    attr_reader :request_date, :vehicles, :customer, :vendor, :provider
 
     # set status to renew
     def set_renew
       @prospect[:status] = STATUSES[:resend]
     end
 
-    def add_id(value, source=nil, sequence=1)
+    def add_id(value, source = nil, sequence = 1)
       Id.new.add(@prospect, value, source, sequence)
     end
   end
-end
+end

data/lib/adf_builder/base/request_date.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class RequestDate
-    WITH_SYMBOLS = '%FT%T%:z'
-    WITHOUT_SYMBOLS = '%Y%m%dT%H%M%S%z'
+    WITH_SYMBOLS = "%FT%T%:z"
+    WITHOUT_SYMBOLS = "%Y%m%dT%H%M%S%z"
 
     def initialize(prospect_node)
-      @request_date_node = Ox::Element.new('requestdate')
-      @request_date_node << DateTime.now.strftime('%FT%T%:z')
+      @request_date_node = Ox::Element.new("requestdate")
+      @request_date_node << DateTime.now.strftime("%FT%T%:z")
       prospect_node << @request_date_node
     end
 
-    def update_val(datetime_value, format=1)
+    def update_val(datetime_value, format = 1)
       if format == 1
         @request_date_node.replace_text(datetime_value.strftime(WITH_SYMBOLS))
       elsif format == 2
@@ -17,4 +19,4 @@ module AdfBuilder
       end
     end
   end
-end
+end

data/lib/adf_builder/customer/customer.rb

@@ -1,25 +1,22 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Customer
     def initialize(prospect)
-      @customer = Ox::Element.new('customer')
+      @customer = Ox::Element.new("customer")
       @contact = nil
       @timeframe = nil
 
       prospect << @customer
     end
 
-    def contact
-      @contact
-    end
+    attr_reader :contact, :timeframe
 
-    def timeframe
-      @timeframe
-    end
-    def add(name, opts={})
+    def add(name, opts = {})
       @contact = Contact.new(@customer, name, opts)
     end
 
-    def add_id(index, value, source=nil, sequence=1)
+    def add_id(index, value, source = nil, sequence = 1)
       if @prospect.locate("customer").empty?
         false
       else
@@ -34,25 +31,20 @@ module AdfBuilder
     # @param latest_date [DateTime] - Latest date customer is interested in. If timeframe tag
     # is present, it is required to specify earliestdate and/or
     # latestdate
-    def add_timeframe(description, earliest_date=nil, latest_date=nil)
-      if earliest_date.nil? and latest_date.nil?
-        return false
-      end
+    def add_timeframe(description, earliest_date = nil, latest_date = nil)
+      return false if earliest_date.nil? && latest_date.nil?
 
-      if earliest_date and earliest_date.class != DateTime
-        return false
-      end
+      return false if earliest_date && (earliest_date.class != DateTime)
 
-      if latest_date and latest_date.class != DateTime
-        return false
-      end
+      return false if latest_date && (latest_date.class != DateTime)
 
       @timeframe = Timeframe.new(@customer, description, earliest_date, latest_date) if @timeframe.nil?
     end
 
     def update_comments(comments)
       return false if comments.class != String
+
       AdfBuilder::Builder.update_node(@customer, :comments, comments)
     end
   end
-end
+end

data/lib/adf_builder/customer/timeframe.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Timeframe
     def initialize(customer, description, earliest_date, latest_date)
-
       begin
-        earliest_date = earliest_date.strftime('%FT%T%:z') if earliest_date
-        latest_date = latest_date.strftime('%FT%T%:z') if latest_date
-      rescue => e
+        earliest_date = earliest_date.strftime("%FT%T%:z") if earliest_date
+        latest_date = latest_date.strftime("%FT%T%:z") if latest_date
+      rescue StandardError
         return nil
       end
 
-      @timeframe = Ox::Element.new('timeframe')
-
+      @timeframe = Ox::Element.new("timeframe")
 
-      @timeframe << (Ox::Element.new('description') << description)
-      @timeframe << (Ox::Element.new('earliestdate') << earliest_date) if earliest_date
-      @timeframe << (Ox::Element.new('latestdate') << latest_date) if latest_date
+      @timeframe << (Ox::Element.new("description") << description)
+      @timeframe << (Ox::Element.new("earliestdate") << earliest_date) if earliest_date
+      @timeframe << (Ox::Element.new("latestdate") << latest_date) if latest_date
       customer << @timeframe
     end
 
@@ -24,8 +24,8 @@ module AdfBuilder
 
     def update_earliest_date(date)
       begin
-        date = date.strftime('%FT%T%:z')
-      rescue
+        date = date.strftime("%FT%T%:z")
+      rescue StandardError
         return false
       end
       AdfBuilder::Builder.update_node(@timeframe, :earliestdate, date)
@@ -33,12 +33,12 @@ module AdfBuilder
 
     def update_latest_date(date)
       begin
-        date = date.strftime('%FT%T%:z')
-      rescue
+        date = date.strftime("%FT%T%:z")
+      rescue StandardError
         return false
       end
 
       AdfBuilder::Builder.update_node(@timeframe, :latestdate, date)
     end
   end
-end
+end

data/lib/adf_builder/dsl.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  class DSL
+    def self.build(&block)
+      root = Nodes::Root.new
+      root.instance_eval(&block) if block_given?
+      root.validate!
+      Serializer.to_xml(root)
+    end
+
+    def self.tree(&block)
+      root = Nodes::Root.new
+      root.instance_eval(&block) if block_given?
+      root
+    end
+  end
+
+  def self.build(&block)
+    DSL.build(&block)
+  end
+
+  def self.tree(&block)
+    DSL.tree(&block)
+  end
+end

data/lib/adf_builder/nodes/customer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Customer < Node
+      def contact(&block)
+        contact = Contact.new
+        contact.instance_eval(&block) if block_given?
+        add_child(contact)
+      end
+    end
+
+    class Contact < Node
+      def name(value, part: nil, type: nil)
+        name_node = Name.new(value, part: part, type: type)
+        add_child(name_node)
+      end
+
+      def email(value)
+        add_child(SimpleElement.new(:email, value))
+      end
+
+      def phone(value, type: nil)
+        phone_node = Phone.new(value, type: type)
+        add_child(phone_node)
+      end
+    end
+
+    class Name < Node
+      def initialize(value, part: nil, type: nil)
+        super()
+        @value = value
+        @attributes[:part] = part if part
+        @attributes[:type] = type if type
+      end
+      attr_reader :value
+    end
+
+    class Phone < Node
+      def initialize(value, type: nil)
+        super()
+        @value = value
+        @attributes[:type] = type if type
+      end
+      attr_reader :value
+    end
+
+    # Simple Helper for tags like <email>foo</email>
+    class SimpleElement < Node
+      def initialize(tag_name, value)
+        super()
+        @tag_name = tag_name
+        @value = value
+      end
+      attr_reader :value, :tag_name
+    end
+  end
+end

data/lib/adf_builder/nodes/node.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Node
+      include AdfBuilder::Validations
+
+      attr_reader :children, :attributes
+
+      def initialize
+        @children = []
+        @attributes = {}
+      end
+
+      def add_child(node)
+        @children << node
+      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
+      attr_reader :tag_name, :value
+    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,32 @@
+# 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
+
+      # 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/vehicle.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AdfBuilder
+  module Nodes
+    class Vehicle < Node
+      validates_inclusion_of :status, in: %i[new used]
+
+      def year(value)
+        @attributes[:year] = value
+      end
+
+      def make(value)
+        @attributes[:make] = value
+      end
+
+      def model(value)
+        @attributes[:model] = value
+      end
+
+      def status(value)
+        @attributes[:status] = value
+      end
+    end
+  end
+end

data/lib/adf_builder/provider/provider.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Provider
-
-
-    FREE_TEXT_OPTIONAL_TAGS = [:service, :url]
+    FREE_TEXT_OPTIONAL_TAGS = %i[service url].freeze
 
     def initialize(prospect)
       @prospect = prospect
@@ -10,41 +10,39 @@ module AdfBuilder
       @contact = nil
     end
 
-    def contact
-      @contact
-    end
-
+    attr_reader :contact
 
-    def add(name, params={})
-      @provider = Ox::Element.new('provider')
-      params.merge!({valid_values: AdfBuilder::Contact::VALID_VALUES, valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@provider, :name, name,  params)
+    def add(name, params = {})
+      @provider = Ox::Element.new("provider")
+      params.merge!({ valid_values: AdfBuilder::Contact::VALID_VALUES,
+                      valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@provider, :name, name, params)
       @prospect << @provider
     end
 
-    def add_contact(name, opts={})
+    def add_contact(name, opts = {})
       @contact = Contact.new(@provider, name, opts)
     end
 
-    def add_phone(phone, params={})
-      params.merge!({valid_values: AdfBuilder::Contact::VALID_VALUES, valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@provider, :phone, phone,  params)
+    def add_phone(phone, params = {})
+      params.merge!({ valid_values: AdfBuilder::Contact::VALID_VALUES,
+                      valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@provider, :phone, phone, params)
     end
 
-    def add_email(email, params={})
-      params.merge!({valid_values: AdfBuilder::Contact::VALID_VALUES, valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@provider, :email, email,  params)
+    def add_email(email, params = {})
+      params.merge!({ valid_values: AdfBuilder::Contact::VALID_VALUES,
+                      valid_parameters: AdfBuilder::Contact::VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@provider, :email, email, params)
     end
 
     def update_tags_with_free_text(tags)
       tags.each do |key, value|
-        if FREE_TEXT_OPTIONAL_TAGS.include? key.to_sym
-          AdfBuilder::Builder.update_node(@provider, key, value)
-        end
+        AdfBuilder::Builder.update_node(@provider, key, value) if FREE_TEXT_OPTIONAL_TAGS.include? key.to_sym
       end
     end
 
-    def add_id(index, value, source=nil, sequence=1)
+    def add_id(index, value, source = nil, sequence = 1)
       if @prospect.locate("provider").empty?
         false
       else
@@ -52,4 +50,4 @@ module AdfBuilder
       end
     end
   end
-end
+end

data/lib/adf_builder/serializer.rb

@@ -0,0 +1,81 @@
+# 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).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].include?(key)
+    end
+  end
+end

data/lib/adf_builder/shared/contact.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Contact
     VALID_PARAMETERS = {
-      name: [:part, :type, :primarycontact],
+      name: %i[part type primarycontact],
       email: [:preferredcontact],
-      phone: [:type, :time, :preferredcontact]
-    }
+      phone: %i[type time preferredcontact]
+    }.freeze
 
     VALID_VALUES = {
       name: {
@@ -13,30 +15,30 @@ module AdfBuilder
         primarycontact: %w[0 1]
       },
       email: {
-        preferredcontact: %w[0 1],
+        preferredcontact: %w[0 1]
       },
       phone: {
         preferredcontact: %w[0 1],
         type: %w[phone fax cellphone pager],
         time: %w[morning afternoon evening nopreference day]
       }
-    }
+    }.freeze
 
-    def initialize(parent_node, name, params={})
-      @contact = Ox::Element.new('contact')
-      params.merge!({valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@contact, :name, name,  params)
+    def initialize(parent_node, name, params = {})
+      @contact = Ox::Element.new("contact")
+      params.merge!({ valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@contact, :name, name, params)
       parent_node << @contact
     end
 
-    def add_phone(phone, params={})
-      params.merge!({valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@contact, :phone, phone,  params)
+    def add_phone(phone, params = {})
+      params.merge!({ valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@contact, :phone, phone, params)
     end
 
-    def add_email(email, params={})
-      params.merge!({valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS})
-      AdfBuilder::Builder.update_node(@contact, :email, email,  params)
+    def add_email(email, params = {})
+      params.merge!({ valid_values: VALID_VALUES, valid_parameters: VALID_PARAMETERS })
+      AdfBuilder::Builder.update_node(@contact, :email, email, params)
     end
   end
-end
+end

data/lib/adf_builder/shared/id.rb

@@ -1,20 +1,18 @@
+# frozen_string_literal: true
+
 module AdfBuilder
   class Id
-    def initialize
-
-    end
+    def initialize; end
 
     # add id tag to the form
-    def add(parent_node, value, source=nil, sequence=1)
-      id_node = Ox::Element.new('id')
+    def add(parent_node, value, source = nil, sequence = 1)
+      id_node = Ox::Element.new("id")
       id_node << value
       id_node[:sequence] = sequence
 
-      if source
-        id_node[:source] = source
-      end
+      id_node[:source] = source if source
 
       parent_node.prepend_child(id_node)
     end
   end
-end
+end