mrglass-qbxml 1.0.0

data/lib/qbxml/hash.rb

@@ -0,0 +1,188 @@
+# XML Conversion References
+#
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/conversions.rb
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/xml_mini/nokogiri.rb
+#
+#
+class Qbxml::Hash < ::Hash
+  include Qbxml::Types
+
+  CONTENT_ROOT = '__content__'.freeze
+  ATTR_ROOT    = 'xml_attributes'.freeze
+  IGNORED_KEYS = [ATTR_ROOT]
+
+  
+  def self.from_hash(hash, opts = {}, &block)
+    key_proc = \
+      if opts[:camelize]
+        lambda { |k|
+          # QB wants things like ListID, not ListId. Adding inflections then using camelize can accomplish
+          # the same thing, but then the inflections will apply to everything the user does everywhere.
+          k.camelize.gsub(Qbxml::Types::ACRONYM_REGEXP) { "#{$1}#{$2.upcase}#{$3}" }
+        }
+      elsif opts[:underscore]
+        lambda { |k| k.underscore } 
+      end
+
+    deep_convert(hash, opts, &key_proc)
+  end
+
+  def to_xml(opts = {})
+    self.class.to_xml(self, opts)
+  end
+
+  def self.to_xml(hash, opts = {})
+    opts[:root], hash = hash.first
+    opts[:attributes] = hash.delete(ATTR_ROOT)
+    hash_to_xml(hash, opts)
+  end
+
+  def self.from_xml(xml, opts = {})
+    from_hash(
+      xml_to_hash(Nokogiri::XML(xml).root, {}, opts), opts)
+  end
+
+private
+
+  def self.hash_to_xml(hash, opts = {})
+    opts = opts.dup
+    opts[:indent]          ||= 2
+    opts[:root]            ||= :hash
+    opts[:attributes]      ||= (hash.delete(ATTR_ROOT) || {})
+    opts[:builder]         ||= Builder::XmlMarkup.new(indent: opts[:indent])
+    opts[:skip_types]      = true unless opts.key?(:skip_types) 
+    opts[:skip_instruct]   = false unless opts.key?(:skip_instruct)
+    builder = opts[:builder]
+    
+    unless opts.delete(:skip_instruct)
+      builder.instruct!(:xml, :encoding => "ISO-8859-1")
+      builder.instruct!(opts[:schema], version: opts[:version])
+    end
+
+    builder.tag!(opts[:root], opts.delete(:attributes)) do
+      hash.each do |key, val| 
+        case val
+        when Hash
+          self.hash_to_xml(val, opts.merge({root: key, skip_instruct: true}))
+        when Array
+          val.map { |i|
+            if i.is_a?(String)
+              next builder.tag!(key, i, {})
+            end
+            next self.hash_to_xml(i, opts.merge({root: key, skip_instruct: true}))
+          }
+        else
+          builder.tag!(key, val, {})
+        end
+      end
+
+      yield builder if block_given?
+    end
+  end
+  
+  def self.xml_to_hash(node, hash = {}, opts = {})
+    node_hash = {CONTENT_ROOT => '', ATTR_ROOT => {}}
+    name = node.name
+    schema = opts[:schema]
+    opts[:typecast_cache] ||= {}
+    opts[:is_repetitive_cache] ||= {}
+
+    # Insert node hash into parent hash correctly.
+    case hash[name]
+      when Array
+        hash[name] << node_hash
+      when Hash, String
+        # This parent has multiple nodes with the same name, but when we checked the first time,
+        # we found it is not defined as repetitive. I guess this means the schema is a liar.
+        hash[name] = [hash[name], node_hash]
+      else
+        # We didn't see this node name under this parent yet.
+        if is_repetitive?(schema, node.path, opts[:is_repetitive_cache])
+          hash[name] = [node_hash]
+        else
+          hash[name] = node_hash
+        end
+    end
+
+    # Handle child elements
+    node.children.each do |c|
+      if c.element?
+        xml_to_hash(c, node_hash, opts)
+      elsif c.text? || c.cdata?
+        node_hash[CONTENT_ROOT] << c.content
+      end
+    end
+
+    # Handle attributes
+    node.attribute_nodes.each { |a| node_hash[ATTR_ROOT][a.node_name] = a.value }
+
+    # TODO: Strip text
+    # node_hash[CONTENT_ROOT].strip!
+
+    # Format node
+    if node_hash.size > 2 || node_hash[ATTR_ROOT].present?
+      node_hash.delete(CONTENT_ROOT)
+    elsif node_hash[CONTENT_ROOT].present?
+      node_hash.delete(ATTR_ROOT)
+      v = schema ? typecast(schema, node.path, node_hash[CONTENT_ROOT], opts[:typecast_cache]) : node_hash[CONTENT_ROOT]
+      # We only updated the last element
+      if hash[name].is_a?(Array)
+        hash[name].pop
+        hash[name] << v
+      else
+        hash[name] = v
+      end
+    else
+      hash[name] = node_hash[CONTENT_ROOT]
+    end
+
+    hash
+  end
+
+
+private
+
+  def self.typecast(schema, xpath, value, typecast_cache)
+    type_path = xpath.gsub(/\[\d+\]/,'')
+    # This is fairly expensive. Cache it for better performance when parsing lots of records of the same type.
+    type_proc = typecast_cache[type_path] ||= Qbxml::TYPE_MAP[schema.xpath(type_path).first.try(:text)]
+    raise "#{xpath} is not a valid type" unless type_proc
+    type_proc[value]
+  end
+
+  # Determines if the node is repetitive. Just because something is repetitive doesn't mean it always repeats.
+  # For example, a customer query could return 1 result or 100, but in both cases, we should be returning an
+  # Array.
+  def self.is_repetitive?(schema, xpath, is_repetitive_cache)
+    # Yes, we are parsing comments.
+    comment_path = xpath.gsub(/\[\d+\]/,'') + "/comment()"
+    return is_repetitive_cache[comment_path] || parse_repetitive_from_comment(schema, comment_path)
+  end
+
+  def self.parse_repetitive_from_comment(schema, comment_path)
+    comment = schema.xpath(comment_path).first
+    return false if comment.nil?
+    return comment.text.include?('may rep')
+  end
+
+  def self.deep_convert(hash, opts = {}, &block)
+    hash.inject(self.new) do |h, (k,v)|
+      k = k.to_s
+      ignored = IGNORED_KEYS.include?(k) 
+      if ignored
+        h[k] = v
+      else
+        key = block_given? ? yield(k) : k
+        h[key] = \
+          case v
+          when Hash
+            deep_convert(v, &block)
+          when Array
+            v.map { |i| i.is_a?(Hash) ? deep_convert(i, &block) : i }
+          else v
+          end
+      end; h
+    end
+  end
+
+end

