stretchr 1.0.0

data/lib/stretchr/client.rb

@@ -0,0 +1,201 @@
+module Stretchr
+
+	class Client
+		def initialize(options = {})
+			options ||= {}
+		
+			options[:project] ||= Stretchr.configuration.project
+			options[:private_key] ||= Stretchr.configuration.private_key
+			options[:public_key] ||= Stretchr.configuration.public_key
+			options[:noisy_errors] ||= (Stretchr.configuration.noisy_errors || false)
+			# check for required arguments
+			[:project, :public_key, :private_key].each do | required_option |
+				raise MissingAttributeError, "#{required_option} is required." unless options[required_option]
+			end
+
+			options.each do |name, value|
+					send("#{name}=", value)
+			end
+
+			# create defaults if the user didn't specify anything
+			@signatory ||= Stretchr::Signatory
+			@transporter ||= Stretchr::DefaultTransporter.new
+			@version ||= "v1"
+			@path ||= ""
+			@query = {}
+
+		end
+
+		attr_accessor :project, :private_key, :public_key, :path, :http_method, :http_body, :version, :transporter, :signatory, :noisy_errors
+
+		#-------------------HTTP Actions-----------------
+
+		# generate_request makes a Stretchr::Request based on the current settings
+		# in this Stretchr object.
+		def generate_request
+			Stretchr::Request.new(
+				:http_method => http_method,
+				:signed_uri => signed_uri,
+				:body => http_body
+			)
+		end
+
+		def make_request!
+			# create and make the request
+			response = self.transporter.make_request(generate_request)
+			raise_errors_in_response(response) if noisy_errors
+			response
+		end
+
+	    def raise_errors_in_response(response)
+	        if [404, 500, 401, 403, 406, 400].include?(response.status)
+	          raise_error(response.status)
+	        end 
+	    end
+
+	    def raise_error(status)
+	      case status
+	      when 404 
+	        raise NotFound
+	      when 500 
+	        raise InternalServerError
+	      when 401 
+	        raise Unauthorized
+	      when 403 
+	        raise Forbidden
+	      when 400 
+	        raise BadRequest
+	      else
+	        raise Unknown
+	      end    
+	    end
+
+		# get performs a GET request and returns the Stretchr::Response.
+		def get
+
+			self.http_method = :get
+			make_request!
+
+		end
+
+		# post performs a POST and returns a Stretch::Response
+		def post
+			self.http_method = :post
+			make_request!
+		end
+
+		def put
+			self.http_method = :put
+			make_request!
+		end
+
+		def delete
+			self.http_method = :delete
+			make_request!
+		end
+
+	    #---------------- Friendly Actions --------------
+
+	    def create(object)
+	      self.body(object).post
+	    end
+
+	    def replace(object)
+	      self.body(object).post
+	    end
+
+	    def update(object)
+	      self.body(object).put
+	    end
+
+	    def read
+	      self.get
+	    end
+
+		#----------------Friendly Functions--------------
+		def url
+			uri.to_s
+		end
+
+		def to_url
+			url
+		end
+
+		def uri
+			URI::HTTP.build(host: "#{project}.stretchr.com", query: merge_query, path: merge_path)
+		end
+
+		def signed_uri
+			Stretchr::Signatory.generate_signed_url(http_method, uri, public_key, private_key, http_body)
+		end
+
+		#---------------Parameter Building---------------
+
+		def order(parameters)
+			@query["~order"] = parameters.to_s
+			self
+		end
+
+		def skip(parameters)
+			@query["~skip"] = parameters.to_i
+			self
+		end
+
+		def limit(parameters)
+			@query["~limit"] = parameters.to_i
+			self
+		end
+
+		def page(parameters)
+			skip((@query["~limit"] * parameters.to_i) - @query["~limit"])
+			self
+		end
+
+		def parameters(parameters)
+			@query.merge!(parameters)
+			self
+		end
+
+		def body(body_params)
+			self.http_body = body_params.to_json
+
+			self
+		end
+
+		def where(params)
+			params.each do |key, value|
+				@query["\:#{key.to_s}"] = value
+			end
+			self
+		end
+
+		#-----------------Basic Routing-----------------
+
+		def method_missing(method, *args)
+			add_collection(method, *args)
+		end
+
+		def add_collection(collection, id = nil)
+			@path += "/#{collection}"
+			if id
+				id.gsub!(/[^0-9A-Za-z.\-]/, '_') if id.is_a?(String) #remove non-ascii
+				@path += "/#{id}"
+			end
+			self
+		end
+
+		private
+
+		def merge_query
+			unless @query == nil || @query == {}
+				URI.encode_www_form(@query)
+			end
+		end
+
+		def merge_path
+			"/api/#{version}" + @path
+		end
+
+	end
+
+end

