quickbooks_api 0.0.7 → 0.1.0

data/lib/quickbooks/support.rb

@@ -1,33 +0,0 @@
-# namespace for dynamically gnerated schema classes
-module Quickbooks::QBXML; end
-module Quickbooks::QBPOSXML; end
-
-module Quickbooks::Support
-
-  def to_attribute_name(obj)
-    name = \
-      case obj
-      when Class
-        simple_class_name(obj)
-      when Nokogiri::XML::Element
-        obj.name
-      else
-        obj.to_s
-      end
-    inflector.underscore(name)
-  end
-
-  def simple_class_name(klass)
-    klass.to_s.split("::").last
-  end
-
-  # easily convert between CamelCase and under_score
-  def inflector
-    ActiveSupport::Inflector
-  end
-
-  def log
-    Quickbooks::API.log
-  end
-
-end

data/lib/quickbooks/support/api.rb

@@ -1,98 +0,0 @@
-module Quickbooks::Support::API
-  include Quickbooks
-
-  API_ROOT = File.join(File.dirname(__FILE__), '..', '..', '..').freeze
-  XML_SCHEMA_PATH = File.join(API_ROOT, 'xml_schema').freeze   
-  RUBY_SCHEMA_PATH = File.join(API_ROOT, 'ruby_schema').freeze 
-
-  SCHEMA_MAP = {
-    :qb    => {:dtd_file => "qbxmlops70.xml", 
-               :namespace => QBXML, 
-               :container_class => lambda { Quickbooks::QBXML::QBXML },
-               :required_xml_attributes => {
-                 "onError" => "stopOnError"
-               }
-              }.freeze,
-    :qbpos => {:dtd_file => "qbposxmlops30.xml", 
-               :namespace => QBPOSXML, 
-               :container_class => lambda { Quickbooks::QBPOSXML::QBPOSXML },
-               :required_xml_attributes => {
-                 "onError" => "stopOnError"
-               }
-              }.freeze,
-  }.freeze
-
-  DEFAULT_LOG_LEVEL = 1
-
-private
-
-  def valid_schema_types
-    SCHEMA_MAP.keys
-  end
-
-  def valid_schema_type?
-    SCHEMA_MAP.include?(schema_type)
-  end
-
-  def get_dtd_file
-    "#{XML_SCHEMA_PATH}/#{SCHEMA_MAP[schema_type][:dtd_file]}" 
-  end
-
-  def get_schema_namespace
-    SCHEMA_MAP[schema_type][:namespace]
-  end
-
-  def get_container_class
-    SCHEMA_MAP[schema_type][:container_class].call
-  end
-
-  def get_disk_cache_path
-    "#{RUBY_SCHEMA_PATH}/#{schema_type.to_s}"
-  end
-
-  def get_template_cache_path
-    "#{RUBY_SCHEMA_PATH}/#{schema_type.to_s}/templates"
-  end
-
-  def get_required_xml_attributes
-    SCHEMA_MAP[schema_type][:required_xml_attributes]
-  end
-
-  # fetches all the dynamically generated schema classes
-  def cached_classes
-    cached_classes = SCHEMA_MAP.inject({}) do |h, (schema_type, opts)|
-      namespace = opts[:namespace]
-      h[schema_type] = namespace.constants.map { |klass| namespace.const_get(klass) }; h
-    end
-    cached_classes[schema_type]
-  end
-
-  def is_cached_class?(klass)
-    SCHEMA_MAP.any? do |schema_type, opts|
-      namespace = opts[:namespace]
-      namespace.constants.include?(simple_class_name(klass))
-    end
-  end
-
-  def find_nested_key(hash, key)
-    hash.each do |k,v|
-      path = [k]
-      if k == key
-        return path
-      elsif v.is_a? Hash
-        nested_val = find_nested_key(v, key)
-        nested_val ? (return path + nested_val) : nil
-      end
-    end
-    return nil
-  end
-
-  def build_hash_wrapper(path, value)
-    hash_constructor = lambda { |h, k| h[k] = Hash.new(&hash_constructor) }
-
-    wrapped_data = Hash.new(&hash_constructor)
-    path.inject(wrapped_data) { |h, k| k == path.last ? h[k] = value: h[k] }
-    wrapped_data
-  end
-
-end

data/lib/quickbooks/support/logger.rb

@@ -1,56 +0,0 @@
-require 'forwardable'
-
-class Quickbooks::Support::Logger
-  extend Forwardable
-
-  def_delegators :@logger, :level, :flush, :auto_flushing=
-
-  DEFAULT_FORMATTER = "%s"
-  DEFAULT_PADDING = ""
-  PADDING_CHAR = " "
-
-  def initialize(log_file, log_level, log_count = nil, log_size = nil)
-    @logger = ActiveSupport::BufferedLogger.new(log_file, log_level)
-    @padding, @formatter = {}, {}
-  end
-
-  def buffer
-    buf = @logger.send(:buffer)
-    buf && buf.join('')
-  end
-
-  # overwrite all the logging methods
-  class_eval do
-    [:debug, :info, :warn, :error, :fatal, :unknown].each do |method|
-      define_method(method) do |message|
-        @logger.send(method, (padding + formatter) % message.to_s)
-      end
-    end
-  end
-
-  def indent(indent_level)
-    @padding[Thread.current] = \
-      if indent_level == :reset
-        ""
-      elsif indent_level > 0
-        padding + (PADDING_CHAR * indent_level)
-      else
-        padding[0..(-1+indent_level)]
-      end
-  end
-
-  def formatter=(format)
-    @formatter[Thread.current] = format
-  end
-
-protected
-
-  def padding
-    @padding[Thread.current] ||= DEFAULT_PADDING
-  end
-  
-  def formatter
-    @formatter[Thread.current] ||= DEFAULT_FORMATTER
-  end
-
-end

