jaehess-powncer 0.1.2

data/Rakefile

@@ -0,0 +1,124 @@
+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
+
+Rake::RDocTask.new do |rdoc|  
+  rdoc.rdoc_dir = 'doc'  
+  rdoc.title    = "Powncer -- A Ruby library to the Pownce REST API"  
+  rdoc.options << '--line-numbers' << '--inline-source'   
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :rdoc do
+  task :deploy => :rerdoc do
+    sh %(scp -r doc jaehess@rubyforge.org:/var/www/gforge-projects/powncer/)
+  end
+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
+  
+  desc 'Install with gem'
+  task :install => :repackage do
+    sh "sudo gem i pkg/#{spec.name}-#{spec.version}.gem"
+  end
+  
+  desc 'Uninstall gem'
+  task :uninstall do
+    sh "sudo gem uninstall #{spec.name} -x"
+  end
+  
+  desc 'Reinstall gem'
+  task :reinstall => [:uninstall, :install]
+  
+  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
+    
+    #version_already_released = lambda do
+    #  releases = rubyforge.userconfig['release_ids']
+    #  releases.has_key?(spec.name) && releases[spec.name][spec.version]
+    #end
+    #
+    #abort("Release #{spec.version} already exists!") if version_already_released.call
+    
+    
+    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
+
+desc 'Upload website files to rubyforge'
+task :website do
+  host = "jaehess@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/powncer/"
+  local_dir = '~/Sites/powncer.rubyforge.org/site'
+  sh %{rsync -av #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+task :cleanup => ['dist:clobber_package', 'clobber_rdoc']

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

data/lib/powncer/media.rb

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

data/lib/powncer/note.rb

@@ -0,0 +1,101 @@
+module Powncer
+  
+  class Note < Base
+    
+    def initialize(options = {})
+      @attributes ||= {}
+      @attributes["body"] = options[:body] if options[:body]
+      @attributes["to"] = options[:to] || default_send_to
+    end
+    
+    def save
+      self.class.create(@attributes)
+    end
+    
+    def recipients
+      url = "/notes/#{self.id}/recipients.#{FORMAT}"
+      request(url)["recipients"]["users"].collect!{|user| User.instantiate(user)}
+    end
+    
+    def type
+      @attributes["type"] || nil
+    end
+    
+    def link
+      @attributes["url"] || @attributes["link"]["url"]
+    end
+    
+    def is_public?
+      self.is_public
+    end
+    
+    def sender
+      User.instantiate(@attributes["sender"])
+    end
+    
+    private
+    
+    def default_send_to
+      User.send_to["selected"].to_sym
+    end
+    
+    class << self
+      
+      def find(*args)
+        options = extract_attributes(args)
+        case args.first
+        when :public
+          find_all_public(options)
+        else
+          find_by_id(args.first, options)
+        end
+      end
+      
+      def create(attributes)
+        attributes.symbolize_keys!
+        note = self.new(attributes)
+        unless note.to.is_a?(Symbol)
+          target_key = ensure_send_to(:friend, note.to)
+        end
+        url = "/send/message.#{self.superclass::FORMAT}"
+        Note.instantiate post(url, {:body => note.body, :to => target_key || note.to})
+      end
+      
+      def ensure_send_to(type, target)
+        ensure_send_to_friends(target) if type.to_s == "friend"
+        #ensure_send_to_sets(target) if type.to_s == "set"
+      end
+      
+      private
+      
+      # Calls profiles for each target recipient. Pulls user's send_to list and verifies all are valid.
+      # This double checks the users input, and also allows to call recipients by username, not id
+      def ensure_send_to_friends(target)
+        valid_targets = User.send_to["options"]["private_note"]
+        target_key = "friend_#{User.find(target).id}"
+        raise InvalidFriend, "You attempting to send a note to an invalid recipient" unless valid_targets.has_key?(target_key)
+        target_key
+      end
+
+      def find_all_public(options)
+        query = options.to_query
+        url = "/note_lists.#{self.superclass::FORMAT}#{query}"
+        request(url)["notes"].collect!{|note| Note.instantiate(note)}
+      end
+      
+      def find_by_id(id, options)
+        query = options.to_query
+        url = "/notes/#{id}.#{self.superclass::FORMAT}"
+        note = request(url)
+        Note.instantiate(note)
+      end
+      
+      def extract_attributes(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+    
+    end
+    
+  end
+
+end

data/lib/powncer/user.rb

@@ -0,0 +1,79 @@
+module Powncer
+  
+  class User < Base
+
+    attr_accessor :_username
+    
+    def initialize(*args)
+      attributes = extract_attributes(args)
+      @_username = args.first
+      @attributes = attributes
+    end
+    
+    def is_pro?
+      self.is_pro
+    end
+    
+    def profile
+      url = "/users/#{@_username}.#{FORMAT}"
+      user = request(url)
+      self.class.instantiate(user)
+    end
+    
+    def friends
+      url = "/users/#{@_username || self.username}/friends.#{FORMAT}"
+      request(url)["friends"]["users"].collect!{|user| self.class.instantiate(user)}
+    end
+    
+    def fans
+      url = "/users/#{@_username || self.username}/fans.#{FORMAT}"
+      users = request(url)["fans"]["users"].collect!{|user| self.class.instantiate(user)} 
+    end
+    
+    def fan_of
+      url = "/users/#{@_username || self.username}/fan_of.#{FORMAT}"
+      request(url)["fan_of"]["users"].collect!{|user| self.class.instantiate(user)} 
+    end
+    
+    def notes
+      url = "/note_lists/#{@_username || self.username}.#{FORMAT}?filter=notes"
+      request(url)["notes"].collect!{|note| Note.instantiate(note)}
+    end
+    
+    def messages
+      url = "/note_lists/#{@_username || self.username}.#{FORMAT}?type=messages"
+      request(url)["notes"].collect!{|note| Note.instantiate(note)}
+    end
+    
+    def links
+      url = "/note_lists/#{@_username || self.username}.#{FORMAT}?type=links"
+      request(url)["notes"].collect!{|note| Link.instantiate(note)}
+    end
+    
+    def events
+      url = "/note_lists/#{@_username || self.username}.#{FORMAT}?type=events"
+      request(url)["notes"].collect!{|note| Event.instantiate(note)}
+    end
+    
+    def send_to
+      self.class.send_to
+    end
+    
+    class << self
+      
+      def find(username)
+        url = "/users/#{username}.#{self.superclass::FORMAT}"
+        user = self.superclass.request(url)
+        instantiate(user)
+      end
+      
+      def send_to
+        url = "/send/send_to.#{self.superclass::FORMAT}"
+        request(url)
+      end
+    
+    end
+    
+  end
+
+end

data/lib/powncer/version.rb

@@ -0,0 +1,16 @@
+module Powncer # :stopdoc:
+  
+  module Version
+    
+    MAJOR = '0'
+    MINOR = '1'
+    TINY  = '2'
+    
+    API_URL     = "http://api.pownce.com"
+    API_VERSION = "2.0"
+    
+    VERSION = [MAJOR, MINOR, TINY].join('.')
+    
+  end
+  
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: jaehess-powncer
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Jae Hess
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: me@jaehess.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/powncer/authentication.rb
+- lib/powncer/base.rb
+- lib/powncer/connection.rb
+- lib/powncer/event.rb
+- lib/powncer/ext.rb
+- lib/powncer/link.rb
+- lib/powncer/media.rb
+- lib/powncer/note.rb
+- lib/powncer/user.rb
+- lib/powncer/version.rb
+- lib/powncer.rb
+has_rdoc: true
+homepage: http://powncer.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: powncer
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Powncer is a Ruby library to the Pownce REST API
+test_files: []
+