quickbooks_api 0.0.7 → 0.1.0

data/lib/quickbooks/logger.rb

@@ -0,0 +1,20 @@
+require 'buffered_logger'
+
+module Quickbooks::Logger
+  def log
+    Quickbooks::Log.log
+  end
+end
+
+class Quickbooks::Log
+  private_class_method :new
+  LOG_LEVEL = 1
+
+  def self.init(log_level)
+    @log = BufferedLogger.new(STDOUT, log_level || LOG_LEVEL)
+  end
+
+  def self.log
+    @log ||= BufferedLogger.new(STDOUT, LOG_LEVEL)
+  end
+end

data/lib/quickbooks/{support → parser}/class_builder.rb

@@ -1,4 +1,4 @@
-module Quickbooks::Support::ClassBuilder
+module Quickbooks::Parser::ClassBuilder
 
 private
 
@@ -10,13 +10,13 @@ def add_strict_attribute(klass, attr_name, type)
     attr_accessor :#{attr_name}
 
     def #{attr_name}=(obj)
-      expected_type = self.class.#{attr_name}_type
-      case obj 
-      when expected_type, Array
-        @#{attr_name} = obj
-      else
-        raise(TypeError, "expecting an object of type \#{expected_type}") 
+      if self.respond_to?("#{attr_name}_type") 
+        expected_type = self.class.#{attr_name}_type
+        unless obj.is_a?(expected_type) || obj.is_a?(Array) 
+          raise(TypeError, "expecting an object of type \#{expected_type}") 
+        end
       end
+      @#{attr_name} = obj
     end
   end
   class_body

data/lib/quickbooks/parser/qbxml_base.rb

@@ -0,0 +1,128 @@
+# inheritance base for schema classes
+class Quickbooks::Parser::QbxmlBase
+  include Quickbooks::Logger
+  extend  Quickbooks::Logger
+  include Quickbooks::Parser::XMLGeneration
+
+  QBXML_BASE = Quickbooks::Parser::QbxmlBase
+
+  FLOAT_CAST = lambda {|d| d ? Float(d) : 0.0}                                  
+  BOOL_CAST  = lambda {|d| d ? (d == 'True' ? true : false) : false }          
+  DATE_CAST  = lambda {|d| d ? Date.parse(d).xmlschema : Date.today.xmlschema } 
+  TIME_CAST  = lambda {|d| d ? Time.parse(d).xmlschema : Time.now.xmlschema }   
+  INT_CAST   = lambda {|d| d ? Integer(d.to_i) : 0 }                                 
+  STR_CAST   = lambda {|d| d ? String(d) : ''}                                  
+
+  QB_TYPE_CONVERSION_MAP= {
+    "AMTTYPE"          => FLOAT_CAST,
+    #"BOOLTYPE"         => BOOL_CAST,
+    "BOOLTYPE"         => STR_CAST,
+    "DATETIMETYPE"     => TIME_CAST,
+    "DATETYPE"         => DATE_CAST,
+    "ENUMTYPE"         => STR_CAST,
+    "FLOATTYPE"        => FLOAT_CAST,
+    "GUIDTYPE"         => STR_CAST,
+    "IDTYPE"           => STR_CAST,
+    "INTTYPE"          => INT_CAST,
+    "PERCENTTYPE"      => FLOAT_CAST,
+    "PRICETYPE"        => FLOAT_CAST,
+    "QUANTYPE"         => INT_CAST,
+    "STRTYPE"          => STR_CAST,
+    "TIMEINTERVALTYPE" => STR_CAST
+  }
+
+  attr_accessor :xml_attributes
+  class << self
+    attr_accessor :xml_attributes
+  end
+
+  def initialize(params = nil)
+    return unless params.is_a?(Hash)
+    @xml_attributes = params[:xml_attributes] || {}
+    params.delete(:xml_attributes)
+
+    params.each do |attr, value|
+      if self.respond_to?(attr)
+        expected_attr_type = self.class.send("#{attr}_type")
+        value = \
+          case value
+          when Hash
+            expected_attr_type.new(value)
+          when Array
+            value.inject([]) { |a,i| a << expected_attr_type.new(i) }
+          else value
+          end
+        self.send("#{attr}=", value)
+      else
+        log.info "Warning: instance #{self} does not respond to attribute #{attr}"
+      end
+    end
+  end
+
+  def self.attribute_names
+    instance_methods(false).reject { |m| m == "xml_attributes" || m[-1..-1] == '=' || m =~ /_xml_class/} 
+  end
+
+  # returns innermost attributes without outer layers of the hash
+  #
+  def inner_attributes(parent = nil)
+    attrs = attributes(false)
+    attrs.delete(:xml_attributes)
+    values = attrs.values.compact
+
+    if values.empty?
+      attributes
+    elsif values.first.is_a?(Array)
+      attributes
+    elsif values.size > 1
+      parent.attributes
+    else
+      first_val = values.first
+      if first_val.respond_to?(:inner_attributes)
+        first_val.inner_attributes(self)
+      else
+        parent.attributes
+      end
+    end
+  end
+
+  def attributes(recursive = true)
+    attrs = {}
+    attrs[:xml_attributes] = xml_attributes
+    self.class.attribute_names.inject(attrs) do |h, m|
+      val = self.send(m)
+      if val
+        if recursive
+          h[m] = case val
+            when QBXML_BASE
+              val.attributes
+            when Array
+              val.inject([]) { |a, obj| obj.is_a?(QBXML_BASE) ? a << obj.attributes : a << obj } 
+            else val
+            end
+        else
+          h[m] = val
+        end
+      end; h
+    end
+  end
+
+  # returns a type map of the object's attributes
+  #
+  def self.template(recursive = false, reload = false)
+    if recursive
+      @template = (!reload && @template) || build_template(true)
+    else build_template(false)
+    end
+  end
+
+private
+
+  def self.build_template(recursive = false)
+    attribute_names.inject({}) do |h, a|
+      attr_type = self.send("#{a}_type") 
+      h[a] = ((attr_type < QBXML_BASE) && recursive) ? attr_type.build_template(true): attr_type.to_s; h
+    end
+  end
+
+end

