dpickett-amazon_associate 0.6.3 → 0.6.4

data/.gitignore

@@ -0,0 +1 @@
+*.swp

data/{README → README.rdoc}

@@ -15,7 +15,7 @@ instead you just need to change the element path.
 Version: 0.6.1
 
 == WANTS
- * instance based refactoring (singletons are not ideal here)
+* instance based refactoring (singletons are not ideal here)
  
 == INSTALLATION
 
@@ -26,7 +26,9 @@ Version: 0.6.1
     require 'amazon_associate'
 	
     # set the default options; options will be camelized and converted to REST request parameters.
-    AmazonAssociate::Request.options = {:aWS_access_key_id => [your developer token]}
+    AmazonAssociate::Request.configure do |options|
+      options[:aWS_access_key_id] = [your developer token]
+    end
 
     # options provided on method call will merge with the default options
     res = AmazonAssociate::Request.item_search('ruby', {:response_group => 'Medium', :sort => 'salesrank'})
@@ -86,23 +88,28 @@ http://www.awszone.com/scratchpads/aws/ecs.us/index.aws
 
 == CACHING
 
-  Filesystem caching is now available.
+Filesystem caching is now available.
   
-  AmazonAssociate::Request.options = {:aWS_access_key_id => [your developer token], :caching_strategy => :filesystem, 
-    :caching_options => {:disk_quota => 200, :cache_path => <path where you want to store requests>, :sweep_frequency => 4}
-  }
+  AmazonAssociate::Request.configure do |options| 
+    options[:aWS_access_key_id] = [your developer token]
+    options[:caching_strategy] = :filesystem
+    options[:caching_options] = {
+      :disk_quota      => 200, 
+      :cache_path      => <path where you want to store requests>, 
+      :sweep_frequency => 4
+    }
+  end
   
-  The above command will cache up to 200MB of requests. It will purge the cache every 4 hours or when the disk quota has been exceeded.
+The above command will cache up to 200MB of requests. It will purge the cache every 4 hours or when the disk quota has been exceeded.
   
-  Every request will be stored in the cache path. On every request, AmazonAssociate::Request will check for the presence of the cached file before querying Amazon directly.
+Every request will be stored in the cache path. On every request, AmazonAssociate::Request will check for the presence of the cached file before querying Amazon directly.
 
 == LINKS
 
 * http://amazon-ecs.rubyforge.org
-* http://www.pluitsolutions.com/amazon-ecs
 
 == LICENSE
 
 (The MIT License)
 
-Copyright (c) 2008 Dan Pickett, Enlight Solutions, Inc.
+Copyright (c) 2008 Dan Pickett, Enlight Solutions, Inc.

data/Rakefile

@@ -16,12 +16,12 @@ Rake::TestTask.new(:test) do |t|
   t.warning = true
 end
 
-desc "Generate documentation for the factory_girl plugin."
+desc "Generate documentation for the amazon_associate plugin."
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.title = "amazon_associate"
   rdoc.options << "--line-numbers" << "--inline-source" << "--main" << "README.textile"
-  rdoc.rdoc_files.include("README", "CHANGELOG")
+  rdoc.rdoc_files.include("README.rdoc", "CHANGELOG")
   rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
@@ -32,7 +32,7 @@ begin
     gemspec.summary = "Amazon Associates API Interface using Hpricot"
     gemspec.email = "dpickett@enlightsolutions.com"
     gemspec.homepage = "http://github.com/dpickett/amazon_associate"
-    gemspec.description = "TODO"
+    gemspec.description = "interfaces with Amazon Associate's API using Hpricot"
     gemspec.authors = ["Dan Pickett"]
   end
 rescue LoadError

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 5
+:major: 0
+:minor: 6

data/amazon_associate.gemspec

