hashblue-api 0.0.8

data/README

@@ -0,0 +1,21 @@
+= It's the Hashblue API gem
+
+For usage, look at Hashblue::API (in lib/firehose/api.rb)
+
+
+= Short usage example
+
+    require 'active_support/all' # unless you have already loaded it
+    require 'hashblue/api'
+
+    Hashblue::API.base_uri "https://api.hashblue.apigee.com"
+    Hashblue::API.basic_auth "dave@example.com", "yourapikey"
+
+    subscriber = Hashblue::API::Subscriber.find("yourapikey")
+
+    subscriber.messages
+
+
+= Testing against the Hashblue API
+
+To learn about stubbing out the Hashblue API, see Hashblue::API::TestHelper

data/Rakefile

@@ -0,0 +1,98 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+
+task :default => :test
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+path = File.expand_path("..", __FILE__)
+
+spec = Dir.chdir(path) do
+  Gem::Specification.new do |s|
+
+    # Change these as appropriate
+    s.name              = "hashblue-api"
+    s.version           = "0.0.8"
+    s.summary           = "It's the Hashblue API, stupid!"
+    s.author            = "FreeRange"
+    s.email             = "lets@gofreerange.com"
+    s.homepage          = "http://gofreerange.com"
+
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = %w(README)
+    s.rdoc_options      = %w(--main README)
+
+    # Add any extra files to include in the gem
+    s.files             = `cd #{path} && git ls-files`.split("\n").sort
+
+    # You need to put your code in a directory which can then be added to
+    # the $LOAD_PATH by rubygems. Typically this is lib, but you don't seem
+    # to have that directory. You'll need to set the line below to whatever
+    # directory your code is in. Rubygems is going to assume lib if you leave
+    # this blank.
+    #
+    s.require_paths = ["lib"]
+
+    # If you want to depend on other gems, add them here, along with any
+    # relevant versions
+    s.add_dependency 'httparty', '0.5.2'
+    s.add_dependency 'activesupport', '>= 2.3.5'
+
+    # If your tests use any gems, include them here
+    # s.add_development_dependency("mocha") # for example
+  end
+end
+
+# Stolen from jeweler
+def prettyify_array(gemspec_ruby, array_name)
+  gemspec_ruby.gsub(/s\.#{array_name.to_s} = \[.+?\]/) do |match|
+    leadin, files = match[0..-2].split("[")
+    leadin + "[\n    #{files.split(",").join(",\n    ")}\n  ]"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["#{path}/test/**/*test.rb"]
+  t.verbose = true
+end
+
+# This task actually builds the gem. We also regenerate a static
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+#
+# To publish your gem online, install the 'gemcutter' gem; Read more 
+# about that here: http://gemcutter.org/pages/gem_docs
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :gemspec do
+  output = spec.to_ruby
+  output = prettyify_array(output, :files)
+  output = prettyify_array(output, :test_files)
+  output = prettyify_array(output, :extra_rdoc_files)
+
+  file = File.expand_path("../#{spec.name}.gemspec", __FILE__)
+  File.open(file, "w") {|f| f << output }
+end
+
+task :package => :gemspec
+
+# Generate documentation
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end

data/hashblue-api.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hashblue-api}
+  s.version = "0.0.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["FreeRange"]
+  s.date = %q{2010-05-06}
+  s.email = %q{lets@gofreerange.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "hashblue-api.gemspec",
+     "lib/dependency/mime_type.rb",
+     "lib/dependency/mime_types.rb",
+     "lib/hashblue/api.rb",
+     "lib/hashblue/api/contact.rb",
+     "lib/hashblue/api/error.rb",
+     "lib/hashblue/api/message.rb",
+     "lib/hashblue/api/model.rb",
+     "lib/hashblue/api/request.rb",
+     "lib/hashblue/api/subscriber.rb",
+     "lib/hashblue/api/test_helper.rb",
+     "test/helpers/test_helper_test.rb",
+     "test/test_helper.rb",
+     "test/unit/api_test.rb",
+     "test/unit/contact_test.rb",
+     "test/unit/message_api_test.rb",
+     "test/unit/message_test.rb",
+     "test/unit/model_test.rb",
+     "test/unit/subscriber_test.rb"
+  ]
+  s.homepage = %q{http://gofreerange.com}
+  s.rdoc_options = ["--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{It's the Hashblue API, stupid!}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httparty>, ["= 0.5.2"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.5"])
+    else
+      s.add_dependency(%q<httparty>, ["= 0.5.2"])
+      s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+    end
+  else
+    s.add_dependency(%q<httparty>, ["= 0.5.2"])
+    s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+  end
+end

