powncer 0.1.0

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require File.join(File.dirname(__FILE__), 'lib', 'powncer', 'version')
+
+def library_root
+  File.dirname(__FILE__)
+end
+
+desc 'Run tests'
+task :default => :test
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*/*_test.rb'
+end
+
+desc 'Check code to test ratio'
+task :stats do 
+  library_files = FileList["#{library_root}/lib/**/*.rb"]
+  test_files    = FileList["#{library_root}/test/**/*_test.rb"]
+  count_code_lines = Proc.new do |lines| 
+    lines.inject(0) do |code_lines, line|
+      next code_lines if [/^\s*$/, /^\s*#/].any? {|non_code_line| non_code_line === line}
+      code_lines + 1
+    end
+  end
+  
+  count_code_lines_for_files = Proc.new do |files|
+    files.inject(0) {|code_lines, file| code_lines + count_code_lines[IO.read(file)]}
+  end
+  
+  library_code_lines = count_code_lines_for_files[library_files]
+  test_code_lines    = count_code_lines_for_files[test_files]
+  ratio = Proc.new { sprintf('%.2f', test_code_lines.to_f / library_code_lines)}
+  
+  puts "Code LOC: #{library_code_lines}    Test LOC: #{test_code_lines}    Code to Test Ratio: 1:#{ratio.call}"
+end
+
+namespace :dist do 
+  spec = Gem::Specification.new do |s| 
+    s.name = "powncer"
+    s.version = Gem::Version.new(Powncer::Version::VERSION)
+    s.author = "Jae Hess"
+    s.email = "jae.hess@gmail.com"
+    s.homepage = "http://powncer.rubyforge.org"
+    s.platform = Gem::Platform::RUBY
+    s.summary = "Powncer is a Ruby library to the Pownce REST API"
+    s.files = FileList['Rakefile', 'lib/**/*.rb']
+    s.require_path = "lib"
+    s.test_files = Dir['test/**/*']
+    s.has_rdoc = true
+    s.rubyforge_project = 'powncer' 
+    s.add_dependency 'json'
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+      pkg.need_tar = true
+  end
+  
+  package_name = lambda {|specification| File.join('pkg', "#{specification.name}-#{specification.version}")}
+  
+  desc 'Push a release to rubyforge'
+  task :release => ['dist:clobber_package', :package] do 
+    require 'rubyforge'
+    package = package_name[spec]
+
+    rubyforge = RubyForge.new
+    rubyforge.login
+    
+    if release_id = rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version, "#{package}.tgz")
+      rubyforge.add_file(spec.rubyforge_project, spec.name, release_id, "#{package}.gem")
+    else
+      puts 'Release failed!'
+    end
+  end
+  
+end

data/lib/powncer.rb

@@ -0,0 +1,20 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'base64'
+require 'open-uri'
+
+require 'powncer/ext'
+require 'powncer/base'
+require 'powncer/connection'
+require 'powncer/authentication'
+require 'powncer/user'
+require 'powncer/note'
+require 'powncer/link'
+require 'powncer/event'
+require 'powncer/media'
+require 'powncer/version'
+
+require_library_or_gem 'json'
+
+begin; load "~/.powncer"; rescue LoadError; end

data/lib/powncer/authentication.rb