@@ -2,23 +2,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{amazon_associate}
-  s.version = "0.6.3"
+  s.version = "0.6.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dan Pickett"]
-  s.date = %q{2009-05-15}
-  s.description = %q{TODO}
+  s.date = %q{2009-06-30}
+  s.description = %q{interfaces with Amazon Associate's API using Hpricot}
   s.email = %q{dpickett@enlightsolutions.com}
   s.extra_rdoc_files = [
-    "README"
+    "README.rdoc"
   ]
   s.files = [
     ".autotest",
+     ".gitignore",
      ".project",
      "CHANGELOG",
      "MIT-LICENSE",
-     "README",
+     "README.rdoc",
      "Rakefile",
+     "VERSION.yml",
      "amazon_associate.gemspec",
      "lib/amazon_associate.rb",
      "lib/amazon_associate/cache_factory.rb",

data/lib/amazon_associate/cache_factory.rb

@@ -9,6 +9,7 @@ module AmazonAssociate
       unless self.strategy_class_hash.keys.include?(options[:caching_strategy])
         raise AmazonAssociate::ConfigurationError, "Invalid caching strategy" 
       end
+
       strategy_class_hash[options[:caching_strategy]].initialize_options(options)
     end
   

data/lib/amazon_associate/caching_strategy/filesystem.rb

@@ -9,106 +9,101 @@ module AmazonAssociate
     
       #frequency of sweeping in hours
       DEFAULT_SWEEP_FREQUENCY = 2
-    
-      def self.cache(request, response)
-        path = self.cache_path
-        cached_filename = Digest::SHA1.hexdigest(response.request_url)
-        cached_folder = cached_filename[0..2]
       
-        FileUtils.mkdir_p(File.join(path, cached_folder, cached_folder))
+      class << self
+        attr_accessor :cache_path
+        attr_accessor :disk_quota
+        attr_accessor :sweep_frequency
+
+        def cache(request, response)
+          path = self.cache_path
+          cached_filename = Digest::SHA1.hexdigest(response.request_url)
+          cached_folder = cached_filename[0..2]
+        
+          FileUtils.mkdir_p(File.join(path, cached_folder, cached_folder))
+        
+          cached_file = File.open(File.join(path, cached_folder, cached_filename), "w")
+          cached_file.puts response.doc.to_s
+          cached_file.close
+        end
       
-        cached_file = File.open(File.join(path, cached_folder, cached_filename), "w")
-        cached_file.puts response.doc.to_s
-        cached_file.close
-      end
-    
-      def self.get(request)
-        path = self.cache_path
-        cached_filename = Digest::SHA1.hexdigest(request)
-        file_path = File.join(path, cached_filename[0..2], cached_filename)
-        if FileTest.exists?(file_path)
-          File.read(file_path).chomp
-        else
-          nil
+        def get(request)
+          path = self.cache_path
+          cached_filename = Digest::SHA1.hexdigest(request)
+          file_path = File.join(path, cached_filename[0..2], cached_filename)
+          if FileTest.exists?(file_path)
+            File.read(file_path).chomp
+          else
+            nil
+          end
         end
-      end
-    
-      def self.initialize_options(options)      
-        #check for required options
-        if options[:caching_options].nil?
-          raise AmazonAssociate::ConfigurationError, "You must specify caching options for filesystem caching: :cache_path is required"
+      
+        def initialize_options(options)      
+          #check for required options
+          if options[:caching_options].nil? || options[:caching_options][:cache_path].nil?
+            raise AmazonAssociate::ConfigurationError, "You must specify caching options for filesystem caching: :cache_path is required"
+          end
+
+          #default disk quota to 200MB
+          Filesystem.disk_quota = options[:caching_options][:disk_quota] || DEFAULT_DISK_QUOTA
+        
+          Filesystem.sweep_frequency = options[:caching_options][:sweep_frequency] || DEFAULT_SWEEP_FREQUENCY
+        
+          Filesystem.cache_path = options[:caching_options][:cache_path]
+        
+          if Filesystem.cache_path.nil? || !File.directory?(Filesystem.cache_path)
+            raise AmazonAssociate::ConfigurationError, "You must specify a cache path for filesystem caching"
+          end
+          return options
         end
       
-        #default disk quota to 200MB
-        @@disk_quota = options[:caching_options][:disk_quota] || DEFAULT_DISK_QUOTA
+        def sweep
+          perform_sweep if must_sweep?
+        end
       
-        @@sweep_frequency = options[:caching_options][:sweep_frequency] || DEFAULT_SWEEP_FREQUENCY
+        private
+        def perform_sweep
+          FileUtils.rm_rf(Dir.glob("#{Filesystem.cache_path}/*"))
+        
+          timestamp_sweep_performance
+        end
       
-        @@cache_path = options[:caching_options][:cache_path]
+        def timestamp_sweep_performance
+          #remove the timestamp
+          FileUtils.rm_rf(timestamp_filename)
+        
+          #create a new one its place
+          timestamp = File.open(timestamp_filename, "w")
+          timestamp.puts(Time.now)
+          timestamp.close
+        end
       
-        if @@cache_path.nil? || !File.directory?(@@cache_path)
-          raise AmazonAssociate::ConfigurationError, "You must specify a cache path for filesystem caching"
+        def must_sweep?
+          sweep_time_expired? || disk_quota_exceeded?
         end
       
-        return options
-      end
-    
-      def self.sweep
-        self.perform_sweep if must_sweep?
-      end
-    
-      def self.disk_quota
-        @@disk_quota
-      end
-    
-      def self.sweep_frequency
-        @@sweep_frequency
-      end
-    
-      def self.cache_path
-        @@cache_path
-      end
-    
-      private
-      def self.perform_sweep
-        FileUtils.rm_rf(Dir.glob("#{@@cache_path}/*"))
+        def sweep_time_expired?
+          FileTest.exists?(timestamp_filename) && Time.parse(File.read(timestamp_filename).chomp) < Time.now - (sweep_frequency * 3600)
+        end
       
-        self.timestamp_sweep_performance
-      end
-    
-      def self.timestamp_sweep_performance
-        #remove the timestamp
-        FileUtils.rm_rf(self.timestamp_filename)
+        def disk_quota_exceeded?
+          cache_size > Filesystem.disk_quota
+        end
       
-        #create a new one its place
-        timestamp = File.open(self.timestamp_filename, "w")
-        timestamp.puts(Time.now)
-        timestamp.close
-      end
-    
-      def self.must_sweep?
-        sweep_time_expired? || disk_quota_exceeded?
-      end
-    
-      def self.sweep_time_expired?
-        FileTest.exists?(timestamp_filename) && Time.parse(File.read(timestamp_filename).chomp) < Time.now - (sweep_frequency * 3600)
-      end
-    
-      def self.disk_quota_exceeded?
-        cache_size > @@disk_quota
-      end
-    
-      def self.timestamp_filename
-        File.join(self.cache_path, ".amz_timestamp")
-      end
-    
-      def self.cache_size
-        size = 0
-        Find.find(@@cache_path) do|f|
-           size += File.size(f) if File.file?(f)
+        def timestamp_filename
+          File.join(Filesystem.cache_path, ".amz_timestamp")
+        end
+      
+        def cache_size
+          size = 0
+          Find.find(Filesystem.cache_path) do|f|
+             size += File.size(f) if File.file?(f)
+          end
+          size / 1000000
         end
-        size / 1000000
+
       end
+
     end
   end
 end

data/test/amazon_associate/cache_test.rb

@@ -29,6 +29,5 @@ class AmazonAssociate::CacheTest < Test::Unit::TestCase
       end
     end
     
-    
   end
-end
+end

data/test/amazon_associate/caching_strategy/filesystem_test.rb

@@ -27,6 +27,15 @@ class AmazonAssociate::CachingStrategy::FilesystemTest < Test::Unit::TestCase
         end
       end
     end
+
+    should "raise an exception when a cache_path is nil" do
+      assert_raise(AmazonAssociate::ConfigurationError) do
+        AmazonAssociate::Request.configure do |options|
+          options[:caching_strategy] = :filesystem
+          options[:caching_options] = {}
+        end
+      end
+    end
     
     should "set default values for disk_quota and sweep_frequency" do
       AmazonAssociate::Request.configure do |options|

data/test/amazon_associate/cart_test.rb

@@ -4,6 +4,7 @@ class AmazonAssociate::CartTest < Test::Unit::TestCase
   
   # create a cart to store cart_id and hmac for add, get, modify, and clear tests
   def setup
+    sleep(2)
     @asin = "0672328844"
     resp = AmazonAssociate::Request.cart_create(@asin)
     @cart_id = resp.doc.get_elements_by_tag_name("cartid").inner_text
@@ -86,4 +87,4 @@ class AmazonAssociate::CartTest < Test::Unit::TestCase
     assert_not_nil resp.doc.get_elements_by_tag_name("hmac").inner_text
   end
   
-end
+end

data/test/amazon_associate/request_test.rb

@@ -2,9 +2,9 @@ require File.dirname(__FILE__) + "/../test_helper"
 
 class AmazonAssociate::RequestTest < Test::Unit::TestCase
   def setup
+    sleep(1)
     AmazonAssociate::Request.configure do |options|
       options[:response_group] = "Large"
-      
     end
   end
   
@@ -105,4 +105,4 @@ class AmazonAssociate::RequestTest < Test::Unit::TestCase
     assert_equal "Dave Thomas", authors.first.get
   end
   
-end
+end

data/test/test_helper.rb

@@ -10,7 +10,7 @@ require 'amazon_associate'
 
 
 AmazonAssociate::Request.configure do |options|
-  options[:aWS_access_key_id] = ""
+  options[:aWS_access_key_id] = ENV["AWS_ACCESS_KEY"] || ""
   
   #raise exception if user has not entered their access key
   if options[:aWS_access_key_id] == ""

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dpickett-amazon_associate
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors: 
 - Dan Pickett
@@ -9,25 +9,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-15 00:00:00 -07:00
+date: 2009-06-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: TODO
+description: interfaces with Amazon Associate's API using Hpricot
 email: dpickett@enlightsolutions.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.rdoc
 files: 
 - .autotest
+- .gitignore
 - .project
 - CHANGELOG
 - MIT-LICENSE
-- README
+- README.rdoc
 - Rakefile
+- VERSION.yml
 - amazon_associate.gemspec
 - lib/amazon_associate.rb
 - lib/amazon_associate/cache_factory.rb