tumblrb 1.0.6 → 2.0.1

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2-p180@tumblrb

data/Gemfile

@@ -1,8 +1,11 @@
 source "http://rubygems.org"
 
-gem "activesupport", "~> 3.0"
-gem "nokogiri", "~> 1.4.4"
-gem "curb", "~> 0.7.15"
+gem "json", "~> 1.6.0"
+gem "faraday", "~> 0.7.5"
+gem "activesupport", "~> 3.1.1"
+gem "i18n", "~> 0.6.0"
 gem "addressable"
+gem 'redis-objects'
+gem 'will_paginate'
 
 gemspec

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    tumblrb (1.1.0)
+      activesupport (~> 3.0)
+      addressable (~> 2.2.0)
+      curb (~> 0.7.15)
+      json (~> 1.6.0)
+      nokogiri (~> 1.4.4)
+      redis-objects (~> 0.5.0)
+      will_paginate (~> 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.1.1)
+      multi_json (~> 1.0)
+    addressable (2.2.6)
+    curb (0.7.15)
+    faraday (0.7.5)
+      addressable (~> 2.2.6)
+      multipart-post (~> 1.1.3)
+      rack (>= 1.1.0, < 2)
+    i18n (0.6.0)
+    json (1.6.1)
+    multi_json (1.0.3)
+    multipart-post (1.1.3)
+    nokogiri (1.4.7)
+    rack (1.3.5)
+    redis (2.2.2)
+    redis-objects (0.5.2)
+      redis (>= 2.1.1)
+    will_paginate (3.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.1.1)
+  addressable
+  faraday (~> 0.7.5)
+  i18n (~> 0.6.0)
+  json (~> 1.6.0)
+  redis-objects
+  tumblrb!
+  will_paginate

data/README.mkd

@@ -1,7 +1,14 @@
-Tumblr API Wrapper
+Tumblr Blogging with Redis
 ====================
 
-A simple, easy to use ruby wrapper for the Tumblr API. 
+A simple, blogging "platform" built on Tumblr and Redis.
+
+Reasoning
+------------
+
+Tumblr has a great interface for tagging, writing, and editing posts, but you shouldn't rely on it for being up all the time. You also shouldn't have to worry about Tumblr API integration or cacheing on your own. Tumblrb handles the Tumblr API integration, Redis cacheing, and fetching all with an easy to use interface.
+
+VOILA!
 
 Installation
 ------------
@@ -19,38 +26,54 @@ to your Gemfile
 Setup
 ------------
 
-Add
+Tumblrb Needs a little configuration to work properly. It needs to know your blog, your Tumblr API key, and how to connect to a running Redis server :
+
+You can do that using the configure method :
 
-    Tumblr.user = Tumblr::User.new 'email@email.com', 'password'
-    Tumblr.blog = 'myblogname'
+    Tumblr.configure do |config|
+      config.blog = "thegorgonlab"
+      config.api_key = "YOUR API KEY"
+      config.redis = {:host => "localhost", :port => 6379}
+    end
+    
+Redis configuration takes a string path to a configuration file, a hash of options, or a Redis instance itself. If you don't include a "." in your blog name it will add ".tumblr.com" to the end of what you provide. For information about API keys see the [Tumblr API documentation](http://www.tumblr.com/docs/en/api/v2)
 
-into your initialization
+Or if you like having all your configuration in a YAML file, you can put it all in a YAML file under the key `tumblr` and call :  
+  
+    Tumblr.load_config("/path/to/config.yml")
 
-Fetching 
-------------
+Blog and Redis
+-----------
 
-Just like `will_paginate` :
+Most interactions with the Tumblrb gem happen through the `Blog` class, which handles fetching from Tumblr and caching in Redis.
 
-    @posts = Tumblr::Item.paginate(:page => 1, :per_page => 20)
-    @posts.next_page => 1
-    @posts.previous_page => nil
-    @posts.each do |post|
-      =render :partial => "post", :object => post
-    end
+To get started, fetch the posts from Tumblr and cache them in Redis, call `Blog.refresh!`. Every time you write a new post for your Tumblr blog, call this method again to keep Tumblrb up to date.
 
