moonclerk 1.0.1

data/lib/moonclerk/form.rb

@@ -0,0 +1,5 @@
+module Moonclerk
+  class Form < APIResource
+    extend Moonclerk::APIOperations::List
+  end
+end

data/lib/moonclerk/list_object.rb

@@ -0,0 +1,98 @@
+module Moonclerk
+  class ListObject < APIResource
+    include Enumerable
+    include Moonclerk::APIOperations::List
+
+    # This accessor allows a `ListObject` to inherit a count that was given to
+    # a predecessor. This allows consistent counts as a user pages through
+    # resources. Offset is used to shift the starting point of the list.
+    attr_accessor :count, :offset
+
+    # An empty list object. This is returned from +next+ when we know that
+    # there isn't a next page in order to replicate the behavior of the API
+    # when it attempts to return a page beyond the last.
+    def self.empty_list
+      ListObject.construct_from({ data: [], object: "" })
+    end
+
+    def [](k)
+      case k
+      when String, Symbol
+        super
+      else
+        raise ArgumentError.new("You tried to access the #{k.inspect} index, but ListObject types only support String keys.")
+      end
+    end
+
+    # Iterates through each resource in the page represented by the current
+    # `ListObject`.
+    #
+    # Note that this method makes no effort to fetch a new page when it gets to
+    # the end of the current page's resources. See also +auto_paging_each+.
+    def each(&blk)
+      self.data.each(&blk)
+    end
+
+    # Iterates through each resource in all pages, making additional fetches to
+    # the API as necessary.
+    #
+    # Note that this method will make as many API calls as necessary to fetch
+    # all resources. For more granular control, please see +each+ and
+    # +next_page+.
+    def auto_paging_each(&blk)
+      return enum_for(:auto_paging_each) unless block_given?
+
+      page = self
+      loop do
+        page.each(&blk)
+        page = page.next_page
+        break if page.empty?
+      end
+    end
+
+    # Returns true if the page object contains no elements.
+    def empty?
+      self.data.blank?
+    end
+
+    def retrieve(id)
+      id, retrieve_params = Util.normalize_id(id)
+      response = request(:get,"#{url}/#{CGI.escape(id)}", retrieve_params)
+      Util.convert_to_moonclerk_object(response)
+    end
+
+    def create(params = {})
+      response = request(:post, url, params)
+      Util.convert_to_moonclerk_object(response)
+    end
+
+    # Fetches the next page in the resource list (if there is one).
+    #
+    # This method will try to respect the count of the current page. If none
+    # was given, the default count will be fetched again.
+    def next_page(params = {})
+      params = {
+        :count          => count, # may be nil
+        :offset         => (offset || 0) + (count || 20),
+      }.merge(params)
+
+      list(params)
+    end
+
+    # Fetches the previous page in the resource list (if there is one).
+    #
+    # This method will try to respect the count of the current page. If none
+    # was given, the default count will be fetched again.
+    def previous_page(params = {})
+      new_offset = (offset || 0) - (count || 20)
+      new_offset = 0 if new_offset < 0
+
+      params = {
+        :count         => count, # may be nil
+        :offset        => new_offset,
+      }.merge(params)
+
+      list(params)
+    end
+  end
+end

data/lib/moonclerk/moonclerk_object.rb

