francois-ad_gear_client 0.1.1

data/lib/ad_gear/config.rb

@@ -0,0 +1,139 @@
+module AdGear
+  class Config
+    # Raised when the specified environment could not be found in the YAML configuration file.
+    class MissingEnvironmentSpecification < RuntimeError; end
+
+    # Reads in a YAML file containing configuration parameters for the AdGear::Client.  The file
+    # can contain sections relating to the environment the client is running within.
+    #
+    # The YAML configuration file *must* use strings as keys.
+    #
+    # @example A sample YAML configuration file:
+    #   development:
+    #     site:     http://localhost:3000/api
+    #     user:     dummy
+    #     password: whatever
+    #     logger:   path/to/log/file.log
+    #   production:
+    #     site:     http://admin.adgear.com/api
+    #     user:     your_real_login
+    #     password: your_real_digest_password
+    #     logger:   path/to/log/file.log
+    #
+    # @example Reading this sample file:
+    #   AdGear.config = AdGear::Config.new("path/to/config/file", "development")
+    #
+    # @example Reading from +config/initializers/ad_gear.rb+ in a Rails environment
+    #   AdGear.config = AdGear::Config.new(Rails.root + "config/ad_gear.yml", Rails.env)
+    #
+    # @param obj [#read, Hash, String] When the object responds to #read, reads in the IO-like
+    #                                  object and parses it as a YAML stream.  If the object is a
+    #                                  Hash, use it as-is. Else, treat the object as the path to a
+    #                                  YAML file containing the configuration.
+    # @param environment [String, Symbol, nil] If this is +nil+, then do no environment unpacking, else
+    #                                          find the environment that matches this string.  If none
+    #                                          matches, a MissingEnvironmentSpecification exception will
+    #                                          be raised.
+    #
+    # @raise MissingEnvironmentSpecification When the +environment+ parameter specifies a missing environment declaration.
+    def initialize(obj, environment=nil)
+      @config = Hash.new
+      @logger = nil
+
+      config = if obj.kind_of?(Hash) then
+                 obj
+               elsif obj.respond_to?(:read) then
+                 YAML.load(obj.read)
+               else
+                 YAML.load_file(obj)
+               end
+      if environment then
+        raise MissingEnvironmentSpecification, "Could not find #{environment.to_s.inspect} in #{config.inspect} read from #{obj.inspect}.  Add the missing environment declaration, or change the parameter to this method." unless config.respond_to?(:has_key?) && config.has_key?(environment.to_s)
+        config = config[environment.to_s]
+      end
+
+      config.each_pair do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    # Returns a Hash of the currect configuration.
+    def to_hash
+      @config.dup
+    end
+
+    def site=(value)
+      @config["site"] = value
+    end
+
+    # Returns the configured site, which is the root of the API.
+    def site
+      @config["site"]
+    end
+
+    def user=(value)
+      @config["user"] = value
+    end
+
+    # Returns the configured username / login.
+    def user
+      @config["user"]
+    end
+
+    def password=(value)
+      @config["password"] = value
+    end
+
+    # Returns the configured password.
+    def password
+      @config["password"]
+    end
+
+    # Denies or allows using Basic authentication method.  This will have an effect only if you are using http://github.com/francois/rails/ar_basic/activeresource
+    def use_basic_authentication
+      @config["use_basic_authentication"]
+    end
+
+    def use_basic_authentication=(value)
+      @config["use_basic_authentication"] = value
+    end
+
+    # Denies or allows using Digest authentication method.  This will have an effect only if you are using http://github.com/francois/rails/ar_digest/activeresource
+    def use_digest_authentication
+      @config["use_digest_authentication"]
+    end
+
+    def use_digest_authentication=(value)
+      @config["use_digest_authentication"] = value
+    end
+
+    # Returns a format object suitable for use by ActiveResource.
+    def format
+      AdGear::XmlFormat
+    end
+
+    # Returns the Logger instance that was configured in #logger=.
+    def logger
+      @logger
+    end
+
+    # Register a Logger for use by AdGear's client.
+    # @param value [nil, String] When nil, no Logger is assigned.
+    #                            When the values STDERR or STDOUT are used, logs to the specified stream.
+    #                            Else, it is taken as the path to a log file.
+    def logger=(value)
+      @config["logger"] = value
+      @logger = case value
+                when nil, ""
+                  # No logger
+                  nil
+                when /^std(err|out)$/i
+                  # Existing stream
+                  Logger.new(Object.const_get(value.upcase))
+                else
+                  # Path to a file
+                  Logger.new(value)
+                end
+    end
+  end
+end