data/lib/quickbooks/parser/xml_generation.rb

@@ -0,0 +1,52 @@
+module Quickbooks::Parser::XMLGeneration
+  include Quickbooks::Parser
+  include Quickbooks::Parser::XMLParsing
+  include Quickbooks::Support::Inflection
+
+  def to_qbxml
+    xml_doc = Nokogiri::XML(self.class.xml_template)
+    root = xml_doc.root
+    log.debug "to_qbxml#nodes_size: #{root.children.size}"
+
+    # replace all children nodes of the template with populated data nodes
+    xml_nodes = []
+    root.children.each do |xml_template|
+      next unless xml_template.is_a? XML_ELEMENT
+      attr_name = underscore(xml_template)
+      log.debug "to_qbxml#attr_name: #{attr_name}"
+
+      val = self.send(attr_name)
+      next unless val && val.not_blank?
+
+      xml_nodes += build_qbxml_nodes(xml_template, val)
+      log.debug "to_qbxml#val: #{val}"
+    end
+
+    log.debug "to_qbxml#xml_nodes_size: #{xml_nodes.size}"
+    root.children = xml_nodes.join('')
+    set_xml_attributes!(root)
+    root.to_s
+  end
+
+private
+
+  def build_qbxml_nodes(node, val)
+    val = [val].flatten
+    val.inject([]) do |a, v|
+      a << case v
+        when QbxmlBase
+          v.to_qbxml
+        else
+          n = node.clone
+          n.children = val.to_s
+          n
+        end
+    end
+  end
+
+  def set_xml_attributes!(node)
+    node.attributes.each { |name, value| node.remove_attribute(name) }
+    self.xml_attributes.each { |a,v| node.set_attribute(a, v) }
+  end
+
+end

