quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/xsd/complex_type.rb

@@ -0,0 +1,77 @@
+module Quickbooks
+  class XSD
+    class Type
+    end
+    class ComplexType < Type
+      attr_reader :name
+      attr_accessor :restriction
+
+      def initialize(attributes={})
+        @name = attributes.delete('name')
+        @items = attributes.delete(:items)
+        warn "!! Unhandled complex type attributes: #{attributes.keys.join(', ')}" if !attributes.empty?
+      end
+
+      def items
+        @items ||= []
+      end
+
+      def <<(something)
+        items << something
+      end
+
+      def merge(attributes)
+        self.class.new({'name' => @name}.merge(attributes))
+      end
+
+      def clone
+        self.class.new('name' => @name, :items => items.map {|i| i.clone})
+      end
+
+      def inspect
+        sprintf("... >%s", items.map{|i|i.inspect.gsub(/\n/,"\n  ")})
+      end
+
+      def validate(object,required=true)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating CONFORMS TO #ComplexType #{name} (#{required ? 'REQUIRED' : 'OPTIONAL'})" if $DEBUG
+        r = items.inject(Valean.new) {|r,i| r << i.validate(object,required?(i)); r}
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def find(key)
+        children.select {|i| i.name == key}[0]
+      end
+
+      def include?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          children.collect {|e| e.name}.include?(key_or_xsd) :
+          (key_or_xsd == self || items.any? {|i| i.include?(key_or_xsd)})
+      end
+
+      def index(key)
+        children.collect {|e| e.name}.index(key.to_s)
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is allowed more than once in its parent.
+      def repeatable?(key)
+        items.any? {|i| i.include?(key) && i.repeatable?(key)}
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is required within its container.
+      def required?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          items.any? {|i| i.include?(key_or_xsd) && i.required?(key_or_xsd)} :
+          (key_or_xsd == self || items.select {|i| i.include?(key_or_xsd)}.any? {|i| i.required?(key_or_xsd)})
+      end
+
+      def children
+        children = []
+        items.each {|i| i.is_a?(Quickbooks::XSD::Element) ? children << i : children.concat(i.children)}
+        children
+      end
+    end
+  end
+end

data/lib/quickbooks/xsd/element.rb

