synapse_pay 0.0.1

data/lib/synapse_pay/apibits/api_object.rb

@@ -0,0 +1,52 @@
+module SynapsePay
+  class APIObject
+    include Enumerable
+    attr_reader :json
+
+    def self.construct(json)
+      if json.is_a?(Array)
+        return json.map{ |a| APIObject.construct(a) }
+      elsif json.is_a?(Hash)
+        return APIObject.new(json)
+      else
+        return json
+      end
+    end
+
+    def initialize(json=nil)
+      refresh_from(json)
+    end
+
+    def refresh_from(json={})
+      @json = Util.sorta_deep_clone(json)
+      @json.each do |k, v|
+        @json[k] = APIObject.construct(v)
+      end
+      self
+    end
+
+    def inspect
+      @json.inspect
+    end
+
+    def to_json(*args)
+      JSON.generate(@json)
+    end
+
+    def method_missing(name, *args, &blk)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        @json[attr] = args[0]
+      else
+        if @json.respond_to?(name)
+          @json.send(name, *args, &blk)
+        elsif @json.has_key?(name.to_sym)
+          return @json[name.to_sym]
+        else
+          super
+        end
+      end
+    end
+
+  end
+end

data/lib/synapse_pay/apibits/api_resource.rb

@@ -0,0 +1,127 @@
+module SynapsePay
+  class APIResource
+    attr_reader :api_method
+    attr_reader :json
+    attr_reader :client
+
+    def initialize(json=nil, api_method=nil, client=nil)
+      refresh_from(json, api_method, client)
+    end
+
+    def refresh_from(json={}, api_method=nil, client=nil)
+      unless json.is_a?(Hash)
+        json = { :id => json }
+      end
+      json = Util.symbolize_keys(json)
+
+      # Clear or write over any old data
+      clear_api_attributes
+      @api_method = api_method
+      @json = Util.sorta_deep_clone(json)
+      @client = client
+
+      # Use json (not the @json, the cloned copy)
+      json.each do |k, v|
+        if self.class.api_attribute_names.include?(k.to_sym)
+          instance_variable_set("@#{k}", determine_api_attribute_value(k, v))
+        end
+      end
+      self
+    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}> Attributes: " + JSON.pretty_generate(inspect_api_attributes)
+    end
+
+    def inspect_nested
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}>"
+    end
+
+    def to_json(*args)
+      JSON.generate(api_attributes)
+    end
+
+    def self.api_attribute_names
+      @api_attributes.map(&:first)
+    end
+
+    def api_attributes
+      ret = {}
+      self.class.api_attribute_names.each do |attribute|
+        ret[attribute] = self.send(attribute)
+      end
+      ret
+    end
+
+    def inspect_api_attributes
+      ret = {}
+      api_attributes.each do |k, v|
+        if v.is_a?(APIResource)
+          ret[k] = v.inspect_nested
+        else
+          ret[k] = v
+        end
+      end
+      ret
+    end
+
+    # TODO(joncalhoun): Make this work for nested class construction.
+    def changed_api_attributes
+      ret = {}
+      self.api_attributes.each do |name, value|
+        if @json[name] != value
+          ret[name] = value
+        end
+      end
+      ret
+    end
+
+    def clear_api_attributes
+      self.class.api_attribute_names.each do |name|
+        instance_variable_set("@#{name}", nil)
+      end
+    end
+
+    def self.determine_api_attribute_value(name, raw_value)
+      if @api_attributes[name] && @api_attributes[name].has_key?(:constructor)
+        klass = Util.constantize(@api_attributes[name][:constructor])
+        if(klass.respond_to?(:construct))
+          klass.construct(raw_value)
+        else
+          klass.new(raw_value)
+        end
+      else
+        APIObject.construct(raw_value)
+      end
+    end
+    def determine_api_attribute_value(name, raw_value)
+      self.class.determine_api_attribute_value(name, raw_value)
+    end
+
+
+    def self.api_subclasses
+      return @api_subclasses ||= Set.new
+    end
+
+    def self.api_subclass_fetch(name)
+      @api_subclasses_hash ||= {}
+      if @api_subclasses_hash.has_key?(name)
+        @api_subclasses_hash[name]
+      end
+    end
+
+    def self.register_api_subclass(subclass, name=nil)
+      @api_subclasses ||= Set.new
+      @api_subclasses << subclass
+
+      unless name.nil?
+        @api_subclasses_hash ||= {}
+        @api_subclasses_hash[name] = subclass
+      end
+    end
+
+    @api_attributes = {}
+  end
+end