data/lib/qbxml/qbxml.rb

@@ -0,0 +1,124 @@
+class Qbxml
+  include Types
+
+  SCHEMA_PATH = File.expand_path('../../../schema', __FILE__)
+
+  SCHEMAS = {
+    qb: {
+      "2.0" => "#{SCHEMA_PATH}/qbxmlops20.xml",
+      "CA3.0" => "#{SCHEMA_PATH}/qbxmlopsCA30.xml",
+      "3.0" => "#{SCHEMA_PATH}/qbxmlops30.xml",
+      "4.0" => "#{SCHEMA_PATH}/qbxmlops40.xml",
+      "4.1" => "#{SCHEMA_PATH}/qbxmlops41.xml",
+      "5.0" => "#{SCHEMA_PATH}/qbxmlops50.xml",
+      "6.0" => "#{SCHEMA_PATH}/qbxmlops60.xml",
+      "7.0" => "#{SCHEMA_PATH}/qbxmlops70.xml",
+      "8.0" => "#{SCHEMA_PATH}/qbxmlops80.xml",
+      "10.0" => "#{SCHEMA_PATH}/qbxmlops100.xml",
+      "11.0" => "#{SCHEMA_PATH}/qbxmlops110.xml",
+      "12.0" => "#{SCHEMA_PATH}/qbxmlops120.xml",
+      "13.0" => "#{SCHEMA_PATH}/qbxmlops130.xml",
+      "14.0" => "#{SCHEMA_PATH}/qbxmlops140.xml"
+    },
+    qbpos: {
+      "3.0" => "#{SCHEMA_PATH}/qbposxmlops30.xml"
+    }
+  }.freeze
+
+  HIDE_IVARS = [:@doc].freeze
+
+  def initialize(key = :qb, version = "7.0")
+    @schema  = key
+    @version = version
+    @doc     = parse_schema(key, version)
+  end
+
+  # returns all xml nodes matching a specified pattern
+  #
+  def types(pattern = nil)
+    @types ||= @doc.xpath("//*").map { |e| e.name }.uniq
+
+    pattern ?
+      @types.select { |t| t =~ Regexp.new(pattern) } :
+      @types
+  end
+
+  # returns the xml node for the specified type
+  #
+  def describe(type)
+    @doc.xpath("//#{type}").first
+  end
+
+  # converts a hash to qbxml with optional validation
+  #
+  def to_qbxml(hash, opts = {})
+    hash = Qbxml::Hash.from_hash(hash, camelize: true)
+    hash = namespace_qbxml_hash(hash) unless opts[:no_namespace] 
+    validate_qbxml_hash(hash) if opts[:validate]
+
+    Qbxml::Hash.to_xml(hash, schema: XML_DIRECTIVES[@schema], version: @version)
+  end
+
+  # converts qbxml to a hash
+  #
+  def from_qbxml(xml, opts = {})
+    hash = Qbxml::Hash.from_xml(xml, underscore: true, schema: @doc)
+
+    opts[:no_namespace] ? hash : namespace_qbxml_hash(hash)
+  end
+
+  # making this more sane so that it doesn't dump the whole schema doc to stdout
+  # every time
+  #
+  def inspect
+    prefix = "#<#{self.class}:0x#{self.__id__.to_s(16)} "
+
+    (instance_variables - HIDE_IVARS).each do |var|
+      prefix << "#{var}=#{instance_variable_get(var).inspect}"
+    end
+
+    return "#{prefix}>"
+  end
+
+# private
+
+  def parse_schema(key, version)
+    File.open(select_schema(key, version)) { |f| Nokogiri::XML(f) }
+  end
+
+  def select_schema(schema_key, version)
+    # Try to handle it if a user gave us a numeric version. Assume 1 decimal.
+    version = '%.1f' % version if version.is_a?(Numeric)
+    raise "invalid schema '#{schema_key}', must be one of #{SCHEMAS.keys.inspect}" if !SCHEMAS.has_key?(schema_key)
+    raise "invalid version '#{version}' for schema #{schema_key}, must be one of #{SCHEMAS[schema_key].keys.inspect}" if !SCHEMAS[schema_key].has_key?(version)
+    return SCHEMAS[schema_key][version]
+  end
+
+# hash to qbxml
+
+  def namespace_qbxml_hash(hash)
+    node = describe(hash.keys.first)
+    return hash unless node
+
+    path = node.path.split('/')[1...-1].reverse
+    path.inject(hash) { |h,p| Qbxml::Hash[ p => h ] }
+  end
+
+  def validate_qbxml_hash(hash, path = [])
+    hash.each do |k,v|
+      next if k == Qbxml::Hash::ATTR_ROOT
+      key_path = path.dup << k
+      if v.is_a?(Hash)
+        validate_qbxml_hash(v, key_path)
+      else
+        validate_xpath(key_path)
+      end
+    end
+  end
+
+  def validate_xpath(path)
+    xpath = "/#{path.join('/')}"
+    raise "#{xpath} is not a valid type" if @doc.xpath(xpath).empty?
+  end
+
+end