@@ -0,0 +1,309 @@
+module Moonclerk
+  class MoonclerkObject
+    include Enumerable
+
+    @@permanent_attributes = Set.new([:id])
+
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    def initialize(id = nil)
+      id, @retrieve_params = Util.normalize_id(id)
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      @values[:id] = id if id
+    end
+
+    def self.construct_from(values)
+      values = Moonclerk::Util.symbolize_names(values)
+      self.new(values[:id]).refresh_from(values)
+    end
+
+    # Determines the equality of two Moonclerk objects. Moonclerk objects are
+    # considered to be equal if they have the same set of values and each one
+    # of those values is the same.
+    def ==(other)
+      @values == other.instance_variable_get(:@values)
+    end
+
+    def to_s(*args)
+      JSON.pretty_generate(@values)
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
+
+    def refresh_from(values)
+      @original_values = Marshal.load(Marshal.dump(values)) # deep copy
+
+      removed = Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added, values)
+      end
+
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+
+      update_attributes(values)
+      values.each do |k, _|
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+
+      return self
+    end
+
+    # Mass assigns attributes on the model.
+    def update_attributes(values)
+      values.each do |k, v|
+        if !@@permanent_attributes.include?(k) && !self.respond_to?(:"#{k}=")
+          next
+        end
+
+        
+        if self.is_a?(Moonclerk::ListObject) && k == :data
+          @values[k] = Util.convert_to_moonclerk_object(v, values[:object])
+        else
+          @values[k] = Util.convert_to_moonclerk_object(v)
+        end
+
+        @unsaved_values.add(k)
+      end
+      self
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      JSON.generate(@values)
+    end
+
+    def as_json(*a)
+      @values.as_json(*a)
+    end
+
+    def to_hash
+      maybe_to_hash = lambda do |value|
+        value.respond_to?(:to_hash) ? value.to_hash : value
+      end
+
+      @values.inject({}) do |acc, (key, value)|
+        acc[key] = case value
+                   when Array
+                     value.map(&maybe_to_hash)
+                   else
+                     maybe_to_hash.call(value)
+                   end
+        acc
+      end
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    def _dump(level)
+      Marshal.dump([@values])
+    end
+
+    def self._load(args)
+      values = Marshal.load(args)
+      construct_from(values)
+    end
+
+    if RUBY_VERSION < '1.9.2'
+      def respond_to?(symbol)
+        @values.has_key?(symbol) || super
+      end
+    end
+
+    def serialize_nested_object(key)
+      new_value = @values[key]
+      if new_value.is_a?(APIResource)
+        return {}
+      end
+
+      if @unsaved_values.include?(key)
+        # the object has been reassigned
+        # e.g. as object.key = {foo => bar}
+        update = new_value
+        new_keys = update.keys.map(&:to_sym)
+
+        # remove keys at the server, but not known locally
+        if @original_values[key]
+          keys_to_unset = @original_values[key].keys - new_keys
+          keys_to_unset.each {|key| update[key] = ''}
+        end
+
+        update
+      else
+        # can be serialized normally
+        self.class.serialize_params(new_value)
+      end
+    end
+
+    def self.serialize_params(obj, original_value=nil)
+      case obj
+      when nil
+        ''
+      when MoonclerkObject
+        unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+        obj_values = obj.instance_variable_get(:@values)
+        update_hash = {}
+
+        unsaved_keys.each do |k|
+          update_hash[k] = serialize_params(obj_values[k])
+        end
+
+        obj_values.each do |k, v|
+          if v.is_a?(MoonclerkObject) || v.is_a?(Hash)
+            update_hash[k] = obj.serialize_nested_object(k)
+          elsif v.is_a?(Array)
+            original_value = obj.instance_variable_get(:@original_values)[k]
+            if original_value && original_value.length > v.length
+              # url params provide no mechanism for deleting an item in an array,
+              # just overwriting the whole array or adding new items. So let's not
+              # allow deleting without a full overwrite until we have a solution.
+              raise ArgumentError.new(
+                "You cannot delete an item from an array, you must instead set a new array"
+              )
+            end
+            update_hash[k] = serialize_params(v, original_value)
+          end
+        end
+
+        update_hash
+      when Array
+        update_hash = {}
+        obj.each_with_index do |value, index|
+          update = serialize_params(value)
+          if update != {} && (!original_value || update != original_value[index])
+            update_hash[index] = update
+          end
+        end
+
+        if update_hash == {}
+          nil
+        else
+          update_hash
+        end
+      else
+        obj
+      end
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def protected_fields
+      []
+    end
+
+    def remove_accessors(keys)
+      f = protected_fields
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if f.include?(k)
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys, values)
+      f = protected_fields
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if f.include?(k)
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            if v == ""
+              raise ArgumentError.new(
+                "You cannot set #{k} to an empty string." \
+                "We interpret empty strings as nil in requests." \
+                "You may set #{self}.#{k} = nil to delete the property.")
+            end
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+
+          if [FalseClass, TrueClass].include?(values[k].class)
+            k_bool = :"#{k}?"
+            define_method(k_bool) { @values[k] }
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      # TODO: only allow setting in updateable classes.
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+
+        # the second argument is only required when adding boolean accessors
+        add_accessors([attr], {})
+
+        begin
+          mth = method(name)
+        rescue NameError
+          raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
+        end
+        return mth.call(args[0])
+      else
+        return @values[name] if @values.has_key?(name)
+      end
+
+      begin
+        super
+      rescue NoMethodError => e
+        if @transient_values.include?(name)
+          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Moonclerk's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
+        else
+          raise
+        end
+      end
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      @values && @values.has_key?(symbol) || super
+    end
+  end
+end

data/lib/moonclerk/payment.rb

@@ -0,0 +1,10 @@
+module Moonclerk
+  class Payment < APIResource
+    extend Moonclerk::APIOperations::List
+    @permitted_attributes = [:form_id,
+                             :customer_id,
+                             :date_from, 
+                             :date_to, 
+                             :status]
+  end
+end

data/lib/moonclerk/util.rb

@@ -0,0 +1,49 @@
+module Moonclerk
+  module Util
+    def self.object_classes
+      @object_classes ||= {
+        'customer' => Customer,
+        'form' => Form,
+        'payment' => Payment
+      }
+    end
+
+    def self.convert_to_moonclerk_object(resp, class_name = nil)
+      case resp
+      when Array
+        resp.map { |i| convert_to_moonclerk_object(i, class_name) }
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic MoonclerkObject
+        object_classes.fetch(class_name, MoonclerkObject).construct_from(resp)
+      else
+        resp
+      end
+    end
+
+    def self.normalize_id(id)
+      if id.kind_of?(Hash) # overloaded id
+        params_hash = id.dup
+        id = params_hash.delete(:id)
+      else
+        params_hash = {}
+      end
+      [id, params_hash]
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new_hash = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new_hash[key] = symbolize_names(value)
+        end
+        new_hash
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+  end
+end