quickbooks_api 0.0.2

data/lib/quickbooks/api.rb

@@ -0,0 +1,123 @@
+class Quickbooks::API
+  include Quickbooks::Support
+  include Quickbooks::Support::API
+  include Quickbooks::Support::QBXML
+
+attr_reader :dtd_parser, :qbxml_parser, :schema_type
+
+def initialize(schema_type = nil, opts = {})
+  @schema_type = schema_type
+  use_disk_cache, log_level = opts.values_at(:use_disk_cache, :log_level)
+
+  unless valid_schema_type?
+    raise(ArgumentError, "schema type required: #{valid_schema_types.inspect}") 
+  end
+
+  @dtd_file = get_dtd_file
+  @dtd_parser = DtdParser.new(schema_type)
+  @qbxml_parser = QbxmlParser.new(schema_type)
+
+  load_qb_classes(use_disk_cache)
+
+  # load the container class template into memory (significantly speeds up wrapping of partial data hashes)
+  get_container_class.template(true, use_disk_cache)
+end
+
+def container
+  get_container_class
+end
+
+def qbxml_classes
+  cached_classes
+end
+
+# QBXML 2 RUBY
+
+def qbxml_to_obj(qbxml)
+  case qbxml
+  when IO
+    qbxml_parser.parse_file(qbxml)
+  else
+    qbxml_parser.parse(qbxml)
+  end
+end
+
+def qbxml_to_hash(qbxml, include_container = false)
+  qb_obj = qbxml_to_obj(qbxml)
+  unless include_container
+    qb_obj.inner_attributes
+  else
+    qb_obj.attributes
+  end
+end
+
+
+# RUBY 2 QBXML
+
+def hash_to_obj(data)
+  key = data.keys.first
+  value = data[key]
+
+  key_path = find_nested_key(container.template(true), key)
+  raise(RuntimeError, "#{key} class not found in api template") unless key_path
+
+  wrapped_data = build_hash_wrapper(key_path, value)
+  container.new(wrapped_data)
+end
+
+def hash_to_qbxml(data)
+  hash_to_obj(data).to_qbxml.to_s
+end
+
+# Disk Cache
+
+def clear_disk_cache(rebuild = false)
+  qbxml_cache = Dir["#{get_disk_cache_path}/*.rb"]
+  template_cache = Dir["#{get_template_cache_path}/*.yml"]
+  File.delete(*(qbxml_cache + template_cache))
+  load_qb_classes(rebuild)
+end
+
+
+private 
+
+
+def load_qb_classes(use_disk_cache = false)
+  if use_disk_cache
+    disk_cache = Dir["#{get_disk_cache_path}/*.rb"]
+    if disk_cache.empty?
+      log.info "Warning: on disk schema cache is empty, rebuilding..."
+      rebuild_schema_cache(false, true)
+    else
+      disk_cache.each {|file| require file }
+    end
+  else
+    rebuild_schema_cache(false, false)
+  end
+end
+
+# rebuilds schema cache in memory and writes to disk if desired
+#
+def rebuild_schema_cache(force = false, write_to_disk = false)
+  dtd_parser.parse_file(@dtd_file) if (cached_classes.empty? || force)
+  dump_cached_classes if write_to_disk
+end
+
+# writes dynamically generated api classes to disk
+#
+def dump_cached_classes
+  cached_classes.each do |c|  
+    File.open("#{get_disk_cache_path}/#{to_attribute_name(c)}.rb", 'w') do |f|
+      f << Ruby2Ruby.translate(c)
+    end
+  end
+end
+
+# class methods
+
+def self.log
+  @@log ||= Logger.new(STDOUT, DEFAULT_LOG_LEVEL)
+end
+
+
+end

data/lib/quickbooks/dtd_parser.rb