data/lib/stretchr/configuration.rb

@@ -0,0 +1,20 @@
+module Stretchr
+
+	class Configuration
+
+		def self.add_option(name, default_value = nil)
+			attr_accessor name
+			@name = default_value		
+		end
+
+		add_option :private_key
+		add_option :public_key
+		add_option :project
+		add_option :noisy_errors
+
+		def method_missing(name, *params)
+			raise Stretchr::UnknownConfiguration
+		end
+	end
+
+end

data/lib/stretchr/exceptions.rb

@@ -0,0 +1,18 @@
+#FIXME : Right now we just define some errors that users can implement if they wish.  Should we implement them for them?
+module Stretchr
+	#basic stretchr error namespace
+	class StretchrError < StandardError; end
+
+	#Configuration
+	class MissingAttributeError < StretchrError; end #thrown when initializing client without params
+	class UnknownConfiguration < StretchrError; end #thrown when we try to set an unknown configuration option
+
+	#stretchr status errors
+	class NotFound < StretchrError; end
+	class InternalServerError < StretchrError; end
+	class BadRequest < StretchrError; end
+	class Unathorized < StretchrError; end
+	class Forbidden < StretchrError; end
+	class Unknown < StretchrError; end
+
+end

data/lib/stretchr/resources/resource.rb