data/lib/quickbooks/{support/qbxml.rb → parser/xml_parsing.rb}

@@ -1,4 +1,6 @@
-module Quickbooks::Support::QBXML
+require 'nokogiri'
+
+module Quickbooks::Parser::XMLParsing
 
   XML_DOCUMENT = Nokogiri::XML::Document
   XML_NODE_SET = Nokogiri::XML::NodeSet
@@ -11,15 +13,6 @@ module Quickbooks::Support::QBXML
   COMMENT_END = "-->"
   COMMENT_MATCHER = /\A#{COMMENT_START}.*#{COMMENT_END}\z/
 
-
-  def is_leaf_node?(xml_obj)
-    xml_obj.children.size == 1 && xml_obj.children.first.class == XML_TEXT
-  end
-
-  def qbxml_class_defined?(name)
-    get_schema_namespace.constants.include?(name)
-  end
-
   # remove all comment lines and empty nodes
   def cleanup_qbxml(qbxml)
     qbxml = qbxml.split('\n')
@@ -28,16 +21,19 @@ module Quickbooks::Support::QBXML
     qbxml.join('')
   end
 
-  def set_required_attributes(xml_obj)
-    required_attributes = get_required_xml_attributes
-    xml_obj.attributes.each do |a,v|
-      if required_attributes.keys.include?(a)
-        xml_obj.set_attribute(a, required_attributes[a])
-      else
-        xml_obj.remove_attribute(a)
-      end
-    end
-    xml_obj
+  def leaf_node?(xml_obj)
+    xml_obj.children.size == 1 && xml_obj.children.first.class == XML_TEXT
+  end
+
+  def parse_leaf_node_data(xml_obj)
+    attr_name = underscore(xml_obj)
+    text_node = xml_obj.children.first
+    [attr_name, text_node.text]
+  end
+
+  def parse_xml_attributes(xml_obj)
+    attrs = xml_obj.attributes
+    attrs.inject({}) { |h, (n,v)| h[n] = v.value; h }
   end
 
 end

data/lib/quickbooks/qbxml_parser.rb

@@ -1,94 +1,94 @@
 #!/usr/bin/env ruby
 
 class Quickbooks::QbxmlParser
-  include Quickbooks::Support
-  include Quickbooks::Support::API
-  include Quickbooks::Support::QBXML
+  include Quickbooks::Config
+  include Quickbooks::Logger
+  include Quickbooks::Parser::XMLParsing
+  include Quickbooks::Support::Inflection
 
-attr_accessor :schema_type
+  attr_accessor :schema_type
 
-def initialize(schema_type)
-  @schema_type = schema_type
-end
+  def initialize(schema_type)
+    @schema_type = schema_type
+  end
 
-def parse_file(qbxml_file)
-  parse(qbxml_file.read)
-end
+  def parse_file(qbxml_file)
+    parse( cleanup_qbxml( File.read_from_unknown(qbxml_file) ) )
+  end
 
-def parse(qbxml)
-  xml_doc = Nokogiri::XML(qbxml)
-  process_xml_obj(xml_doc, nil)
-end
+  def parse(qbxml)
+    xml_doc = Nokogiri::XML(qbxml)
+    process_xml_obj(xml_doc, nil)
+  end
 
 private
 