@@ -0,0 +1,46 @@
+class Quickbooks::DtdParser < Quickbooks::QbxmlParser
+  include Quickbooks::Support::ClassBuilder
+
+def parse_file(qbxml_file)
+  parse( 
+    cleanup_qbxml(
+      File.read(qbxml_file)))
+end
+
+private
+
+def process_leaf_node(xml_obj, parent_class)
+ attr_name, qb_type = parse_leaf_node_data(xml_obj)
+  if parent_class
+    add_casting_attribute(parent_class, attr_name, qb_type)
+  end
+end
+
+def process_non_leaf_node(xml_obj, parent_class)
+  klass = build_qbxml_class(xml_obj)
+  attr_name = to_attribute_name(xml_obj)
+  if parent_class
+    add_strict_attribute(parent_class, attr_name, klass)
+  end
+  klass
+end
+
+def process_comment_node(xml_obj, parent_class)
+  parent_class
+end
+
+# helpers
+
+def build_qbxml_class(xml_obj)
+  obj_name = xml_obj.name
+  unless qbxml_class_defined?(obj_name) 
+    klass = Class.new(QbxmlBase)
+    get_schema_namespace.const_set(obj_name, klass) 
+    add_xml_template(klass, xml_obj.to_xml)
+  else
+    klass = get_schema_namespace.const_get(obj_name)
+  end
+  klass
+end
+
+end

data/lib/quickbooks/qbxml_base.rb