data/lib/ad_gear/file.rb

@@ -0,0 +1,4 @@
+module AdGear
+  class File < AdGear::Base
+  end
+end

data/lib/ad_gear/format.rb

@@ -0,0 +1,4 @@
+module AdGear
+  class Format < AdGear::Base
+  end
+end

data/lib/ad_gear/has_many_array.rb

@@ -0,0 +1,50 @@
+module AdGear
+  class HasManyArray
+    include Enumerable
+
+    def initialize(name, saved=nil)
+      @name  = name.to_s.singularize.dasherize + "-attributes"
+      @new   = []
+      @saved = []
+      saved.each do |obj|
+        self << obj
+      end if saved
+    end
+
+    def <<(object)
+      is_new = object.respond_to?(:new_record?) && object.new_record?
+      root   = is_new ? @new : @saved
+      root << object
+    end
+
+    def each(&block)
+      @saved.each(&block)
+      @new.each(&block)
+    end
+
+    def length
+      @saved.length + @new.length
+    end
+
+    alias_method :size, :length
+
+    def to_xml(options={})
+      xml = options[:builder] || Builder::XmlMarkup.new
+      xml.__send__(@name) do
+        unless @new.empty?
+          xml.tag!(:new) do
+            @new.each_with_index do |obj, index|
+              obj.to_xml(options.merge(:root => "n" << index.to_s))
+            end
+          end
+        end
+
+        unless @saved.empty?
+          @saved.each do |obj|
+            obj.to_xml(options.merge(:root => "n" << obj.id.to_s))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ad_gear/interaction.rb

@@ -0,0 +1,4 @@
+module AdGear
+  class Interaction < AdGear::Base
+  end
+end

data/lib/ad_gear/site.rb

@@ -0,0 +1,6 @@
+module AdGear
+  class Site < AdGear::Base
+    has_many :ad_spots
+    ignorable_attributes :embed_code
+  end
+end

data/lib/ad_gear/template.rb

@@ -0,0 +1,4 @@
+module AdGear
+  class Template < AdGear::Base
+  end
+end

data/lib/ad_gear/upload.rb

@@ -0,0 +1,46 @@
+begin
+  gem "francois-rest-client", ">= 1.1.5"
+rescue
+  # Ignored.  We hope we got what we wanted
+  warn "Could not ensure francois-rest-client 1.1.5 is loaded.  If you have problems uploading files, make sure you have that gem install and that the AdGear::Client uses that version."
+end
+require "restclient"
+
+module AdGear
+  class Upload < AdGear::Base
+    def save
+      retried = false
+      headers = Hash.new
+      begin
+        uri = self.class.site.merge(URI.parse(self.class.collection_path))
+        params  = {"upload[uploaded_data]" => ::File.new(attributes["filename"]), "upload[filename]" => ::File.basename(attributes["filename"])}
+        out = RestClient.post(uri.to_s, params, headers)
+        logger.debug out if logger
+        load(connection.format.decode(out))
+      rescue RestClient::Unauthorized => e
+        # Retry once only
+        raise if retried
+
+        www_authenticate = e.response["www-authenticate"]
+        header = ActiveResource::Digest.authenticate(uri, self.class.user, self.class.password, www_authenticate, :post)
+        headers["Authorization"] = header
+
+        retried = true
+        retry
+      end
+    end
+
+    def update_attribute(*args)
+      raise_unsupported_operation
+    end
+
+    def update_attributes(*args)
+      raise_unsupported_operation
+    end
+
+    protected
+    def raise_unsupported_operation
+      raise UnsupportedOperation, "Unsupported operation: uploads are write-once only"
+    end
+  end
+end

data/lib/ad_gear/variable.rb

@@ -0,0 +1,4 @@
+module AdGear
+  class Variable < AdGear::Base
+  end
+end

data/lib/ad_gear/xml_format.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/hash/conversions'
+
+module AdGear
+  # Copied from ActiveResource's +active_resource/formats/xml_format.rb+.  Changed +mime_type+ to return AdGear's expected mime type.
+  module XmlFormat
+    extend self
+
+    def extension
+      "agml"
+    end
+
+    def mime_type
+      "application/vnd.bloom.adgear.v1+xml"
+    end
+
+    def encode(hash, options={})
+      hash.to_xml(options)
+    end
+
+    def decode(xml)
+      from_xml_data(Hash.from_xml(xml))
+    end
+
+    private
+      # Manipulate from_xml Hash, because xml_simple is not exactly what we
+      # want for Active Resource.
+      def from_xml_data(data)
+        if data.is_a?(Hash) && data.keys.size == 1
+          data.values.first
+        else
+          data
+        end
+      end
+  end
+end

