quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/element_collection.rb

@@ -0,0 +1,105 @@
+class ElementCollection
+  include Enumerable
+  def each
+    items.each {|e| yield e}
+  end
+
+  attr_reader :type
+  def initialize(parent, type, items=[])
+    @parent = parent
+    @type = QB[type.to_s]
+    (items.is_a?(Enumerable) ? items : [items]).each { |item| add_item(item) }
+  end
+
+  # Access items by index.
+  def [](index)
+    items[index]
+  end
+
+  # Adds an item to the collection. The item type must be the same as the registered type for this Collection.
+  def build(item={})
+    raise RuntimeError, "cannot introduce an existing #{@type.to_s} to a new #{self.class.short_name}!" if item.is_a?(Quickbooks::Model) && !item.new_record? && @parent.new_record?
+    item = add_item(item)
+    item.instance_variable_set(:@collection_index, items.length-1)
+    return item
+  end
+  alias :<< :build
+
+  # Returns the number of items in the collection
+  def length
+    items.length
+  end
+
+  def empty? #:nodoc:
+    items.empty?
+  end
+
+  def valid?
+    errors.clear
+    r = items.inject(Valean.new) {|r,e| r << e.validate; r}
+    errors.concat(r.errors) if !r.errors.empty?
+    r.perfect?
+  end
+
+  def errors
+    @errors ||= []
+  end
+  def add_error(msg) #:nodoc:
+    errors << [nil, msg]
+  end
+
+  def dirty? #:nodoc:
+    @dirty ||= false
+  end
+
+  def inspect #:nodoc:
+    "[Collection of #{@type.short_name}: #{items.join(', ')}]"
+  end
+
+  # TODO: Has a problem when an element is a new_record and a child isn't, or vice-versa.
+  def to_element #:nodoc:
+    element_klass = @type < Quickbooks::Model ? (@type.short_name + (@parent.new_record? ? 'Add' : 'Mod')) : @type.short_name
+    puts "Converting to #{element_klass}"
+    elements = ElementCollection.new(@parent, element_klass)
+    items.each {|e| elements << (@type < Quickbooks::Model ? e.to_element : e)}
+    return elements
+  end
+
+  def to_model #:nodoc:
+    # Strips off Add, Mod, or Ret to turn whatever it is into a Model object
+    models = ElementCollection.new(@parent, @type.short_name.gsub(/(Add|Mod|Ret)$/,''))
+    items.each {|e| models << e.to_model}
+    return models
+  end
+
+  # Returns this collection but as a regular Array.
+  def to_a
+    items.dup
+  end
+
+  def save_associations #:nodoc:
+    each { |el| el.save_associations if el.respond_to?(:save_associations) }
+  end
+
+  private
+
+  def items
+    @items ||= []
+  end
+
+  def add_item(item)
+    item = @type.new(item) unless item.is_a?(@type)
+    item.send(:dirty!) if dirty?
+    items << item
+    return item
+  end
+
+  def clean!
+    @dirty = false
+    items.each {|e| e.send(:clean!)}
+  end
+
+  def dirty!
+    @dirty = true
+  end
+end

data/lib/quickbooks/extlib.rb

@@ -0,0 +1,8 @@
+require 'quickbooks/extlib/class'
+require 'quickbooks/extlib/object'
+require 'quickbooks/extlib/string'
+require 'quickbooks/extlib/hash'
+require 'quickbooks/extlib/time'
+require 'quickbooks/extlib/assertions'
+require 'quickbooks/extlib/inflection'
+require 'quickbooks/extlib/days_and_times'

data/lib/quickbooks/extlib/assertions.rb

@@ -0,0 +1,8 @@
+module Extlib
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

data/lib/quickbooks/extlib/class.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/quickbooks/extlib/days_and_times.rb

@@ -0,0 +1,10 @@
+module DaysAndTimes
+  def self.VERSION
+    '1.0.0'
+  end
+end
+
+require File.dirname(__FILE__)+'/days_and_times/duration'
+require File.dirname(__FILE__)+'/days_and_times/numeric'
+require File.dirname(__FILE__)+'/days_and_times/time'
+require File.dirname(__FILE__)+'/days_and_times/object'

data/lib/quickbooks/extlib/days_and_times/duration.rb