@@ -0,0 +1,214 @@
+require 'quickbooks/element'
+require 'quickbooks/property'
+module Quickbooks
+  class XSD
+    # The basic Element.
+    class Element
+      attr_reader :ref, :minOccurs, :maxOccurs
+      cascading_attr_reader :name, :type, :default
+
+      def initialize(attributes={})
+        @parent = attributes.delete(:parent)
+        @name = attributes.delete('name')
+        self.type = attributes.delete('type') if attributes.has_key?('type')
+        @default = attributes.delete('default') # or nil
+        @minOccurs = (attributes.delete('minOccurs') || 1).to_i # default is 1, unless otherwise stated
+        @maxOccurs = attributes.delete('maxOccurs') # or nil
+        @ref = attributes.delete('ref') # or nil
+        warn "!! Unhandled attributes: #{attributes.keys.join(', ')}" if !attributes.empty?
+      end
+
+      def type=(type_or_name)
+        return unless type_or_name
+        if (@type ||= nil).nil?
+          @type = type_or_name.is_a?(Quickbooks::XSD::Type) ? type_or_name : SimpleType.new('name' => type_or_name)
+        else
+          @type.merge!(type) if type_or_name.is_a?(Quickbooks::XSD::Type)
+        end
+      end
+
+      attr_reader :parent
+      private :parent
+
+      def complex?
+        type.is_a?(ComplexType)
+      end
+      alias :is_element? :complex?
+      def simple?
+        type.is_a?(SimpleType)
+      end
+      alias :is_property? :simple?
+      def is_model?
+        name.to_s =~ /Ret$/
+      end
+      def kind
+        # TODO: [Multi-mode] Should return Quickbooks::V6_0::Element or Quickbooks::VCA3_0::Element
+        complex? ? Quickbooks::Element : Quickbooks::Property
+      end
+
+      def gsub!(*args,&block)
+        if block_given?
+          @name = name.gsub(*args) {|*a| yield(*a)} if name.is_a?(String)
+          children.each {|c| c.gsub!(*args) {|*a| yield(*a)}}
+        else
+          @name = name.gsub(*args) if name.is_a?(String)
+          children.each {|c| c.gsub!(*args)}
+        end
+        self
+      end
+      def gsub(*args,&block)
+        if block_given?
+          clone.gsub!(*args) {|*a| yield(*a)}
+        else
+          clone.gsub!(*args)
+        end
+      end
+      def clone
+        self.class.new(:parent => @parent, 'name' => "#{name}", 'type' => type.clone, 'default' => @default, 'minOccurs' => @minOccurs, 'maxOccurs' => @maxOccurs, 'ref' => @ref)
+      end
+
+      def merge(attributes)
+        self.class.new({:parent => self, 'name' => name, 'type' => type, 'default' => @default, 'minOccurs' => @minOccurs, 'maxOccurs' => @maxOccurs, 'ref' => @ref}.merge(attributes))
+      end
+
+      def merge!(attributes)
+        @name = attributes.delete('name') || @name
+        self.type = attributes.delete('type') if attributes.has_key?('type')
+        @default = attributes.delete('default') || @default
+        @minOccurs = (attributes.delete('minOccurs') || @minOccurs).to_i
+        @maxOccurs = attributes.delete('maxOccurs') || @maxOccurs
+        @ref = attributes.delete('ref') || @ref
+        return self
+      end
+
+      def <<(something)
+        case something
+        when SimpleType
+          self.type = something
+        when ComplexType
+          self.type = something
+        else
+          warn "Something (#{something.inspect}) not handled by #{inspect}"
+        end
+      end
+
+      def inspect
+        sprintf("\n<%s%s %s", name || ref, (@minOccurs == 0 ? (@maxOccurs == 'unbounded' ? '*' : '?') : (@maxOccurs == 'unbounded' ? '+' : '')), type.inspect) + (type.is_a?(ComplexType) ? '' : '>')
+      end
+
+      def to_class(klass_name)
+        puts "Classifying #{klass_name}/#{kind}..." if $DEBUG
+        begin
+          if name == klass_name+'Ret' || name == klass_name+'Add' || name == klass_name+'Mod'
+            # Generate a Model
+            # TODO: [Multi-mode] Should generate Quickbooks::V6_0::Models or Quickbooks::VCA3_0::Models container modules on-demand
+            const = Quickbooks::Models.const_set(klass_name, ::Class.new(Quickbooks::Model))
+
+            const.write_xsd(Quickbooks.xsd["#{klass_name}Add"].gsub(/Add$/,'')) if Quickbooks.xsd.include?("#{klass_name}Add")
+            const.read_write_xsd(
+              Quickbooks.xsd["#{klass_name}Mod"].gsub(/(.*)Mod$/) {|m| Quickbooks.xsd.include?(m.gsub(/Mod$/,'Ret')) ? m.gsub(/Mod$/,'') : m}
+            )                                                                   if Quickbooks.xsd.include?("#{klass_name}Mod")
+
+            const.read_xsd(Quickbooks.xsd["#{klass_name}Ret"].gsub(/Ret$/,''))  if Quickbooks.xsd.include?("#{klass_name}Ret")
+
+            const.query_xsd(Quickbooks.xsd["#{klass_name}QueryRq"])             if Quickbooks.xsd.include?("#{klass_name}QueryRq")
+
+          else
+            # Generate an Element
+            # TODO: [Multi-mode] Should generate Quickbooks::V6_0::Elements or Quickbooks::VCA3_0::Elements container modules on-demand
+            const = kind.pluralize.const_set(klass_name, ::Class.new(kind))
+            const.xsd = self
+          end
+        rescue => e
+          raise e, "Error: #{e.inspect}\n#{e.backtrace.join("\n")}"
+        end
+        return const
+      end
+
+      include Validation
+      # Validate the object's properties, or validate that this property exists within the object.
+      def validate(object,required=true)
+        if object.class.short_name == name || (object.is_a?(Hash) && object.has_key?(name))
+          # Validate the object's contents
+          object = object[name] if object.is_a?(Hash)
+          puts "#{$DEBUG<<"\t"}Validating\n#{object.inspect}\n#{$DEBUG} CONFORMS TO #{name} (#{required ? 'REQUIRED' : 'OPTIONAL'})" if $DEBUG
+          r = type.validate(object,required?(type))
+          $DEBUG.chop! if $DEBUG
+        else
+          puts "#{$DEBUG<<"\t"}Validating #{required ? 'REQUIRED' : 'OPTIONAL'} #{name}" if $DEBUG
+          # Validate this (self) property of object
+          # puts "Validating #{inspect} IN #{object.inspect}"
+          # A) am I required?
+          r = Valean.new(name,required)
+          # B) do I exist?
+          r.exists! if exists_in?(object)
+          # C) if exists, do I validate with my own requirements?
+          objects = object[name].is_a?(Enumerable) ? object[name] : [object[name]]
+          r << validate_these(objects) if r.exists?
+          $DEBUG.chop! if $DEBUG
+        end
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def exists_in?(object)
+        !(object[name].is_a?(Enumerable) ? object[name].empty? : object[name].nil?)
+      end
+
+      def find(key)
+        name == key ? self : children.select {|i| i.name == key}[0]
+      end
+      alias :[] :find
+
+      # Report whether a named Quickbooks::XSD::Element or any xsd object is a descendent of self.
+      def include?(key_or_xsd)
+        raise "#{self} not defined properly! This is a BUG! Please report to behindlogic.lighthouseapp.com." if !key_or_xsd.is_a?(String) && type.nil?
+        key_or_xsd.is_a?(String) ?
+          (name == key_or_xsd ? true : children.collect {|e| e.name}.include?(key_or_xsd)) :
+          (key_or_xsd == self || type.include?(key_or_xsd))
+      end
+
+      # Report the position of a named Quickbooks::XSD::Element
+      def index(key)
+        children.collect {|e| e.name}.index(key.to_s)
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is allowed more than once in its parent.
+      def repeatable?(key=nil)
+        if key
+          found = find(key)
+          return nil unless found
+          found.repeatable? || type.repeatable?(key)
+        else
+          @maxOccurs == 'unbounded'
+        end
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is required within its container.
+      def required?(key_or_xsd)
+        if key_or_xsd.is_a?(String)
+          if found = find(key_or_xsd)
+            found.required?(found) || type.required?(found)
+          else
+            nil
+          end
+        else
+          (key_or_xsd == self && @minOccurs > 0) || type.required?(key_or_xsd)
+        end
+      end
+
+      def attributes
+        children.collect {|i| i.name}
+      end
+
+      # Return the closest-descended child elements
+      def children
+        begin
+          @children ||= type.children
+        rescue => e
+          raise e, "In object #{inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/quickbooks/xsd/group.rb

