royw-read_page_cache 0.0.1

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2009 Roy Wright
+
+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.

data/README.rdoc

@@ -0,0 +1,43 @@
+= read_page_cache
+
+== Synopsis
+The purpose of the module is to cache web pages used for testing by overriding
+the classes' read_page method and replacing it with one that will cache pages.
+
+== Usage
+Your main code needs to have a read_page(page) instance method(s).  Here's an
+example:
+
+  class ClassName
+    def read_page(page)
+      open(page).read
+    end
+  end
+
+Then your test code should include:
+
+  # default directory is '/tmp'
+  directory = '/path/to/cache/files'
+
+  require 'cache_extensions'
+  ReadPageCache.attach_to ClassName, directory
+
+You may attach_to however many classes that you need to.
+
+If you want to override all the read_page(page) methods in your application,
+then your test code can instead use:
+
+  # default directory is '/tmp'
+  directory = '/path/to/cache/files'
+
+  require 'cache_extensions'
+  ReadPageCache.attach_to_classes directory
+
+That's it.  The first time you run your tests, the web pages your application
+accesses with read_page will be cached, then the cached files will be used by
+all subsequent accesses.  You may want to review the cache and add any files
+you want to your version control system.
+
+== Copyright
+
+Copyright (c) 2009 Roy Wright. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "read_page_cache"
+    gem.summary = %Q{TODO}
+    gem.email = "roy@wright.org"
+    gem.homepage = "http://github.com/royw/read_page_cache"
+    gem.authors = ["Roy Wright"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "read_page_cache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

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

data/lib/file_extensions.rb

@@ -0,0 +1,18 @@
+# == Synopsis
+# add a mkdirs method to the File class
+class File
+  class << self
+    my_extension("mkdirs") do
+      ##
+      # make directories including any missing in the path
+      #
+      # @param [String] dirspec the path to make sure exists
+      def File.mkdirs(dirspec)
+        unless File.exists?(dirspec)
+          mkdirs(File.dirname(dirspec))
+          Dir.mkdir(dirspec)
+        end
+      end
+    end
+  end
+end

data/lib/module_extensions.rb

@@ -0,0 +1,27 @@
+######################################################################
+# my extensions to Module. (taken from rake, named changed to not clash
+# when rake is used for this rails project.
+#
+class Module
+  # Check for an existing method in the current class before extending.  IF
+  # the method already exists, then a warning is printed and the extension is
+  # not added.  Otherwise the block is yielded and any definitions in the
+  # block will take effect.
+  #
+  # Usage:
+  #
+  #   class String
+  #     rake_extension("xyz") do
+  #       def xyz
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  def my_extension(method)
+    unless instance_methods.include?(method.to_s) || instance_methods.include?(method.to_sym)
+      yield
+    end
+  end
+end # module Module
+

data/lib/read_page_cache.rb

@@ -0,0 +1,89 @@
+require 'module_extensions'
+require 'file_extensions'
+
+# == Synopsis
+# The purpose of the module is to cache web pages used for
+# testing by overriding the classes' read_page method and
+# replacing it with one that will cache pages.
+#
+# == Usage
+# Your main code needs to have a read_page(page) instance
+# method(s).  Here's an example:
+#
+#   class ClassName
+#     def read_page(page)
+#       open(page).read
+#     end
+#   end
+#
+# Then your test code should include:
+#
+#   # default directory is '/tmp'
+#   directory = '/path/to/cache/files'
+#   require 'cache_extensions'
+#   ReadPageCache.attach_to ClassName, directory
+#
+# You may attach_to however many classes that you need to.
+#
+# If you want to override all the read_page(page) methods
+# in your application, then your test code can instead use:
+#
+#   # default directory is '/tmp'
+#   directory = '/path/to/cache/files'
+#   require 'cache_extensions'
+#   ReadPageCache.attach_to_classes directory
+#
+# That's it.  The first time you run your tests, the pages
+# your application accesses with read_page will be cached,
+# then the cached files will be used by all subsequent accesses.
+#
+module ReadPageCache
+  # == Synopsis
+  # Attach the read_page and cache_file methods to the given
+  # class (cls) and use the given directory for the cache files
+  def self.attach_to(cls, directory='/tmp')
+
+    # define the read_page(page) method on the given class: cls
+    cls.send('define_method', "read_page") do |page|
+      data = nil
+      filespec = page.gsub(/^http:\//, directory).gsub(/\/$/, '.html')
+      if File.exist?(filespec)
+        data = open(filespec).read
+      else
+        data = open(page).read
+        _cache_file(page, data)
+      end
+      data
+    end
+
+    # define the cache_file(page, data) method on the given class: cls
+    cls.send('define_method', "_cache_file") do |page, data|
+      begin
+        filespec = page.gsub(/^http:\//, directory).gsub(/\/$/, '.html')
+        unless File.exist?(filespec)
+          puts "caching #{filespec}"
+          File.mkdirs(File.dirname(filespec))
+          File.open(filespec, 'w') { |f| f.puts data }
+        end
+      rescue Exception => eMsg
+        puts eMsg.to_s
+      end
+    end
+  end
+
+  # == Synopsis
+  # Find all classes that have a read_page instance method and
+  # then overwrite that read_page method with one that handles
+  # the caching.  Use the given directory for the cache files.
+  def self.attach_to_classes(directory='/tmp')
+    ObjectSpace.each_object(Class) do |cls|
+      # need to check all scopes for read_page instance method
+      if(cls.public_instance_methods(false).include?("read_page") ||
+        cls.protected_instance_methods(false).include?("read_page") ||
+        cls.private_instance_methods(false).include?("read_page"))
+        ReadPageCache.attach_to(cls, directory)
+      end
+    end
+  end
+end
+

data/spec/read_page_cache_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'ruby-debug'
+require 'open-uri'
+
+TMPDIR = File.join(File.dirname(__FILE__), '../tmp')
+Dir.mkdir(TMPDIR) unless File.exist?(TMPDIR)
+
+TEST_DATA = "Testing cache read"
+
+describe "ReadPageCache" do
+
+  after(:each) do
+    Dir.glob(File.join(TMPDIR, '*')).each {|f| File.delete(f) if File.exist?(f)}
+  end
+
+  it 'should add read_page method to a class' do
+    class A
+    end
+    # attach to the class then create instance
+    ReadPageCache.attach_to A, TMPDIR
+    a = A.new
+    a.respond_to?('read_page').should be_true
+  end
+
+  it 'should add read_page method to a class not the instance' do
+    class A
+    end
+    # create instance then attach to the class
+    a = A.new
+    ReadPageCache.attach_to A, TMPDIR
+    a.respond_to?('read_page').should be_true
+  end
+
+  # this is not nice but we make a web access to www.example.com
+  # just to get a response to cache.  There probably is a better
+  # website to do this to.
+  it 'should override the read_page method in a class' do
+    class A
+      def read_page(page)
+        open(page).read
+      end
+    end
+    ReadPageCache.attach_to A, TMPDIR
+    a = A.new
+    a.read_page('http://www.example.com/')
+    filespec = File.join(TMPDIR, 'www.example.com.html')
+    (File.exist?(filespec).should be_true) && (File.size(filespec).should > 0)
+  end
+
+  it 'should read from the cache' do
+    filespec = File.join(TMPDIR, 'www.example.com.html')
+    File.open(filespec, "w") {|f| f.puts TEST_DATA}
+
+    class A
+      def read_page(page)
+        open(page).read
+      end
+    end
+    ReadPageCache.attach_to A, TMPDIR
+    a = A.new
+    data = a.read_page('http://www.example.com/').strip
+    data.should == TEST_DATA
+  end
+
+  it 'should replace all read_page methods in all classes' do
+    # create two classes with read_page methods
+    class A
+      def read_page(page)
+        open(page).read
+      end
+    end
+    class B
+      def read_page(page)
+        open(page).read
+      end
+    end
+    # when we attach to the class, ReadPageCache also puts a _cache_file method
+    # into the class, so we can simply test for it's presence.
+    ReadPageCache.attach_to_classes(TMPDIR)
+    a = A.new
+    b = B.new
+    (a.respond_to?('_cache_file').should be_true) && (b.respond_to?('_cache_file').should be_true)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'read_page_cache'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: royw-read_page_cache
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Roy Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: roy@wright.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/file_extensions.rb
+- lib/module_extensions.rb
+- lib/read_page_cache.rb
+- spec/read_page_cache_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/royw/read_page_cache
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- spec/spec_helper.rb
+- spec/read_page_cache_spec.rb