Recharge 1.0.0

data/lib/happymapper/attribute.rb

@@ -0,0 +1,3 @@
+module HappyMapper
+  class Attribute < Item; end
+end

data/lib/happymapper/element.rb

@@ -0,0 +1,3 @@
+module HappyMapper
+  class Element < Item; end
+end

data/lib/happymapper/item.rb

@@ -0,0 +1,179 @@
+module HappyMapper
+  class Item
+    attr_accessor :name, :type, :tag, :options, :namespace
+    
+    Types = [String, Float, Time, Date, DateTime, Integer, Boolean]
+    
+    # options:
+    #   :deep   =>  Boolean False to only parse element's children, True to include
+    #               grandchildren and all others down the chain (// in expath)
+    #   :namespace => String Element's namespace if it's not the global or inherited
+    #                  default
+    #   :parser =>  Symbol Class method to use for type coercion.
+    #   :raw    =>  Boolean Use raw node value (inc. tags) when parsing.
+    #   :single =>  Boolean False if object should be collection, True for single object
+    #   :tag    =>  String Element name if it doesn't match the specified name.
+    def initialize(name, type, o={})
+      self.name = name.to_s
+      self.type = type
+      self.tag = o.delete(:tag) || name.to_s
+      self.options = o
+      
+      @xml_type = self.class.to_s.split('::').last.downcase
+    end
+    
+    def constant
+      @constant ||= constantize(type)
+    end
+        
+    def from_xml_node(node, namespace)
+      if primitive?
+        find(node, namespace) do |n|
+          if n.respond_to?(:content)
+            typecast(n.content)
+          else
+            typecast(n.to_s)
+          end
+        end
+      else
+        if options[:parser]
+          find(node, namespace) do |n|
+            if n.respond_to?(:content) && !options[:raw]
+              value = n.content
+            else
+              value = n.to_s
+            end
+
+            begin
+              constant.send(options[:parser].to_sym, value)
+            rescue
+              nil
+            end
+          end
+        else
+          constant.parse(node, options)
+        end
+      end
+    end
+    
+    def xpath(namespace = self.namespace)
+      xpath  = ''
+      xpath += './/' if options[:deep]
+      xpath += "#{DEFAULT_NS}:" if namespace
+      xpath += tag
+      # puts "xpath: #{xpath}"
+      xpath
+    end
+    
+    def primitive?
+      Types.include?(constant)
+    end
+    
+    def element?
+      @xml_type == 'element'
+    end
+    
+    def attribute?
+      !element?
+    end
+    
+    def method_name
+      @method_name ||= name.tr('-', '_')
+    end
+    
+    def typecast(value)
+      return value if value.kind_of?(constant) || value.nil?
+      begin        
+        if    constant == String    then value.to_s
+        elsif constant == Float     then value.to_f
+        elsif constant == Time      then Time.parse(value.to_s)
+        elsif constant == Date      then Date.parse(value.to_s)
+        elsif constant == DateTime  then DateTime.parse(value.to_s)
+        elsif constant == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
+        elsif constant == Integer
+          # ganked from datamapper
+          value_to_i = value.to_i
+          if value_to_i == 0 && value != '0'
+            value_to_s = value.to_s
+            begin
+              Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+            rescue ArgumentError
+              nil
+            end
+          else
+            value_to_i
+          end
+        else
+          value
+        end
+      rescue
+        value
+      end
+    end
+    
+    private
+      def constantize(type)
+        if type.is_a?(String)
+          names = type.split('::')
+          constant = Object
+          names.each do |name|
+            constant =  constant.const_defined?(name) ? 
+                          constant.const_get(name) : 
+                          constant.const_missing(name)
+          end
+          constant
+        else
+          type
+        end
+      end
+      
+      def find(node, namespace, &block)
+        if options[:namespace] == false
+          namespace = nil
+        elsif options[:namespace]
+          # from an element definition
+          namespace = "#{DEFAULT_NS}:#{options[:namespace]}"
+        elsif self.namespace
+          # this node has a custom namespace (that is present in the doc)
+          namespace = "#{DEFAULT_NS}:#{self.namespace}"
+        end
+        
+        if element?
+          if(options[:single].nil? || options[:single])
+            result = node.find_first(xpath(namespace), namespace)
+          else
+            result = node.find(xpath(namespace))
+          end
+          # puts "vfxn: #{xpath} #{result.inspect}"
+          if result
+            if(options[:single].nil? || options[:single])
+              value = yield(result)
+            else
+              value = []
+
+              result.each do |res|
+                value << yield(res)
+              end
+            end
+            if options[:attributes].is_a?(Hash)
+              result.attributes.each do |xml_attribute|
+                if attribute_options = options[:attributes][xml_attribute.name.to_sym]
+                  attribute_value = Attribute.new(xml_attribute.name.to_sym, *attribute_options).from_xml_node(result, namespace)
+                  result.instance_eval <<-EOV
+                    def value.#{xml_attribute.name}
+                      #{attribute_value.inspect}
+                    end
+                  EOV
+                end
+              end
+            end
+            value
+          else
+            nil
+          end
+        else
+          yield(node[tag])
+        end
+      end
+  end
+end