@@ -0,0 +1,84 @@
+module Powncer
+
+  module Authentication
+
+    class Basic < Connection
+      
+      attr_accessor :options
+      
+      def initialize(options={})
+        super(true)
+        options[:username]        ||= Basic.load_username
+        options[:password]        ||= Basic.load_password
+        options[:application_key] ||= Basic.load_application_key
+        options[:secret_key]      ||= Basic.load_secret_key
+        @options = options
+        Powncer.connections << self
+      end
+      
+      def get(uri)
+        super(uri, true)
+      end
+      
+      def post(uri, params={})
+        # TODO: Refactor
+        endpoint = "#{@url}#{uri}"
+        url = URI.parse(endpoint)
+        req = Net::HTTP::Post.new(url.path)
+        req.basic_auth(options[:username], options[:password])
+        # create hash to add Link, Event params to request
+        form_params = {}
+        form_params.merge!({'note_body' => params[:body]}) if params[:body]
+        form_params.merge!({'url' => params[:url]}) if params[:url]
+        form_params.merge!({'event_name' => params[:name]}) if params[:name]
+        form_params.merge!({'event_location' => params[:location]}) if params[:location]
+        form_params.merge!({'event_date' => params[:date]}) if params[:date]
+        form_params.merge!({'media_file' => params[:data]}) if params[:data]
+        req.set_content_type('multipart/form-data')
+        req.set_form_data({'app_key' => options[:application_key], 'note_to' => "#{params[:to]}"}.merge(form_params))
+        response = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
+        response.body
+      end
+      
+      class << self
+        
+        [:username, :password, :application_key, :secret_key].each do |type|
+          class_eval(<<-EVAL, __FILE__, __LINE__)
+            def load_#{type}
+              env_key(:#{type})
+            end
+          EVAL
+        end
+        
+        def connect!(options={})
+          self.new(options)
+        end
+        
+        def open(uri, options, *args, &block)
+          query_params = URI.parse(uri).query
+          headers = {}
+          headers["Authorization"] = Header.new(options[:username], options[:password])
+          uri << "#{query_params.nil? ? "?" : "&"}"
+          uri << "app_key=#{options[:application_key]}"
+          Kernel::open(uri, headers, *args, &block)
+        end
+        
+        def env_key(key_name)
+          ENV["POWNCER_#{key_name.to_s.upcase}"]
+        end
+        
+      end
+      
+      class Header < String
+        
+        def initialize(username, password)
+          self << "Basic #{Base64.encode64("#{username}:#{password}")}"
+        end
+      
+      end
+      
+    end
+    
+  end
+
+end

data/lib/powncer/base.rb

@@ -0,0 +1,103 @@
+module Powncer
+  
+  class PowncerError < StandardError; end
+  class PownceConnectionError < PowncerError; end
+  class ConnectionUnavailable < PownceConnectionError; end
+  class BadResponse < PownceConnectionError; end
+  class WebServiceError < PownceConnectionError; end
+  class InvalidFriend < PowncerError; end
+  class RequirementMissing < PowncerError; end
+  class InvalidFormat < RequirementMissing; end
+  
+  class Base
+    
+    FORMAT = 'json'
+    
+    def id
+      @attributes["id"] || nil
+    end
+    
+    def request(url)
+      self.class.request(url)
+    end
+    
+    def post(url, *params)
+      self.class.post(url, params)
+    end
+    
+    class << self
+      
+      def request(url)
+        response = Powncer.connect!.get(url)
+        parse(response)
+      end
+      
+      def post(url, *params)
+        options = extract_options(params.flatten)
+        response = Powncer.connect!.post(url, options)
+        parse(response)
+      end
+      
+      def parse(response)
+        json = JSON.parse(response)
+        if json.has_key? 'error'
+          raise WebServiceError, json["error"]["message"]
+        end
+        return json
+      end
+
+      def instantiate(attributes)
+        object = allocate
+        object.instance_variable_set("@attributes", attributes)
+        object
+      end
+      
+      def extract_options(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+    end
+    
+    private
+    
+    def extract_attributes(args)
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+    
+    alias :orig_method_missing :method_missing
+    
+    def method_missing(method_id, *args)
+      attribute_name = method_id.to_s
+      if @attributes.stringify_keys!.has_key?(attribute_name)
+        return @attributes.fetch(method_id.to_s)
+      else
+        orig_method_missing(method_id, args)
+      end
+    end
+    
+  end
+  
+  class << self
+    
+    def connections
+      @connections ||= []
+    end
+  
+    def add_connection(connection)
+      connections << connection
+    end
+  
+    def make_default_connection
+      add_connection(Connection.new).first
+    end
+  
+    def connect!
+      connections.last || make_default_connection
+    end
+  
+    def disconnect!
+      @connections.clear unless connections.empty?
+    end
+    
+  end
+
+end

data/lib/powncer/connection.rb

@@ -0,0 +1,33 @@
+module Powncer
+
+  class Connection
+    
+    attr_accessor :url, :authenticated
+    
+    def initialize(is_auth=false)
+      @url = "#{Powncer::Version::API_URL}/#{Powncer::Version::API_VERSION}"
+      @authenticated = is_auth
+    end
+    
+    def get(uri, use_auth=false)
+      endpoint = "#{@url}#{uri}"    
+      begin
+        if use_auth
+          response = Authentication::Basic.open(endpoint, Powncer.connect!.options)
+        else
+          response = open(endpoint)
+        end
+        case response.status
+        when ["200", "OK"]
+          response.read
+        else
+          raise BadResponse
+        end
+      rescue
+        raise ConnectionUnavailable
+      end
+    end
+    
+  end #/Connection
+
+end #/Powncer

data/lib/powncer/event.rb

@@ -0,0 +1,40 @@
+module Powncer
+  
+  class Event < Note
+    
+    def initialize(options = {})
+      raise RequirementMissing, "Event requires a name" unless options[:name]
+      raise RequirementMissing, "Event requires a location" unless options[:location]
+      raise RequirementMissing, "Event requires a date" unless options[:date]
+      raise InvalidFormat, "Event date should be formatted YYYY-MM-DD hh:mm" unless options[:date].is_valid_date?
+      super
+      @attributes["name"] = options[:name]
+      @attributes["location"] = options[:location]
+      @attributes["date"] = options[:date]
+    end
+    
+    [:name, :location, :date].each do |attribute|
+      class_eval(<<-EVAL, __FILE__, __LINE__)
+        def #{attribute}
+          @attributes["#{attribute}"] || @attributes["event"]["#{attribute}"]
+        end
+      EVAL
+    end
+
+    class << self
+      
+      def create(attributes)
+        attributes.symbolize_keys!
+        event = self.new(attributes)
+        unless event.to.is_a?(Symbol)
+         target_key = self.superclass.ensure_send_to(:friend, event.to)
+        end
+        url = "/send/event.#{self.superclass::FORMAT}"
+        Event.instantiate post(url, {:to => target_key || event.to, :name => event.name, :location => event.location, :date => event.date})
+      end
+      
+    end
+    
+  end
+
+end

data/lib/powncer/ext.rb

@@ -0,0 +1,58 @@
+# :stopdoc:
+class Hash
+  def to_query
+    query_string = self.empty? ? "" : "?"
+    query_array = []
+    self.map.each{|ary| query_array << "#{ary.first}=#{ary.last}"}
+    query_string << query_array.join("&")
+  end
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+  def stringify_keys!
+    self.replace(self.stringify_keys)
+  end
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_sym || key] = value
+      options
+    end
+  end
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end
+
+class String
+  def is_valid_url?
+    return true if self =~ /http\:\/\//
+  end
+  def is_valid_date?
+    return !/\d{4}\-\d{2}\-\d{2}\s\d{2}\:\d{2}/.match(self).nil?
+  end
+end
+
+module Kernel
+  def require_library_or_gem(library)
+    require library
+  rescue LoadError => library_not_installed
+    begin
+      require 'rubygems'
+      require library
+    rescue LoadError
+      raise library_not_installed
+    end
+  end
+end
+
+module Net
+  module HTTPHeader
+    def set_form_data(params, sep = '&')
+      self.body = params.map {|k,v| "#{urlencode(k.to_s)}=#{urlencode(v.to_s)}" }.join(sep)
+      self.content_type ||= 'application/x-www-form-urlencoded'
+    end
+  end
+end

data/lib/powncer/link.rb

@@ -0,0 +1,28 @@
+module Powncer
+  
+  class Link < Note
+    
+    def initialize(options = {})
+      options[:url] ||= ""
+      raise RequirementMissing unless options[:url].is_valid_url?
+      super
+      @attributes["url"] = options[:url]
+    end
+    
+    class << self
+      
+      def create(attributes)
+        attributes.symbolize_keys!
+        link = self.new(attributes)
+        unless link.to.is_a?(Symbol)
+         target_key = self.superclass.ensure_send_to(:friend, link.to)
+        end
+        url = "/send/link.#{self.superclass::FORMAT}"
+        Link.instantiate post(url, {:body => link.body, :to => target_key || link.to, :url => link.url})
+      end
+      
+    end
+    
+  end
+
+end