data/lib/dependency/mime_type.rb

@@ -0,0 +1,231 @@
+require 'set'
+require 'active_support/core_ext/class/attribute_accessors'
+
+module Mime
+  class Mimes < Array
+    def symbols
+      @symbols ||= map {|m| m.to_sym }
+    end
+
+    %w(<< concat shift unshift push pop []= clear compact! collect!
+    delete delete_at delete_if flatten! map! insert reject! reverse!
+    replace slice! sort! uniq!).each do |method|
+      module_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{method}(*)
+          @symbols = nil
+          super
+        end
+      CODE
+    end
+  end
+
+  SET              = Mimes.new
+  EXTENSION_LOOKUP = {}
+  LOOKUP           = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
+
+  def self.[](type)
+    return type if type.is_a?(Type)
+    Type.lookup_by_extension(type.to_s)
+  end
+
+  # Encapsulates the notion of a mime type. Can be used at render time, for example, with:
+  #
+  #   class PostsController < ActionController::Base
+  #     def show
+  #       @post = Post.find(params[:id])
+  #
+  #       respond_to do |format|
+  #         format.html
+  #         format.ics { render :text => post.to_ics, :mime_type => Mime::Type["text/calendar"]  }
+  #         format.xml { render :xml => @people.to_xml }
+  #       end
+  #     end
+  #   end
+  class Type
+    @@html_types = Set.new [:html, :all]
+    cattr_reader :html_types
+
+    # These are the content types which browsers can generate without using ajax, flash, etc
+    # i.e. following a link, getting an image or posting a form.  CSRF protection
+    # only needs to protect against these types.
+    @@browser_generated_types = Set.new [:html, :url_encoded_form, :multipart_form, :text]
+    cattr_reader :browser_generated_types
+    attr_reader :symbol
+
+    @@unverifiable_types = Set.new [:text, :json, :csv, :xml, :rss, :atom, :yaml]
+    def self.unverifiable_types
+      ActiveSupport::Deprecation.warn("unverifiable_types is deprecated and has no effect", caller)
+      @@unverifiable_types
+    end
+
+    # A simple helper class used in parsing the accept header
+    class AcceptItem #:nodoc:
+      attr_accessor :order, :name, :q
+
+      def initialize(order, name, q=nil)
+        @order = order
+        @name = name.strip
+        q ||= 0.0 if @name == Mime::ALL # default wilcard match to end of list
+        @q = ((q || 1.0).to_f * 100).to_i
+      end
+
+      def to_s
+        @name
+      end
+
+      def <=>(item)
+        result = item.q <=> q
+        result = order <=> item.order if result == 0
+        result
+      end
+
+      def ==(item)
+        name == (item.respond_to?(:name) ? item.name : item)
+      end
+    end
+
+    class << self
+      def lookup(string)
+        LOOKUP[string]
+      end
+
+      def lookup_by_extension(extension)
+        EXTENSION_LOOKUP[extension.to_s]
+      end
+
+      # Registers an alias that's not used on mime type lookup, but can be referenced directly. Especially useful for
+      # rendering different HTML versions depending on the user agent, like an iPhone.
+      def register_alias(string, symbol, extension_synonyms = [])
+        register(string, symbol, [], extension_synonyms, true)
+      end
+
+      def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false)
+        Mime.instance_eval { const_set symbol.to_s.upcase, Type.new(string, symbol, mime_type_synonyms) }
+
+        SET << Mime.const_get(symbol.to_s.upcase)
+
+        ([string] + mime_type_synonyms).each { |str| LOOKUP[str] = SET.last } unless skip_lookup
+        ([symbol.to_s] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext] = SET.last }
+      end
+
+      def parse(accept_header)
+        if accept_header !~ /,/
+          [Mime::Type.lookup(accept_header)]
+        else
+          # keep track of creation order to keep the subsequent sort stable
+          list = []
+          accept_header.split(/,/).each_with_index do |header, index| 
+            params, q = header.split(/;\s*q=/)       
+            if params
+              params.strip!          
+              list << AcceptItem.new(index, params, q) unless params.empty?
+            end
+          end
+          list.sort!
+
+          # Take care of the broken text/xml entry by renaming or deleting it
+          text_xml = list.index("text/xml")
+          app_xml = list.index(Mime::XML.to_s)
+
+          if text_xml && app_xml
+            # set the q value to the max of the two
+            list[app_xml].q = [list[text_xml].q, list[app_xml].q].max
+
+            # make sure app_xml is ahead of text_xml in the list
+            if app_xml > text_xml
+              list[app_xml], list[text_xml] = list[text_xml], list[app_xml]
+              app_xml, text_xml = text_xml, app_xml
+            end
+
+            # delete text_xml from the list
+            list.delete_at(text_xml)
+
+          elsif text_xml
+            list[text_xml].name = Mime::XML.to_s
+          end
+
+          # Look for more specific XML-based types and sort them ahead of app/xml
+
+          if app_xml
+            idx = app_xml
+            app_xml_type = list[app_xml]
+
+            while(idx < list.length)
+              type = list[idx]
+              break if type.q < app_xml_type.q
+              if type.name =~ /\+xml$/
+                list[app_xml], list[idx] = list[idx], list[app_xml]
+                app_xml = idx
+              end
+              idx += 1
+            end
+          end
+
+          list.map! { |i| Mime::Type.lookup(i.name) }.uniq!
+          list
+        end
+      end
+    end
+    
+    def initialize(string, symbol = nil, synonyms = [])
+      @symbol, @synonyms = symbol, synonyms
+      @string = string
+    end
+    
+    def to_s
+      @string
+    end
+    
+    def to_str
+      to_s
+    end
+    
+    def to_sym
+      @symbol || @string.to_sym
+    end
+
+    def ===(list)
+      if list.is_a?(Array)
+        (@synonyms + [ self ]).any? { |synonym| list.include?(synonym) }
+      else
+        super
+      end
+    end
+    
+    def ==(mime_type)
+      return false if mime_type.blank?
+      (@synonyms + [ self ]).any? do |synonym| 
+        synonym.to_s == mime_type.to_s || synonym.to_sym == mime_type.to_sym 
+      end
+    end
+
+    def =~(mime_type)
+      return false if mime_type.blank?
+      regexp = Regexp.new(Regexp.quote(mime_type.to_s))
+      (@synonyms + [ self ]).any? do |synonym|
+        synonym.to_s =~ regexp
+      end
+    end
+
+    # Returns true if Action Pack should check requests using this Mime Type for possible request forgery.  See
+    # ActionController::RequestForgeryProtection.
+    def verify_request?
+      @@browser_generated_types.include?(to_sym)
+    end
+
+    def html?
+      @@html_types.include?(to_sym) || @string =~ /html/
+    end
+
+    private
+      def method_missing(method, *args)
+        if method.to_s =~ /(\w+)\?$/
+          $1.downcase.to_sym == to_sym
+        else
+          super
+        end
+      end
+  end
+end
+
+require 'dependency/mime_types'

