resterl 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+PRIVATE_TODO.rdoc
+nbproject

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 fduetsch
+
+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,17 @@
+= resterl
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 fduetsch. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "resterl"
+    gem.summary = %Q{Rudimentary HTTP client with focus on caching}
+    gem.description = %Q{Rudimentary HTTP client with focus on caching}
+    gem.email = "florian.duetsch@nix-wie-weg.de"
+    gem.homepage = "http://nix-wie-weg.de/"
+    gem.authors = ["Florian Dütsch"]
+
+    # TODO
+    #gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20
+    # for additional settings
+
+    # TODO: Können wir auf einen neuere Version gehen?
+    gem.add_dependency 'hashie', '~> 0.4.0'
+    gem.add_dependency 'yajl-ruby', '~> 0.7.7'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. " \
+       "Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: " \
+          "sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "resterl #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,5 @@
+* Edit README.rdoc
+* Use technoweenie's faraday as base (http://github.com/technoweenie/faraday)
+* Secure caching with tests
+* Store parsed objects in cache (instead of the plain response)
+* Persistent connections

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/resterl/base_object.rb

@@ -0,0 +1,39 @@
+require 'hashie'
+
+class Resterl::BaseObject #< Hashie::Mash
+
+  class_inheritable_accessor :resterl_client, :parser, :complete_mime_type,
+                             :mapper
+  #self.resterl_client = nil
+  #self.complete_mime_type = 'text/plain'
+
+  def initialize data = {}
+    @data = Hashie::Mash.new data
+  end
+
+  def method_missing sym, *args, &block
+    # Vielleicht lassen sich auch feste Attribute delegieren, das wäre als
+    # method_missing.
+    @data.send sym, *args, &block
+  end
+
+  protected
+
+  def self.get_object url, params = {}
+    headers = { 'Accept' => complete_mime_type }
+    doc = resterl_client.get(url, params, headers).body
+    doc = parser.call(doc)
+    doc = mapper.map(doc) if @mapper
+    new(doc)
+  end
+
+  def self.mime_type= t
+    self.parser, self.complete_mime_type = case t
+    when :json
+      [proc {|str| JSON.parse(str)}, 'application/json']
+    when :xml
+      [proc {|str| Hash.from_xml(str)}, 'application/xml']
+    end
+  end
+
+end

data/lib/resterl/cache_interface.rb

@@ -0,0 +1,11 @@
+class Resterl::CacheInterface
+  def read key
+    raise 'Not yet implemented!'
+  end
+  def write key, value, expires_in
+    raise 'Not yet implemented!'
+  end
+  def delete key
+    raise 'Not yet implemented!'
+  end
+end

data/lib/resterl/client.rb

@@ -0,0 +1,94 @@
+class Resterl::Client
+  attr_reader :options
+  DEFAULTS = {
+    :max_redirect_depth => 10,
+    :cache => Resterl::SimpleCache.new,
+    :ssl_verify_mode => OpenSSL::SSL::VERIFY_NONE,
+    :expiry_multiplier => 10,
+    :minimum_cache_lifetime => 5 * 60 # 5 Minuten
+  }
+
+  class TooManyRedirects < StandardError; end
+
+  def initialize(options = {})
+    @options = DEFAULTS.merge(options).freeze
+    @cache = @options[:cache]
+  end
+
+  def get url, params, headers
+    url = setup_url(url)
+
+    # Cache-Schlüssel aus Pfad hashen
+    cache_key = data_to_cache_key url, params, headers
+
+    # Response aus Cache holen
+    old_response = @cache.read(cache_key)
+
+    if old_response and not old_response.expired?
+      # Anfrage noch nicht abgelaufen, Ergebnis aus dem Cache verwenden
+      old_response
+    else
+      # Neue Anfrage
+      new_get_request url, cache_key, params, headers, old_response
+    end
+  end
+
+  private
+
+  def new_get_request url, cache_key, params, headers, old_response
+
+    # Ggf. ETag und Last-Modified auslesen
+    if old_response
+      etag = old_response.net_http_response['ETag']
+      headers['If-None-Match'] = etag if etag
+
+      last_modified = old_response.net_http_response['Last-Modified']
+      headers['If-Modified-Since'] = last_modified if last_modified
+    end
+
+    # Anfrage stellen, ggf. ETag mit übergeben
+    request = Resterl::Request.new(self, url, params, headers)
+    new_response = request.perform.response
+
+    response, max_age_seconds = case new_response
+
+    when Net::HTTPClientError, Net::HTTPServerError
+      # Aus dem Cache muss nichts entfernt werden, weil ja auch kein Eintrag
+      # (mehr) drin ist.
+      new_response.error!
+
+    when Net::HTTPNotModified
+      # Wenn "304 Not Modified", dann altes Ergebnis als neues Ergebnis
+      # verwenden
+      r_temp = Resterl::Response.new(new_response)
+      old_response.update_expires_at(r_temp.expires_at)
+      [old_response, r_temp.expires_at - Time.now]
+
+    when Net::HTTPSuccess
+      r = Resterl::Response.new(new_response)
+      [r, r.expires_at - Time.now]
+    else
+      raise 'unknown response'
+    end
+
+    # Cachezeit berechnen
+    expiry = [
+      max_age_seconds * options[:expiry_multiplier],
+      options[:minimum_cache_lifetime]
+    ].max
+
+    # Ergebnis im Cache speichern
+    @cache.write cache_key, response, expiry
+
+    response
+  end
+
+  def setup_url url
+    bu = options[:base_uri]
+    bu ? "#{bu}#{url}" : url
+  end
+
+  def data_to_cache_key *args
+    args.hash
+  end
+end