@@ -0,0 +1,212 @@
+# inheritance base for schema classes
+class Quickbooks::QbxmlBase
+  include Quickbooks::Support
+  include Quickbooks::Support::QBXML
+
+  extend  Quickbooks::Support
+  extend  Quickbooks::Support::API
+
+#QB_TYPE_CONVERSION_MAP= {
+  #"AMTTYPE"          => lambda {|d| String(d)},
+  #"BOOLTYPE"         => lambda {|d| String(d)},
+  #"DATETIMETYPE"     => lambda {|d| Date.parse(d)},
+  #"DATETYPE"         => lambda {|d| Date.parse(d)},
+  #"ENUMTYPE"         => lambda {|d| String(d)},
+  #"FLOATTYPE"        => lambda {|d| String(d)},
+  #"GUIDTYPE"         => lambda {|d| String(d)},
+  #"IDTYPE"           => lambda {|d| String(d)},
+  #"INTTYPE"          => lambda {|d| Integer(d)},
+  #"PERCENTTYPE"      => lambda {|d| Float(d)},
+  #"PRICETYPE"        => lambda {|d| Float(d)},
+  #"QUANTYPE"         => lambda {|d| Integer(d)},
+  #"STRTYPE"          => lambda {|d| String(d)},
+  #"TIMEINTERVALTYPE" => lambda {|d| String(d)}
+#}
+
+QB_TYPE_CONVERSION_MAP= {
+  "AMTTYPE"          => lambda {|d| String(d)},
+  "BOOLTYPE"         => lambda {|d| String(d)},
+  "DATETIMETYPE"     => lambda {|d| String(d)},
+  "DATETYPE"         => lambda {|d| String(d)},
+  "ENUMTYPE"         => lambda {|d| String(d)},
+  "FLOATTYPE"        => lambda {|d| String(d)},
+  "GUIDTYPE"         => lambda {|d| String(d)},
+  "IDTYPE"           => lambda {|d| String(d)},
+  "INTTYPE"          => lambda {|d| String(d)},
+  "PERCENTTYPE"      => lambda {|d| String(d)},
+  "PRICETYPE"        => lambda {|d| String(d)},
+  "QUANTYPE"         => lambda {|d| String(d)},
+  "STRTYPE"          => lambda {|d| String(d)},
+  "TIMEINTERVALTYPE" => lambda {|d| String(d)}
+}
+
+
+def initialize(params = nil)
+  return unless params.is_a?(Hash)
+  params.each do |k,v|
+    if self.respond_to?(k)
+      self.send("#{k}=", v)
+    end
+  end
+end
+
+
+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 = to_attribute_name(xml_template)
+    log.debug "to_qbxml#attr_name: #{attr_name}"
+
+    val = self.send(attr_name)
+    next unless val
+
+    case val
+    when Array
+      xml_nodes += build_qbxml_nodes(xml_template, val)
+    else
+      xml_nodes << build_qbxml_node(xml_template, val)
+    end
+    log.debug "to_qbxml#val: #{val}"
+  end
+
+  log.debug "to_qbxml#xml_nodes_size: #{xml_nodes.size}"
+  root.children = xml_nodes.join('')
+  root
+end
+
+
+def self.template(recursive = false, use_disk_cache = false)
+  if recursive
+    @template ||= load_template(true, use_disk_cache)
+  else build_template(false)
+  end
+end
+
+
+def self.attribute_names
+  instance_methods(false).reject { |m| m[-1..-1] == '=' || m =~ /_xml_class/} 
+end
+
+
+def inner_attributes
+  top_level_attrs = \
+    self.class.attribute_names.inject({}) do |h, m|
+      h[m] = self.send(m); h
+    end
+  
+  values = top_level_attrs.values.compact
+  if values.size > 1 || values.first.is_a?(Array)
+    attributes
+  else
+    values.first.inner_attributes
+  end
+end
+
+
+def attributes(recursive = true)
+  self.class.attribute_names.inject({}) do |h, m|
+    val = self.send(m)
+    if val
+      unless recursive
+        h[m] = val
+      else
+        h[m] = nested_attributes(val)
+      end
+    end; h
+  end
+end
+
+
+private
+
+# qbxml conversion
+
+def nested_attributes(val)
+  case val
+  when Quickbooks::QbxmlBase
+    val.attributes
+  when Array
+    val.inject([]) do |a, obj| 
+      case obj
+      when Quickbooks::QbxmlBase
+        a << obj.attributes 
+      else a << obj
+      end
+    end
+  else val
+  end
+end
+
+def build_qbxml_node(node, val)
+  case val
+  when Quickbooks::QbxmlBase
+    val.to_qbxml
+  else
+    node.children = val.to_s
+    node
+  end
+end
+
+def build_qbxml_nodes(node, val)
+  val.inject([]) do |a, v|
+    n = clone_qbxml_node(node,v)
+    a << n
+  end
+end
+
+def clone_qbxml_node(node, val)
+  n = node.clone
+  n.children = \
+    case val
+    when Quickbooks::QbxmlBase
+      val.to_qbxml 
+    else 
+      val.to_s
+    end; n
+end
+
+# qbxml class templates
+
+def self.load_template(recursive = false, use_disk_cache = false)
+  if use_disk_cache && File.exist?(template_cache_path)
+    YAML.load(File.read(template_cache_path))
+  else
+    log.info "Warning: on disk template is missing, rebuilding..." if use_disk_cache
+    template = build_template(recursive)
+    dump_template(template) if use_disk_cache
+    template
+  end
+end
+
+def self.build_template(recursive = false)
+  attribute_names.inject({}) do |h, a|
+    attr_type = self.send("#{a}_type") 
+    h[a] = (is_cached_class?(attr_type) && recursive) ? attr_type.build_template(true): attr_type.to_s; h
+  end
+end
+
+def self.dump_template(template)
+  File.open(template_cache_path, 'w') do |f|
+    f << template.to_yaml
+  end
+end
+
+def self.template_cache_path
+  "#{get_template_cache_path}/#{to_attribute_name(self)}.yml"
+end
+
+def self.schema_type
+  namespace = self.to_s.split("::")[1]
+  API::SCHEMA_MAP.find do |k,v|
+    simple_class_name(v[:namespace]) == namespace
+  end.first
+end
+
+
+end

