quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/types.rb

@@ -0,0 +1,58 @@
+require 'quickbooks/type'
+module Quickbooks
+  module Types
+    class AMTTYPE < Type
+      native Quickbooks::Support::Amount
+    end
+    class BOOLTYPE < Type
+      native Boolean
+    end
+    class DATETIMETYPE < Type
+      native Quickbooks::Support::DateTime
+    end
+    class DATETYPE < Type
+      require 'date'
+      native Quickbooks::Support::Date
+    end
+    class ENUMTYPE < Type
+      native String
+      # Need to create the Enum functionality. The dtd's don't specify the allowed values for any of the ENUMTYPEs.
+      # For example, the JobStatus property holds one of the following:
+      # Awarded, Closed, InProgress, None [DEFAULT], NotAwarded, Pending
+      # But there is yet no way to specify allowed values or to validate them.
+      class << self
+        def enum(in_klass,*args)
+          @enum ||= {}
+          @enum[in_klass] = args
+        end
+      end
+    end
+    class FLOATTYPE < Type
+      native Quickbooks::Support::Float
+    end
+    class GUIDTYPE < Type
+      native String
+    end
+    class IDTYPE < Type
+      native String
+    end
+    class INTTYPE < Type
+      native Quickbooks::Support::Integer
+    end
+    class PERCENTTYPE < Type
+      native String
+    end
+    class PRICETYPE < Type
+      native String
+    end
+    class QUANTYPE < Type
+      native Quickbooks::Support::Float
+    end
+    class STRTYPE < Type
+      native String
+    end
+    class TIMEINTERVALTYPE < Type
+      native Quickbooks::Support::TimeInterval
+    end
+  end
+end

data/lib/quickbooks/version.rb

@@ -0,0 +1,10 @@
+module Quickbooks #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 9
+    BUILD_DATE = '2009-08-05'
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/quickbooks/xsd.rb

