botr 0.1.0

data/lib/botr/channels/channel_view.rb

@@ -0,0 +1,88 @@
+module BOTR
+
+	class ChannelView < BOTR::Object
+
+		class << self
+
+			attr_reader :last_status
+
+			def show(key, **options)
+				json = get_request(options.merge(:method => 'show',
+								    			 :channel_key => key))
+				res = JSON.parse(json.body)
+
+				if json.status == 200
+					params = process_show_response(res)
+				else
+					raise "HTTP Error #{json.status}: #{json.body}"
+				end
+
+				return new(params)
+			end
+
+			alias :find :show
+
+			def list(**options)
+				json = get_request(options.merge(:method => 'list'))
+				res = JSON.parse(json.body)
+				
+				if json.status == 200
+					results = process_list_response(res)
+				else
+					raise "HTTP Error #{json.status}: #{json.body}"
+				end
+
+				return results
+			end
+
+			def all
+				list({})
+			end
+
+			private
+
+				def process_show_response(body)
+					@last_status = body["status"]
+
+					return body["channel"]
+				end
+
+				def process_list_response(body)
+					@last_status = body["status"]
+					res = []
+
+					if body["channels"]
+						body["channels"].each do |channel|
+							res << new(channel)
+						end
+					elsif body["days"]
+						body["days"].each do |day|
+							res << new(day)
+						end
+					elsif body["years"]
+						body["years"].each do |year|
+							res << new(year)
+						end
+					else
+						res << new(body)
+					end
+
+					return res
+				end
+
+		end
+
+		attr_reader :last_status, :key, :days, :years, :views, :title, :date,
+					:timestamp, :number, :year, :number, :total
+
+		def initialize(params = {})
+			params.each do |key, val|
+				param = "@#{key.to_s}"
+				next unless methods.include? key.to_sym
+				instance_variable_set(param, val)
+			end		
+		end
+
+	end
+
+end

data/lib/botr/common/logger.rb

@@ -0,0 +1,31 @@
+module BOTR
+
+	module Logger
+
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+
+		def logger=(log)
+            @logger = log
+        end
+
+        def logger
+            @logger ||= self.class.logger
+        end
+
+        module ClassMethods
+
+            def logger=(log)
+                @@logger = log
+            end
+
+            def logger
+                @@logger ||= nil
+            end
+
+        end
+
+	end
+
+end

data/lib/botr/configuration.rb

@@ -0,0 +1,18 @@
+module BOTR
+
+	class << self
+		attr_accessor :configuration
+	end
+
+	def self.configure
+		self.configuration ||= Configuration.new
+		yield(configuration)
+	end
+
+	class Configuration
+
+		attr_accessor :protocol, :server, :api_key, :secret_key
+
+	end
+
+end

data/lib/botr/http/http.rb