data/lib/happymapper/version.rb

@@ -0,0 +1,3 @@
+module HappyMapper
+  Version = '0.4.0'
+end

data/lib/happymapper.rb

@@ -0,0 +1,315 @@
+require 'rubygems'
+require 'date'
+require 'time'
+require 'xml'
+
+class Boolean; end
+
+module HappyMapper
+
+  DEFAULT_NS = "happymapper"
+
+  def self.included(base)
+    base.instance_variable_set("@attributes", {})
+    base.instance_variable_set("@elements", {})
+    base.instance_variable_set("@registered_namespaces", {})
+    
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def attribute(name, type, options={})
+      attribute = Attribute.new(name, type, options)
+      @attributes[to_s] ||= []
+      @attributes[to_s] << attribute
+      attr_accessor attribute.method_name.intern
+    end
+
+    def attributes
+      @attributes[to_s] || []
+    end
+
+    def element(name, type, options={})
+      element = Element.new(name, type, options)
+      @elements[to_s] ||= []
+      @elements[to_s] << element
+      attr_accessor element.method_name.intern
+    end
+
+    def content(name)
+      @content = name
+      attr_accessor name
+    end
+
+    def after_parse_callbacks
+      @after_parse_callbacks ||= []
+    end
+
+    def after_parse(&block)
+      after_parse_callbacks.push(block)
+    end
+
+    def elements
+      @elements[to_s] || []
+    end
+
+    def has_one(name, type, options={})
+      element name, type, {:single => true}.merge(options)
+    end
+
+    def has_many(name, type, options={})
+      element name, type, {:single => false}.merge(options)
+    end
+
+    # Specify a namespace if a node and all its children are all namespaced
+    # elements. This is simpler than passing the :namespace option to each
+    # defined element.
+    def namespace(namespace = nil)
+      @namespace = namespace if namespace
+      @namespace
+    end
+    
+    def register_namespace(namespace, ns)
+      @registered_namespaces.merge!(namespace => ns)
+    end
+
+    def tag(new_tag_name)
+      @tag_name = new_tag_name.to_s
+    end
+
+    def tag_name
+      @tag_name ||= to_s.split('::')[-1].downcase
+    end
+
+    def parse(xml, options = {})
+      if xml.is_a?(XML::Node)
+        node = xml
+      else
+        if xml.is_a?(XML::Document)
+          node = xml.root
+        else
+          node = XML::Parser.string(xml).parse.root
+        end
+
+        root = node.name == tag_name
+      end
+
+      namespace = @namespace || (node.namespaces && node.namespaces.default)
+      namespace = "#{DEFAULT_NS}:#{namespace}" if namespace
+
+      xpath = root ? '/' : './/'
+      xpath += "#{DEFAULT_NS}:" if namespace
+      xpath += tag_name
+
+      nodes = node.find(xpath, Array(namespace))
+      collection = nodes.collect do |n|
+        obj = new
+
+        attributes.each do |attr|
+          obj.send("#{attr.method_name}=",
+          attr.from_xml_node(n, namespace))
+        end
+
+        elements.each do |elem|
+          obj.send("#{elem.method_name}=",
+          elem.from_xml_node(n, namespace))
+        end
+
+        obj.send("#{@content}=", n.content) if @content
+
+        obj.class.after_parse_callbacks.each { |callback| callback.call(obj) }
+
+        obj
+      end
+
+      # per http://libxml.rubyforge.org/rdoc/classes/LibXML/XML/Document.html#M000354
+      nodes = nil
+
+      if options[:single] || root
+        collection.first
+      else
+        collection
+      end
+    end
+
+  end
+
+  #
+  # Create an xml representation of the specified class based on defined
+  # HappyMapper elements and attributes. The method is defined in a way
+  # that it can be called recursively by classes that are also HappyMapper
+  # classes, allowg for the composition of classes.
+  #
+  def to_xml(parent_node = nil, default_namespace = nil)
+
+    #
+    # Create a tag that uses the tag name of the class that has no contents
+    # but has the specified namespace or uses the default namespace
+    #
+    current_node = XML::Node.new(self.class.tag_name)
+
+
+    if parent_node
+      #
+      # if #to_xml has been called with a parent_node that means this method
+      # is being called recursively (or a special case) and we want to return
+      # the parent_node with the new node as a child
+      #
+      parent_node << current_node
+    else
+      #
+      # If #to_xml has been called without a Node (and namespace) that
+      # means we want to return an xml document
+      #
+      write_out_to_xml = true
+    end
+    
+    #
+    # Add all the registered namespaces to the current node and the current node's
+    # root element. Without adding it to the root element it is not possible to
+    # parse or use xpath to find elements.
+    #
+    if self.class.instance_variable_get('@registered_namespaces')
+      
+      # Given a node, continue moving up to parents until there are no more parents
+      find_root_node = lambda {|node| while node.parent? ; node = node.parent ; end ; node }
+      root_node = find_root_node.call(current_node)
+      
+      # Add the registered namespace to the found root node only if it does not already have one defined
+      self.class.instance_variable_get('@registered_namespaces').each_pair do |prefix,href|
+        XML::Namespace.new(current_node,prefix,href)
+        XML::Namespace.new(root_node,prefix,href) unless root_node.namespaces.find_by_prefix(prefix)
+      end
+    end
+
+    #
+    # Determine the tag namespace if one has been specified. This value takes
+    # precendence over one that is handed down to composed sub-classes.
+    #
+    tag_namespace = current_node.namespaces.find_by_prefix(self.class.namespace) || default_namespace
+    
+    # Set the namespace of the current node to the specified namespace
+    current_node.namespaces.namespace = tag_namespace if tag_namespace
+
+    #
+    # Add all the attribute tags to the current node with their namespace, if one
+    # is defined, or the namespace handed down to the node.
+    #
+    self.class.attributes.each do |attribute|
+      attribute_namespace = current_node.namespaces.find_by_prefix(attribute.options[:namespace]) || default_namespace
+      
+      value = send(attribute.method_name)
+
+      #
+      # If the attribute has a :on_save attribute defined that is a proc or
+      # a defined method, then call those with the current value.
+      #
+      if on_save_operation = attribute.options[:on_save]
+        if on_save_operation.is_a?(Proc)
+          value = on_save_operation.call(value)
+        elsif respond_to?(on_save_operation)
+          value = send(on_save_operation,value)
+        end
+      end
+      
+      current_node[ "#{attribute_namespace ? "#{attribute_namespace.prefix}:" : ""}#{attribute.tag}" ] = value
+    end
+
+    #
+    # All all the elements defined (e.g. has_one, has_many, element) ...
+    #
+    self.class.elements.each do |element|
+
+      tag = element.tag || element.name
+      
+      element_namespace = current_node.namespaces.find_by_prefix(element.options[:namespace]) || tag_namespace
+      
+      value = send(element.name)
+
+      #
+      # If the element defines an :on_save lambda/proc then we will call that
+      # operation on the specified value. This allows for operations to be 
+      # performed to convert the value to a specific value to be saved to the xml.
+      #
+      if on_save_operation = element.options[:on_save]
+        if on_save_operation.is_a?(Proc)
+          value = on_save_operation.call(value)
+        elsif respond_to?(on_save_operation)
+          value = send(on_save_operation,value)
+        end
+      end
+
+      #
+      # Normally a nil value would be ignored, however if specified then
+      # an empty element will be written to the xml
+      #
+      if value.nil? && element.options[:state_when_nil]
+        current_node << XML::Node.new(tag,nil,element_namespace)
+      end
+
+      #
+      # To allow for us to treat both groups of items and singular items
+      # equally we wrap the value and treat it as an array.
+      #
+      if value.nil?
+        values = []
+      elsif value.respond_to?(:to_ary) && !element.options[:single]
+        values = value.to_ary
+      else
+        values = [value]
+      end
+
+
+      values.each do |item|
+
+        if item.is_a?(HappyMapper)
+
+          #
+          # Other HappyMapper items that are convertable should not be called
+          # with the current node and the namespace defined for the element.
+          #
+          item.to_xml(current_node,element_namespace)
+
+        elsif item
+
+          #
+          # When a value exists we should append the value for the tag
+          #
+          current_node << XML::Node.new(tag,item.to_s,element_namespace)
+
+        else
+          
+          #
+          # Normally a nil value would be ignored, however if specified then
+          # an empty element will be written to the xml
+          #
+          current_node << XML.Node.new(tag,nil,element_namespace) if element.options[:state_when_nil]
+
+        end
+
+      end
+
+    end
+
+
+    #
+    # Generate xml from a document if no node was passed as a parameter. Otherwise
+    # this method is being called recursively (or special case) and we should
+    # return the node with this node attached as a child.
+    #
+    if write_out_to_xml
+      document = XML::Document.new
+      document.root = current_node
+      document.to_s
+    else
+      parent_node
+    end
+
+  end
+
+
+end
+
+require File.dirname(__FILE__) + '/happymapper/item'
+require File.dirname(__FILE__) + '/happymapper/attribute'
+require File.dirname(__FILE__) + '/happymapper/element'

data/lib/recharge/base.rb

@@ -0,0 +1,45 @@
+module Recharge
+  class Base
+    class << self
+      def get(uri)
+        client = Client.new()
+        return client.request('GET', uri)
+      end
+      
+      def post(uri, data=nil)
+        client = Client.new()
+        return client.request('POST', uri, data)
+      end
+      
+      def delete(uri)
+        client = Client.new()
+        return client.request('DELETE', uri)
+      end
+      
+      def returnImportantXML(data)
+        require "rexml/document"
+        doc = REXML::Document.new(data)
+        
+        if doc.elements[1].elements[3].length == 1
+          return doc.elements[1].elements[3].elements[1]
+        else 
+          return doc.elements[1].elements[3]
+        end
+      end
+      
+      def returnErrorXML(data)
+        require "rexml/document"
+        doc = REXML::Document.new(data)
+        
+        doc.elements["/response/result/resultDescription"].text
+      end
+      
+      def returnStatusXML(data)
+        require "rexml/document"
+        doc = REXML::Document.new(data)
+        
+        doc.elements["/response/result/resultDescription"]
+      end 
+    end
+  end
+end

data/lib/recharge/charge.rb

@@ -0,0 +1,45 @@
+module Recharge
+  class Charge
+    include HappyMapper
+    
+    tag 'charge'
+  
+    element :id, String
+    element :product, String
+    element :payMethod, String
+    element :billingStartDate, String
+    element :billingEndDate, String
+    element :billingEndAmount, String
+    element :price, String
+    element :intervalValue, String
+    element :intervalUnit, String
+    element :nextChargeDate, String
+    element :totalRevenue, String
+    element :pubID, String
+    element :oneTime, String
+    element :error, String
+    
+    def initialize(id='')
+      @id = id
+    end
+    def self.find_all
+      responseXML = Recharge::Base.get('charges')
+      parse(responseXML.to_s)
+    end
+    def self.find (id)
+      responseXML = Recharge::Base.get('charges/'+id)
+      parse(responseXML.to_s)
+    end
+    def self.create (attributes = {})
+      responseXML = Recharge::Base.post('charges', attributes)
+      parse(responseXML.to_s)
+    end
+    def update (attributes = {})
+      responseXML = Recharge::Base.post('charges/'+self.id, attributes)
+      Charge.parse(responseXML.to_s)
+    end
+    def destroy
+      responseXML = Recharge::Base.delete('charges/'+self.id)
+    end
+  end
+end

data/lib/recharge/client.rb

@@ -0,0 +1,58 @@
+class Client
+  
+  def baseURL
+    "https://www.rechargebilling.com/API/v2/"
+  end
+  
+  def request(method, uri, data=nil)
+    response = sendRequest(method, uri, data)
+    response.assertValidResponse
+    if response.code.to_i == 200
+      if method != "DELETE"
+        Recharge::Base.returnImportantXML(response.body)
+      else
+        Recharge::Base.returnStatusXML(response.body)
+      end
+    else 
+      Recharge::Base.returnErrorXML(response.body)
+    end
+    
+  end
+  
+  def sendRequest(method, uri, data=nil)
+    require "net/https"
+    require "uri"
+    
+    if !Recharge.api_key
+      puts "no api key"
+      return
+    end
+    
+    uri = baseURL+uri
+    uri = URI.parse(uri)
+    
+    if method == "GET"
+      request = Net::HTTP::Get.new(uri.request_uri)
+    end
+    
+    if method == "POST"
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.set_form_data(data)
+    end
+    
+    if method == "DELETE"
+      request = Net::HTTP::Delete.new(uri.request_uri)
+    end
+    
+    request.basic_auth(Recharge.api_key, "")
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    
+    response = http.request(request)
+    
+    return Response.new(response.code, response.body)
+
+  end
+end

data/lib/recharge/customer.rb

@@ -0,0 +1,53 @@
+module Recharge
+  class Customer
+    include HappyMapper
+    
+    tag 'customer'
+  
+    element :id, String
+    element :refID, String
+    element :firstName, String
+    element :lastName, String
+    element :email, String
+    element :company, String
+    element :phone, String
+    element :billingAddress1, String
+    element :billingAddress2, String
+    element :billingCity, String
+    element :billingState, String
+    element :billingZIP, String
+    element :shippingAddress1, String
+    element :shippingAddress2, String
+    element :shippingCity, String
+    element :shippingState, String
+    element :shippingZIP, String
+    element :emailOption, String
+    element :signupDate, String
+    
+    has_many :payMethods, PayMethod
+    has_many :charges, Charge
+    
+    def initialize(id='')
+      @id = id
+    end
+    def self.find_all
+      responseXML = Recharge::Base.get('customers')
+      parse(responseXML.to_s)
+    end
+    def self.find (id)
+      responseXML = Recharge::Base.get('customers/'+id)
+      parse(responseXML.to_s)
+    end
+    def self.create (attributes = {})
+      responseXML = Recharge::Base.post('customers', attributes)
+      parse(responseXML.to_s)
+    end
+    def update (attributes = {})
+      responseXML = Recharge::Base.post('customers/'+self.id, attributes)
+      Customer.parse(responseXML.to_s)
+    end
+    def destroy
+      responseXML = Recharge::Base.delete('customers/'+self.id)
+    end
+  end
+end