@@ -0,0 +1,94 @@
+module Quickbooks
+  class XSD
+    # Group of elements, so that we can refer to them by name...
+    class Group
+      attr_reader :name, :ref, :minOccurs, :maxOccurs
+
+      def initialize(attributes={})
+        @name = attributes.delete('name')
+        @ref = attributes.delete('ref')
+        @minOccurs = attributes.delete('minOccurs')
+        @maxOccurs = attributes.delete('maxOccurs')
+        @items = attributes.delete(:items)
+        puts "EG Attributes: #{attributes.inspect}" unless attributes.empty?
+      end
+
+      def items
+        @items ||= []
+      end
+
+      def <<(something)
+        items << something
+      end
+
+      def merge(attributes)
+        self.class.new({'name' => @name, 'ref' => @ref, 'minOccurs' => @minOccurs, 'maxOccurs' => @maxOccurs, :items => items}.merge(attributes))
+      end
+
+      def merge!(attributes)
+        @name = attributes.delete('name') || @name
+        @ref = attributes.delete('ref') || @ref
+        @minOccurs = attributes.delete('minOccurs') || @minOccurs
+        @maxOccurs = attributes.delete('maxOccurs') || @maxOccurs
+        return self
+      end
+
+      def inspect
+        items.map {|i| i.inspect}.join
+      end
+
+      def clone
+        self.class.new('name' => @name, 'ref' => @ref, 'minOccurs' => @minOccurs, 'maxOccurs' => @maxOccurs, :items => items.map {|i| i.clone})
+      end
+
+      # include Validations
+      def validate(object,required=true)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating CONFORMS TO Group[#{name}]" if $DEBUG
+        # 1) is it required?
+        # 2) do all items exist?
+        # 3) are all items valid?
+        r = items.inject(Valean.new(nil, required, :exists => true)) {|r,i| r << i.validate(object,required?(i)); r}
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def exists_in?(object)
+        items.any? {|i| i.exists_in?(object)}
+      end
+
+      def find(key)
+        children.select {|i| i.name == key}[0]
+      end
+
+      def include?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          children.collect {|e| e.name}.include?(key_or_xsd) :
+          (key_or_xsd == self || items.any? {|i| i.include?(key_or_xsd)})
+      end
+
+      def index(key)
+        children.collect {|e| e.name}.index(key.to_s)
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is allowed more than once in its parent.
+      def repeatable?(key)
+        items.any? {|i| i.include?(key) && i.repeatable?(key)}
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is required within its container.
+      def required?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          items.any? {|i| i.include?(key_or_xsd) && i.required?(key_or_xsd)} :
+          (key_or_xsd == self || items.select {|i| i.include?(key_or_xsd)}.any? {|i| i.required?(key_or_xsd)})
+      end
+
+      def children
+        children = []
+        items.map {|i| i.is_a?(Quickbooks::XSD::Element) ? children << i : children.concat(i.children)}
+        children
+      end
+    end
+  end
+end

data/lib/quickbooks/xsd/restriction.rb

@@ -0,0 +1,51 @@
+module Quickbooks
+  class XSD
+    class Restriction
+      attr_reader :base
+      attr_accessor :maxLength, :pattern
+      def enum_values
+        @enum_values || []
+      end
+      def enum_values!
+        @enum_values ||= []
+      end
+
+      def initialize(attributes)
+        @base = attributes.delete('base')
+        @enum_values = attributes.delete(:enum_values)
+        @pattern = attributes.delete(:pattern)
+        @maxLength = attributes.delete(:maxLength)
+  			puts "More attributes for Restriction: #{attributes.inspect}" unless attributes.empty?
+      end
+
+      def inspect
+        insp = []
+        insp << "#{@base.gsub(/(xsd:|TYPE)/,'').capitalize}" if @base
+        insp << "max-length:#{@maxLength}" if @maxLength
+        insp << "must-match:/#{@pattern}/" if @pattern
+        insp << "choice-of:#{@enum_values.inspect}" if @enum_values && !@enum_values.empty?
+        insp.join(', ')
+      end
+
+      def pattern
+        @pattern ? Regexp.new(@pattern) : nil
+      end
+
+      def validate(object,required=true)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating #{object.to_s.inspect} FOLLOWS #{inspect}" if $DEBUG
+        r = Valean.new(nil, required, :exists => true)
+        r.invalid!("exceeds the max length #{maxLength}") if maxLength && object.to_s.length > maxLength.to_i
+        r.invalid!("doesn't match regexp #{pattern}") if r.perfect? && pattern && object.to_s !~ pattern
+        r.invalid!("is not one of (#{enum_values.join(', ')})") if r.perfect? && !enum_values.empty? && !enum_values.include?(object.to_s)
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def clone
+        self.class.new('base' => @base.clone, :maxLength => @maxLength, :enum_values => enum_values.map {|i|i})
+      end
+    end
+  end
+end

data/lib/quickbooks/xsd/sequence.rb

@@ -0,0 +1,85 @@
+module Quickbooks
+  class XSD
+    class Sequence
+      def initialize(attributes={})
+        @items = attributes.delete(:items)
+        puts "More attributes for Sequence: #{attributes.inspect}" unless attributes.empty?
+      end
+
+      def items
+        @items ||= []
+      end
+
+      def <<(something)
+        self.items << something
+      end
+
+      def clone
+        self.class.new(:items => items.map {|i| i.clone})
+      end
+
+      def inspect
+        items.map {|i|i.inspect}.join
+      end
+
+      include Validation
+      def validate(object,required=true)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating CONFORMS TO #Sequence (#{required ? 'REQUIRED' : 'OPTIONAL'})" if $DEBUG
+        # 1) is it required?
+        # 2) do all required children exist?
+        # 3) are all existing children valid?
+        r = Valean.new(nil, required, :exists => true)
+        missings = []
+        items.each do |i|
+          v = i.validate(object,required?(i))
+          r << v
+          missings << (i.respond_to?(:name) ? i.name : i) if v.required? && v.missing?
+        end
+        # (a sequence is also invalid if any are missing)
+        r.invalid!("missing required element#{'s' if missings.length > 1} #{missings.join(', ')}") if r.missing?
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def exists_in?(object)
+        items.any? {|i| i.exists_in?(object)}
+      end
+
+      def find(key)
+        children.select {|i| i.name == key}[0]
+      end
+
+      # Report whether a named Quickbooks::XSD::Element or any xsd object is a descendent of self.
+      def include?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          children.collect {|e| e.name}.include?(key_or_xsd) :
+          (key_or_xsd == self || items.any? {|i| i.include?(key_or_xsd)})
+      end
+
+      # Report the position of a named Quickbooks::XSD::Element
+      def index(key)
+        children.collect {|e| e.name}.index(key.to_s)
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is allowed more than once in its parent.
+      def repeatable?(key)
+        items.any? {|i| i.include?(key) && i.repeatable?(key)}
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is required within its container.
+      def required?(key_or_xsd)
+        key_or_xsd.is_a?(String) ?
+          items.any? {|i| i.include?(key_or_xsd) && i.required?(key_or_xsd)} :
+          (key_or_xsd == self || items.select {|i| i.include?(key_or_xsd)}.any? {|i| i.required?(key_or_xsd)})
+      end
+
+      def children
+        children = []
+        items.map {|i| i.is_a?(Quickbooks::XSD::Element) ? children << i : children.concat(i.children)}
+        children
+      end
+    end
+  end
+end