quickbooks 0.4.0 → 0.9.9

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

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__)+'/duration'
+class Numeric
+  def weeks
+    self == 1 ? Week.new : Weeks.new(self)
+  end
+  def week
+    self.weeks
+  end
+
+  def days
+    self == 1 ? Day.new : Days.new(self)
+  end
+  def day
+    self.days
+  end
+
+  def hours
+    self == 1 ? Hour.new : Hours.new(self)
+  end
+  def hour
+    self.hours
+  end
+
+  def minutes
+    self == 1 ? Minute.new : Minutes.new(self)
+  end
+  def minute
+    self.minutes
+  end
+
+  def seconds
+    self == 1 ? Second.new : Seconds.new(self)
+  end
+  def second
+    self.seconds
+  end
+
+  def is_multiple_of?(num)
+    self % num == 0
+  end
+
+  def am
+    Time.parse("#{self}:00:00")
+  end
+  def pm
+    Time.parse("#{self+12}:00:00")
+  end
+end

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

@@ -0,0 +1,19 @@
+class Object
+  def bind_class_object_method(other, self_method_name, other_method_name, args=[[],[]])
+    # Since I can't pass the 'other' object into eval as a string, I have to
+    #   set a class instance variable and copy the contents to a class variable
+    #   so that the generated method will play nicely with subclasses.
+    self.instance_variable_set("@#{self_method_name.to_s}_OBJ", other)
+    self.send :eval, "@@#{self_method_name.to_s}_OBJ = @#{self_method_name.to_s}_OBJ
+    def #{self_method_name.to_s}(#{args[0].join(', ')})
+      @@#{self_method_name.to_s}_OBJ.#{other_method_name.to_s}(#{args[1].join(', ')})
+    end"
+    self
+  end
+  def bind_object_method(other, self_method_name, other_method_name, args=[[],[]])
+    self.instance_variable_set("@#{self_method_name}_OBJ", other)
+    eval "def self.#{self_method_name}(#{args[0].join(', ')})
+      @#{self_method_name}_OBJ.#{other_method_name}(#{args[1].join(', ')})
+    end"
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'time'
+class Time
+  def to_time
+    self
+  end
+
+  # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+  # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
+  # minute is passed, then sec and usec is set to 0.
+  def change(options)
+    ::Time.send(
+      self.utc? ? :utc_time : :local_time,
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || options[:mday] || self.day, # mday is deprecated
+      options[:hour]  || self.hour,
+      options[:min]   || (options[:hour] ? 0 : self.min),
+      options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+      options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+    )
+  end
+
+  def day_name
+    self.strftime("%A")
+  end
+  def month_name
+    self.strftime("%B")
+  end
+
+  # Seconds since midnight: Time.now.seconds_since_midnight
+  def seconds_since_midnight
+    self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
+  end
+
+  # Returns a new Time representing the start of the day (0:00)
+  def beginning_of_day
+    (self - self.seconds_since_midnight).change(:usec => 0)
+  end
+  alias :midnight :beginning_of_day
+  alias :at_midnight :beginning_of_day
+  alias :at_beginning_of_day :beginning_of_day
+
+  # Returns a new Time if requested year can be accomodated by Ruby's Time class
+  # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
+  # otherwise returns a DateTime
+  def self.time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+    ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+  rescue
+    offset = if utc_or_local.to_sym == :utc then 0 else ::DateTime.now.offset end
+    ::DateTime.civil(year, month, day, hour, min, sec, offset, 0)
+  end
+
+  # wraps class method time_with_datetime_fallback with utc_or_local == :utc
+  def self.utc_time(*args)
+    time_with_datetime_fallback(:utc, *args)
+  end
+
+  # wraps class method time_with_datetime_fallback with utc_or_local == :local
+  def self.local_time(*args)
+    time_with_datetime_fallback(:local, *args)
+  end
+
+  def self.tomorrow
+    Time.now.beginning_of_day + 1.day
+  end
+  def tomorrow
+    self.beginning_of_day + 1.day
+  end
+  def self.yesterday
+    Time.now.beginning_of_day - 1.day
+  end
+  def yesterday
+    self.beginning_of_day - 1.day
+  end
+  def self.today
+    Time.now.beginning_of_day
+  end
+  def self.next_month
+    today.change(:day => 1, :month => today.month + 1)
+  end
+
+  def until(end_time)
+    Duration.new(end_time - self, self)
+  end
+  def through(duration)
+    self.until(duration)
+  end
+  def for(duration)
+    raise TypeError, "must be a Duration object." unless duration.is_a?(Duration)
+    duration.start_time = self
+    duration
+  end
+  def is_today?
+    self.beginning_of_day == Time.today
+  end
+  def strfsql
+    self.strftime("%Y-#{self.strftime("%m").to_i.to_s}-#{self.strftime("%d").to_i.to_s}")
+  end
+  def self.from_tzid(tzid) #We aren't handling the Time Zone part here...
+     if tzid =~ /(\d\d\d\d)(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z/ # yyyymmddThhmmss
+       Time.xmlschema("#{$1}-#{$2}-#{$3}T#{$4}:#{$5}:#{$6}")
+     else
+       return nil
+     end
+  end
+  def humanize_time
+    self.strftime("%M").to_i > 0 ? self.strftime("#{self.strftime("%I").to_i.to_s}:%M%p").downcase : self.strftime("#{self.strftime("%I").to_i.to_s}%p").downcase
+  end
+  def humanize_date(length_profile='medium') #There may be decent reason to change how this works entirely...
+    case length_profile
+    when 'abbr' || 'abbreviated'
+      self.strftime("%m/%d/%y")
+    when 'short'
+      self.strftime("%b #{self.strftime("%d").to_i.to_s}")
+    when 'medium'
+      self.strftime("%B #{self.strftime("%d").to_i.to_s}")
+    when 'long'
+      self.strftime("%B #{self.strftime("%d").to_i.to_s}, %Y")
+    end
+  end
+  def humanize_date_time
+    self.humanize_date + ' ' + self.humanize_time
+  end
+end
+
+def Today
+  Time.today
+end
+def Yesterday
+  Time.yesterday
+end
+def Tomorrow
+  Time.tomorrow
+end
+def Now
+  Time.now
+end

data/lib/quickbooks/extlib/hash.rb

@@ -0,0 +1,327 @@
+class Hash
+  ##
+  # Convert to URL query param string
+  #
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+  #
+  # @return [String] This hash as a query string
+  #
+  # @api public
+  def to_params
+    params = self.map { |k,v| normalize_param(k,v) }.join
+    params.chop! # trailing &
+    params
+  end
+
+  ##
+  # Convert a key, value pair into a URL query param string
+  #
+  #   normalize_param(:name, "Bob")   #=> "name=Bob&"
+  #
+  # @param [Object] key The key for the param.
+  # @param [Object] value The value for the param.
+  #
+  # @return <String> This key value pair as a param
+  #
+  # @api public
+  def normalize_param(key, value)
+    param = ''
+    stack = []
+
+    if value.is_a?(Array)
+      param << value.map { |element| normalize_param("#{key}[]", element) }.join
+    elsif value.is_a?(Hash)
+      stack << [key,value]
+    else
+      param << "#{key}=#{value}&"
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          stack << ["#{parent}[#{key}]", value]
+        else
+          param << normalize_param("#{parent}[#{key}]", value)
+        end
+      end
+    end
+
+    param
+  end
+
+  ##
+  # Create a hash with *only* key/value pairs in receiver and +allowed+
+  #
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
+  #
+  # @param [Array[String, Symbol]] *allowed The hash keys to include.
+  #
+  # @return [Hash] A new hash with only the selected keys.
+  #
+  # @api public
+  def only(*allowed)
+    hash = {}
+    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
+  ##
+  # Create a hash with all key/value pairs in receiver *except* +rejected+
+  #
+  #    { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { :two => 2, :three => 3 }
+  #
+  # @param [Array[String, Symbol]] *rejected The hash keys to exclude.
+  #
+  # @return [Hash] A new hash without the selected keys.
+  #
+  # @api public
+  def except(*rejected)
+    hash = self.dup
+    rejected.each {|k| hash.delete(k) }
+    hash
+  end
+
+  # @return <String> The hash as attributes for an XML tag.
+  #
+  # @example
+  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+  #     #=> 'one="1" two="TWO"'
+  def to_xml_attributes
+    map do |k,v|
+      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+    end.join(' ')
+  end
+
+  alias_method :to_html_attributes, :to_xml_attributes
+
+  # @param html_class<#to_s>
+  #   The HTML class to add to the :class key. The html_class will be
+  #   concatenated to any existing classes.
+  #
+  # @example hash[:class] #=> nil
+  # @example hash.add_html_class!(:selected)
+  # @example hash[:class] #=> "selected"
+  # @example hash.add_html_class!("class1 class2")
+  # @example hash[:class] #=> "selected class1 class2"
+  def add_html_class!(html_class)
+    if self[:class]
+      self[:class] = "#{self[:class]} #{html_class}"
+    else
+      self[:class] = html_class.to_s
+    end
+  end
+
+  # Converts all keys into string values. This is used during reloading to
+  # prevent problems when classes are no longer declared.
+  #
+  # @return <Array> An array of they hash's keys
+  #
+  # @example
+  #   hash = { One => 1, Two => 2 }.proctect_keys!
+  #   hash # => { "One" => 1, "Two" => 2 }
+  def protect_keys!
+    keys.each {|key| self[key.to_s] = delete(key) }
+  end
+
+  # Attempts to convert all string keys into Class keys. We run this after
+  # reloading to convert protected hashes back into usable hashes.
+  #
+  # @example
+  #   # Provided that classes One and Two are declared in this scope:
+  #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
+  #   hash # => { One => 1, Two => 2 }
+  def unprotect_keys!
+    keys.each do |key|
+      (self[Object.full_const_get(key)] = delete(key)) rescue nil
+    end
+  end
+
+  # Destructively and non-recursively convert each key to an uppercase string,
+  # deleting nil values along the way.
+  #
+  # @return <Hash> The newly environmentized hash.
+  #
+  # @example
+  #   { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
+  #     #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }
+  def environmentize_keys!
+    keys.each do |key|
+      val = delete(key)
+      next if val.nil?
+      self[key.to_s.upcase] = val
+    end
+    self
+  end
+end
+
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the
+# underlying parser.
+class REXMLUtilityNode
+  attr_accessor :name, :attributes, :children, :type
+  cattr_accessor :typecasts, :available_typecasts
+
+  self.typecasts = {}
+  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
+  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
+  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
+  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
+  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
+  self.typecasts["string"]        = lambda{|v| v.to_s}
+  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
+
+  self.available_typecasts = self.typecasts.keys
+
+  def initialize(name, attributes = {})
+    @name         = name.tr("-", "_")
+    # leave the type alone if we don't know what it is
+    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+    @nil_element  = attributes.delete("nil") == "true"
+    @attributes   = undasherize_keys(attributes)
+    @children     = []
+    @text         = false
+  end
+
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+
+  def to_hash
+    if @type == "file"
+      f = StringIO.new((@children.first || '').unpack('m').first)
+      class << f
+        attr_accessor :original_filename, :content_type
+      end
+      f.original_filename = attributes['name'] || 'untitled'
+      f.content_type = attributes['content_type'] || 'application/octet-stream'
+      return {name => f}
+    end
+
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #change repeating groups into an array
+      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+      out = nil
+      if @type == "array"
+        out = []
+        groups.each do |k, v|
+          if v.size == 1
+            out << v.first.to_hash.entries.first.last
+          else
+            out << v.map{|e| e.to_hash[k]}
+          end
+        end
+        out = out.flatten
+
+      else # If Hash
+        out = {}
+        groups.each do |k,v|
+          if v.size == 1
+            out.merge!(v.first)
+          else
+            out.merge!( k => v.map{|e| e.to_hash[k]})
+          end
+        end
+        out.merge! attributes unless attributes.empty?
+        out = out.empty? ? nil : out
+      end
+
+      if @type && out.nil?
+        { name => typecast_value(out) }
+      else
+        { name => out }
+      end
+    end
+  end
+
+  # Typecasts a value based upon its type. For instance, if
+  # +node+ has #type == "integer",
+  # {{[node.typecast_value("12") #=> 12]}}
+  #
+  # @param value<String> The value that is being typecast.
+  #
+  # @details [:type options]
+  #   "integer"::
+  #     converts +value+ to an integer with #to_i
+  #   "boolean"::
+  #     checks whether +value+, after removing spaces, is the literal
+  #     "true"
+  #   "datetime"::
+  #     Parses +value+ using Time.parse, and returns a UTC Time
+  #   "date"::
+  #     Parses +value+ using Date.parse
+  #
+  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+  #   The result of typecasting +value+.
+  #
+  # @note
+  #   If +self+ does not have a "type" key, or if it's not one of the
+  #   options specified above, the raw +value+ will be returned.
+  def typecast_value(value)
+    return value unless @type
+    proc = self.class.typecasts[@type]
+    proc.nil? ? value : proc.call(value)
+  end
+
+  # Convert basic XML entities into their literal values.
+  #
+  # @param value<#gsub> An XML fragment.
+  #
+  # @return <#gsub> The XML fragment after converting entities.
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
+  end
+
+  # Take keys of the form foo-bar and convert them to foo_bar
+  def undasherize_keys(params)
+    params.keys.each do |key, value|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+
+  # Get the inner_html of the REXML node.
+  def inner_html
+    @children.join
+  end
+
+  # Converts the node into a readable HTML node.
+  #
+  # @return <String> The HTML node in text form.
+  def to_html
+    attributes.merge!(:type => @type ) if @type
+    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+  end
+
+  # @alias #to_html #to_s
+  def to_s
+    to_html
+  end
+end