data/lib/synapse_pay/apibits/headers_builder.rb

@@ -0,0 +1,47 @@
+module SynapsePay
+  module HeadersBuilder
+
+    def self.build(headers)
+      headers ||= {}
+      default_headers.merge(headers)
+    end
+
+    def self.default_headers
+      headers = {
+        :user_agent => "SynapsePay/#{SynapsePay.api_version} RubyBindings/#{SynapsePay::VERSION}",
+      }.merge({
+        "Content-Type" => "application/json",
+      })
+
+      begin
+        headers.update(:x_synapse_pay_client_user_agent => JSON.generate(user_agent))
+      rescue => e
+        headers.update(:x_synapse_pay_client_raw_user_agent => user_agent.inspect,
+                       :error => "#{e} (#{e.class})")
+      end
+      headers
+    end
+
+
+
+    def self.user_agent
+      lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+      {
+        :bindings_version => SynapsePay::VERSION,
+        :lang => 'ruby',
+        :lang_version => lang_version,
+        :platform => RUBY_PLATFORM,
+        :publisher => 'synapse_pay',
+        :uname => get_uname
+      }
+    end
+
+    def self.get_uname
+      `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+    rescue Errno::ENOMEM => ex # couldn't create subprocess
+      "uname lookup failed"
+    end
+
+  end
+end

data/lib/synapse_pay/apibits/params_builder.rb

@@ -0,0 +1,30 @@
+module SynapsePay
+  module ParamsBuilder
+
+    def self.clean(params)
+      Util.symbolize_keys(params || {})
+    end
+
+    # Clean the params, and the hash to_merge, and then merge them.
+    # This ensures that we dont get something like { "id" => 123, :id => 321 }.
+    def self.merge(*args)
+      ret = {}
+      args.each do |arg|
+        ret = ret.merge(clean(arg))
+      end
+      ret
+    end
+
+    def self.build(params, api_key=nil, auth_key=nil)
+      default_params.merge(clean(params))
+    end
+
+    def self.default_params
+      params = {
+        :client_id => SynapsePay.client_id,
+        :client_secret => SynapsePay.client_secret,
+      }
+    end
+
+  end
+end

data/lib/synapse_pay/apibits/path_builder.rb

@@ -0,0 +1,38 @@
+module SynapsePay
+  module PathBuilder
+
+    # Take a path like:
+    #   ":path/:id/dogs/:dog_id"
+    # and convert it to:
+    #   "#{object.path}/#{object.id}/dogs/#{params[:id]}" => "/objects/1/dogs/2"
+    #
+    # Path priority is:
+    #   1. Object - this will be a class or an instance of a class.
+    #   2. Params - this is a hash of key values. All keys *must* be symbolized.
+    def self.build(path, object, params)
+      ret = path.dup
+      if ret.include?(":")
+        matches = ret.scan(/:([^\/]*)/).flatten.map(&:to_sym)
+        missing = Set.new(matches)
+
+        matches.each do |match|
+          value = determine_value(match, object, params)
+          missing.delete(match) unless value.nil?
+          ret.sub!(match.inspect, "#{value}")
+        end
+
+        if missing.any?
+          raise ArgumentError.new("Could not determine the full URL. The following values of the path are missing: #{missing.to_a.join(', ')}. Try setting them in your params.")
+        end
+      end
+      ret
+    end
+
+    def self.determine_value(match, object, params)
+      value = object.send(match) if object && object.respond_to?(match)
+      value ||= params[match] if params && params.has_key?(match)
+      value
+    end
+
+  end
+end

data/lib/synapse_pay/apibits/requester.rb

@@ -0,0 +1,104 @@
+module SynapsePay
+  module Requester
+
+    def self.request(method, url, params, headers)
+      method = method.to_sym
+      url, params = prepare_params(method, url, params, headers)
+      request_opts = {
+        :method => method,
+        :url => url,
+        :headers => headers,
+        :payload => params,
+
+        :verify_ssl => false,
+        :open_timeout => 30,
+        :timeout => 60
+      }
+
+      execute_request(request_opts)
+    end
+
+    def self.execute_request(opts)
+      RestClient::Request.execute(opts)
+    end
+
+    def self.get(url, params, headers)
+      self.request(:get, url, params, headers)
+    end
+
+    def self.delete(url, params, headers)
+      self.request(:delete, url, params, headers)
+    end
+
+    def self.put(url, params, headers)
+      self.request(:put, url, params, headers)
+    end
+
+    def self.post(url, params, headers)
+      self.request(:post, url, params, headers)
+    end
+
+    def self.prepare_params(method, url, params, headers)
+      if [:get, :head, :delete].include?(method)
+        unless params.empty?
+          url += URI.parse(url).query ? '&' : '?' + query_string(params)
+        end
+        params = nil
+      else
+        if headers["Content-Type"] == "application/json"
+          params = JSON.generate(params)
+        else
+          headers["Content-Type"] = "application/x-www-form-urlencoded"
+          if !RestClient::Payload.has_file?(params)
+            params = query_string(params)
+          end
+        end
+      end
+      [url, params]
+    end
+
+    def self.query_string(params)
+      params ||= {}
+      if params.any?
+        query_array(params).join('&')
+      else
+        ""
+      end
+    end
+
+    # Three major use cases (and nesting of them needs to be supported):
+    #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+    #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+    #   { :a => "value" }          => ["a=value"]
+    def self.query_array(params, key_prefix=nil)
+      ret = []
+      params.each do |key, value|
+        if params.is_a?(Array)
+          value = key
+          key = ''
+        end
+        key_suffix = escape(key)
+        full_key = key_prefix ? "#{key_prefix}[#{key_suffix}]" : key_suffix
+
+        if value.is_a?(Hash) || value.is_a?(Array)
+          # Handles the following cases:
+          #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+          #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+          ret += query_array(value, full_key)
+        elsif value.is_a?(APIObject)
+          ret += query_array(value.json, full_key)
+        else
+          # Handles the base case with just key and value:
+          #   { :a => "value" } => ["a=value"]
+          ret << "#{full_key}=#{escape(value)}"
+        end
+      end
+      ret
+    end
+
+    def self.escape(val)
+      URI.escape(val.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+  end
+end

data/lib/synapse_pay/apibits/util.rb

@@ -0,0 +1,51 @@
+module SynapsePay
+  module Util
+
+    def self.symbolize_keys(obj)
+      if obj.is_a?(Hash)
+        ret = {}
+        obj.each do |key, value|
+          ret[(key.to_sym rescue key) || key] = symbolize_keys(value)
+        end
+        return ret
+      elsif obj.is_a?(Array)
+        return obj.map{ |value| symbolize_keys(value) }
+      else
+        return obj
+      end
+    end
+
+    def self.sorta_deep_clone(json)
+      if json.is_a?(Hash)
+        ret = {}
+        json.each do |k, v|
+          ret[k] = sorta_deep_clone(v)
+        end
+        ret
+      elsif json.is_a?(Array)
+        json.map{ |j| sorta_deep_clone(j) }
+      else
+        begin
+          json.dup
+        rescue
+          json
+        end
+      end
+    end
+
+    def self.constantize(str, prefix=false)
+      str = str.to_s
+      begin
+        str.split('::').reduce(Module, :const_get)
+      rescue NameError => e
+        if prefix
+          raise e
+        else
+          p = "#{self.name}".split("::").first
+          constantize("#{p}::#{str}", true)
+        end
+      end
+    end
+
+  end
+end