boffinio 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc5e3dd39ced57fc37476164d47fa27484c0d44f
+  data.tar.gz: c6580ad97f7899de92e4e43e347a599bdeb3b69b
+SHA512:
+  metadata.gz: 5c5798f070896462537939c5337c8d2308dd1f8927146757793f75e258cdc20db969b08fa94dfa5dfadee64b115e378c8036a142b77eb774bffeeccbc5859b70
+  data.tar.gz: 3f189982b3af8be9e9ccc467aa8832a28312820157679b0693e877ee96eff3426aafe9211a7af340f449105f28ca8b5d5057062b414a98aedaecd45ed3e228d3

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in boffinio.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tim Williams
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,29 @@
+# Boffinio
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'boffinio'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install boffinio
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/boffinio/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/boffinio.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'boffinio/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "boffinio"
+  spec.version       = BoffinIO::VERSION
+  spec.authors       = ["Tim Williams"]
+  spec.email         = ["tim@teachmatic.com"]
+  spec.summary       = %q{Gem wrapper for the Boffin.io API}
+  spec.description   = %q{Gem wrapper for the Boffin.io API. Officially supported and maintained by the Boffin.io team }
+  spec.homepage      = "http://www.boffin.io"
+  spec.license       = "MIT"
+
+  spec.files         =  `git ls-files`.split("\n")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "vcr", '~> 2.9'
+  spec.add_development_dependency "webmock",'~> 1.20'
+
+  spec.add_dependency('rest-client', '~> 1.4')
+  spec.add_dependency('json', '~> 1.8')
+  spec.add_dependency('mime-types', '>= 1.25', '< 3.0')
+
+end

data/lib/boffinio/api_operations/create.rb

@@ -0,0 +1,16 @@
+module BoffinIO
+  module APIOperations
+    module Create
+      module ClassMethods
+        def create(params={}, api_key=nil)
+          response, api_key = BoffinIO.request(:post, self.url, api_key, params)
+          Util.convert_to_boffinio_object(response, api_key)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/boffinio/api_operations/delete.rb

@@ -0,0 +1,11 @@
+module BoffinIO
+  module APIOperations
+    module Delete
+      def delete(params = {})
+        response, api_key = BoffinIO.request(:delete, url, @api_key, params)
+        refresh_from(response, api_key)
+        self
+      end
+    end
+  end
+end

data/lib/boffinio/api_operations/list.rb

@@ -0,0 +1,16 @@
+module BoffinIO
+  module APIOperations
+    module List
+      module ClassMethods
+        def all(filters={}, api_key=nil)
+          response, api_key = BoffinIO.request(:get, url, api_key, filters)
+          Util.convert_to_boffinio_object(response, api_key)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/boffinio/api_operations/update.rb

@@ -0,0 +1,57 @@
+module BoffinIO
+  module APIOperations
+    module Update
+      def save(opts={})
+        values = serialize_params(self).merge(opts)
+
+        if @values[:metadata]
+          values[:metadata] = serialize_metadata
+        end
+
+        if values.length > 0
+          values.delete(:id)
+
+          response, api_key = BoffinIO.request(:put, url, @api_key, values)
+          refresh_from(response, api_key)
+        end
+        self
+      end
+
+      def serialize_metadata
+        if @unsaved_values.include?(:metadata)
+          # the metadata object has been reassigned
+          # i.e. as object.metadata = {key => val}
+          metadata_update = @values[:metadata]  # new hash
+          new_keys = metadata_update.keys.map(&:to_sym)
+          # remove keys at the server, but not known locally
+          keys_to_unset = @previous_metadata.keys - new_keys
+          keys_to_unset.each {|key| metadata_update[key] = ''}
+
+          metadata_update
+        else
+          # metadata is a BoffinIOObject, and can be serialized normally
+          serialize_params(@values[:metadata])
+        end
+      end
+
+      def serialize_params(obj)
+        case obj
+        when nil
+          ''
+        when BoffinIOObject
+          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
+
+          update_hash
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/boffinio/api_resource.rb

@@ -0,0 +1,33 @@
+module BoffinIO
+  class APIResource < BoffinIOObject
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.url()
+      if self == APIResource
+        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Charge, Customer, etc.)')
+      end
+      "/v1/#{CGI.escape(class_name.downcase)}s"
+    end
+
+    def url
+      unless id = self['id']
+        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+      end
+      "#{self.class.url}/#{CGI.escape(id)}"
+    end
+
+    def refresh
+      response, api_key = BoffinIO.request(:get, url, @api_key, @retrieve_options)
+      refresh_from(response, api_key)
+      self
+    end
+
+    def self.retrieve(id, api_key=nil)
+      instance = self.new(id, api_key)
+      instance.refresh
+      instance
+    end
+  end
+end

data/lib/boffinio/boffinio_object.rb