@@ -0,0 +1,88 @@
+module BOTR
+
+	module HTTP
+
+		def client
+			@client = BOTR::HTTPBackend.new unless @client
+			@client
+		end
+
+		def get_request(options = {})
+			params = options.dup
+
+			http      = params.delete(:client)        || client
+			method    = params.delete(:method)
+			url       = params.delete(:api_url)       || api_url(method)
+			format    = params.delete(:api_format)    || api_format
+			key       = params.delete(:api_key)       || api_key
+			timestamp = params.delete(:api_timestamp) || api_timestamp
+			nonce     = params.delete(:api_nonce)     || api_nonce
+			secret    = params.delete(:api_secret_key)|| api_secret_key
+
+			params = params.merge(:api_format    => format,
+								  :api_key       => key,
+								  :api_timestamp => timestamp,
+								  :api_nonce     => nonce)
+
+			http.get(url, params.merge(:api_signature => self.signature(params)))
+		end
+
+		def post_request(options = {}, data_path = nil)
+			params = options.dup
+
+			http      = params.delete(:client)        || client
+			url       = params.delete(:api_url)    	  || upload_url
+			format    = params.delete(:api_format)    || api_format
+			key       = params.delete(:upload_key)    || upload_key
+			token     = params.delete(:upload_token)  || upload_token
+
+			params = params.merge(:api_format    => format,
+								  :key           => key,
+								  :token         => token)
+
+			http.post(url, params, data_path)
+		end
+
+		def put_request(options = {})
+			params = options.dup
+
+			http      = params.delete(:client)        || client
+			method    = 'update'
+			url       = params.delete(:api_url)       || api_url(method)
+			format    = params.delete(:api_format)    || api_format
+			key       = params.delete(:api_key)       || api_key
+			timestamp = params.delete(:api_timestamp) || api_timestamp
+			nonce     = params.delete(:api_nonce)     || api_nonce
+			secret    = params.delete(:api_secret_key)|| api_secret_key
+
+			params = params.merge(:api_format    => format,
+								  :api_key       => key,
+								  :api_timestamp => timestamp,
+								  :api_nonce     => nonce)
+
+			http.post(url, params.merge(:api_signature => self.signature(params)))
+		end
+
+		def delete_request(options = {})
+			params = options.dup
+
+			http      = params.delete(:client)        || client
+			method    = 'delete'
+			url       = params.delete(:api_url)       || api_url(method)
+			format    = params.delete(:api_format)    || api_format
+			key       = params.delete(:api_key)       || api_key
+			timestamp = params.delete(:api_timestamp) || api_timestamp
+			nonce     = params.delete(:api_nonce)     || api_nonce
+			secret    = params.delete(:api_secret_key)|| api_secret_key
+
+			params = params.merge(:api_format    => format,
+								  :api_key       => key,
+								  :api_timestamp => timestamp,
+								  :api_nonce     => nonce)
+
+			http.post(url, params.merge(:api_signature => self.signature(params)))
+		end
+
+	end
+
+end

data/lib/botr/http/http_backend.rb

@@ -0,0 +1,66 @@
+require 'net/http'
+
+module BOTR
+
+	class HTTPBackend
+
+		# GET request.
+		def get(path, params = {})
+			uri = URI(path)
+			uri.query = URI.encode_www_form(params)
+			
+			res = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+				http.request_get uri
+			end
+			
+			respond(res)
+		end
+
+		# POST request with optional multipart/form-data.
+		def post(path, params = {}, data_path = "")
+			uri = URI(path)
+			uri.query = URI.encode_www_form(params)
+
+			res = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+				req = Net::HTTP::Post.new(uri.request_uri)
+
+				if data_path.empty?
+					req.set_form_data(params)
+				else
+					boundary = rand(1000000).to_s
+					
+					req.body_stream = BOTR::Multipart.new(data_path, boundary)
+					req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+					req["Content-Length"] = req.body_stream.size.to_s		
+				end
+				
+				http.request req
+			end
+
+			respond(res)			
+		end		
+
+		private
+
+			# Map Net::HTTPResponses to internal ones.
+			def respond(resp)
+				case resp
+	            when Net::HTTPOK
+	                BOTR::OKResponse.new(resp.body)
+	            when Net::HTTPBadRequest
+	                BOTR::BadRequestResponse.new(resp.body)
+	            when Net::HTTPUnauthorized
+	                BOTR::UnauthorizedResponse.new(resp.body)
+	            when Net::HTTPForbidden
+	                BOTR::ForbiddenResponse.new(resp.body)
+	            when Net::HTTPNotFound
+	                BOTR::NotFoundResponse.new(resp.body)
+	            when Net::HTTPMethodNotAllowed
+	                BOTR::NotAllowedResponse.new(resp.body)
+	            else
+	                BOTR::HTTPResponse.new(resp.code, resp.body)
+	            end
+			end
+	end
+
+end

data/lib/botr/http/http_response.rb

@@ -0,0 +1,48 @@
+module BOTR
+
+	class HTTPResponse
+		attr_accessor :status, :body
+
+		def initialize(status, body = "")
+			@status = status
+			@body = body
+		end
+	end
+
+	class OKResponse < HTTPResponse
+		def initialize(body = "")
+			super(200, body)
+		end
+	end
+
+	class BadRequestResponse < HTTPResponse
+		def initialize(body = "")
+			super(400, body)
+		end
+	end
+
+	class UnauthorizedResponse < HTTPResponse
+		def initialize(body = "")
+			super(401, body)
+		end
+	end
+
+	class ForbiddenResponse < HTTPResponse
+		def initialize(body = "")
+			super(403, body)
+		end
+	end
+
+	class NotFoundResponse < HTTPResponse
+		def initialize(body = "")
+			super(404, body)
+		end
+	end
+
+	class NotAllowedResponse < HTTPResponse
+		def initialize(body = "")
+			super(405, body)
+		end
+	end
+
+end

