baabedo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61434ffedb6433c45f9108a0109cee173e3c54b8
+  data.tar.gz: 5f0caa4785b0db8160ab5ac3a6ec475a5ac14377
+SHA512:
+  metadata.gz: 5334eab942b46b1d8ed382da70675a092919b42628c0ab999a61e755f6516065d68225a181f29da4a424451ea4bec5c7cc0736df1e5f3fc9e23d229fd54cc245
+  data.tar.gz: d28741c3992fa960b5700ec5dc30402feb59ea6b4a253b775af71b8368fdfd25af6ec4b5ef0a46fab3868a0e46cff014432423e132241952b682088297d63fad

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Storeness UG(haftungsbeschraenkt)
+
+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,65 @@
+# Baabedo Ruby bindings
+
+Ruby bindings for the Baabedo API
+
+**still under construction**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'baabedo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install baabedo
+
+## Usage
+
+Simple usage:
+
+```
+Baabedo.access_token = 'xxxxxxxxxxxxx'
+
+Baabedo::Channel.all # list all channels
+```
+
+Advanced usage if you need to handle different access_tokens
+
+```
+client = Baabedo::Client.new
+client.access_token = 'xxxxxxxxxxxxx'
+
+# the access_token and any other configuration made on the client will only be used inside this block
+client.use do
+  Baabedo::Channel.all
+end
+
+```
+
+## Contributing
+
+### For bugfixes:
+
+1. Fork it ( https://github.com/[my-github-username]/baabedo-ruby/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
+
+### For new features:
+
+If you want to request a new feature in the API, please create an issue first. :)
+
+## Thank you
+
+A huge thank you to the Stripe team for stripe-ruby!
+
+This gem is based on [stripe-ruby](https://github.com/stripe/stripe-ruby)
+at [8ba1a0e4908cccf20198791aa8f72acc63575589](https://github.com/stripe/stripe-ruby/tree/8ba1a0e4908cccf20198791aa8f72acc63575589)

data/Rakefile

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

data/baabedo.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'baabedo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "baabedo"
+  spec.version       = Baabedo::VERSION
+  spec.authors       = ["Maximilian Goisser"]
+  spec.email         = ["maximilian.goiser@baabedo.com"]
+  spec.summary       = %q{Ruby bindings for the Baabedo API}
+  spec.description   = %q{Baabedo is an easy to use price optimization AI. See https://baabedo.com}
+  spec.homepage      = "https://baabedo.com/api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency('rest-client', '~> 1.4')
+  spec.add_dependency('json', '~> 1.8.1')
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "guard-rspec", "~> 4.5"
+end

data/lib/baabedo/api_object.rb

@@ -0,0 +1,263 @@
+module Baabedo
+  class APIObject
+    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, opts={})
+      # parameter overloading!
+      if id.kind_of?(Hash)
+        @retrieve_params = id.dup
+        @retrieve_params.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_params = {}
+      end
+
+      @opts = opts
+      @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, opts={})
+      self.new(values[:id]).refresh_from(values, opts)
+    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, opts, partial=false)
+      @opts = opts
+      @original_values = Marshal.load(Marshal.dump(values)) # deep copy
+      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_api_object(v, @opts)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+
+      return 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
+      @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, @opts])
+    end
+
+    def self._load(args)
+      values, opts = Marshal.load(args)
+      construct_from(values, opts)
+    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.include?(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 APIObject
+        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?(APIObject) || 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 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 Baabedo'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/baabedo/api_operations/create.rb

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

data/lib/baabedo/api_operations/delete.rb

@@ -0,0 +1,11 @@
+module Baabedo
+  module APIOperations
+    module Delete
+      def delete(params={}, opts={})
+        opts = Util.normalize_opts(opts)
+        response, opts = request(:delete, url, params, opts)
+        refresh_from(response, opts)
+      end
+    end
+  end
+end

data/lib/baabedo/api_operations/list.rb

@@ -0,0 +1,17 @@
+module Baabedo
+  module APIOperations
+    module List
+      module ClassMethods
+        def all(filters={}, opts={})
+          opts = Util.normalize_opts(opts)
+          response, opts = request(:get, url, filters, opts)
+          Util.convert_to_api_object(response, opts)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/baabedo/api_operations/request.rb

@@ -0,0 +1,41 @@
+module Baabedo
+  module APIOperations
+    module Request
+      module ClassMethods
+        OPTS_KEYS_TO_PERSIST = Set[:access_token, :api_base, :api_version]
+
+        def request(method, url, params={}, opts={})
+          opts = Util.normalize_opts(opts)
+
+          headers = opts.clone
+          access_token = headers.delete(:access_token)
+          api_base = headers.delete(:api_base)
+          # Assume all remaining opts must be headers
+
+          response, opts[:access_token] = Baabedo.request(method, url, access_token, params, headers, api_base)
+
+          # Hash#select returns an array before 1.9
+          opts_to_persist = {}
+          opts.each do |k, v|
+            if OPTS_KEYS_TO_PERSIST.include?(k)
+              opts_to_persist[k] = v
+            end
+          end
+
+          [response, opts_to_persist]
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected
+
+      def request(method, url, params={}, opts={})
+        opts = @opts.merge(Util.normalize_opts(opts))
+        self.class.request(method, url, params, opts)
+      end
+    end
+  end
+end

data/lib/baabedo/api_operations/update.rb

@@ -0,0 +1,17 @@
+module Baabedo
+  module APIOperations
+    module Update
+      def save(params={})
+        values = self.class.serialize_params(self).merge(params)
+
+        if values.length > 0
+          values.delete(:id)
+
+          response, opts = request(:post, url, values)
+          refresh_from(response, opts)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/baabedo/api_resource.rb

@@ -0,0 +1,37 @@
+module Baabedo
+  class APIResource < APIObject
+    include Baabedo::APIOperations::Request
+
+    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
+      type_endpoint = CGI.escape(class_name.downcase)
+      type_endpoint = type_endpoint.gsub(/y$/, 'ies') # pluralize for companies
+      "/#{Baabedo.api_version}/#{type_endpoint}"
+    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, opts = request(:get, url, @retrieve_params)
+      refresh_from(response, opts)
+    end
+
+    def self.retrieve(id, opts={})
+      opts = Util.normalize_opts(opts)
+      instance = self.new(id, opts)
+      instance.refresh
+      instance
+    end
+  end
+end

data/lib/baabedo/client.rb

@@ -0,0 +1,29 @@
+module Baabedo
+  class Client
+    attr_accessor :access_token, :api_base, :api_version, :verify_ssl_certs
+
+    def use
+      Baabedo.with_mutex do
+        begin
+          save = {}
+          save[:access_token] = Baabedo.access_token
+          save[:api_base] = Baabedo.api_base
+          save[:api_version] = Baabedo.api_version
+          save[:verify_ssl_certs] = Baabedo.verify_ssl_certs
+
+          Baabedo.access_token = access_token if access_token
+          Baabedo.api_base = api_base if api_base
+          Baabedo.api_version = api_version if api_version
+          Baabedo.verify_ssl_certs = verify_ssl_certs if verify_ssl_certs
+
+          yield
+        ensure
+          Baabedo.access_token = save[:access_token]
+          Baabedo.api_base = save[:api_base]
+          Baabedo.api_version = save[:api_version]
+          Baabedo.verify_ssl_certsapi_version = save[:verify_ssl_certs]
+        end
+      end
+    end
+  end
+end

data/lib/baabedo/errors/api_connection_error.rb

@@ -0,0 +1,4 @@
+module Baabedo
+  class APIConnectionError < BaabedoError
+  end
+end

data/lib/baabedo/errors/api_error.rb

@@ -0,0 +1,4 @@
+module Baabedo
+  class APIError < BaabedoError
+  end
+end

data/lib/baabedo/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module Baabedo
+  class AuthenticationError < BaabedoError
+  end
+end