data/lib/quickbooks/qbxml_parser.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+class Quickbooks::QbxmlParser
+  include Quickbooks::Support
+  include Quickbooks::Support::API
+  include Quickbooks::Support::QBXML
+
+attr_accessor :schema_type
+
+def initialize(schema_type)
+  @schema_type = schema_type
+end
+
+def parse_file(qbxml_file)
+  parse(qbxml_file.read)
+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
+    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)
+  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)
+  end
+  instance
+end
+
+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)
+  instance = get_schema_namespace.const_get(xml_obj.name).new
+  instance
+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
+    else
+      instance.send("#{attr_name}=", [cur_val, data])
+    end
+  end
+end
+
+
+end

data/lib/quickbooks/support/api.rb

@@ -0,0 +1,88 @@
+module Quickbooks::Support::API
+  include Quickbooks
+
+  API_ROOT = File.join(File.dirname(__FILE__), '..', '..', '..').freeze
+  XML_SCHEMA_PATH = File.join(API_ROOT, 'xml_schema').freeze   
+  RUBY_SCHEMA_PATH = File.join(API_ROOT, 'ruby_schema').freeze 
+
+  SCHEMA_MAP = {
+    :qb    => {:dtd_file => "qbxmlops70.xml", 
+               :namespace => QBXML, 
+               :container_class => lambda { Quickbooks::QBXML::QBXML },
+              }.freeze,
+    :qbpos => {:dtd_file => "qbposxmlops30.xml", 
+               :namespace => QBPOSXML, 
+               :container_class => lambda { Quickbooks::QBPOSXML::QBPOSXML },
+              }.freeze,
+  }.freeze
+
+  DEFAULT_LOG_LEVEL = 1
+
+private
+
+  def valid_schema_types
+    SCHEMA_MAP.keys
+  end
+
+  def valid_schema_type?
+    SCHEMA_MAP.include?(schema_type)
+  end
+
+  def get_dtd_file
+    "#{XML_SCHEMA_PATH}/#{SCHEMA_MAP[schema_type][:dtd_file]}" 
+  end
+
+  def get_schema_namespace
+    SCHEMA_MAP[schema_type][:namespace]
+  end
+
+  def get_container_class
+    SCHEMA_MAP[schema_type][:container_class].call
+  end
+
+  def get_disk_cache_path
+    "#{RUBY_SCHEMA_PATH}/#{schema_type.to_s}"
+  end
+
+  def get_template_cache_path
+    "#{RUBY_SCHEMA_PATH}/#{schema_type.to_s}/templates"
+  end
+
+  # fetches all the dynamically generated schema classes
+  def cached_classes
+    cached_classes = SCHEMA_MAP.inject({}) do |h, (schema_type, opts)|
+      namespace = opts[:namespace]
+      h[schema_type] = namespace.constants.map { |klass| namespace.const_get(klass) }; h
+    end
+    cached_classes[schema_type]
+  end
+
+  def is_cached_class?(klass)
+    SCHEMA_MAP.any? do |schema_type, opts|
+      namespace = opts[:namespace]
+      namespace.constants.include?(simple_class_name(klass))
+    end
+  end
+
+  def find_nested_key(hash, key)
+    hash.each do |k,v|
+      path = [k]
+      if k == key
+        return path
+      elsif v.is_a? Hash
+        nested_val = find_nested_key(v, key)
+        nested_val ? (return path + nested_val) : nil
+      end
+    end
+    return nil
+  end
+
+  def build_hash_wrapper(path, value)
+    hash_constructor = lambda { |h, k| h[k] = Hash.new(&hash_constructor) }
+
+    wrapped_data = Hash.new(&hash_constructor)
+    path.inject(wrapped_data) { |h, k| k == path.last ? h[k] = value: h[k] }
+    wrapped_data
+  end
+
+end

data/lib/quickbooks/support/class_builder.rb