data/lib/botr/http/multipart.rb

@@ -0,0 +1,84 @@
+require 'mime/types'
+require 'tempfile'
+
+module BOTR	
+
+	class Multipart
+
+		def initialize(data_path = "", boundary = nil)
+			@data_path = data_path
+			@boundary = boundary
+
+			build_stream
+		end
+
+		def close
+			@stream.close! unless @stream.closed?
+		end
+
+      	def method_missing(*args)
+      		@stream.send(*args)
+      	end
+
+      	def respond_to?(meth)
+      		@stream.respond_to?(meth) || super(meth)
+      	end
+
+
+		private
+
+			def boundary
+				@boundary ||= rand(1000000).to_s
+			end
+
+			def mime_type_for(path)
+				mime = MIME::Types.type_for(path).first
+				mime ? mime.content_type : 'text/plain'
+			end
+
+			# Build a multipart/form-data body as per RFC 2388.
+			def build_stream
+				# Form input field name for the file path must be set to file.
+				# Any other field name will not be picked up by the upload server.
+				name = 'file'
+				content_length = File.size(@data_path)
+				content_type = mime_type_for(@data_path)
+
+				@stream = Tempfile.new("BitsOnTheRun.Upload.")
+				@stream.binmode
+				
+				write_stream_head(name, content_type, content_length)
+				write_stream_body
+				write_stream_tail
+
+				@stream.seek(0)
+			end
+
+			def write_stream_head(name, content_type, content_length)
+				transfer_encoding = "binary"
+				content_disposition = "form-data"
+
+				@stream.write "--#{boundary}\r\n"
+				@stream.write "Content-Disposition: #{content_disposition}; name=\"#{name}\"; filename=\"#{File.basename(@data_path)}\"\r\n"
+				@stream.write "Content-Length: #{content_length}\r\n"
+				@stream.write "Content-Type: #{content_type}\r\n"
+				@stream.write "Content-Transfer-Encoding: #{transfer_encoding}\r\n"
+				@stream.write "\r\n"
+			end
+
+			def write_stream_body
+				f = File.new(@data_path)
+				while data = f.read(8124)
+					@stream.write(data)
+				end
+			ensure
+				f.close unless f.closed?
+			end
+
+			def write_stream_tail
+				@stream.write "\r\n"
+				@stream.write "--#{boundary}--\r\n"
+			end
+
+	end
+end

data/lib/botr/http/uri_ext.rb

@@ -0,0 +1,28 @@
+module URI
+
+	# FIX: For some reason, the Bits on the Run API doesn't support the encoding
+	#      of spaces to "+". As such, (ASCII space) will encode to "%20".
+	TBLENCWWWCOMP__ = TBLENCWWWCOMP_.dup
+	TBLENCWWWCOMP__[' '] = '%20'
+	TBLENCWWWCOMP__.freeze
+
+	def self.encode_www_form_component(str, enc=nil)
+		str = str.to_s.dup
+
+		if str.encoding != Encoding::ASCII_8BIT
+	  		if enc && enc != Encoding::ASCII_8BIT
+				str.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace)
+				str.encode!(enc, fallback: ->(x){"&#{x.ord};"})
+	  		end
+	  		str.force_encoding(Encoding::ASCII_8BIT)
+		end
+		str.gsub!(/[^*\-.0-9A-Z_a-z]/, TBLENCWWWCOMP__)
+		str.force_encoding(Encoding::US_ASCII)
+  	end
+
+  	def self.decode_www_form_component(str, enc=Encoding::UTF_8)
+		raise ArgumentError, "invalid %-encoding (#{str})" unless /\A[^%]*(?:%\h\h[^%]*)*\z/ =~ str
+		str.b.gsub(/\+|%\h\h/, TBLENCWWWCOMP__).force_encoding(enc)
+  	end
+
+end