quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/option.rb

@@ -0,0 +1,95 @@
+module Quickbooks
+  # A collection of Option objects. Can validate that a given object contains all required options and allowed values in this collection.
+  class Options
+    def self.from_xsd(xsd)
+      options = new
+      # puts "Options from xsd: #{xsd.inspect}"
+      xsd.type.items.select {|i| i.class == Quickbooks::XSD::Attribute}.each do |option_xsd|
+        options << Option.from_xsd(option_xsd)
+      end
+      options
+    end
+
+    def <<(option)
+      options << option
+    end
+
+    def validate(object)
+      puts "Validating #{object.inspect}!" if $DEBUG
+      options.check_all? { |option| option.validate(object) }
+    end
+
+    def include?(name)
+      options.any? {|option| option.name == name}
+    end
+
+    def defaults
+      options.inject({}) {|h,option| h[option.name.to_s] = option.default if option.default && option.required?; h}
+    end
+
+    def [](name)
+      name = name.to_s
+      options.select {|option| option.name == name}[0]
+    end
+
+    def delete(name)
+      options.reject! {|a| a.name == name}
+    end
+
+    private
+    
+    def options
+      @options ||= []
+    end
+  end
+
+  # An Option is a tag attribute. Not all Elements have them. They might include things like :iterator or :iteratorID, or :onError instructions. Can validate that a given object conforms to the Option's spec.
+  class Option
+    attr_reader :name, :type
+    attr_accessor :default # This way we can set our own defaults
+
+    def self.from_xsd(xsd)
+      #<Quickbooks::XSD::Attribute:0x18005ec @use=nil, @default=nil, @type="MACROTYPE", @name="defMacro">
+      new(xsd.name, xsd.type, xsd.default, xsd.use)
+    end
+
+    def initialize(name, type, default, use)
+      @name = name
+      @type = type
+      @default = default
+      @use = use
+    end
+
+    def required?
+      @use == 'required'
+    end
+
+    def inspect #:nodoc:
+      "<Option #{@name}#{@default ? " default="+@default.inspect : ''}#{@use ? ' '+@use.upcase : ''} #{@type.inspect}>"
+    end
+
+    # Validates that the given object conforms to the Option's spec.
+    def validate(object)
+      errors = (object.respond_to?(:errors) ? object.errors : [])
+      if required? && object[@name].nil?
+        errors << "#{object.class.short_name} requires the #{@name} option."
+        return false
+      end
+      # True if there is a value and it's valid, or if there is no value.
+      if object[@name].nil?
+        true
+      else
+        if @type
+          if @type.validate({object[@name] => true})
+            true
+          else
+            object.errors << "#{object.class.short_name}[#{@name}] is not valid. It must conform to #{@type.inspect}"
+            false
+          end
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/quickbooks/property.rb

@@ -0,0 +1,69 @@
+require 'quickbooks/types'
+module Quickbooks
+  module Properties
+    def self.singularize
+      Quickbooks::Property
+    end
+  end
+  class Property
+    def self.pluralize
+      Quickbooks::Properties
+    end
+    class << self
+      attr_accessor :xsd
+
+      def native
+        @native ||= Quickbooks::Types.const_get(xsd.type.name)
+      end
+    
+      alias :instantiate :new
+    end
+    
+    attr_reader :value
+    def value=(value)
+      @value = ((value.is_a?(self.class.native) || value.nil?) ? value : self.class.native.new(value))
+    end
+    alias :__value__ :value
+    
+    def initialize(value=nil)
+      raise RuntimeError, "Type class '#{self.class.short_name}' has no native class set. This is a BUG. Please report it!" unless self.class.native.is_a?(Class)
+      @value = value.is_a?(self.class.native) ? value : self.class.native.new(value)
+    end
+    
+    def eql?(value)
+      @value.eql?(value)
+    end
+    alias :=== :eql?
+    
+    def nil?
+      @value.nil?
+    end
+    
+    def inspect
+      "#{self.class.short_name}[#{@value.class.short_name.gsub(/type$/,'')}]=#{@value.inspect}"
+    end
+    
+    def to_s
+      @value.to_s
+    end
+    def to_xml
+      '<' + self.class.short_name + '>' + @value.to_xml + '</' + self.class.short_name + '>'
+    end
+    def to_dirty_xml(include_required=false)
+      to_xml
+    end
+    
+    def method_missing(method_name, *args, &block)
+      if block_given?
+        if @value.respond_to?(method_name)
+          @value.method(method_name).call(*args) {|*arr| yield *arr }
+        else
+          args << block
+          @value.send(method_name, *args)
+        end
+      else
+        @value.send(method_name, *args)
+      end
+    end
+  end
+end

data/lib/quickbooks/ruby_ext.rb