@@ -0,0 +1,65 @@
+module Quickbooks::Support::ClassBuilder
+
+private
+
+def add_strict_attribute(klass, attr_name, type)
+  add_attribute_type(klass, attr_name, type)
+  
+  eval <<-class_body
+  class #{klass}
+    attr_accessor :#{attr_name}
+
+    def #{attr_name}=(obj)
+      expected_type = self.class.#{attr_name}_type
+      if obj.class == expected_type
+        @#{attr_name} = obj
+      elsif obj.is_a?(Hash)
+        @#{attr_name} = #{type}.new(obj)
+      else
+        raise(TypeError, "expecting an object of type \#{expected_type}") 
+      end
+    end
+  end
+  class_body
+end
+
+def add_casting_attribute(klass, attr_name, type)
+  type_casting_proc = klass::QB_TYPE_CONVERSION_MAP[type]
+  type = type_casting_proc.call(nil).class
+  add_attribute_type(klass, attr_name, type)
+
+  eval <<-class_body
+  class #{klass}
+    attr_accessor :#{attr_name}
+
+    def #{attr_name}=(obj)
+      type_casting_proc = QB_TYPE_CONVERSION_MAP["#{type}"] 
+      @#{attr_name} = type_casting_proc ? type_casting_proc.call(obj) : obj
+    end
+  end
+  class_body
+end
+
+def add_attribute_type(klass, attr_name, type)
+  eval <<-class_body
+  class #{klass}
+    @@#{attr_name}_type = #{type}
+    def self.#{attr_name}_type
+      #{type}
+    end
+  end
+  class_body
+end
+
+def add_xml_template(klass, xml_template)
+  eval <<-class_body
+  class #{klass}
+    def self.xml_template
+      #{xml_template.dump}
+    end
+  end
+  class_body
+end
+
+
+end

data/lib/quickbooks/support/logger.rb

@@ -0,0 +1,56 @@
+require 'forwardable'
+
+class Quickbooks::Support::Logger
+  extend Forwardable
+
+  def_delegators :@logger, :level, :flush, :auto_flushing=
+
+  DEFAULT_FORMATTER = "%s"
+  DEFAULT_PADDING = ""
+  PADDING_CHAR = " "
+
+  def initialize(log_file, log_level, log_count = nil, log_size = nil)
+    @logger = ActiveSupport::BufferedLogger.new(log_file, log_level)
+    @padding, @formatter = {}, {}
+  end
+
+  def buffer
+    buf = @logger.send(:buffer)
+    buf && buf.join('')
+  end
+
+  # overwrite all the logging methods
+  class_eval do
+    [:debug, :info, :warn, :error, :fatal, :unknown].each do |method|
+      define_method(method) do |message|
+        @logger.send(method, (padding + formatter) % message.to_s)
+      end
+    end
+  end
+
+  def indent(indent_level)
+    @padding[Thread.current] = \
+      if indent_level == :reset
+        ""
+      elsif indent_level > 0
+        padding + (PADDING_CHAR * indent_level)
+      else
+        padding[0..(-1+indent_level)]
+      end
+  end
+
+  def formatter=(format)
+    @formatter[Thread.current] = format
+  end
+
+protected
+
+  def padding
+    @padding[Thread.current] ||= DEFAULT_PADDING
+  end
+  
+  def formatter
+    @formatter[Thread.current] ||= DEFAULT_FORMATTER
+  end
+
+end

data/lib/quickbooks/support/qbxml.rb

@@ -0,0 +1,31 @@
+module Quickbooks::Support::QBXML
+
+  XML_DOCUMENT = Nokogiri::XML::Document
+  XML_NODE_SET = Nokogiri::XML::NodeSet
+  XML_NODE = Nokogiri::XML::Node
+  XML_ELEMENT = Nokogiri::XML::Element
+  XML_COMMENT= Nokogiri::XML::Comment
+  XML_TEXT = Nokogiri::XML::Text
+
+  COMMENT_START = "<!--"
+  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')
+    qbxml.map! { |l| l.strip }
+    qbxml.reject! { |l| l =~ COMMENT_MATCHER }
+    qbxml.join('')
+  end
+
+end