@@ -0,0 +1,243 @@
+class Class
+  def cascading_attr_reader(*names)
+    names.each do |name|
+      class_eval "def #{name}; @#{name} || (parent ? parent.#{name} : nil); end"
+    end
+  end
+
+  def cascading_attr_accessor(*names)
+    names.each do |name|
+      attr_writer name
+      class_eval "def #{name}; @#{name} || (parent ? parent.#{name} : nil); end"
+    end
+  end
+end
+
+req_base = File.dirname(__FILE__)
+require req_base + '/xsd/xml_parse'
+require req_base + '/xsd/validation'
+require req_base + '/xsd/element'
+require req_base + '/xsd/group'
+require req_base + '/xsd/sequence'
+require req_base + '/xsd/simple_type'
+require req_base + '/xsd/complex_type'
+require req_base + '/xsd/restriction'
+require req_base + '/xsd/choice'
+require req_base + '/xsd/union'
+require req_base + '/xsd/attribute'
+
+module Quickbooks
+  class XSD
+    def inspect
+      properties_size = properties.size
+      sprintf("#<%s:0x%x %s models, %s elements, %s properties, %s types>", self.class.name, __id__, models.size, elements.size - properties_size, properties_size, types.size)
+    end
+
+    def source_paths
+      @source_paths ||= []
+    end
+    def source_path
+      source_paths.last
+    end
+
+    def elements
+      @elements ||= {}
+    end
+    def groups
+      @groups ||= {}
+    end
+    def types
+      @types ||= {}
+    end
+
+    def properties
+      Hash[*elements.select {|k,e| e.is_property?}.flatten]
+    end
+    def models
+      Hash[*elements.select {|k,e| e.is_model?}.flatten]
+    end
+
+    # Get any name that is saved in elements.
+    def [](key)
+      elements[key]
+    end
+    def include?(key)
+      elements.include?(key)
+    end
+
+    def self.parse_file(file, path=nil)
+      Quickbooks::XSD.new.parse_file(file, path)
+    end
+
+    def parse_file(file, path=nil)
+      file = (path || source_path) + '/' + file unless path.nil? && source_path.nil?
+
+      if File.exists?(file)
+        file = File.expand_path(file)
+        source_paths << File.dirname(file)
+        # puts "Parsing #{file}..."
+        xsd = parse(File.read(file))
+        source_paths.pop
+        xsd
+      else
+        raise "XSD source file #{file} does not exist!"
+      end
+    end
+
+    def parse(source)
+      element_stack = []
+      waiting_types = Hash.new {|h,k| h[k] = []}
+      parser = REXML::Parsers::BaseParser.new(source)
+      status = {}
+      loop do
+        event = parser.pull
+        case event[0]
+        when :end_document
+          break
+        when :end_doctype, :start_doctype
+          # do nothing
+        when :start_element
+          # Create a node
+          tag_name, attributes = event[1], event[2]
+          case tag_name
+          when 'xsd:schema'
+            # Just the schema element at the top.
+
+          when 'xsd:include'     # Parse this file at this point before continuing.
+            parse_file(attributes['schemaLocation'], source_path)
+
+          when 'xsd:element'     # an element. If inside another element any number of levels deep, it's not a declaration, just an inclusion.
+            if type_name = attributes.delete('type')
+              type = types[type_name]
+              attributes.merge!('type' => type)
+            end
+            element = if element_stack.empty?
+              (elements[attributes['name']] ||= Element.new).merge!(attributes)
+            elsif attributes.has_key?('ref')
+              (elements[attributes['ref']] ||= Element.new).merge(attributes)
+            elsif elements.has_key?(attributes['name'])
+              elements[attributes['name']].merge(attributes)
+            elsif attributes.has_key?('name') && attributes.has_key?('type')
+              elements[attributes['name']] ||= Element.new(attributes)
+            else
+              Element.new(attributes)
+            end
+            waiting_types[type_name] << element if type_name && type.nil? # When the type is created it will retroactively set the type to this element.
+            element_stack.last << element unless element_stack.empty?
+            element_stack << element
+
+          when 'xsd:simpleType'  # simpleType means its parent is a property and this defines the possible value
+            # If it's being declared on the top level, create a new one
+            type = (types[attributes['name']] || SimpleType.new).merge(attributes)
+            if element_stack.empty?
+              types[type.name] = type
+            else
+              element_stack.last << type
+            end
+            element_stack << type
+            waiting_types.delete(type.name).each {|e| e.type = type} if type.name && waiting_types.has_key?(type.name)
+
+          when 'xsd:complexType' # defines a complex requirement, usually a sequence
+            # If it's being declared on the top level, create a new one
+            type = (types[attributes['name']] || ComplexType.new).merge(attributes)
+            if element_stack.empty?
+              types[type.name] = type
+            else
+              element_stack.last << type
+            end
+            element_stack << type
+            waiting_types.delete(type.name).each {|e| e.type = type} if type.name && waiting_types.has_key?(type.name)
+
+          when 'xsd:restriction' # restriction defines a restriction on the possible value of an element
+  					element_stack.last.restriction = Restriction.new(attributes)
+            element_stack.last.type = types[attributes['base']] # Sets the base type onto the parent SimpleType
+            # TODO: currently we don't step into these restrictions, we're referencing them more explicitly (see xsd:enumeration below)
+
+          when 'xsd:enumeration' # enumerates the values for an ENUM property
+            element_stack.last.restriction.enum_values! << attributes.delete('value')
+  					puts "More attributes for Enumeration: #{attributes.inspect}" unless attributes.empty?
+
+          when 'xsd:group'       # defines a group of elements used together
+            group = if element_stack.empty?
+              # being declared by name. Save the new attributes into it for sure.
+              (groups[attributes['name']] ||= Group.new).merge!(attributes)
+            elsif attributes.has_key?('ref')
+              # We are referencing a common element, which may or may not already be declared.
+              groups[attributes['ref']] ||= Group.new
+            else
+              # We're not declaring nor are we referencing a declared element.
+              Group.new
+            end.merge(attributes)
+            element_stack.last << group unless element_stack.empty?
+            element_stack << group
+
+          when 'xsd:sequence'    # defines a sequence of elements/element-groups
+            sequence = Sequence.new(attributes)
+            element_stack.last << sequence
+            element_stack << sequence
+
+          when 'xsd:choice'      # choice means include any one of the enclosed elements/element-groups
+            choice = Choice.new(attributes)
+            element_stack.last << choice
+            element_stack << choice
+  					puts "More attributes for Choice: #{attributes.inspect}" unless attributes.empty?
+
+          when 'xsd:union'
+            union = Union.new(attributes)
+            element_stack.last << union
+            element_stack << union
+  					puts "More attributes for Union: #{attributes.inspect}" unless attributes.empty?
+
+          when 'xsd:attribute'   # an attribute of the parent element
+            if type = attributes.delete('type')
+              type = types[type] # assuming that all types are declared before they're referenced.
+              attributes.merge!('type' => type)
+            end
+            attribute = Attribute.new(attributes)
+            element_stack.last << attribute
+            element_stack << attribute
+
+          when 'xsd:maxLength'   # a restriction of a STRTYPE property
+  					element_stack.last.restriction.maxLength = attributes.delete('value')
+  					puts "More attributes for maxLength: #{attributes.inspect}" unless attributes.empty?
+
+          when 'xsd:pattern'     # a restriction of a STRTYPE property
+  					element_stack.last.restriction.pattern = attributes.delete('value')
+  					puts "More attributes for pattern: #{attributes.inspect}" unless attributes.empty?
+
+          when 'xsd:maxInclusive'
+          when 'xsd:minInclusive'
+          when 'xsd:simpleContent'
+          when 'xsd:extension'
+          else
+            warn "!! Other element: #{tag_name} (#{attributes.inspect})"
+          end
+        when :end_element
+          name = event[1]
+          case name
+          when 'xsd:element'
+            element_stack.pop
+          when 'xsd:simpleType'
+            element_stack.pop
+          when 'xsd:group'
+            element_stack.pop
+          when 'xsd:union'
+            element_stack.pop
+          when 'xsd:choice'
+            element_stack.pop
+          when 'xsd:sequence'
+            element_stack.pop
+          when 'xsd:complexType'
+            element_stack.pop
+          when 'xsd:attribute'
+            element_stack.pop
+          end
+        when :text, :cdata
+          puts "!! Text Data: #{event[1]}" if event[1].strip.length > 0
+        end
+      end
+
+  		self
+    end
+  end
+end