data/lib/ad_gear.rb

@@ -0,0 +1,93 @@
+#--
+# Copyright (c) 2009 François Beausoleil
+# Copyright (c) 2009 Bloom Digital Platforms
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require "active_support"
+require "active_resource"
+require "logger"
+
+warn "You are using the plain jane version of ActiveResource.  You could use Digest authentication if you used http://github.com/francois/rails/tree/ar_digest" unless ActiveResource::Base.respond_to?(:use_basic_authentication)
+
+module AdGear
+  # AdGear's models superclass
+  autoload :Base, "ad_gear/base"
+
+  # AdGear models themselves
+  autoload :Site, "ad_gear/site"
+  autoload :AdSpot, "ad_gear/ad_spot"
+  autoload :Campaign, "ad_gear/campaign"
+  autoload :Format, "ad_gear/format"
+  autoload :Upload, "ad_gear/upload"
+
+  # AdUnits and it's child models
+  autoload :AdUnit, "ad_gear/ad_unit"
+  autoload :AdUnitFile, "ad_gear/ad_unit_file"
+  autoload :AdUnitInteraction, "ad_gear/ad_unit_interaction"
+  autoload :AdUnitClick, "ad_gear/ad_unit_click"
+  autoload :AdUnitVariable, "ad_gear/ad_unit_variable"
+
+  # Templates and their dependencies, to know what child models are required
+  autoload :Template, "ad_gear/template"
+  autoload :File, "ad_gear/file"
+  autoload :Variable, "ad_gear/variable"
+  autoload :Click, "ad_gear/click"
+  autoload :Interaction, "ad_gear/interaction"
+
+  # Miscellaneous stuff
+  autoload :Config, "ad_gear/config"
+  autoload :XmlFormat, "ad_gear/xml_format"
+  autoload :HasManyArray, "ad_gear/has_many_array"
+
+  class UnsupportedOperation < RuntimeError; end
+
+  # Configures AdGear's ActiveResource models.
+  #
+  # NOTE: AdGear's client expects and uses Nokogiri instead of REXML.
+  # See http://rubyglasses.blogspot.com/2009/07/40-speedup-using-nokogiri.html#instructions
+  def self.config=(config)
+    @config = config
+
+    AdGear::Base.logger   = config.logger
+
+    AdGear::Base.site     = config.site
+    AdGear::Base.user     = config.user
+    AdGear::Base.password = config.password
+    AdGear::Base.format   = config.format
+
+    if AdGear::Base.respond_to?(:use_basic_authentication=)
+      AdGear::Base.use_basic_authentication = config.use_basic_authentication
+    end
+
+    if AdGear::Base.respond_to?(:use_digest_authentication=)
+      AdGear::Base.use_digest_authentication = config.use_digest_authentication
+    end
+
+    ActiveSupport::XmlMini.backend = "Nokogiri"
+
+    require "core_ext"
+  end
+
+  def self.config
+    config
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,18 @@
+#
+# ActiveSupport's Array#to_xml will build an XML with root set to the full class name including
+# module(s) it may be nested in - we don't want that, we want it to be *just* the class name,
+# make it so with this monkey patch...
+#
+# Note this is loaded last from AdGear.config= after ActiveSupport has already been loaded.  We
+# cannot simply override because ActiveSupport does lazy loading.
+#
+class Array
+  def to_xml_with_module_prefixing(options = {})
+    raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+    root = all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ?
+      ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(first.class.to_s.split("::").last)) : "records"
+    to_xml_without_module_prefixing({ :root => root }.merge(options))
+  end
+
+  alias_method_chain :to_xml, :module_prefixing
+end