@@ -0,0 +1,190 @@
+module BoffinIO
+  class BoffinIOObject
+    include Enumerable
+
+    attr_accessor :api_key
+    @@permanent_attributes = Set.new([:api_key, :id])
+
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    def initialize(id=nil, api_key=nil)
+      # parameter overloading!
+      if id.kind_of?(Hash)
+        @retrieve_options = id.dup
+        @retrieve_options.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_options = {}
+      end
+
+      @api_key = api_key
+      @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, api_key=nil)
+      obj = self.new(values[:id], api_key)
+      obj.refresh_from(values, api_key)
+      obj
+    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, api_key, partial=false)
+      @api_key = api_key
+
+      @previous_metadata = values[:metadata]
+      removed = partial ? Set.new : 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)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = Util.convert_to_boffinio_object(v, api_key)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+    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
+      @values.inject({}) do |acc, (key, value)|
+        acc[key] = value.respond_to?(:to_hash) ? value.to_hash : value
+        acc
+      end
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    def _dump(level)
+      Marshal.dump([@values, @api_key])
+    end
+
+    def self._load(args)
+      values, api_key = Marshal.load(args)
+      construct_from(values, api_key)
+    end
+
+    if RUBY_VERSION < '1.9.2'
+      def respond_to?(symbol)
+        @values.has_key?(symbol) || super
+      end
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |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)
+      metaclass.instance_eval do
+        keys.each do |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
+        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
+        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 BoffinIO'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/boffinio/customer.rb

@@ -0,0 +1,36 @@
+API_URL = "customers"
+
+module BoffinIO 
+  class Customer < APIResource
+    include BoffinIO::APIOperations::List
+    include BoffinIO::APIOperations::Create
+    include BoffinIO::APIOperations::Update
+   
+   def cancel_subscription(params={})
+      response, api_key = BoffinIO.request(:delete, subscriptions_url, @api_key, params)
+      refresh_from({ :subscription => response }, api_key, true)
+      subscription
+    end
+
+    def update_subscription(params)
+      response, api_key = BoffinIO.request(:post, subscriptions_url, @api_key, params)
+      refresh_from({ :subscription => response }, api_key, true)
+      subscription
+    end
+
+    def create_subscription(params)
+      response, api_key = BoffinIO.request(:post, subscriptions_url, @api_key, params)
+      refresh_from({ :subscription => response }, api_key, true)
+      subscription
+    end
+
+  private
+    def subscription_url
+      url + '/subscription'
+    end
+
+    def subscriptions_url
+      url + '/subscriptions'
+    end
+  end
+end

data/lib/boffinio/errors/api_error.rb

@@ -0,0 +1,4 @@
+module BoffinIO
+  class APIError < BoffinIOError
+  end
+end

data/lib/boffinio/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module BoffinIO
+  class AuthenticationError < BoffinIOError
+  end
+end

data/lib/boffinio/errors/boffinio_error.rb

@@ -0,0 +1,20 @@
+module BoffinIO
+  class BoffinIOError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/boffinio/errors/invalid_request_error.rb

@@ -0,0 +1,4 @@
+module BoffinIO
+  class InvalidRequestError < BoffinIOError
+  end
+end

data/lib/boffinio/list_object.rb

@@ -0,0 +1,35 @@
+module BoffinIO
+  class ListObject < BoffinIOObject
+
+    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. (HINT: List calls return an object with a 'data' (which is the data array). You likely want to call #data[#{k.inspect}])")
+      end
+    end
+
+    def each(&blk)
+      self.data.each(&blk)
+    end
+
+    def retrieve(id, api_key=nil)
+      api_key ||= @api_key
+      response, api_key = BoffinIO.request(:get,"#{url}/#{CGI.escape(id)}", api_key)
+      Util.convert_to_boffinio_object(response, api_key)
+    end
+
+    def create(params={}, api_key=nil)
+      api_key ||= @api_key
+      response, api_key = BoffinIO.request(:post, url, api_key, params)
+      Util.convert_to_boffinio_object(response, api_key)
+    end
+
+    def all(params={}, api_key=nil)
+      api_key ||= @api_key
+      response, api_key = BoffinIO.request(:get, url, api_key, params)
+      Util.convert_to_boffinio_object(response, api_key)
+    end
+  end
+end

data/lib/boffinio/plan.rb

@@ -0,0 +1,7 @@
+module BoffinIO 
+  class Plan < APIResource
+    include BoffinIO::APIOperations::List
+    include BoffinIO::APIOperations::Create
+  
+  end
+end

data/lib/boffinio/subscription.rb

@@ -0,0 +1,10 @@
+module BoffinIO 
+  class Subscription < APIResource
+    include BoffinIO::APIOperations::Create
+    include BoffinIO::APIOperations::Update
+
+    def url
+      "#{Customer.url}/#{CGI.escape(customer)}/subscriptions/#{CGI.escape(id)}"
+    end
+  end
+end

data/lib/boffinio/util.rb

@@ -0,0 +1,87 @@
+module BoffinIO
+ module Util
+
+    def self.objects_to_ids(h)
+      case h
+      when Hash
+        res = {}
+        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+        res
+      when Array
+        h.map { |v| objects_to_ids(v) }
+      else
+        h
+      end
+    end
+
+    def self.object_classes
+      @object_classes ||= {
+        'list' => ListObject,
+        'customer' => Customer,
+        'subscription' => Subscription,
+        'plan' => Plan
+      }
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new[key] = symbolize_names(value)
+        end
+        new
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+  def self.url_encode(key)
+    URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+  end
+
+   def self.flatten_params(params, parent_key=nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+
+    def self.convert_to_boffinio_object(resp, api_key)
+      case resp
+      when Array
+        resp.map { |i| convert_to_boffinio_object(i, api_key) }
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic BoffinIOObject
+        object_classes.fetch(resp[:object], BoffinIOObject).construct_from(resp, api_key)
+      else
+        resp
+      end
+    end
+end
+end

data/lib/boffinio/version.rb

@@ -0,0 +1,3 @@
+module BoffinIO
+  VERSION = "0.0.1"
+end