-def process_xml_obj(xml_obj, parent)
-  case xml_obj
-  when XML_DOCUMENT
-      process_xml_obj(xml_obj.root, parent)
-  when XML_NODE_SET
-    if !xml_obj.empty?
-      process_xml_obj(xml_obj.shift, parent) 
-      process_xml_obj(xml_obj, parent) 
-    end
-  when XML_ELEMENT
-    if is_leaf_node?(xml_obj)
-      process_leaf_node(xml_obj, parent)
-    else
-      obj = process_non_leaf_node(xml_obj, parent)
-      process_xml_obj(xml_obj.children, obj)
-      obj
+  def process_xml_obj(xml_obj, parent)
+    case xml_obj
+    when XML_DOCUMENT
+        process_xml_obj(xml_obj.root, parent)
+    when XML_NODE_SET
+      if !xml_obj.empty?
+        process_xml_obj(xml_obj.shift, parent) 
+        process_xml_obj(xml_obj, parent) 
+      end
+    when XML_ELEMENT
+      if leaf_node?(xml_obj)
+        process_leaf_node(xml_obj, parent)
+      else
+        obj = process_non_leaf_node(xml_obj, parent)
+        process_xml_obj(xml_obj.children, obj)
+        obj
+      end
+    when XML_COMMENT
+      process_comment_node(xml_obj, parent)
     end
-  when XML_COMMENT
-    process_comment_node(xml_obj, parent)
   end
-end
 
-def process_leaf_node(xml_obj, parent_instance)
-  attr_name, data = parse_leaf_node_data(xml_obj)
-  if parent_instance
-    set_attribute_value(parent_instance, attr_name, data)
+  def process_leaf_node(xml_obj, parent_instance)
+    attr_name, data = parse_leaf_node_data(xml_obj)
+    if parent_instance
+      set_attribute_value(parent_instance, attr_name, data)
+    end
+    parent_instance
   end
-  parent_instance
-end
 
-def process_non_leaf_node(xml_obj, parent_instance)
-  instance = fetch_qbxml_class_instance(xml_obj)
-  attr_name = to_attribute_name(instance.class)
-  if parent_instance
-    set_attribute_value(parent_instance, attr_name, instance)
+  def process_non_leaf_node(xml_obj, parent_instance)
+    instance = fetch_qbxml_class_instance(xml_obj)
+    attr_name = underscore(instance.class)
+    if parent_instance
+      set_attribute_value(parent_instance, attr_name, instance)
+    end
+    instance
   end
-  instance
-end
 
-def process_comment_node(xml_obj, parent_instance)
-  parent_instance
-end
+  #TODO: stub
+  def process_comment_node(xml_obj, parent_instance)
+    parent_instance
+  end
 
 # helpers
 
-def parse_leaf_node_data(xml_obj)
-  attr_name = to_attribute_name(xml_obj)
-  text_node = xml_obj.children.first
-  [attr_name, text_node.text]
-end
-
-def fetch_qbxml_class_instance(xml_obj)
-  get_schema_namespace.const_get(xml_obj.name).new
-end
+  def fetch_qbxml_class_instance(xml_obj)
+    obj = schema_namespace.const_get(xml_obj.name).new
+    obj.xml_attributes = parse_xml_attributes(xml_obj)
+    obj
+  end
 
-def set_attribute_value(instance, attr_name, data)
-  if instance.respond_to?(attr_name) 
-    cur_val = instance.send(attr_name)
-    case cur_val
-    when nil
-      instance.send("#{attr_name}=", data)
-    when Array
-      cur_val << data
+  def set_attribute_value(instance, attr_name, data)
+    if instance.respond_to?(attr_name) 
+      cur_val = instance.send(attr_name)
+      case cur_val
+      when nil
+        instance.send("#{attr_name}=", data)
+      when Array
+        cur_val << data
+      else
+        instance.send("#{attr_name}=", [cur_val, data])
+      end
     else
-      instance.send("#{attr_name}=", [cur_val, data])
+      log.info "Warning: instance #{instance} does not respond to attribute #{attr_name}"
     end
   end
-end
 
 end

data/lib/quickbooks/support/inflection.rb

@@ -0,0 +1,18 @@
+require 'active_support/core_ext'
+
+module Quickbooks::Support::Inflection
+
+  def underscore(obj)
+    name = \
+      case obj
+      when Class
+        obj.simple_name
+      when Nokogiri::XML::Element
+        obj.name
+      else
+        obj.to_s
+      end
+    name.underscore
+  end
+
+end