wordpressto 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+wordpressto is released under the MIT License.
+
+Copyright (c) 2010 John Leach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the acts_as_xapian 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,48 @@
+= Wordpressto
+
+Wordpressto is a Ruby library for reading from and writing to
+{Wordpress}[http://www.wordpress.org] blogs via their XMLRPC
+interface.
+
+It was extracted from another project and isn't yet feature complete,
+but it is still useful. The documentation is lacking and the test
+suite is not complete. Remember though: release early and release
+often!
+
+== Installation
+
+  sudo gem install wordpressto
+
+== Documentation
+
+  require 'wordpressto'
+  blog = Wordpressto::WordpressBlog.new :url => 'http://www.example.com/xmlrpc.php',
+                                        :username => 'john', :password=> 'letmein'
+
+  # Output the list of categories
+  blog.categories.each { |c| puts c.name }
+
+  # Get the 20 most recent posts
+  blog.posts.find_recent(:limit => 20)
+
+  # Create a new blog post
+  post = blog.posts.new(:title => 'Test', :description => 'This is a test', 
+                        :keywords => 'test, testing', :published => true)
+  post.save
+  
+  # Edit a blog post
+  post = blog.posts.find(123)
+  post.title = "Edited title"
+  post.save
+
+  # Upload an attachment
+  attachment = blog.attachments.new(:name => 'Photo of me', :filename => '/home/john/me.jpg')
+  attachment.save
+
+
+= More Info
+
+Author::  John Leach  (mailto:john@johnleach.co.uk)
+Copyright:: Copyright (c) 2010 John Leach
+License:: MIT
+Github:: http://github.com/johnl/wordpressto/tree/master

data/lib/wordpressto.rb

@@ -0,0 +1,232 @@
+require 'wordpressto/base'
+require 'wordpressto/category_collection'
+module Wordpressto
+  require "xmlrpc/client"
+  require 'uri'
+  require 'mime/types'
+
+  class WordpressBlog
+    attr_accessor :url, :username, :password, :blog_id
+
+    def initialize(options = { })
+      @username = options[:username] if options[:username]
+      @password = options[:password] if options[:password]
+      @blog_id = options[:blog_id] || 1
+      @url = options[:url] if options[:url]
+    end
+    
+    def posts
+      @post_collection ||= WordpressPostCollection.new(:conn => self)
+    end
+    
+    def attachments
+      @attachments ||= WordpressAttachmentCollection.new(:conn => self)
+    end
+
+    def categories
+      @categories ||= CategoryCollection.new(:conn => self)
+    end
+    
+    def get_recent_posts(limit = 10)
+      call('metaWeblog.getRecentPosts', blog_id, username, password, limit)
+    end
+
+    def get_post(qid)
+      call('metaWeblog.getPost', qid, username, password)
+    end
+    
+    def edit_post(qid, attributes, published = nil)
+      cargs = ['metaWeblog.editPost', qid, username, password, attributes]
+      cargs << published unless published.nil?
+      call(*cargs)
+    end
+    
+    def new_post(attributes, published = nil)
+      cargs = ['metaWeblog.newPost', blog_id, username, password, attributes]
+      cargs << published unless published.nil?
+      call(*cargs)
+    end
+    
+    def upload_file(name, mimetype, bits, overwrite = false)
+      call('wp.uploadFile', blog_id, username, password, 
+           { :name => name, :type => mimetype, :bits => XMLRPC::Base64.new(bits), :overwrite => overwrite })
+    end
+    
+    def call(*args)
+      xmlrpc.call(*args)
+    rescue XMLRPC::FaultException => e
+      if e.message =~ /XML-RPC services are disabled/
+        raise Wordpressto::ConnectionFailure, e.message
+      else
+        raise Wordpressto::Error, e.message
+      end
+    end
+    
+    def xmlrpc
+      @xclient ||= XMLRPC::Client.new2(url)
+    end
+    
+  end
+  
+  class WordpressAttachmentCollection < Base
+    def new(attributes)
+      WordpressAttachment.new(attributes, :conn => conn)
+    end
+  end
+  
+  class WordpressAttachment < Base
+    attr_accessor :name, :mimetype, :file, :filename, :url
+    
+    def initialize(attributes, options = { })
+      super(options)
+      self.name = attributes[:name]
+      self.filename = attributes[:filename]
+      self.mimetype = attributes[:mimetype]
+      self.file = attributes[:file]
+    end
+    
+    def save
+      ret = conn.upload_file(name, mimetype, bits)
+      self.url = ret["url"]
+      self
+    end
+    
+    def mimetype
+      @mimetype ||= MIME::Types.type_for(name).to_s
+    end
+    
+    def name
+      @name ||= File.basename(filename)
+    end
+    
+    private
+    
+    def bits
+      file.read
+    end
+    
+    def file
+      @file ||= File.open(filename)
+    end
+  end
+  
+  class WordpressPostCollection < Base
+    def find_recent(options = { })
+      options = { :limit => 10 }.merge(options)
+      posts = conn.get_recent_posts(options[:limit])
+      posts.collect { |post|  WordpressPost.new(post, :conn => conn) }
+    end
+    
+    def find(qid, options = { })
+      if qid.is_a?(Array)
+        qid.collect { |sqid| find(sqid) }
+      elsif qid == :recent
+        find_recent(options)
+      else
+        post = conn.get_post(qid)
+        WordpressPost.new(post, :conn => conn)
+      end
+    end
+    
+    def new(attributes = { })
+      WordpressPost.new(attributes, :conn => conn)
+    end
+    
+  end
+  
+  
+  class WordpressPost < Base
+    attr_accessor :title, :description
+    attr_accessor :created_at
+    attr_accessor :keywords, :categories, :published
+    
+    def initialize(attributes = { }, options = { })
+      super(options)
+      self.attributes = attributes
+    end
+    
+    def attributes=(attr)
+      symbolized_attr = { }
+      attr = attr.each { |k,v| symbolized_attr[k.to_sym] = v }
+      attr = symbolized_attr
+      @title = attr[:title]
+      @keywords = attr[:mt_keywords].to_s.split(/,|;/).collect { |k| k.strip }
+      @categories = attr[:categories]
+      @description = attr[:description]
+      @created_at = attr[:dateCreated]
+      @id = attr[:postid]
+      @userid = attr[:userid]
+      @published = attr[:published]
+    end
+    
+    def id
+      @id
+    end
+    
+    def save
+      id ? update : create
+    end
+    
+    def update
+      conn.edit_post(id, attributes, published)
+      self
+    end
+    
+    def create
+      @id = conn.new_post(attributes, published)
+      self
+    end
+    
+    def publish
+      self.published = true
+      save
+    end
+    
+    def keywords
+      if @keywords.is_a? String
+        @keywords = @keywords.split(",")
+      elsif @keywords.is_a? Array
+        @keywords
+      else
+        []
+      end
+    end
+    
+    def created_at
+      @created_at
+    end
+    
+    def categories
+      if @categories.nil?
+        []
+      elsif @categories.is_a?(Array)
+        @categories
+      elsif @categories.is_a(String)
+        @categories = @categories.split(",")
+      else
+        []
+      end
+    end
+    
+    def attributes
+      h = { }
+      h[:title] = title if title
+      h[:description] = description if description
+      h[:dateCreated] = created_at if created_at
+      h[:mt_keywords] = keywords.join(",")
+      h[:categories] = categories if categories
+      h
+    end
+    
+    def reload
+      if id
+        saved_id = id
+        self.attributes = conn.posts.find(id).attributes
+        @id = saved_id
+        true
+      end
+    end
+
+    
+  end
+end

data/lib/wordpressto/base.rb

@@ -0,0 +1,14 @@
+module Wordpressto
+  class Error < StandardError ; end
+  class ConnectionFailure < Error ; end
+
+  class Base
+    def initialize(options = { })
+      @conn = options[:conn] || options[:connection]
+    end
+    
+    def conn
+      @conn
+    end
+  end
+end

data/lib/wordpressto/category.rb

@@ -0,0 +1,36 @@
+module Wordpressto
+  class Category
+    attr_reader :id, :category_id, :description, :name, :url, :rss_url, :conn
+
+    def initialize(attributes = {}, options = {})
+      @id = attributes[:id]
+      @category_id = attributes[:category_id] || 0
+      @description = attributes[:description]
+      @name = attributes[:name]
+      @url = attributes[:url]
+      @rss_url = attributes[:rss_url]
+      @slug = attributes[:slug]
+      @conn = options[:conn]
+    end
+    
+    def self.new_from_xmlrpc(attributes, options = {})
+      self.new( { :id => attributes['categoryId'], :category_id => attributes['parentId'],
+                  :description => attributes['description'], :name => attributes['categoryName'],
+                  :url => attributes['htmlUrl'], :rss_url => attributes['rssUrl'] },
+                options )
+    end
+
+    def save
+      @id = conn.call 'wp.newCategory', conn.blog_id, conn.username, conn.password, to_xmlrpc_struct
+    end
+
+    def to_xmlrpc_struct
+      { "name" => name, "slug" => slug, "parent_id" => category_id, "description" => description.to_s }
+    end
+
+    def slug
+      @slug ||= @name.to_s.downcase.strip.gsub(/\s/, '-')
+    end
+  end
+end
+

data/lib/wordpressto/category_collection.rb

@@ -0,0 +1,37 @@
+require 'wordpressto/category'
+module Wordpressto
+  class CategoryCollection < Base
+    include Enumerable
+
+    def initialize(*args)
+      super(*args)
+    end
+
+    def all
+      @categories ||= load
+    end
+    
+    # retrieve the categories via xmlrpc
+    def load
+      cats = []
+      conn.call('wp.getCategories', conn.blog_id, conn.username, conn.password).each do |c|
+        cats << Category.new_from_xmlrpc(c, :conn => conn)
+      end
+      @categories = cats
+    end
+
+    def [](i)
+      all[i]
+    end
+
+    def each
+      all.each { |c| yield c }
+    end
+
+    def create(attributes)
+      new_cat = Category.new(attributes, :conn => conn)
+      new_cat.save
+      new_cat
+    end
+  end
+end

data/spec/category_collection_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe CategoryCollection do
+  it "should retrieve categories via xmlrpc" do
+    blog = a_wordpress_blog
+    blog.xmlrpc.should_receive(:call).once.with('wp.getCategories', blog.blog_id, blog.username, blog.password).and_return([{}, {}, {}])
+    cats = blog.categories.load
+    cats.size.should == 3
+    cats.first.should be_a_kind_of Category
+    cats.first.conn.should == blog
+  end
+end

data/spec/category_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Category do
+  describe "create" do
+    it "should call wp.newCategory" do
+      blog = a_wordpress_blog
+      blog.xmlrpc.should_receive(:call).once.with('wp.newCategory', blog.blog_id, blog.username, blog.password,
+                                                  hash_including("name" => valid_category_options[:name])).and_return(10)
+      blog.categories.create valid_category_options
+    end
+
+    it "should return a Category instance with the right id" do
+      blog = a_wordpress_blog
+      blog.xmlrpc.should_receive(:call).once.and_return(10)
+      blog.categories.create(valid_category_options).id.should == 10
+    end
+  end
+
+  it "should generate a slug from the title if not provided" do
+    Category.new(:name => "Blog Posts ").slug.should == "blog-posts"
+    Category.new(:name => "Blog Posts", :slug => 'posts').slug.should == "posts"
+    Category.new(:name => nil).slug.should be_empty
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format n
+--loadby mtime
+--reverse
+

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'lib/wordpressto.rb'
+include Wordpressto
+
+def valid_wordpress_blog_options
+  { :username => 'lily', :password => 'lilybeans', :url => 'http://example.com', :blog_id => 666 }
+end
+  
+def valid_wordpress_post_options
+  { :title => "Test Post", :description => "The text of the post", :dateCreated => Time.at(1284243726),
+    :mt_keywords => 'test,post,example', :categories => 'blog' }
+end
+
+def a_wordpress_blog
+  WordpressBlog.new(valid_wordpress_blog_options)
+end
+
+def valid_wordpress_upload_options
+  { :name => "A file", :type => "application/octet-stream",
+    :bits => "12345678910", :overwrite => false }
+end
+
+def valid_category_options
+  { :name => 'Posts', :slug => 'posts', :parent_id => nil, :description => "Blog posts" }
+end

data/spec/wordpress_blog_spec.rb

@@ -0,0 +1,119 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe WordpressBlog do
+
+  describe "initialize" do
+    it "take the :username, :password, :url and :blog_id options" do
+      blog = a_wordpress_blog
+      blog.username.should == valid_wordpress_blog_options[:username]
+      blog.password.should == valid_wordpress_blog_options[:password]
+      blog.blog_id.should == valid_wordpress_blog_options[:blog_id]
+    end
+    
+    it "should default to blog_id 1" do
+      WordpressBlog.new.blog_id.should == 1
+    end
+  end
+
+  it "should return an XMLRPC::Client" do
+    xmlrpc = a_wordpress_blog.send(:xmlrpc)
+    xmlrpc.should be_a_kind_of XMLRPC::Client
+  end
+
+  it "should make xmlrpc calls to metaWeblog.getPost" do
+    blog = a_wordpress_blog
+    blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.getPost', 
+                                                       999, blog.username, blog.password )
+    blog.get_post(999)
+  end
+
+  it "should make xmlrpc calls to metaWeblog.getRecentPosts" do
+    blog = a_wordpress_blog
+    blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.getRecentPosts',
+                                                       blog.blog_id, blog.username, blog.password,  345)
+    blog.get_recent_posts(345)
+  end
+
+  describe "edit_post" do
+
+    it "should make xmlrpc calls to metaWeblog.editPost with no published arg by default" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wordpress_post_options)
+      blog.edit_post(98, valid_wordpress_post_options)
+    end
+
+    it "should make xmlrpc calls to metaWeblog.editPost with published = true" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wordpress_post_options, true)
+      blog.edit_post(98, valid_wordpress_post_options, true)
+    end
+
+    it "should make xmlrpc calls to metaWeblog.editPost with published = false" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wordpress_post_options, false)
+      blog.edit_post(98, valid_wordpress_post_options, false)
+    end
+
+
+  end
+
+  describe "new_post" do 
+    it "should make metaWeblog.newPost calls with no published arg by default" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wordpress_post_options)
+      blog.new_post(valid_wordpress_post_options)
+    end
+
+    it "should make metaWeblog.newPost calls with published = true" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wordpress_post_options, true)
+      blog.new_post(valid_wordpress_post_options, true)
+    end
+
+    it "should make metaWeblog.newPost calls with published = false" do
+      blog = a_wordpress_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wordpress_post_options, false)
+      blog.new_post(valid_wordpress_post_options, false)
+    end
+
+  end
+
+  describe "upload_file" do
+    it "should make wp.uploadFile calls" do
+      blog = a_wordpress_blog
+      xmlrpc_valid_wordpress_upload_options = valid_wordpress_upload_options.merge({
+        :bits => XMLRPC::Base64.new(valid_wordpress_upload_options[:bits])
+      })
+      blog.send(:xmlrpc).should_receive(:call).once.with('wp.uploadFile', blog.blog_id, blog.username, 
+                                                         blog.password, 
+                                                         hash_including({
+                                                                          :name => valid_wordpress_upload_options[:name],
+                                                                          :type => valid_wordpress_upload_options[:type],
+                                                                          :overwrite => valid_wordpress_upload_options[:overwrite],
+                                                                          :bits => an_instance_of(XMLRPC::Base64)
+                                                                        }))
+      args = [:name, :type, :bits, :overwrite].collect { |k| valid_wordpress_upload_options[k] }
+      blog.upload_file(*args)
+    end
+  end
+
+  it "should return a CategoryCollection" do
+    blog = a_wordpress_blog
+    blog.categories.should be_a_kind_of CategoryCollection
+    blog.categories.conn.should == blog
+  end
+
+end
+

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: wordpressto
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- John Leach
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-12 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A Ruby library to interact with the Wordpress XMLRPC interface
+email: john@johnleach.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- lib/wordpressto.rb
+- lib/wordpressto/base.rb
+- lib/wordpressto/category.rb
+- lib/wordpressto/category_collection.rb
+- README.rdoc
+- LICENSE
+- spec/spec_helper.rb
+- spec/wordpress_blog_spec.rb
+- spec/category_collection_spec.rb
+- spec/category_spec.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/johnl/wordpressto
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Wordpressto
+- --main
+- README.rdoc
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby library to interact with the Wordpress XMLRPC interface
+test_files: 
+- spec/spec_helper.rb
+- spec/wordpress_blog_spec.rb
+- spec/category_collection_spec.rb
+- spec/category_spec.rb
+- spec/spec.opts