@@ -0,0 +1,362 @@
+require 'time'
+class Duration
+  # Length is the length of the time span, in seconds
+  # Unit is a length of time (in seconds) to use in collection methods
+  # StartTime is an optional attribute that can 'anchor' a duration
+  #   to a specific real time.
+  attr_accessor :length, :unit, :start_time
+  def initialize(count=0,unit=1,start_time=nil,auto_klass={})
+    if unit.is_a?(Time) || unit.is_a?(DateTime)
+      start_time = unit
+      unit = 1
+    end
+    options = {:count => count || 0, :unit => unit || 1, :start_time => start_time}.merge(count.is_a?(Hash) ? count : {})
+
+    @unit = options[:unit]
+    @length = (@unit * options[:count].to_f).round
+    @start_time = options[:start_time]
+  end
+  def self.new(*args)
+    a = super
+    if self.name == 'Duration' && (args.last.is_a?(Hash) ? args.last[:auto_class] == true : true)
+      a.send(:auto_class)
+    else
+      a
+    end
+  end
+  def self.length
+    1
+  end
+
+  # * * * * * * * * * * * * * * * *
+  # A Duration is a LENGTH of Time
+  #   -This is measured in seconds,
+  #    but set in terms of the unit
+  #    currently being used.
+  def length=(value)
+    if value.respond_to?(:to_f)
+      @length = (self.unit * value.to_f).round
+    else
+      raise TypeError, "Can't set a Duration's length to a #{value.class.name} object."
+    end
+  end
+  def length
+    length  = @length.to_f / self.unit
+    length.to_i == length ? length.to_i : length
+  end
+  def abs_length=(value)
+    if value.respond_to?(:to_i)
+      @length = value.to_i
+    else
+      raise TypeError, "Can't set a Duration's length to a #{value.class.name} object."
+    end
+  end
+  def abs_length
+    @length
+  end
+  def to_i
+    self.abs_length.to_i
+  end
+  def to_f
+    self.abs_length.to_f
+  end
+  def to_s
+    "#{self.length} #{self.class.name}"
+  end
+  def coerce(*args)
+    to_f.coerce(*args)
+  end
+
+  def ===(other)
+    self.to_f == other.to_f
+  end
+  def inspect
+    "#<#{self.class.name}:#{self.object_id} (length=#{self.length.inspect}) #{self.instance_variables.reject {|d| d=='@length' || self.instance_variable_get(d).nil?}.collect {|iv| "#{iv}=#{self.instance_variable_get(iv).inspect}"}.join(' ')}>"
+  end
+  # * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * *
+  # A Duration's calculations utilize a UNIT
+  #   -This is stored as the number of
+  #    seconds equal to the unit's value.
+  def unit=(value)
+    if value.respond_to?(:to_i)
+      @unit = value.to_i
+    else
+      raise TypeError, "Can't set a Duration's unit to a #{value.class.name} object."
+    end
+  end
+  def -(value)
+    if value.respond_to?(:to_i)
+      auto_class(Duration.new(@length - value.to_i))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def +(value)
+    if value.respond_to?(:to_i)
+      auto_class(Duration.new(@length + value.to_i))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def *(value)
+    if value.is_a?(Duration)
+      @length * value.length * value.unit
+    elsif value.respond_to?(:to_i)
+      auto_class(Duration.new(@length * value))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def /(value)
+    if value.is_a?(Duration)
+      @length / (value.length * value.unit)
+    elsif value.respond_to?(:to_i)
+      auto_class(Duration.new(@length / value))
+    else
+      raise TypeError, "Can't convert #{value.class.name} to an integer."
+    end
+  end
+  def in_weeks
+    Duration.new(@length.to_f / Week.length, Week.length)
+  end
+  def in_days
+    Duration.new(@length.to_f / Day.length, Day.length)
+  end
+  def in_hours
+    Duration.new(@length.to_f / Hour.length, Hour.length)
+  end
+  def in_minutes
+    Duration.new(@length.to_f / Minute.length, Minute.length)
+  end
+  def in_seconds
+    Duration.new(@length.to_f / Second.length, Second.length)
+  end
+  def weeks
+    @length.to_f / Week.length
+  end
+  def days
+    @length.to_f / Day.length
+  end
+  def hours
+    @length.to_f / Hour.length
+  end
+  def minutes
+    @length.to_f / Minute.length
+  end
+  def seconds
+    @length.to_f / Second.length
+  end
+  # * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * *
+  # A Duration can be 'anchored' to a START_TIME
+  #   -This start_time is a Time object
+  def start_time=(value)
+    if value.is_a?(Time) || value.is_a?(DateTime)
+      @start_time = value.to_time
+    else
+      raise TypeError, "A Duration's start_time must be a Time or DateTime object."
+    end
+  end
+  def end_time=(value)
+    if value.is_a?(Time) || value.is_a?(DateTime)
+      @start_time = value.to_time - self #Subtracts this duration from the end_time to get the start_time
+    else
+      raise TypeError, "A Duration's end_time must be a Time or DateTime object."
+    end
+  end
+  def end_time
+    @start_time + self
+  end
+  def anchored?
+    !self.start_time.nil?
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * *
+  # Calculations using Duration as an intermediate
+  def from(time)
+    time + @length
+  end
+  def before(time)
+    time - @length
+  end
+  def from_now
+    self.from(Time.now)
+  end
+  def ago
+    self.before(Time.now)
+  end
+  def starting(time)
+    self.start_time = time
+    self
+  end
+  def ending(time)
+    self.end_time = time
+    self
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  # A Duration can be treated as a 'collection' of units
+  def each_week(&block)
+    self.each(Week.length,&block)
+  end
+  def each_day(&block)
+    self.each(Day.length,&block)
+  end
+  def each_hour(&block)
+    self.each(Hour.length,&block)
+  end
+  def each_minute(&block)
+    self.each(Minute.length,&block)
+  end
+  def each_second(&block)
+    self.each(Second.length,&block)
+  end
+  def collect(use_unit=self.class.length,&block)
+    ary = []
+    self.each(use_unit) do |x|
+      ary << (block_given? ? yield(x) : x)
+    end
+    ary
+  end
+  def each(use_unit=self.class.length)
+    remainder = @length.to_f % use_unit
+    ret = []
+    if self.start_time.nil?
+      (@length.to_f / use_unit).to_i.times do |i|
+        ret << Duration.new(1, use_unit)
+        yield(ret[-1])
+      end
+    else
+      (@length.to_f / use_unit).to_i.times do |i|
+        ret << Duration.new(1, use_unit, (self.start_time + (use_unit * i)))
+        yield(ret[-1])
+      end
+    end
+    if remainder > 0
+      ret << (self.start_time.nil? ? Duration.new(remainder, 1) : Duration.new(remainder, 1, (self.start_time + @length - remainder)))
+      yield(ret[-1])
+    end
+    ret
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+  # Through some ingenious metacoding (see 'def bind_object_method') below,
+  # it is possible to create a new method on a Duration object
+  # to a method on another object, in order to gather information
+  # based on the duration mentioned.
+  def create_find_within_method_for(other, method_name, other_method_name)
+    self.bind_object_method(other, method_name, other_method_name, [[], ['self.start_time', 'self.end_time']])
+  end
+  def self.create_find_within_method_for(other, method_name, other_method_name)
+    self.bind_class_object_method(other, method_name, other_method_name, [[], ['self.start_time', 'self.end_time']])
+  end
+  # * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+  def method_missing(method_name, *args)
+    # Delegate any missing methods to the start_time Time object, if we have a start_time and the method exists there.
+    return self.start_time.send(method_name, *args) if self.anchored? && self.start_time.respond_to?(method_name)
+    super
+  end
+
+  private
+    def auto_class(obj=self)
+      new_obj = case obj.unit
+      when 1
+        obj.class.name == 'Seconds'  ? obj : (obj.length == 1 ? Second.new(obj.start_time) : Seconds.new(obj.length,obj.start_time))
+      when 60
+        obj.class.name == 'Minutes'  ? obj : (obj.length == 1 ? Minute.new(obj.start_time) : Minutes.new(obj.length,obj.start_time))
+      when 3600
+        obj.class.name == 'Hours'    ? obj : (obj.length == 1 ? Hour.new(obj.start_time) : Hours.new(obj.length,obj.start_time))
+      when 86400
+        obj.class.name == 'Days'     ? obj : (obj.length == 1 ? Day.new(obj.start_time) : Days.new(obj.length,obj.start_time))
+      when 604800
+        obj.class.name == 'Weeks'    ? obj : (obj.length == 1 ? Week.new(obj.start_time) : Weeks.new(obj.length,obj.start_time))
+      else
+        obj.class.name == 'Duration' ? obj : Duration.new(obj.length,obj.unit,obj.start_time,{:auto_class => false})
+      end
+      # Now, auto-transform class if possible:
+      case
+      when !['Weeks', 'Week'].include?(new_obj.class.name) && new_obj.to_i.remainder(Week.length) == 0
+        new_obj.to_i == Week.length ? Week.new(new_obj.start_time) : Weeks.new(new_obj.to_f / Week.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day'].include?(new_obj.class.name) && new_obj.to_i.remainder(Day.length) == 0
+        new_obj.to_i == Day.length ? Day.new(new_obj.start_time) : Days.new(new_obj.to_f / Day.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day', 'Hours', 'Hour'].include?(new_obj.class.name) && new_obj.to_i.remainder(Hour.length) == 0
+        new_obj.to_i == Hour.length ? Hour.new(new_obj.start_time) : Hours.new(new_obj.to_f / Hour.length,new_obj.start_time)
+      when !['Weeks', 'Week', 'Days', 'Day', 'Hours', 'Hour', 'Minutes', 'Minute'].include?(new_obj.class.name) && new_obj.to_f.remainder(Minute.length) == 0
+        new_obj.to_i == Minute.length ? Minute.new(new_obj.start_time) : Minutes.new(new_obj.to_f / Minute.length,new_obj.start_time)
+      else
+        new_obj
+      end
+    end
+end
+class Weeks < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Week.length,start_time)
+  end
+  def self.length
+    604800
+  end
+end
+class Week < Weeks
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Days < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Day.length,start_time)
+  end
+  def self.length
+    86400
+  end
+end
+class Day < Days
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Hours < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Hour.length,start_time)
+  end
+  def self.length
+    3600
+  end
+end
+class Hour < Hours
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Minutes < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Minute.length,start_time)
+  end
+  def self.length
+    60
+  end
+end
+class Minute < Minutes
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end
+class Seconds < Duration
+  def initialize(count=1,start_time=nil)
+    super(count,Second.length,start_time)
+  end
+  def self.length
+    1
+  end
+end
+class Second < Seconds
+  def initialize(start_time=nil)
+    super(1,start_time)
+  end
+end