quickbooks_api 0.0.7 → 0.1.0

data/README

@@ -0,0 +1,74 @@
+INITIALIZATION
+------------------------------------------------------------------------------
+
+# supported data types are:
+# :qb    - Quickbooks
+# :qbpos - Quickbooks Point Of Sale
+
+api = Quickbooks::API.instance(:qbpos)
+
+# shorthand initialization
+api = Quickbooks::API[:qbpos]
+
+
+API INTROSPECTION
+------------------------------------------------------------------------------
+
+# returns all available wrapper classes
+api.qbxml_classes
+
+# returns the top level wrapper class for the api
+api.container
+
+# find specific qbxml class by name
+api.find('customer_mod_rq')
+
+# find all qbxml classes that contain a pattern
+api.grep(/_mod_rq/)
+
+# returns a hash of all the data types for a wrapper class
+wrapper_class.template
+
+# returns the full teplate for a wrapper class (SLOOOW for top level classes)
+wrapper_class.template(true)
+
+# returns all the supported fields for the wrapper class
+wrapper_class.attribute_names
+
+# returns the qbxml template used to generate the wrapper class
+wrapper_class.xml_template
+
+
+QBXML TO RUBY
+------------------------------------------------------------------------------
+
+# wrap qbxml data in a qbxml object
+o = api.qbxml_to_obj(qbxml)
+
+# convert qbxml object to hash
+o.inner_attributes
+
+# same as above but includes the top level containers
+o.attributes
+
+# retrieves attributes from nested objects
+o.attributes(true)
+
+# directly convert raw qbxml to a hash
+h = api.qbxml_to_hash(qbxml)
+
+# same as above but includes the top level containers 
+h = api.qbxml_to_hash(qbxml, true) 
+
+
+RUBY TO QBXML
+------------------------------------------------------------------------------
+
+# convert a hash to a qbxml object (automagically creates the top level containers)
+o = api.hash_to_obj(data_hash)
+
+# convert a qbxml object to raw qbxml
+o.to_qbxml.to_s
+
+# convert a hash directly to raw qbxml
+qbxml = api.hash_to_qbxml(data_hash)

data/TODO

@@ -0,0 +1,5 @@
+- tests
+- support for node type constraints and validation
+- hash to obj doesn't work when converting from an inner level hash ex. 'customer_mod_rq'
+- add processing instruction to node set <?qbposxml version="3.0"?>
+- handle node attributes properly

data/lib/quickbooks.rb

@@ -1,17 +1,19 @@
 require 'rubygems'
-require 'ruby2ruby' # must be version 1.2.1 of ruby2ruby
-require 'nokogiri'
-require 'active_support'
-require 'active_support/core_ext'
 
 module Quickbooks; end
+module Quickbooks::QBXML; end
+module Quickbooks::QBPOSXML; end
+module Quickbooks::Support; end
+module Quickbooks::Parser; end
 
-require 'quickbooks/support'
-require 'quickbooks/support/api'
-require 'quickbooks/support/logger'
-require 'quickbooks/support/qbxml'
-require 'quickbooks/support/class_builder'
-require 'quickbooks/qbxml_base'
+require 'quickbooks/support/monkey_patches'
+require 'quickbooks/support/inflection'
+require 'quickbooks/logger'
+require 'quickbooks/config'
+require 'quickbooks/parser/xml_parsing'
+require 'quickbooks/parser/xml_generation'
+require 'quickbooks/parser/class_builder'
+require 'quickbooks/parser/qbxml_base'
 require 'quickbooks/qbxml_parser'
 require 'quickbooks/dtd_parser'
 require 'quickbooks/api'

data/lib/quickbooks/api.rb

@@ -1,143 +1,103 @@
 class Quickbooks::API
-  include Quickbooks::Support
-  include Quickbooks::Support::API
-  include Quickbooks::Support::QBXML
+  include Quickbooks::Logger
+  include Quickbooks::Config
+  include Quickbooks::Support::Inflection
 