-In addition to any paging parameters, `paginate` also accepts all the documented params from the [Tumblr API](http://www.tumblr.com/docs/en/api).
+Afterwards, to access your blog entries use an AREL type interface to access posts. 
 
-You can also fetch the last post with
+    Blog.tagged_with("technology").per_page(3).page(2).all
+  
+Fetching only happens when array methods are called in the chain.
+
+Loading posts directly
+------------
 
-    Tumblr::Item.first
+You can also load posts directly using a similar interface :
+
+    Post.page(1).per_page(20).tagged_with("technology").type("text").all
+  
+Or you can load 1 post by Tumblr id :
+ 
+    Post.find(tumblr_id)
   
-Item Classes
+  
+Post Classes
 ------------
 
 Every Tumblr entry type is a separate class so you can do stuff like :
 
     case post
-    when Tumblr::Regular
+    when Tumblr::Text
       # Display a regular post
     when Tumblr::Quote
       # Display a quote
@@ -59,10 +82,17 @@ Every Tumblr entry type is a separate class so you can do stuff like :
     ...
     end
 
+This makes custom display easier.
+
 Known Issues
 ------------
 
-There's no testing or documentation. I know, I'm on it.
+There's no testing or real documentation. I know, wanna help?
+
+This isn't the same...
+------------
+
+If you were using Tumblrb 1.0, this is completely different. I realize that. However, I didn't think anyone was using that gem and I think this is a better more holistic solution. Sorry for the inconvenience.
 
 Anything else?
 ------------

data/lib/tumblr.rb

@@ -1,33 +1,34 @@
-require 'addressable/uri'
-require 'nokogiri'
-require 'curl'
-require 'tumblr/user'
-require 'tumblr/page'
-require 'tumblr/item'
-require 'tumblr/answer'
-require 'tumblr/audio'
-require 'tumblr/conversation'
-require 'tumblr/item'
-require 'tumblr/link'
-require 'tumblr/photo'
-require 'tumblr/quote'
-require 'tumblr/regular'
-require 'tumblr/video'
+require 'bundler'
+Bundler.require(:default)
 
-module Tumblr  
-  def self.blog=(blog)
-    @blog = (blog =~ /\./) ? blog : "#{blog}.tumblr.com"
-  end
-  
-  def self.blog
-    @blog
+require 'faraday'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/inflections'
+require 'active_support/core_ext/array/extract_options'
+require "redis/objects"
+require "redis/set"
+require "redis/value"
+require "redis/list"
+require 'will_paginate/collection'
+require 'tumblr/config'
+require 'tumblr/query'
+require 'tumblr/api'
+require 'tumblr/object'
+require 'tumblr/blog'
+require 'tumblr/middleware/params'
+require 'tumblr/middleware/parsing'
+
+module Tumblr
+  def self.configure(&block)
+    @config = Config.new
+    block.call(@config)
   end
   
-  def self.user
-    @user
+  def self.config
+    @config
   end
   
-  def self.user=(value)
-    @user = value
+  def self.load_config(path)
+    @config.load(path)
   end
 end

data/lib/tumblr/api.rb

@@ -0,0 +1,49 @@
+module Tumblr
+  class Api  
+    class Exception < IOError; end
+
+    class << self
+      def connection
+        unless @connection
+          @connection = ::Faraday.new(:url => host) do |builder|
+            builder.use ::Faraday::Request::UrlEncoded
+            builder.use ::Faraday::Response::Logger
+            builder.use Tumblr::Params
+            builder.use Tumblr::Parsing
+            builder.adapter ::Faraday.default_adapter
+          end
+        end
+        @connection
+      end
+    
+      def get(method, params={})
+        response = nil
+        5.times do |attempt|
+          response = connection.get path(method, params)
+          break if response.success?
+        end
+        if response && response.success?
+          response
+        else
+          error = response ? "#{response["status"]}: #{response["message"]}" : "Something went wrong"
+          raise Tumblr::Api::Exception.new(error)
+        end
+      end
+    
+      def url(method='', params={})
+        "#{host}#{path(method, params)}"
+      end
+    
+      def host
+        "http://api.tumblr.com"
+      end
+    
+      def path(method="", params={})
+        uri = Addressable::URI.new
+        params.keys.each { |key| params[key] = params[key].to_s }
+        uri.query_values = params
+        "/v2/blog/#{Tumblr.config.blog}/#{method}?#{uri.query}"
+      end
+    end
+  end
+end

data/lib/tumblr/blog.rb

@@ -0,0 +1,97 @@
+module Tumblr 
+  class Blog < Object
+    extend Query::DelegateMethods
+    
+    STORAGE_KEY = "gorgon:blog:entries"
+    string_attribute :title, :name, :description
+    numeric_attribute :posts, :likes
+    boolean_attribute :ask, :ask_anon
+    date_attribute :updated
+
+    class << self
+      attr_accessor :page_size
+      
+      def page_size
+        @page_size ||= 3
+      end
+      
+      def clear!
+        Tumblr.config.redis.keys("#{STORAGE_KEY}:*").each { |key| Tumblr.config.redis.del(key) }
+        index.clear
+      end
+
+      def refresh!(options={})
+        clear!
+
+        page = options[:min] || 1
+        per_page = options[:per_page] || 100
+        max_page = options[:max]
+
+        loop do
+          posts = Post.per_page(per_page).page(page)
+          if posts.length > 0
+            page = posts.next_page
+            posts.each do |post|
+              index << post.slug
+              post.commit
+            end
+            break if page.nil? || (max_page && page > max_page)
+          end
+        end
+        true
+      end
+
+      def entries(slugs=nil)
+        slugs ||= index
+        entries = slugs.collect { |slug| entry(slug) }
+        entries.compact!
+        entries
+      end
+      
+      def index
+        @index ||= Redis::List.new(STORAGE_KEY, Tumblr.config.redis)
+      end
+
+      def entry(slug)
+        value = Redis::Value.new("#{STORAGE_KEY}:#{slug}", Tumblr.config.redis)
+        Tumblr::Object.unserialize(value.value)
+      end
+      
+      def find(slug)
+        entry(slug)
+      end
+
+      def tags
+        Redis::Set.new("#{STORAGE_KEY}:tags", Tumblr.config.redis)
+      end
+      
+      def page(n)
+        query.page([1, n.to_i].max)
+      end
+
+      def tagged_with(tag)
+        query.tagged_with(tag)
+      end
+      
+      private
+      
+      def query
+        @query ||= Query.new(:page, :per_page, :tagged_with) do |params|
+          if tag = params[:tagged_with]
+            slugs = Redis::List.new("#{STORAGE_KEY}:tags:#{tag.downcase.underscore}", Tumblr.config.redis)
+          else
+            slugs = index
+          end
+          page_size = params[:per_page] || self.page_size
+          if page = params[:page]
+            WillPaginate::Collection.create(page, page_size, slugs.count) do |pager|
+              pager.replace entries(slugs[pager.offset, pager.per_page]).to_a
+            end
+          else
+            entries(slugs).to_a
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tumblr/config.rb

@@ -0,0 +1,25 @@
+module Tumblr
+  class Config
+    attr_accessor :blog, :api_key, :redis
+    
+    def load(path)
+      config = YAML.load_file(path)["tumblr"]
+      self.blog = config["blog"]
+      self.api_key = config["api_key"]
+      self.redis = config["redis"]
+    end
+    
+    def redis=(value)
+      value = YAML.load_file(value)["redis"] rescue nil if value.kind_of?(String) && File.exists?(value)
+      value = Redis.new(value) if value.kind_of?(Hash)
+      unless value.kind_of?(Redis)
+        raise ArgumentError, "Tumblr redis accepts a Redis object, path to a YAML file, or hash of Redis options"
+      end
+      @redis = value
+    end
+    
+    def blog=(value)
+      @blog = (blog =~ /\./) ? blog : "#{value}.tumblr.com"
+    end
+  end
+end

data/lib/tumblr/middleware/params.rb

@@ -0,0 +1,10 @@
+module Tumblr
+  class Params < ::Faraday::Middleware
+    def call(env)
+      params = env[:url].query_values || {}
+      env[:url].query_values ||= {}
+      env[:url].query_values = { 'api_key' => Tumblr.config.api_key }.merge!(params)
+      @app.call env
+    end
+  end
+end

data/lib/tumblr/middleware/parsing.rb

@@ -0,0 +1,34 @@
+module Tumblr
+  class Parsing < ::Faraday::Response::Middleware
+    def parse_body(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        JSON.parse(body) rescue nil
+      end
+    end
+    
+    def on_complete(env)
+      parsed = parse_body(env[:body])
+      
+      if parsed && parsed.kind_of?(Hash) && parsed["meta"]
+        env[:status] = parsed["meta"]["status"]
+        env[:message] = parsed["meta"]["msg"]
+        env[:body] = Tumblr::Object.objectify(parsed["response"])
+      else
+        handle_formatting_error(env)
+      end
+      
+    end
+  
+    def handle_formatting_error(env)
+      env[:status] = 500
+      env[:message] = "Poorly formatted response"
+    end
+  end
+end