data/lib/resterl/redis_cache.rb

@@ -0,0 +1,22 @@
+class Resterl::RedisCache < Resterl::CacheInterface
+
+  def initialize client
+    @client = client
+  end
+
+  def read key
+    dump = @client.get key
+    Marshal.load(dump) if dump
+  end
+  def write key, value, expires_in
+    @client.pipelined do
+      #@client.multi do
+        @client.set key, Marshal.dump(value)
+        @client.expire key, expires_in
+      #end
+    end
+  end
+  def delete key
+    @client.del key
+  end
+end

data/lib/resterl/request.rb

@@ -0,0 +1,72 @@
+# Redirect code from:
+# http://railstips.org/blog/archives/2009/03/04/following-redirects-with-nethttp/
+class Resterl::Request
+  attr_accessor :rest_client, :url, :body, :redirect_limit, :response
+  DEFAULT_HEADERS = {}
+
+  def initialize client, url, query_params, headers
+    @rest_client = client
+    @url = url
+    @query_params = query_params
+    @redirect_limit = @rest_client.options[:max_redirect_depth]
+    @headers = DEFAULT_HEADERS.merge headers
+  end
+  def perform
+    raise TooManyRedirects if redirect_limit < 0
+
+    # build URL
+    #complete_url = url.dup
+    #complete_url << "?#{query_param_string}" unless query_param_string.blank?
+    #puts complete_url
+    uri = URI.parse(url)#complete_url)
+    #puts uri.path
+
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    apply_ssl http, uri
+
+    path_with_query = uri.path
+    path_with_query << "?#{query_param_string}" unless query_param_string.blank?
+    request = Net::HTTP::Get.new path_with_query, @headers
+    apply_basic_auth request
+    self.response = http.request(request)
+
+    # Follow redirects
+    if response.is_a?(Net::HTTPRedirection) &&
+       !response.is_a?(Net::HTTPNotModified)
+      self.url = redirect_url
+      self.redirect_limit -= 1
+      perform
+    end
+    self
+  end
+
+  private
+
+  def query_param_string
+    @query_param_string ||= begin
+      @query_params.collect do |key, value|
+        "#{URI.escape(key.to_s)}=#{URI.escape(value.to_s)}"
+      end.join('&')
+    end
+  end
+
+  def redirect_url
+    if response['location'].nil?
+      response.body.match(/<a href=\"([^>]+)\">/i)[1]
+    else
+      response['location']
+    end
+  end
+
+  def apply_ssl http, uri
+    if uri.is_a? URI::HTTPS
+      http.use_ssl = true
+      http.verify_mode = rest_client.options[:ssl_verify_mode]
+    end
+  end
+  def apply_basic_auth request
+    ba = rest_client.options[:basic_auth]
+    request.basic_auth(ba[:username], ba[:password]) if ba
+  end
+end

data/lib/resterl/response.rb

@@ -0,0 +1,25 @@
+class Resterl::Response
+  attr_reader :body, :expires_at, :net_http_response
+
+  def initialize(r)
+    @net_http_response = r
+    @body = r.body
+    #@expires_in = extract_max_age
+    @expires_at = Time.now + extract_max_age
+  end
+
+  def expired?
+    @expires_at < Time.now
+  end
+
+  def update_expires_at t
+    @expires_at = t
+  end
+
+  private
+  
+  def extract_max_age
+    cc = @net_http_response['Cache-Control']
+    cc.is_a?(String) ? cc[/max-age=(\d+)/, 1].to_i : 0
+  end
+end

data/lib/resterl/simple_cache.rb

@@ -0,0 +1,109 @@
+# From:
+# http://github.com/der-flo/localmemcache_store/blob/master/lib/expiry_cache.rb
+
+class Resterl::SimpleCache < Resterl::CacheInterface
+
+  class Entry < Struct.new(:data, :expires_at)
+    def expired?
+      expires_at && expires_at <= Time.now
+    end
+  end
+
+  def initialize options = {}
+    @options = {
+      :expiration_check_interval => 1_000,
+      :cache_key_prefix => 'RESTERL_'
+    }.merge options
+    @expiration_check_counter = 0
+    @data = {}
+  end
+
+  def read key
+    key = internal_key key
+    #ap "in read #{key}"
+
+    do_expiration_check
+    entry = @data[key]
+
+    # return if nothing in cache
+    return nil unless entry
+
+    # entry expired?
+    if verify_entry_not_expired(key, entry)
+      entry.data
+    else
+      nil
+    end
+  end
+
+  def write key, value, expires_in = nil
+    key = internal_key key
+
+    do_expiration_check
+    #value.freeze
+
+    # calculate expiration
+    expires_at = if expires_in.to_i > 0
+      Time.now + expires_in.to_i
+    end
+
+    # store data
+    if expires_at.nil? || expires_at > Time.now
+      entry = Entry.new(value, expires_at)
+      @data[key] = entry
+    end
+
+    value
+  end
+
+  def delete key
+    key = internal_key key
+
+    @data.delete key
+  end
+
+  private
+
+  def verify_key_not_expired key
+    entry = @cache[key]
+    verify_entry_not_expired(key, entry) if entry
+  end
+
+  def verify_entry_not_expired key, entry
+    if entry.expired?
+      @data.delete(key)
+      false
+    else
+      true
+    end
+  end
+
+  def do_expiration_check
+    @expiration_check_counter += 1
+    unless @expiration_check_counter >= @options[:expiration_check_interval]
+      return
+    end
+    @expiration_check_counter = 0
+    expire_random_entries
+  end
+
+  def expire_random_entries count = 1_000
+    [count, @data.length].min.times do
+      key, entry = @data.random_pair
+      break if key.nil?
+      verify_entry_not_expired key, entry
+    end
+  end
+
+  def expire_some_entries count = 100
+    count = [count, @data.length].min
+    @data.each_pair do |key, value|
+      break if count <= 0
+      count -= 1 unless verify_entry_not_expired(key, entry)
+    end
+  end
+
+  def internal_key key
+    "#{@options[:cache_key_prefix]}#{key}"
+  end
+end

data/lib/resterl.rb

@@ -0,0 +1,106 @@
+require 'net/http'
+require 'net/https'
+require 'yajl/json_gem'
+################################################################################
+module Resterl; end
+################################################################################
+#require 'resterl/class_level_inheritable_attributes'
+require 'resterl/cache_interface'
+require 'resterl/redis_cache'
+require 'resterl/simple_cache'
+require 'resterl/client'
+require 'resterl/request'
+require 'resterl/response'
+require 'resterl/base_object'
+################################################################################
+Net::HTTP.version_1_1
+################################################################################
+
+# TODOs Prio 2:
+# * Nach Möglichkeit unsere Bibliothek auf Basis von Faraday
+# * Caching mit Tests absichern
+# * Objekte auch in den Cache? Ja, im Idealfall nur die Objekte
+# * Komplettes User-Framework
+# * Memoization
+# * Eigener Client?
+# * Cookie mit remember-Token?
+# * Persistente Verbindungen
+
+# TODOs ID-Service-Integration
+# * Anforderungen in Kunden-DB-2 prüfen
+#   * Zentrale Frage: Fallback-Lösung notwendig?
+#   * Eher zweiten ID-Server?
+
+
+# Composition-Pattern?
+
+
+=begin
+Beispiel Kunden-DB:
+
+User-Model
+* Holt prename, email, wiki_name
+* Hat in der Tabelle login
+* Merkt sich den User über ein remember_token in einem Cookie
+
+Zusätzlich lib/authenticated_system.rb
+
+=end
+
+
+
+
+=begin
+http://www.slideshare.net/pengwynn/json-and-the-apinauts
+
+Transports
+
+Net::HTTP
+Patron      http://toland.github.com/patron/
+Typhoeus    http://github.com/pauldix/typhoeus
+em-http-request   http://github.com/igrigorik/em-http-request
+
+Parsers
+
+Crack       http://github.com/jnunemaker/crack
+yajl-ruby   http://github.com/brainmario/yajl-ruby
+multi_json  http://github.com/intridea/multi_json
+
+
+Higher Level Libs
+
+HTTParty      http://github.com/jnunemaker/httparty
+monster_mash  http://github.com/dbalatero/monster_mash
+RestClient    http://github.com/adamwiggins/rest-client
+Weary         http://github.com/mwunsch/weary
+RackClient    http://github.com/halorgium/rack-client
+Faraday       http://github.com/technoweenie/faraday
+Faraday Middleware  http://github.com/pengwynn/faraday-middleware
+
+
+Tools
+
+Hashie
+hurl
+HTTPScoop
+Charles Proxy
+
+
+
+url = 'http://api.twitter.com/1'
+conn = Faraday::Connection.new(:url => url ) do |builder|
+  builder.adapter Faraday.default_adapter
+  builder.use Faraday::Response::MultiJson
+  builder.use Faraday::Response::Mashify
+end
+
+resp = conn.get do |req|
+  req.url '/users/show.json', :screen_name => 'pengwynn'
+end
+
+u = resp.body
+u.name
+# => "Wynn Netherland"
+
+
+=end

data/resterl.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resterl}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Florian Dütsch"]
+  s.date = %q{2010-09-29}
+  s.description = %q{Rudimentary HTTP client with focus on caching}
+  s.email = %q{florian.duetsch@nix-wie-weg.de}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc",
+     "TODO"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "lib/resterl.rb",
+     "lib/resterl/base_object.rb",
+     "lib/resterl/cache_interface.rb",
+     "lib/resterl/client.rb",
+     "lib/resterl/redis_cache.rb",
+     "lib/resterl/request.rb",
+     "lib/resterl/response.rb",
+     "lib/resterl/simple_cache.rb",
+     "resterl.gemspec",
+     "test/helper.rb",
+     "test/test_resterl.rb"
+  ]
+  s.homepage = %q{http://nix-wie-weg.de/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Rudimentary HTTP client with focus on caching}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_resterl.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<hashie>, ["~> 0.4.0"])
+      s.add_runtime_dependency(%q<yajl-ruby>, ["~> 0.7.7"])
+    else
+      s.add_dependency(%q<hashie>, ["~> 0.4.0"])
+      s.add_dependency(%q<yajl-ruby>, ["~> 0.7.7"])
+    end
+  else
+    s.add_dependency(%q<hashie>, ["~> 0.4.0"])
+    s.add_dependency(%q<yajl-ruby>, ["~> 0.7.7"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'resterl'
+
+class Test::Unit::TestCase
+end

data/test/test_resterl.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestResterl < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: resterl
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Florian D\xC3\xBCtsch"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 7
+        version: 0.7.7
+  type: :runtime
+  version_requirements: *id002
+description: Rudimentary HTTP client with focus on caching
+email: florian.duetsch@nix-wie-weg.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- TODO
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION
+- lib/resterl.rb
+- lib/resterl/base_object.rb
+- lib/resterl/cache_interface.rb
+- lib/resterl/client.rb
+- lib/resterl/redis_cache.rb
+- lib/resterl/request.rb
+- lib/resterl/response.rb
+- lib/resterl/simple_cache.rb
+- resterl.gemspec
+- test/helper.rb
+- test/test_resterl.rb
+has_rdoc: true
+homepage: http://nix-wie-weg.de/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rudimentary HTTP client with focus on caching
+test_files: 
+- test/helper.rb
+- test/test_resterl.rb