-attr_reader :dtd_parser, :qbxml_parser, :schema_type
-@@instances = {}
+  attr_reader :dtd_parser, :qbxml_parser, :schema_type
+  private_class_method :new
+  @@instances = {}
 
-def initialize(schema_type = nil, opts = {})
-  @schema_type = schema_type
-  use_disk_cache, log_level = opts.values_at(:use_disk_cache, :log_level)
+  def initialize(schema_type = nil, opts = {})
+    self.class.check_schema_type!(schema_type)
+    @schema_type = schema_type
 
-  unless valid_schema_type?
-    raise(ArgumentError, "schema type required: #{valid_schema_types.inspect}") 
-  end
+    @dtd_parser = Quickbooks::DtdParser.new(schema_type)
+    @qbxml_parser = Quickbooks::QbxmlParser.new(schema_type)
 
-  @dtd_file = get_dtd_file
-  @dtd_parser = DtdParser.new(schema_type)
-  @qbxml_parser = QbxmlParser.new(schema_type)
+    load_qb_classes
+    @@instances[schema_type] = self
+  end
 
-  load_qb_classes(use_disk_cache)
-  @@instances[schema_type] = self
-end
+  # simple singleton constructor without caching support
+  #
+  def self.[](schema_type)
+    @@instances[schema_type] || new(schema_type)
+  end
 
-# returns the last created api instance
-def self.[](schema_type)
-  @@instances[schema_type] || self.new(schema_type)
-end
+  # full singleton constructor
+  #
+  def self.instance(schema_type = nil, opts = {})
+    @@instances[schema_type] || new(schema_type, opts)
+  end
 
-def container
-  get_container_class
-end
+  # user friendly api decorators. Not used anywhere else.
+  # 
+  def container
+    container_class
+  end
 
-def qbxml_classes
-  cached_classes
-end
+  def qbxml_classes
+    cached_classes
+  end
 
-def find(class_name)
-  class_name = class_name.to_s
-  cached_classes.find { |c| to_attribute_name(c) == class_name }
-end
+  # api introspection
+  #
+  def find(class_name)
+    cached_classes.find { |c| underscore(c) == class_name.to_s }
+  end
 
