rlivsey-middleman 0.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+cache

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Richard Livsey
+
+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.markdown

@@ -0,0 +1,60 @@
+## About
+
+Middleman is a simple logging/caching proxy for Net::HTTP which can make developing against remote services easier (especially if they have API limits).
+
+By default, it caches to a file, so the cache is persistent across multiple runs of your app.
+
+## Installation
+
+gem sources -a http://gems.github.com
+sudo gem install rlivsey-middleman
+
+## Example usage
+
+    require 'rubygems'
+    require 'twitter'
+    gem 'middleman'
+    require 'middleman'
+    
+    Twitter::Search.new('bacon') # makes the request to Twitter
+    Twitter::Search.new('bacon') # same search, so returns from the cache
+
+## Options
+
+Output information to the console
+
+    Middleman.options[:verbose] = true
+    
+Change the store used for the cache, see the 'stores' section below for more information,
+but it's basically an object which acts like a Hash
+
+    Middleman.options[:store] = {}
+    
+Change where verbose output is sent, by default it's STDOUT
+
+    Middleman.options[:logger] = Logger.new('middleman.log')
+    
+    
+## Stores
+    
+By default Middleman uses Middleman::Store::File to cache the requests to files in a directory.
+The file names are MD5 hashes of the request details.
+
+The interface to Middleman::Store::File is basically a Hash, so any object which responds to [], []= and 
+is enumerable can be used as a store. 
+
+Using a Hash for the store will work fine, but will not persist across runs of your application.    
+    
+## Notes
+
+At the moment this only works against Net::HTTP. I've got plans to make it easier to extend and add the ability to work with other libraries such as Curb etc...
+
+Feel free to fork and send in patches.
+
+## Me
+
+ * Home & Contact info: http://livsey.org
+ * Twitter: http://twitter.com/rlivsey
+ * GitHub: http://github.com/rlivsey
+ * Recommend: http://www.workingwithrails.com/person/5436-richard-livsey
+ 