data/lib/dependency/mime_types.rb

@@ -0,0 +1,23 @@
+# Build list of Mime types for HTTP responses
+# http://www.iana.org/assignments/media-types/
+
+Mime::Type.register "text/html", :html, %w( application/xhtml+xml ), %w( xhtml )
+Mime::Type.register "text/plain", :text, [], %w(txt)
+Mime::Type.register "text/javascript", :js, %w( application/javascript application/x-javascript )
+Mime::Type.register "text/css", :css
+Mime::Type.register "text/calendar", :ics
+Mime::Type.register "text/csv", :csv
+Mime::Type.register "application/xml", :xml, %w( text/xml application/x-xml )
+Mime::Type.register "application/rss+xml", :rss
+Mime::Type.register "application/atom+xml", :atom
+Mime::Type.register "application/x-yaml", :yaml, %w( text/yaml )
+
+Mime::Type.register "multipart/form-data", :multipart_form
+Mime::Type.register "application/x-www-form-urlencoded", :url_encoded_form
+
+# http://www.ietf.org/rfc/rfc4627.txt
+# http://www.json.org/JSONRequest.html
+Mime::Type.register "application/json", :json, %w( text/x-json application/jsonrequest )
+
+# Create Mime::ALL but do not add it to the SET.
+Mime::ALL = Mime::Type.new("*/*", :all, [])