data/test/ad_gear/ad_spot_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+require "ostruct"
+
+class AdGear::AdSpotTest < Test::Unit::TestCase
+  def setup
+    super
+    AdGear.config = OpenStruct.new(:site => "http://test.host", :format => :xml)
+  end
+
+  def teardown
+    AdGear::Base.site = nil
+    super
+  end
+
+  def test_embed_code_should_not_be_encoded
+    spot = AdGear::AdSpot.new(:id => 84, :name => "XLsuite", :format_id => 42, :embed_code => "some code")
+
+    doc = Nokogiri::XML(spot.encode)
+    xpath doc, "/ad-spot/embed-code" do |ns|
+      assert ns.empty?, doc
+    end
+  end
+
+  def test_setting_format_sets_format_id_internally
+    format = stub("AdGear::Format", :id => 231)
+
+    spot = AdGear::AdSpot.new
+    spot.format = format
+    assert_equal 231, spot.attributes["format_id"], spot.attributes
+  end
+
+  def test_instantiating_with_format_sets_format_id_internally
+    format = stub("AdGear::Format", :id => 231)
+    spot = AdGear::AdSpot.new(:format => format)
+    assert_equal 231, spot.attributes["format_id"], spot.attributes
+  end
+  
+  def test_setting_format_to_nil_sets_format_id_to_nil
+    spot = AdGear::AdSpot.new
+    spot.format = nil
+    assert_nil spot.attributes["format_id"]
+  end
+end

data/test/ad_gear/config_test.rb

@@ -0,0 +1,91 @@
+require "test_helper"
+require "tempfile"
+require "stringio"
+
+class AdGear::ConfigTest < Test::Unit::TestCase
+  should "read a file on disk when given a path" do
+    econf = {"site" => "http://whatever.com/", "user" => "francois", "password" => "many"}
+    Tempfile.open("config") do |io|
+      io.write econf.to_yaml
+      io.close
+
+      aconf = AdGear::Config.new(io.path)
+      assert_equal econf, aconf.to_hash
+    end
+  end
+
+  should "read a stream" do
+    econf = {"site" => "http://whatever.com/", "user" => "francois", "password" => "many"}
+    Tempfile.open("config") do |io|
+      io.write econf.to_yaml
+      io.rewind
+
+      aconf = AdGear::Config.new(io)
+      assert_equal econf, aconf.to_hash
+    end
+  end
+
+  should "read the specified env" do
+    econf = {"site" => "http://whatever.com/", "user" => "francois", "password" => "many"}
+    env = {"development" => econf}
+    aconf = AdGear::Config.new(StringIO.new(env.to_yaml), "development")
+    assert_equal econf, aconf.to_hash
+  end
+
+  should "raise a MissingEnvironmentSpecification when the file is empty" do
+    assert_raise AdGear::Config::MissingEnvironmentSpecification do
+      AdGear::Config.new(StringIO.new(""), "development")
+    end
+  end
+
+  should "raise a MissingEnvironmentSpecification when the env doesn't exist" do
+    econf = {"site" => "http://whatever.com/", "user" => "francois", "password" => "many"}
+    env = {"development" => econf}
+
+    assert_raise AdGear::Config::MissingEnvironmentSpecification do
+      AdGear::Config.new(StringIO.new(env.to_yaml), "test")
+    end
+  end
+
+  should "instantiate a Logger for STDOUT when the logger key is 'stdout'" do
+    Logger.expects(:new).with(STDOUT).returns(mock("Logger"))
+    AdGear::Config.new(StringIO.new({"logger" => "stdout"}.to_yaml))
+  end
+
+  should "instantiate a Logger for STDERR when the logger key is 'stderr'" do
+    Logger.expects(:new).with(STDERR).returns(mock("Logger"))
+    AdGear::Config.new("logger" => "stderr")
+  end
+
+  should "instantiate a Logger for the file named 'log/adgear.log' when the key is 'log/adgear.log'" do
+    Logger.expects(:new).with("log/adgear.log").returns(mock("Logger"))
+    AdGear::Config.new(StringIO.new({"logger" => "log/adgear.log"}.to_yaml))
+  end
+
+  context "Given a configured AdGear::Config" do
+    setup do
+      conf = {"site" => "http://whatever.com/", "user" => "francois", "password" => "many", "use_basic_authentication" => false, "use_digest_authentication" => true}
+      @config = AdGear::Config.new(conf)
+    end
+
+    should "return the correct site from #site" do
+      assert_equal "http://whatever.com/", @config.site
+    end
+
+    should "return the correct user from #user" do
+      assert_equal "francois", @config.user
+    end
+
+    should "return the correct password from #password" do
+      assert_equal "many", @config.password
+    end
+
+    should "return the correct use_basic_authentication from #use_basic_authentication" do
+      assert_equal false, @config.use_basic_authentication
+    end
+
+    should "return the correct use_digest_authentication from #use_digest_authentication" do
+      assert_equal true, @config.use_digest_authentication
+    end
+  end
+end