data/RakeFile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "middleman"
+    gem.summary = "simple logging/caching proxy for Net::HTTP"
+    gem.email = "richard@livsey.org"
+    gem.homepage = "http://github.com/rlivsey/middleman"
+    gem.authors = ["Richard Livsey"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+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 = "Middleman #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/intercepts/net_http.rb

@@ -0,0 +1,36 @@
+module Net
+  class HTTP
+    alias :old_initialize :initialize
+    alias :old_request :request
+
+    def initialize(*args, &block)
+      Middleman.log "CONNECT: #{args.inspect}" if Middleman.options[:verbose]
+      old_initialize(*args, &block)
+    end
+
+    def request(*args, &block)
+      req = args[0].class::METHOD      
+      key = "#{req}:#{@address}:#{@port}#{args[0].path}"     
+
+      if started? && Middleman.options[:verbose]
+        Middleman.log "#{req} #{@address}:#{@port}#{args[0].path}"     
+      end
+      
+      if result = Middleman.retrieve(key)
+        Middleman.log "CACHE HIT"             
+      else
+        Middleman.log "NOT IN CACHE"             
+        result = old_request(*args, &block)        
+        Middleman.cache(key, result.body)
+      end
+      
+      if started? && Middleman.options[:verbose]
+        Middleman.log "PARAMS #{CGI.parse(args[0].body).inspect} " if args[0].body && req != 'CONNECT'
+        Middleman.log "RESPONSE: #{result.class.name}"
+      end      
+    
+      result
+    end
+    
+  end
+end

data/lib/middleman.rb

@@ -0,0 +1,41 @@
+require 'store/file'
+require 'intercepts/net_http'
+
+module Middleman
+  
+  # default options
+  @options = {
+    :verbose    => false,       # don't output any info
+    :logger     => nil,         # defaults to STDOUT
+    :store      => {}
+  }
+  
+  class << self
+    attr_accessor :options
+    
+    def store
+      @options[:store]
+    end
+    
+    def logger
+      @options[:logger]
+    end
+    
+    def log(message)
+      return unless @options[:verbose]
+      logger ? logger.info(message) : puts(message)
+    end
+    
+    def cache(key, value)
+      return unless store
+      store[key] = value
+    end
+    
+    def retrieve(key)
+      return unless store
+      store[key]
+    end
+    
+  end  
+  
+end

data/lib/store/file.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'digest/md5'
+
+module Middleman
+  module Store
+    class File
+      
+      attr_accessor :path
+      
+      def initialize(path)
+        @path = path.chomp('/')
+        
+        unless ::File.exists? path
+          FileUtils.mkdir_p(path)
+        end
+        
+      end
+      
+      def [](key)
+        return unless ::File.exist?(path_from_key(key))
+        Marshal.load(::File.read(path_from_key(key)))
+      end
+      
+      def []=(key, val)
+        ::File.open(path_from_key(key), 'w') do |f|
+          f.write(Marshal.dump(val))
+        end
+      end
+      
+      def clear
+        ::File.delete(*Dir["#{@path}/*"])
+      end
+      
+      private
+      
+        def path_from_key(key)
+          "#{@path}/#{Digest::MD5.hexdigest(key)}"
+        end
+      
+    end
+  end
+end

data/middleman.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{middleman}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Richard Livsey"]
+  s.date = %q{2009-05-08}
+  s.email = %q{richard@livsey.org}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "RakeFile",
+     "VERSION",
+     "lib/intercepts/net_http.rb",
+     "lib/middleman.rb",
+     "lib/store/file.rb",
+     "middleman.gemspec",
+     "spec/middleman_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/rlivsey/middleman}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{simple logging/caching proxy for Net::HTTP}
+  s.test_files = [
+    "spec/middleman_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/middleman_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'pp'
+
+describe Middleman do
+  
+  def do_get
+    Net::HTTP.get(URI.parse('http://www.google.com?q=test'))
+  end
+  
+  describe "default options" do
+    
+    it "should not be verbose" do
+      Middleman.options[:verbose].should == false
+    end
+    
+    it "should be a hash store" do
+      Middleman.options[:store].class.should == Hash
+    end
+    
+    it "should not have a logger" do
+      Middleman.options[:logger].should be_nil
+    end
+    
+  end
+  
+  describe "with store" do
+    
+    before :each do
+      @store = mock(:store, :null_object => true)
+      @store.clear
+      Middleman.options[:store] = @store
+    end    
+        
+    it "should store the result of the request in a file the first time" do
+      Middleman.store.should_receive(:[]).and_return(nil)
+      Middleman.store.should_receive(:[]=).once
+      do_get
+    end
+      
+    it "should retrieve the results from the cache on subsequent requests" do
+      Middleman.store.should_receive(:[]).and_return(mock(:response, :null_object => true))
+      Middleman.store.should_not_receive(:[]=)
+      do_get
+    end      
+      
+  end
+  
+  describe "with no store" do
+    before :all do
+      Middleman.options[:store] = nil
+    end
+    
+    it "should not die..." do
+      do_get
+    end
+    
+  end
+  
+  describe "with verbose logging" do
+    
+    before :all do
+      Middleman.options[:verbose] = true
+      Middleman.options[:logger]  = DummyLogger.new
+    end
+    
+    it "should log to the logger" do
+      Middleman.options[:logger].lines.should be_empty
+      do_get
+      Middleman.options[:logger].lines.should_not be_empty      
+    end
+    
+  end
+  
+end
+
+
+
+
+describe Middleman::Store::File do
+  
+  before :each do
+    @store = Middleman::Store::File.new('cache/mman')     
+    @store.clear   
+  end
+  
+  it "should create the cache dir if it doesn't exist" do
+    FileUtils.rm_rf('cache')
+    File.exist?('cache').should == false
+    Middleman::Store::File.new('cache/mman')    
+    File.exist?('cache').should == true
+  end
+  
+  describe "#clear" do
+    
+    it "should delete all the files in the cache directory" do
+      @store["test"] = 'test'
+      Dir["#{@store.path}/*"].should_not be_empty
+      @store.clear
+      Dir["#{@store.path}/*"].should be_empty
+    end
+    
+  end
+  
+  describe "#[]" do
+    
+    it "should retrieve the contents of the file if it exists" do
+      @store["test"] = 'test'
+      @store["test"].should == 'test'
+    end
+    
+    it "should return nil if the file doesn't exist" do
+      @store["test"].should == nil
+    end
+    
+  end
+  
+  describe "#[]=" do
+    
+    it "should create a file with the MD5 of the name" do
+      @store["test"] = 'test'
+      File.exist?("#{@store.path}/#{Digest::MD5.hexdigest('test')}").should == true
+    end
+    
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--format
+  progress
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'net/http'
+require 'twitter'
+require 'middleman'
+
+Spec::Runner.configure do |config|
+  
+end
+
+# used so we don't pollute STDOUT when running the specs
+class DummyLogger 
+  
+  attr_accessor :lines
+  
+  def initialize
+    reset!
+  end
+  
+  def <<(msg)
+    @lines << msg
+  end
+  
+  def info(msg)
+     @lines << msg
+  end
+ 
+  def reset!
+    @lines = []
+  end
+  
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: rlivsey-middleman
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Richard Livsey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: richard@livsey.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- RakeFile
+- VERSION
+- lib/intercepts/net_http.rb
+- lib/middleman.rb
+- lib/store/file.rb
+- middleman.gemspec
+- spec/middleman_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/rlivsey/middleman
+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: simple logging/caching proxy for Net::HTTP
+test_files: 
+- spec/middleman_spec.rb
+- spec/spec_helper.rb