data/lib/qbxml/types.rb

@@ -0,0 +1,45 @@
+module Qbxml::Types
+  require 'bigdecimal'
+
+  
+  XML_DIRECTIVES = {
+    :qb => :qbxml,
+    :qbpos => :qbposxml
+  }.freeze
+
+  FLOAT_CAST = Proc.new {|d| d ? d.to_f : 0.0}
+  BOOL_CAST  = Proc.new {|d| d ? (d.to_s.downcase == 'true' ? true : false) : false }
+  DATE_CAST  = Proc.new {|d| d ? Date.parse(d).strftime("%Y-%m-%d") : Date.today.strftime("%Y-%m-%d") }
+  TIME_CAST  = Proc.new {|d| d ? Time.parse(d).xmlschema : Time.now.xmlschema }
+  INT_CAST   = Proc.new {|d| d ? Integer(d.to_i) : 0 }
+  STR_CAST   = Proc.new {|d| d ? String(d) : ''}
+  BIGDECIMAL_CAST = Proc.new {|d| d ? BigDecimal(d) : 0.0}
+
+  TYPE_MAP= {
+    "AMTTYPE"          => FLOAT_CAST,
+    "BOOLTYPE"         => BOOL_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"         => BIGDECIMAL_CAST,
+    "STRTYPE"          => STR_CAST,
+    "TIMEINTERVALTYPE" => STR_CAST
+  }
+
+  # Strings in tag names that should be capitalized in QB's XML
+  ACRONYMS = ['AP', 'AR', 'COGS', 'COM', 'UOM', 'QBXML', 'UI', 'AVS', 'ID',
+              'PIN', 'SSN', 'COM', 'CLSID', 'FOB', 'EIN', 'UOM', 'PO', 'PIN', 'QB']
+
+  # Based on the regexp in ActiveSupport::Inflector.camelize
+  # Substring 1: Start of string, lower case letter, or slash
+  # Substring 2: One of the acronyms above, In Capitalized Casing
+  # Substring 3: End of string or capital letter
+  ACRONYM_REGEXP = Regexp.new("(?:(^|[a-z]|\\/))(#{ACRONYMS.map{|a| a.capitalize}.join("|")})([A-Z]|$)")
+
+end

data/lib/qbxml/version.rb

@@ -0,0 +1,3 @@
+class Qbxml
+  VERSION = "1.0.0"
+end

data/lib/qbxml.rb

@@ -0,0 +1,11 @@
+require "qbxml/version"
+
+require 'nokogiri'
+require 'active_support/builder'
+require 'active_support/core_ext/string'
+
+class Qbxml; end
+
+require_relative 'qbxml/types.rb'
+require_relative 'qbxml/qbxml.rb'
+require_relative 'qbxml/hash.rb'

data/qbxml.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qbxml/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mrglass-qbxml"
+  gem.version       = Qbxml::VERSION
+  gem.authors       = ["Alex Skryl", "Jason Barnabe"]
+  gem.email         = ["rut216@gmail.com", "jason.barnabe@gmail.com"]
+  gem.description   = %q{Quickbooks XML Parser}
+  gem.summary       = %q{Quickbooks XML Parser and Validation Tool}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('activesupport', '>= 5.0.0')
+  gem.add_dependency('nokogiri', '~> 1.5')
+  gem.add_dependency('builder', '~> 3.0')
+
+  gem.add_development_dependency('pry')
+  gem.add_development_dependency('pry-nav')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('appraisal')
+end