data/test/ad_gear/site_test.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+require "ostruct"
+
+class AdGear::SiteTest < Test::Unit::TestCase
+  def setup
+    super
+    AdGear.config = OpenStruct.new(:site => "http://test.host", :format => :xml)
+  end
+
+  def teardown
+    AdGear::Base.site = nil
+    super
+  end
+
+  def test_adding_an_ad_spot_puts_it_in_the_new_collection
+    site = AdGear::Site.new(:name => "XLsuite", :url => "http://xlsuite.com/", :publisher_id => 1)
+    site.ad_spots << AdGear::AdSpot.new(:format_id => 13, :name => "sidebar top")
+
+    doc = Nokogiri::XML(site.to_xml)
+    xpath doc, "/site/ad-spot-attributes/new/*/name" do |ns|
+      assert_equal 1, ns.length, doc
+    end
+  end
+
+  def test_adding_an_existing_ad_spot_puts_it_in_the_old_collection
+    site = AdGear::Site.new(:name => "XLsuite", :url => "http://xlsuite.com/", :publisher_id => 1)
+    FakeWeb.register_uri(:get, "http://test.host/ad_spots/42.xml", :body => "<ad-spot><id>42</id><name>bla</name></ad-spot>")
+    site.ad_spots << AdGear::AdSpot.find(42)
+
+    doc = Nokogiri::XML(site.to_xml)
+    xpath doc, "/site/ad-spot-attributes/n42/name" do |ns|
+      assert_equal 1, ns.length, doc
+    end
+  end
+
+  def test_instantiating_with_ad_spots_still_generates_ad_spots_in_the_new_collection
+    site = AdGear::Site.new(:name         => "XLsuite",
+                            :url          => "http://xlsuite.com/",
+                            :publisher_id => 1,
+                            :ad_spots     => [{:format_id => 13, :name => "sidebar top"}])
+
+    doc = Nokogiri::XML(site.to_xml)
+    xpath doc, "/site/ad-spot-attributes/new/*/name" do |ns|
+      assert_equal 1, ns.length, doc
+    end
+  end
+
+  def test_adding_a_new_ad_spot_to_existing_ad_spots_adds_to_new_collection
+    site = AdGear::Site.new(:name         => "XLsuite",
+                            :url          => "http://xlsuite.com/",
+                            :publisher_id => 1,
+                            :ad_spots     => [{:format_id => 13, :name => "sidebar top"}])
+    site.ad_spots << AdGear::AdSpot.new(:format_id => 13, :name => "homepage bottom")
+
+    doc = Nokogiri::XML(site.to_xml)
+    xpath doc, "/site/ad-spot-attributes/new/*/name" do |ns|
+      assert_equal 2, ns.length, doc
+    end
+  end
+
+  def test_embed_code_should_not_be_encoded
+    site = AdGear::Site.new(:id => 84, :name => "XLsuite", :url => "http://xlsuite.com/", :embed_code => "some code")
+
+    doc = Nokogiri::XML(site.encode)
+    xpath doc, "/site/embed-code" do |ns|
+      assert ns.empty?, doc
+    end
+  end
+end

data/test/ad_gear/upload_test.rb

@@ -0,0 +1,37 @@
+require "test_helper"
+
+class AdGear::UploadTest < Test::Unit::TestCase
+  def setup
+    super
+    AdGear.config = OpenStruct.new(:site => "http://test.host/api", :format => :xml)
+  end
+
+  def teardown
+    AdGear::Base.site = nil
+    super
+  end
+
+  should "upload the data using RestClient" do
+		xml = Builder::XmlMarkup.new
+		xml.upload do
+			xml.id 42
+		end
+
+		RestClient.expects(:post).with(responds_with(:to_s, URI.parse("http://test.host/api/uploads.xml").to_s), has_entry(:upload, has_entry(:uploaded_data, kind_of(File))), kind_of(Hash)).returns(xml.target!)
+		upload = AdGear::Upload.new(:filename => "test/fixtures/access-denied-no-auth.txt")
+		upload.save
+		assert_equal 42, upload.id.to_i
+  end
+
+  should "raise an exception when calling #update_attribute" do
+    assert_raise(AdGear::UnsupportedOperation) do
+      AdGear::Upload.new.update_attribute
+    end
+  end
+
+  should "raise an exception when calling #update_attributes" do
+    assert_raise(AdGear::UnsupportedOperation) do
+      AdGear::Upload.new.update_attributes
+    end
+  end
+end