data/spec/quickbooks/qbxml_spec.rb

@@ -1,23 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
-
-describe Quickbooks::QbxmlBase do
-
-  it "should have a type conversion map with all qb types" do
-  end
-
-  it "should build up a wrapper object given an attribute hash" do
-  end
-
-  it "should convert a wrapper object to its equivalent qbxml" do
-  end
-
-  it "should return the attribute values of the wrapper object" do
-  end
-
-  it "should return the attribute names of the wrapper class" do
-  end
-
-  it "should return the type map of the wrapper class" do
-  end
-
-end

data/spec/quickbooks/support_spec.rb

@@ -1,118 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
-
-include Quickbooks::Support
-include Quickbooks::Support::QBXML
-
-describe Quickbooks::Support do
-
-  describe "configuration helpers" do
-
-    it "should return the supported schema types" do
-      valid_schema_types.should be_an_instance_of(Array)
-      valid_schema_types.include?(:qb).should be_true 
-      valid_schema_types.include?(:qbpos).should be_true 
-    end
-
-    it "should check if a particular schema type is supported" do
-      self.stub!(:schema_type => :qb)
-      valid_schema_type?.should be_true
-      self.stub!(:schema_type => :qbpos)
-      valid_schema_type?.should be_true
-      self.stub!(:schema_type => :doesntexist)
-      valid_schema_type?.should == false
-    end
-    
-    it "should determine the dtd file path for any supported schema type" do
-      self.stub!(:schema_type => :qb)
-      File.exists?(get_dtd_file).should be_true
-      self.stub!(:schema_type => :qbpos)
-      File.exists?(get_dtd_file).should be_true
-    end
-
-    it "should determine the namespace for any supported schema type" do
-      self.stub!(:schema_type => :qb)
-      get_schema_namespace.should be_a_kind_of(Module)
-      self.stub!(:schema_type => :qbpos)
-      get_schema_namespace.should be_a_kind_of(Module)
-    end
-
-    it "should determine the container class for any supported schema type" do
-    end
-
-    it "should return the disk cache path" do
-      self.stub!(:schema_type => :qb)
-      File.exists?(get_disk_cache_path).should be_true
-    end
-
-  end
-
-  describe "other helpers" do
-    
-    before :all do
-      @qb_api = Quickbooks::API.new(:qb)
-      @qbpos_api = Quickbooks::API.new(:qbpos)
-    end
-
-    it "should return all the cached classes" do
-      self.stub!(:schema_type => :qb)
-      cached_classes.should be_an_instance_of(Array)
-      cached_classes.empty?.should be_false
-      self.stub!(:schema_type => :qbpos)
-      cached_classes.should be_an_instance_of(Array)
-      cached_classes.empty?.should be_false
-    end
-
-    it "should check if a particular class is cached" do
-      self.stub!(:schema_type => :qb)
-      is_cached_class?(Quickbooks::QBXML::QBXML).should be_true
-      self.stub!(:schema_type => :qbpos)
-      is_cached_class?(Quickbooks::QBPOSXML::QBPOSXML).should be_true
-    end
-
-  end
-
-end
-
-describe Quickbooks::Support::QBXML do
-
-  it "should set useful parsing constants" do
-    XML_DOCUMENT.should == Nokogiri::XML::Document
-    XML_NODE_SET.should == Nokogiri::XML::NodeSet
-    XML_NODE.should == Nokogiri::XML::Node
-    XML_ELEMENT.should == Nokogiri::XML::Element
-    XML_COMMENT= Nokogiri::XML::Comment
-    XML_TEXT.should == Nokogiri::XML::Text
-  end
-
-  describe "xml parsing helpers" do
-
-    before :each do
-      @klass = Nokogiri::XML::NodeSet
-      stub_child = stub(:class => XML_TEXT)
-      @stub_xml_node = stub(:name => "SomeNodeName", :children => [stub_child])
-      @stub_xml_node.stub!(:is_a?).with(anything).and_return(false)
-      @stub_xml_node.stub!(:is_a?).with(XML_ELEMENT).and_return(true)
-    end
-
-    it "should check if a node is a leaf node" do
-      is_leaf_node?(@stub_xml_node).should be_true
-    end
-    
-    it "should convert a class or xml element name to underscored" do
-      to_attribute_name(@klass).should == 'node_set'
-      to_attribute_name(@stub_xml_node).should == 'some_node_name'
-    end
-
-    it "should convert a full class name to a simple class name" do
-      simple_class_name(@klass).should == 'NodeSet'
-    end
-
-  end
-
-  it "should check if a class is already defined in a particular namespace" do
-  end
-
-  it "should cleanup qbxml" do
-  end
-  
-end