data/lib/hashblue/api.rb

@@ -0,0 +1,89 @@
+require 'active_support/all'
+require 'httparty'
+require 'timeout'
+
+# By using autoload rather than require, we only use our fallback
+# dependency if Mime hasn't been loaded elsewhere
+autoload :Mime, 'dependency/mime_type'
+
+module Hashblue
+
+  # = It's the Hashblue API gem
+  # 
+  # == Connecting
+  # 
+  # Hashblue API requires ActiveSupport; if this isn't already loaded, you'll need
+  # to ensure that it is available - either by requiring rubygems, or ensuring
+  # it is in the +LOAD_PATH+ already.
+  # 
+  # To connect to the Hashblue API, you need to set the base URL, and provide
+  # your credentials (you can find these in your hashblue.com account). For
+  # example:
+  # 
+  #     require 'active_support/all' # unless you have already loaded it
+  #     require 'hashblue/api'
+  # 
+  #     Hashblue::API.base_uri "https://api.hashblue.apigee.com"
+  #     Hashblue::API.basic_auth "dave@example.com", "yourapikey"
+  # 
+  # 
+  # == Using the API
+  # 
+  # Everything is loaded via your subscriber:
+  # 
+  #     subscriber = Hashblue::API::Subscriber.find("yourapikey")
+  # 
+  # Once you have this, you can load all messages, all contacts, or all
+  # messages for a specific contact:
+  # 
+  #     all_messages = subscriber.messages
+  #     all_contacts = subscriber.contacts
+  #     messages_between_me_and_a_contact = all_contacts.first.messages
+  # 
+  # == Interacting with messages
+  # 
+  # It's simple to delete a message:
+  # 
+  #     all_messages.first.delete
+  # 
+  # This message is now deleted. You can see a list of all deleted messages
+  # via the subscriber:
+  # 
+  #     subscriber.deleted_messages
+  module API
+    autoload :Contact, 'hashblue/api/contact'
+    autoload :Message, 'hashblue/api/message'
+    autoload :Model, 'hashblue/api/model'
+    autoload :Request, 'hashblue/api/request'
+    autoload :Subscriber, 'hashblue/api/subscriber'
+    autoload :Error, 'hashblue/api/error'
+    autoload :TestHelper, 'hashblue/api/test_helper'
+
+    # Raised when the API fails to respond with a timeout. The timeout
+    # can be set using Hashblue::API.timeout
+    class NotRespondingError < StandardError; end
+    # Raised when the API responded in a way that we couldn't handle.
+    class BadResponseError < Hashblue::API::Error; end
+    # Raised when the object requested cannot be found.
+    class NotFoundError < Hashblue::API::Error; end
+    # Raised when the object requested is not available given the
+    # credentials used; most often is is because a Contact or Message
+    # belongs to a different Subscriber
+    class AccessDeniedError < Hashblue::API::Error
+      def status
+        :unauthorized
+      end
+    end
+
+    # Sets the timeout used before raising an error.
+    def self.timeout(value)
+      default_options[:timeout] = value
+    end
+
+    include HTTParty
+    extend Request
+
+    base_uri "https://api.hashblue.apigee.com"
+    timeout  5
+  end
+end