@@ -0,0 +1,251 @@
+class Module
+  def short_name
+    name.gsub(/.*::/,'')
+  end
+end
+
+class Array
+  def to_hash_via(&block) # Expects the block to receive each element and return a two-element array
+    Hash[*(collect {|e| yield e}.flatten)]
+  end
+
+  def group_by_count(int)
+    ary = []
+    nxt = 0
+    until(nxt*4 > length)
+      n = []
+      int.times do |i|
+        break if nxt*4+i >= length
+        n << self[nxt*4+i]
+      end
+      nxt += 1
+      ary << n unless n.empty?
+    end
+    ary
+  end
+
+  def check_all?
+    passed = true
+    each { |e| passed = false unless yield(e) }
+    passed
+  end
+
+  def occurrances_of
+    count = 0
+    each { |e| count += 1 if yield(e) }
+    count
+  end
+
+  # # Gives Array#first the ability to pass a block, and the first item that causes the block to return true is returned
+  # def first(count=1)
+  #   if block_given?
+  #     choice = self.inject([]) {|a,j| a << j if yield(j); break(a) if a.length == count; a}
+  #     return count > 1 ? choice : choice[0]
+  #   else
+  #     count > 1 ? self[0..(count-1)] : self[0]
+  #   end
+  # end
+end
+
+class String
+  def countr(regexp)
+    i = 0
+    gsub(regexp) {|m| i += 1}
+    i
+  end
+
+  def xml_escaped
+    gsub(/[&<>'"]/) {|match|
+      case match
+      when '&' then return '&amp;'
+      when '<' then return '&lt;'
+      when '>' then return '&gt;'
+      when "'" then return '&apos;'
+      when '"' then return '&quote;'
+      end
+    }
+  end
+
+  def unescape_xml
+    gsub(/&(amp|quot|gt|lt|\#[0-9]+|\#x[0-9A-Fa-f]+);/n) do
+      match = $1.dup
+      case match
+      when 'amp'                 then '&'
+      when 'quot'                then '"'
+      when 'gt'                  then '>'
+      when 'lt'                  then '<'
+      when /\A#0*(\d+)\z/n       then
+        if Integer($1) < 256
+          Integer($1).chr
+        else
+          if Integer($1) < 65536 and ($KCODE[0] == ?u or $KCODE[0] == ?U)
+            [Integer($1)].pack("U")
+          else
+            "&##{$1};"
+          end
+        end
+      when /\A#x([0-9a-f]+)\z/ni then
+        if $1.hex < 256
+          $1.hex.chr
+        else
+          if $1.hex < 65536 and ($KCODE[0] == ?u or $KCODE[0] == ?U)
+            [$1.hex].pack("U")
+          else
+            "&#x#{$1};"
+          end
+        end
+      else
+        "&#{match};"
+      end
+    end
+  end
+end
+
+class Boolean
+  def initialize(value)
+    raise ArgumentError, "must be true or false!" unless ['true', 'false'].include?(value.to_s)
+    @value = (value.to_s == 'true')
+  end
+
+  def __value__
+    @value
+  end
+
+  def ==(other)
+    to_s == other.to_s
+  end
+
+  def to_s
+    @value.to_s
+  end
+  alias :inspect :to_s
+end
+
+module Kernel
+  def todo(task)
+    $TODO ||= []
+    $TODO << task
+  end
+end
+
+require 'rexml/light/node'
+require 'rexml/document'
+module Quickbooks
+  module Support
+    def self.parse_xml(xml)
+      stack = []
+      parser = REXML::Parsers::BaseParser.new(xml)
+      while true
+        event = parser.pull
+        case event[0]
+        when :end_document
+          break
+        when :end_doctype, :start_doctype
+          # do nothing
+        when :start_element
+          stack.push(event[2].empty? ? QB[event[1]].instantiate : QB[event[1]].instantiate(event[2]))
+        when :end_element
+          if stack.size > 1
+            temp = stack.pop
+            stack.last.attributes << temp
+          end
+        when :text, :cdata
+          stack.last.value = event[1].unescape_xml if stack.last.class < Quickbooks::Property
+        end
+      end
+      obj = stack.pop
+      obj.send(:clean!)
+      obj
+    end
+
+    module Amount
+      def self.new(whatever)
+        amt = case
+        when whatever.is_a?(String)
+          # Sanitize the string, taking out things like $.
+          whatever.gsub(/[^\d\.+-]/,'').match(/([+-]?\d{1,13}(?:\.\d\d)?)/)[1]
+        when whatever.respond_to?(:to_f)
+          whatever # cool, it can do to_f
+        when whatever.respond_to?(:to_s)
+          self.new(whatever.to_s) # to_s will be the second-best opportunity
+        when whatever.respond_to?(:to_i)
+          whatever.to_i # last resort, use integer
+        else
+          raise "Invalid value for Amount. Must be up to 13 digits with optional 2-digit decimal place."
+        end
+        # Format it
+        "%.2f" % amt.to_f
+      end
+    end
+    module DateTime
+      def self.new(whatever)
+        case
+        when String
+          ::DateTime.parse(whatever)
+        when ::DateTime
+          whatever
+        when whatever.respond_to?(:to_datetime)
+          whatever.to_datetime
+        when whatever.respond_to?(:to_s)
+          ::DateTime.parse(whatever.to_s)
+        else
+          ::DateTime.new(whatever)
+        end
+      end
+    end
+    module Date
+      def self.new(whatever)
+        case
+        when whatever.is_a?(::String)
+          ::Date.parse(whatever)
+        when whatever.is_a?(::Date)
+          whatever
+        when whatever.respond_to?(:to_date)
+          whatever.to_date
+        when whatever.respond_to?(:to_s)
+          ::Date.parse(whatever.to_s)
+        else
+          ::Date.new(whatever)
+        end
+      end
+    end
+    module Float
+      def self.new(flt)
+        flt.to_f
+      end
+    end
+    module Integer
+      def self.new(int)
+        int.to_i
+      end
+    end
+    module TimeInterval
+      # The TIMEINTERVALTYPE type takes the form PTnHnMnS:
+      # The characters P and T are always present.
+      # • The character H follows the number of hours.
+      # • The character M follows the number of minutes.
+      # • The character S follows the number of seconds.
+      # • n is an integer that represents the number of hours, minutes, or seconds.
+      # Examples:
+      #   PT2H30M0S means: 2 hours, 30 minutes
+      #   PT2H0M0S means: 2 hours
+      #   PT0H0M5S means: 5 seconds
+      def self.new(whatever)
+        case
+        when whatever.is_a?(String) && whatever =~ /PT\d\d?H\d\d?M\d\d?S/
+          whatever
+        when whatever.is_a?(String) && whatever =~ /(\d\d?):(\d\d?)(?:\.(\d\d?))?/
+          s, hours, minutes, seconds = *whatever.match(/(\d\d?):(\d\d?)(?:\.(\d\d?))?/)
+          "PT#{hours.to_i}H#{minutes.to_i}M#{seconds.to_i}S"
+        when whatever.is_a?(Duration)
+          hours = whatever.hours.to_i
+          minutes = (whatever - hours.hours).minutes.to_i
+          seconds = (whatever - hours.hours - minutes.minutes).seconds.to_i
+          "PT#{hours}H#{minutes}M#{seconds}S"
+        else
+          raise ArgumentError, "duration given must be either a String formatted correctly (/PT\d\d?H\d\d?M\d\d?S/, where ) or a Duration object (try whatever english makes sense: 1.hour + 20.minutes, for example.)"
+        end
+      end
+    end
+  end
+end

data/lib/quickbooks/type.rb

@@ -0,0 +1,75 @@
+require 'quickbooks/types'
+module Quickbooks
+  class Type
+    class << self
+      def native(type=nil)
+        @native = type if type
+        @native
+      end
+    
+      alias :instantiate :new
+    end
+    
+    attr_reader :value
+    def value=(value)
+      @value = ((value.is_a?(self.class.native) || value.nil?) ? value : self.class.native.new(value))
+    end
+    alias :__value__ :value
+    
+    def initialize(value=nil)
+      raise RuntimeError, "Type class '#{self.class.short_name}' has no native class set. This is a BUG. Please report it!" unless self.class.native.is_a?(Module)
+      self.value = value
+      clean!
+    end
+    
+    def eql?(value)
+      @value.eql?(value)
+    end
+    alias :=== :eql?
+    
+    def nil?
+      @value.nil?
+    end
+    
+    def to_s
+      @value.to_s
+    end
+    
+    def dirty?
+      @dirty || @value != @original_value
+    end
+    
+    def valid?
+      raise "Not Implemented Yet! (Type Validation)"
+    end
+    
+    def inspect
+      $DEBUG ? super : @value.inspect
+    end
+    
+    def to_xml
+      @value.to_s.xml_escaped
+    end
+    
+    private
+    
+    def clean!
+      @dirty = false
+      begin
+        @original_value = [NilClass, Fixnum].include?(@value.class) ? @value : @value.dup # Fixnum and NilClass can't be dup'd
+      rescue TypeError
+        @original_value = @value
+      end
+    end
+    
+    def dirty!
+      @dirty = true
+    end
+    
+    def method_missing(method_name, *args, &block)
+      block_given? ?
+        @value.method(method_name).call(*args) {|*arr| yield *arr } :
+        @value.method(method_name).call(*args)
+    end
+  end
+end