@@ -0,0 +1,129 @@
+module Stretchr
+	class Resource
+
+		# Class Methods to find objects
+
+		def self.find(params = {})
+			stretchr = stretchr_client
+			#FIXME : Why does this need to be duplicated?
+			stretchr.path = prep_path(stretchr.path.dup, params)
+			response = stretchr.get
+			return false if !response.success?
+			self.new(response.data)
+		end
+
+		def self.all(params = {})
+			stretchr = stretchr_client
+			stretchr.path = prep_path(stretchr.path.dup, params)
+			response = stretchr.get
+			return [] if response.data["~c"] == 0 || !response.data["~i"]
+			response.data["~i"].map {|r| self.new(r) }
+		end
+
+		def self.where(params = {})
+			stretchr = stretchr_client
+			#snag the vars that are needed for the path
+			path_vars = stretchr.path.scan(/:([a-zA-Z0-9_-]*)/i).flatten
+			#now convert the path as best we can
+			stretchr.path = prep_path(stretchr.path.dup, params)
+			#now remove the path params from the request
+			params.delete_if {|key, value| path_vars.include?(key.to_s)}
+
+			response = stretchr.where(params).get
+			#return false if nothing returned or search wasn't successful
+			return false if !response.success? || response.data["~c"] == 0 || !response.data["~i"]
+			response.data["~i"].map {|i| self.new(i) }
+		end
+
+		def self.stretchr_client
+			Stretchr::Client.new(@config)
+		end
+
+		def self.create(objects = [], params = {})
+			#convert it to an array for easy adding
+			objects = [objects] if !objects.is_a?(Array)
+			objects.map! {|o| setup_attributes_for_stretchr(o) }
+			stretchr = stretchr_client
+			stretchr.path = prep_path(stretchr.path.dup, params)
+			stretchr.body(objects)
+			response = stretchr.post
+			count = 0
+			stretchr_objects = objects.map do |o|
+				account = self.new(o)
+				account.parse_changes(response.changed[count])
+				count += 1
+				account
+			end
+			return stretchr_objects.first if stretchr_objects.length == 1
+			return stretchr_objects
+		end
+
+		def self.stretchr_config(params = {})
+			@config ||= {}
+			@config.merge!(params)
+		end
+
+		# Instance Methods
+
+		def initialize(params = {})
+			@attributes = {}
+			params.each {|key, value| self.send("#{key}=", value) }
+		end
+
+		def save(params = {})
+			stretchr = self.class.stretchr_client
+			stretchr.path = self.class.prep_path(stretchr.path.dup, params)
+			stretchr.body(setup_attributes_for_stretchr)
+			if self.stretchr_id
+				response = stretchr.put
+			else
+				response = stretchr.post
+			end
+			parse_changes(response.changed)
+		end
+
+		def parse_changes(response)
+			#FIXME : Should handle change objects and deltas here and update the object accordingly
+			return unless response
+			response.each {|key, value| self.send("#{key}=", value)}
+			self
+		end
+
+		def to_hash
+			@attributes
+		end
+
+		def to_json
+			to_hash.to_json
+		end
+	  
+		def method_missing(method, *args)
+			attribute = method.to_s
+			if attribute =~ /=$/ #if the method name ends in an =
+				@attributes[attribute.chop.gsub("~", "stretchr_")] = args[0]
+			else
+				@attributes[attribute]
+			end
+		end
+
+		private
+
+		def self.prep_path(path, params = {})
+			params.each {|key, value| path.gsub!(":#{key.to_s}", value.to_s) unless value == nil}
+			#remove any unchanged params from the path
+			path.gsub!(/(:[a-zA-Z0-9_-]*)/, "")
+			path
+		end
+
+		def setup_attributes_for_stretchr
+			self.class.setup_attributes_for_stretchr(@attributes)
+		end
+
+		def self.setup_attributes_for_stretchr(attributes)
+			stretchr_attributes = {}
+			attributes.each_pair {|key, value| stretchr_attributes[key.to_s.gsub(/^stretchr_/, "~")] = value}
+			stretchr_attributes
+		end
+
+	end
+end

data/lib/stretchr/resources.rb

@@ -0,0 +1 @@
+require_relative 'resources/resource.rb'

data/lib/stretchr/security/signatory.rb

@@ -0,0 +1,52 @@
+require 'uri' unless defined? URI
+require 'cgi' unless defined? CGI
+require 'digest/sha1'
+
+module Stretchr
+	class Signatory
+		class << self
+			def generate_signed_url(method, uri, public_key, private_key, body = nil)
+
+				#we need a URI, let's make sure it's what we have
+				uri = URI.parse(URI.escape(uri)) unless uri.is_a?(URI)
+
+				#preparation
+				query = CGI.parse(uri.query || "")
+				query["~key"] = public_key
+
+				#store this for later, we'll need it
+				public_query = URI.encode_www_form(query)
+
+				#now add the private stuff
+				query["~private"] = private_key
+				query["~bodyhash"] = Digest::SHA1.hexdigest(body) unless body == nil
+
+				#sort it
+				query = sort_query(query)
+				uri.query = URI.encode_www_form(query)
+
+				#append the method
+				signature = generate_signature(method, uri.to_s)
+
+				#now we prepare it for public use
+				public_query = public_query + "&" unless public_query == nil
+				uri.query = public_query + URI.encode_www_form("~sign" => signature)
+
+				return uri
+			end
+
+			private
+
+			def generate_signature(http_method, private_url)
+				combined = "#{http_method.to_s.upcase}&#{CGI.unescape(private_url.to_s)}"
+				Digest::SHA1.hexdigest(combined)
+			end
+
+			def sort_query(query)
+				query.each do |key, value|
+					value.sort! if value.is_a?(Array)
+				end.sort
+			end
+		end
+	end
+end

data/lib/stretchr/security.rb

@@ -0,0 +1 @@
+require_relative 'security/signatory'

data/lib/stretchr/stretchr_request.rb