-def grep(pattern)
-  case pattern
-  when Regexp
-    cached_classes.select { |c| to_attribute_name(c).match(pattern) }
-  when String
-    cached_classes.select { |c| to_attribute_name(c).include?(pattern) }
+  def grep(pattern)
+    cached_classes.select { |c| underscore(c).match(/#{pattern}/) }
   end
-end
 
-# QBXML 2 RUBY
+  # QBXML 2 RUBY
 
-def qbxml_to_obj(qbxml)
-  case qbxml
-  when IO
-    qbxml_parser.parse_file(qbxml)
-  else
+  def qbxml_to_obj(qbxml)
     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
+  def qbxml_to_hash(qbxml, include_container = false)
+    if include_container
+      qbxml_to_obj(qbxml).attributes
+    else
+      qbxml_to_obj(qbxml).inner_attributes
+    end
   end
-end
-
 
-# RUBY 2 QBXML
+  # RUBY 2 QBXML
 
-def hash_to_obj(data)
-  key = data.keys.first
-  value = data[key]
+  def hash_to_obj(data)
+    key, value = data.detect { |name, value| name != :xml_attributes }
+    key_path = container_class.template(true).path_to_nested_key(key.to_s)
+    raise(RuntimeError, "#{key} class not found in api template") unless key_path
 
-  key_path = find_nested_key(container.template(true), key.to_s)
-  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
-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
+    wrapped_data = Hash.nest(key_path, value)
+    container_class.new(wrapped_data)
+  end
 
+  def hash_to_qbxml(data)
+    hash_to_obj(data).to_qbxml
+  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)
+  def load_qb_classes
+    rebuild_schema_cache(false)
+    load_full_container_template
+    container_class
   end
 
-  # load the container class template into memory (significantly speeds up wrapping of partial data hashes)
-  get_container_class.template(true, use_disk_cache, use_disk_cache)
-  true
-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
+  # rebuilds schema cache in memory
+  #
+  def rebuild_schema_cache(force = false)
+    dtd_parser.parse_file(dtd_file) if (cached_classes.empty? || force)
   end
-end
-
-def self.log
-  @@log ||= Logger.new(STDOUT, DEFAULT_LOG_LEVEL)
-end
 
+  # load the recursive container class template into memory (significantly
+  # speeds up wrapping of partial data hashes)
+  # 
+  def load_full_container_template(use_disk_cache = false)
+      container_class.template(true)
+  end
 
 end

data/lib/quickbooks/config.rb

@@ -0,0 +1,59 @@
+module Quickbooks::Config
+
+  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 => Quickbooks::QBXML, 
+               :container_class => 'QBXML'
+              }.freeze,
+    :qbpos => {:dtd_file => "qbposxmlops30.xml", 
+               :namespace => Quickbooks::QBPOSXML, 
+               :container_class => 'QBPOSXML'
+              }.freeze,
+  }.freeze
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+private
+
+  def container_class
+    schema_namespace.const_get(SCHEMA_MAP[schema_type][:container_class])
+  end
+
+  def dtd_file
+    "#{XML_SCHEMA_PATH}/#{SCHEMA_MAP[schema_type][:dtd_file]}" 
+  end
+
+  def schema_namespace
+    SCHEMA_MAP[schema_type][:namespace]
+  end
+
+# introspection
+  
+  def cached_classes
+    schema_namespace.constants.map { |const| schema_namespace.const_get(const) }
+  end
+
+module ClassMethods
+
+  def check_schema_type!(schema_type)
+    unless SCHEMA_MAP.include?(schema_type)
+      raise(ArgumentError, "valid schema type required: #{valid_schema_types.inspect}") 
+    end
+  end
+
+private
+
+  def valid_schema_types
+    SCHEMA_MAP.keys
+  end
+
+end
+
+
+end

data/lib/quickbooks/dtd_parser.rb

@@ -1,47 +1,42 @@
 class Quickbooks::DtdParser < Quickbooks::QbxmlParser
-  include Quickbooks::Support::ClassBuilder
-
-def parse_file(qbxml_file)
-  parse( 
-    cleanup_qbxml(
-      File.read(qbxml_file)))
-end
+  include Quickbooks::Parser::ClassBuilder
 
 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)
+  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
-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)
+  def process_non_leaf_node(xml_obj, parent_class)
+    klass = build_qbxml_class(xml_obj)
+    attr_name = underscore(xml_obj)
+    if parent_class
+      add_strict_attribute(parent_class, attr_name, klass)
+    end
+    klass
   end
-  klass
-end
 
-def process_comment_node(xml_obj, parent_class)
-  parent_class
-end
-
-# helpers
+  #TODO: stub
+  def process_comment_node(xml_obj, parent_class)
+    parent_class
+  end
 
-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) 
-    xml_obj = set_required_attributes(xml_obj)
-    add_xml_template(klass, xml_obj.to_xml)
-  else
-    klass = get_schema_namespace.const_get(obj_name)
+  # helpers
+
+  def build_qbxml_class(xml_obj)
+    obj_name = xml_obj.name
+    unless schema_namespace.const_defined?(obj_name)
+      klass = Class.new(Quickbooks::Parser::QbxmlBase)
+      schema_namespace.const_set(obj_name, klass) 
+      klass.xml_attributes = parse_xml_attributes(xml_obj)
+      add_xml_template(klass, xml_obj.to_xml)
+    else
+      klass = schema_namespace.const_get(obj_name)
+    end
+    klass
   end
-  klass
-end
 
 end