data/lib/quickbooks/xsd/attribute.rb

@@ -0,0 +1,57 @@
+module Quickbooks
+  class XSD
+    class Attribute
+      attr_reader :name, :use, :default
+      attr_accessor :type
+
+      def initialize(attributes)
+        @name = attributes.delete('name')
+        @type = attributes.delete('type')
+        @use  = attributes.delete('use')
+        @default = attributes.delete('default')
+        warn "!! Unhandled Attribute attributes: #{attributes.keys.join(', ')}" if !attributes.empty?
+      end
+
+      def items
+        @items ||= []
+      end
+
+      def <<(something)
+        case something
+        when SimpleType
+          self.type = something
+        else
+          items << something
+        end
+      end
+
+      def validate(object,required=true)
+        return Valean.perfect!(name, required) if object.is_a?(Quickbooks::Model)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating #{required ? 'REQUIRED' : 'OPTIONAL'} Attribute #{name}" if $DEBUG
+        # A) am I required?
+        # B) do I exist?
+        # TODO: Also validate by @type
+        r = Valean.new(name, required, :exists => !object[name].nil?)
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def inspect
+        "<Attribute: '#{name}' #{use if use} #{type.inspect} #{"default="+default.inspect if default}>".gsub(/  +/,' ').gsub(/ >/,'>')
+      end
+
+      # Reports whether the named Quickbooks::XSD::Element or other xsd object is required within its container.
+      def required?(key_or_xsd=nil)
+        @use == 'required'
+      end
+      def include?(key_or_xsd)
+        false
+      end
+      def children
+        []
+      end
+    end
+  end
+end

data/lib/quickbooks/xsd/choice.rb

@@ -0,0 +1,94 @@
+module Quickbooks
+  class XSD
+    class Choice
+      attr_accessor :sequence
+
+      def initialize(attributes)
+        @minOccurs = (attributes.delete('minOccurs') || 1).to_i
+        @maxOccurs = attributes.delete('maxOccurs')
+        @items = attributes.delete(:items)
+        puts "More attributes for Choice: #{attributes.inspect}" unless attributes.empty?
+      end
+
+      def name
+        "either of (#{children.collect {|e| e.name}.join(', ')})"
+      end
+
+      def items
+        @items ||= []
+      end
+
+      def <<(something)
+        self.items << something
+      end
+
+      def inspect
+        sprintf("\n%s", items.map{|i|i.inspect.gsub(/\n/,"\n ")}.join("\n OR"))
+      end
+
+      def clone
+        self.class.new('minOccurs' => @minOccurs, 'maxOccurs' => @maxOccurs, :items => items.map {|i| i.clone})
+      end
+
+      # true if present and valid, or optional and missing
+      # false if required and either missing or invalid content
+      # :invalid if optional and invalid content
+      def validate(object,required=true)
+        # Validate the object's contents
+        puts "#{$DEBUG<<"\t"}Validating CONFORMS TO #Choice (#{required ? 'REQUIRED' : 'OPTIONAL'})" if $DEBUG
+        # 1) Is it required?
+        r = Valean.new(nil,required)
+        # 2) Do any of the choices exist? (if not, choice is missing)
+  # TODO: PROBLEM WITH THIS LINE -- DOESN'T ALWAYS FIND EXISTENCE!!!
+        existing = items.select {|i| i.exists_in?(object)}
+        r.exists! if existing.length > 0
+        # 3) Does ONLY ONE of the choices exist? (if not, choice itself is invalid)
+        r.invalid!("Must only include 1 of #{children.collect {|e| e.name}.inspect}") if existing.length > 1
+        # 4) Is the existing choice valid? (if not, the item is invalid)
+        r << existing[0].validate(object) if !existing.empty? && r.perfect?
+        $DEBUG.chop! if $DEBUG
+        puts "#{$DEBUG}\t- #{r}" if $DEBUG
+        r
+      end
+
+      def exists_in?(other)
+        items.any? {|i| i.exists_in?(other)}
+      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=nil)
+        if key
+          # puts "Checking repeatable: #{items.inspect}"
+          repeatable? || items.any? {|i| i.include?(key) && i.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=nil)
+        (key_or_xsd && @minOccurs > 0) || false
+      end
+
+      def children
+        children = []
+        items.map {|i| i.is_a?(Quickbooks::XSD::Element) ? children << i : children.concat(i.children)}
+        children
+      end
+    end
+  end
+end