@@ -0,0 +1,16 @@
+module Stretchr
+	class Request
+
+	  attr_accessor :http_method, :body, :signed_uri, :headers
+
+	  def initialize(options = {})
+
+	    @http_method = options[:http_method]
+	    @body = options[:body]
+	    @signed_uri = options[:signed_uri]
+	    @headers = options[:headers]
+
+	  end
+
+	end
+end

data/lib/stretchr/stretchr_response.rb

@@ -0,0 +1,39 @@
+require 'json' unless defined? JSON
+module Stretchr
+  class Response
+
+    attr_reader :json_string, :json_object, :status, :client_context, :data, :changed, :errors, :raw_response
+
+    def initialize(options = nil)
+
+      options ||= {}
+
+      @raw_response = options[:response]
+
+      if options[:json]
+        
+        # save the original json string
+        @json_string = options[:json]
+        @json_object = JSON.parse(@json_string)
+
+        @status = @json_object["~s"]
+
+        @client_context = @json_object["~x"]
+        @data = @json_object["~d"]
+        @changed = @json_object["~ch"]["~deltas"] if @json_object["~ch"]
+
+        unless @json_object["~e"].nil?
+          @errors = @json_object["~e"].collect {| error_obj | error_obj["~m"] }
+        end
+
+      end
+
+    end
+
+    # Gets whether this is a successful response.
+    def success?
+      @status >= 200 && @status <= 299
+    end
+
+  end
+end

data/lib/stretchr/transporters/default_transporter.rb

@@ -0,0 +1,41 @@
+require "uri" if !defined? URI
+require "net/http" if !defined? Net
+
+module Stretchr
+	class DefaultTransporter
+
+		def make_request(request)
+			response = nil
+			
+			Net::HTTP.start(request.signed_uri.host, request.signed_uri.port) do |http|
+
+			  http_request = generate_request(request)
+			  response = http.request http_request # Net::HTTPResponse object
+
+			end
+
+			return Stretchr::Response.new({:response => response, :json => response.body})
+		end
+
+		def generate_request(request)
+			
+			request_uri = request.signed_uri.request_uri
+
+			case request.http_method
+			when :get
+				req = Net::HTTP::Get.new request_uri
+			when :post
+				req = Net::HTTP::Post.new request_uri, {'Content-Type' => "application/json"}
+				req.body = request.body
+				req
+			when :put
+				req = Net::HTTP::Put.new request_uri, {'Content-Type' => "application/json"}
+				req.body = request.body
+				req
+			when :delete
+				req = Net::HTTP::Delete.new request_uri
+			end
+		end
+
+	end
+end

data/lib/stretchr/transporters/test_transporter.rb

@@ -0,0 +1,25 @@
+module Stretchr
+  class TestTransporter
+
+    attr_accessor :requests, :responses
+
+    def initialize
+      self.requests = []
+      self.responses = []
+    end
+   
+  	def make_request(request)
+  		
+  		# store the request and return the next response in the local queue
+  		# not NOT actually make any http requests
+
+      self.requests << request
+
+      # return the response
+      self.responses.shift
+
+  	end
+
+    
+  end
+end

data/lib/stretchr/transporters.rb

@@ -0,0 +1,2 @@
+require_relative 'transporters/default_transporter.rb'
+require_relative 'transporters/test_transporter.rb'

data/lib/stretchr.rb

@@ -0,0 +1,32 @@
+require "uri"
+require "cgi"
+require "json"
+
+
+module Stretchr
+	#exceptions that can be used by stretchr
+	require_relative 'stretchr/exceptions'
+
+	#configuration
+	require_relative 'stretchr/configuration'
+
+	@configuration = Stretchr::Configuration.new
+
+	def self.configuration
+		@configuration
+	end
+
+	def self.config
+		yield(@configuration)	
+	end
+
+	#the actual client library
+	require_relative 'stretchr/client'
+	require_relative 'stretchr/security'
+	require_relative 'stretchr/transporters'
+	require_relative 'stretchr/resources'
+	require_relative 'stretchr/stretchr_request'
+	require_relative 'stretchr/stretchr_response'
+
+	
+end