wp_rpc 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+teste.rb
+teste.jpg

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--colour
+--format n
+

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wp_rpc.gemspec
+gemspec
+gem 'rake'
+gem "rack", "~>1.1"
+gem "rspec", :require => "spec"
+gem 'mime-types'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alex Ferreira
+
+MIT License
+
+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.md

@@ -0,0 +1,54 @@
+# WpRpc
+
+WpRpc is a Ruby library for reading and writing blogs to Wordpress via XMLRPC interface.
+
+The documentation is missing and the test set is not complete.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wp_rpc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wp_rpc
+
+### Usage
+
+	require 'wp_rpc'
+	blog = WpRpc::Blog.new :url => 'http://www.example.com/xmlrpc.php', :username => 'admin', :password=> 'admin'
+
+	# Output the list of categories
+	blog.categories.map { |c| puts "Category: #{c.name}" }
+	
+	# Get List of Posts
+	blog.posts.all.map{|p| puts p['title']}
+
+	# Get the 20 most recent posts
+	blog.posts.find_recent(:limit => 20).map { |p| puts "#{p.id} | #{p.title}" }
+
+	# 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(1)
+	post.title = "Edited title"
+	post.save
+
+	# Upload an attachment
+	attachment = blog.attachments.new(:name => 'Photo of me', :filename => '/home/john/me.jpg')
+	attachment.save
+
+### Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/wp_rpc/attachment.rb

@@ -0,0 +1,38 @@
+require "wp_rpc/collections/attachments"
+module WpRpc  
+  class Attachment < 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
+end

data/lib/wp_rpc/base.rb

@@ -0,0 +1,23 @@
+module WpRpc
+  class Error < StandardError ; end
+  class ConnectionFailure < Error ; end
+
+  class Base
+    def initialize(options = { })
+      @conn = options[:conn] || options[:connection]
+    end
+    
+    def conn
+      @conn
+    end
+
+    def pattern
+      @pattern = {"post_title" => "title", "post_content" => "content"}
+    end
+
+    def change_attributes(source, mappings = {})
+      source.map{ |obj| obj.keys.each { |k| obj[mappings[k] ] = obj.delete(k) if mappings[k] } }
+      source
+    end
+  end
+end

data/lib/wp_rpc/blog.rb

@@ -0,0 +1,65 @@
+module WpRpc
+  class Blog
+    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 ||= Collection::Posts.new(:conn => self)
+    end
+    
+    def attachments
+      @attachments ||= Collection::Attachments.new(:conn => self)
+    end
+
+    def categories
+      @categories ||= Collection::Categories.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 WpRpc::ConnectionFailure, e.message
+      else
+        raise WpRpc::Error, e.message
+      end
+    end
+    
+    def xmlrpc
+      @xclient ||= XMLRPC::Client.new2(url)
+    end
+    
+  end
+end

data/lib/wp_rpc/category.rb

@@ -0,0 +1,37 @@
+require "wp_rpc/collections/categories"
+module WpRpc
+  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/wp_rpc/collections/attachments.rb

@@ -0,0 +1,9 @@
+module WpRpc
+  module Collection
+    class Attachments < Base
+      def new(attributes)
+        WpRpc::Attachment.new(attributes, :conn => conn)
+      end
+    end 
+  end
+end

data/lib/wp_rpc/collections/categories.rb

@@ -0,0 +1,38 @@
+module WpRpc
+  module Collection
+    class Categories < 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 << WpRpc::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 = WpRpc::Category.new(attributes, :conn => conn)
+        new_cat.save
+        new_cat
+      end
+    end
+  end
+end

data/lib/wp_rpc/collections/posts.rb

@@ -0,0 +1,30 @@
+module WpRpc
+  module Collection
+    class Posts < Base
+      def find_recent(options = { })
+        options = { :limit => 10 }.merge(options)
+        posts = conn.get_recent_posts(options[:limit])
+        posts.collect { |post|  Post.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)
+          Post.new(post, :conn => conn)
+        end
+      end
+      
+      def new(attributes = { })
+        WpRpc::Post.new(attributes, :conn => conn)
+      end
+
+      def all
+        change_attributes(conn.call('wp.getPosts', conn.blog_id, conn.username, conn.password), pattern)
+      end
+    end  
+  end
+end

data/lib/wp_rpc/post.rb

@@ -0,0 +1,95 @@
+require "wp_rpc/collections/posts"
+module WpRpc
+  class Post < Base
+    attr_accessor :title, :content
+    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[:keywords].to_s.split(/,|;/).collect { |k| k.strip }
+      @categories = attr[:categories]
+      @content = attr[:content]
+      @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] = content if content
+      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/wp_rpc/version.rb

@@ -0,0 +1,3 @@
+module WpRpc
+  VERSION = "0.0.1"
+end

data/lib/wp_rpc.rb

@@ -0,0 +1,11 @@
+require 'wp_rpc/base'
+require "wp_rpc/blog"
+require "wp_rpc/post"
+require "wp_rpc/category"
+require "wp_rpc/attachment"
+require "wp_rpc/version"
+module WpRpc
+  require "xmlrpc/client"
+  require 'uri'
+  require 'mime/types'
+end

data/spec/blog_spec.rb

@@ -0,0 +1,119 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Blog do
+
+  describe "initialize" do
+    it "take the :username, :password, :url and :blog_id options" do
+      blog = a_wp_blog
+      blog.username.should == valid_wp_blog_options[:username]
+      blog.password.should == valid_wp_blog_options[:password]
+      blog.blog_id.should == valid_wp_blog_options[:blog_id]
+    end
+    
+    it "should default to blog_id 1" do
+      Blog.new.blog_id.should == 1
+    end
+  end
+
+  it "should return an XMLRPC::Client" do
+    xmlrpc = a_wp_blog.send(:xmlrpc)
+    xmlrpc.should be_a_kind_of XMLRPC::Client
+  end
+
+  it "should make xmlrpc calls to metaWeblog.getPost" do
+    blog = a_wp_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_wp_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_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wp_post_options)
+      blog.edit_post(98, valid_wp_post_options)
+    end
+
+    it "should make xmlrpc calls to metaWeblog.editPost with published = true" do
+      blog = a_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wp_post_options, true)
+      blog.edit_post(98, valid_wp_post_options, true)
+    end
+
+    it "should make xmlrpc calls to metaWeblog.editPost with published = false" do
+      blog = a_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.editPost',
+                                                         98, blog.username, blog.password,
+                                                         valid_wp_post_options, false)
+      blog.edit_post(98, valid_wp_post_options, false)
+    end
+
+
+  end
+
+  describe "new_post" do 
+    it "should make metaWeblog.newPost calls with no published arg by default" do
+      blog = a_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wp_post_options)
+      blog.new_post(valid_wp_post_options)
+    end
+
+    it "should make metaWeblog.newPost calls with published = true" do
+      blog = a_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wp_post_options, true)
+      blog.new_post(valid_wp_post_options, true)
+    end
+
+    it "should make metaWeblog.newPost calls with published = false" do
+      blog = a_wp_blog
+      blog.send(:xmlrpc).should_receive(:call).once.with('metaWeblog.newPost',
+                                                         blog.blog_id, blog.username, blog.password,
+                                                         valid_wp_post_options, false)
+      blog.new_post(valid_wp_post_options, false)
+    end
+
+  end
+
+  describe "upload_file" do
+    it "should make wp.uploadFile calls" do
+      blog = a_wp_blog
+      xmlrpc_valid_wp_upload_options = valid_wp_upload_options.merge({
+        :bits => XMLRPC::Base64.new(valid_wp_upload_options[:bits])
+      })
+      blog.send(:xmlrpc).should_receive(:call).once.with('wp.uploadFile', blog.blog_id, blog.username, 
+                                                         blog.password, 
+                                                         hash_including({
+                                                                          :name => valid_wp_upload_options[:name],
+                                                                          :type => valid_wp_upload_options[:type],
+                                                                          :overwrite => valid_wp_upload_options[:overwrite],
+                                                                          :bits => an_instance_of(XMLRPC::Base64)
+                                                                        }))
+      args = [:name, :type, :bits, :overwrite].collect { |k| valid_wp_upload_options[k] }
+      blog.upload_file(*args)
+    end
+  end
+
+  it "should return a CategoryCollection" do
+    blog = a_wp_blog
+    blog.categories.should be_a_kind_of Collection::Categories
+    blog.categories.conn.should == blog
+  end
+
+end
+

data/spec/category_collection_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Collection::Categories do
+  it "should retrieve categories via xmlrpc" do
+    blog = a_wp_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_wp_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_wp_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_helper.rb

@@ -0,0 +1,28 @@
+ROOT_PATH = File.join(File.dirname(__FILE__), '..')
+$:.unshift ROOT_PATH unless $:.include? ROOT_PATH
+
+require 'rubygems'
+require 'lib/wp_rpc.rb'
+include WpRpc
+
+def valid_wp_blog_options
+  { :username => 'lily', :password => 'lilybeans', :url => 'http://example.com', :blog_id => 666 }
+end
+  
+def valid_wp_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_wp_blog
+  Blog.new(valid_wp_blog_options)
+end
+
+def valid_wp_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/wp_rpc.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/wp_rpc/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alex Ferreira"]
+  gem.email         = ["alex@dsol.com.br"]
+  gem.description   = "A Ruby library to interact with the Wordpress XMLRPC interface"
+  gem.summary       = "A Ruby library to interact with the Wordpress XMLRPC interface"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "wp_rpc"
+  gem.require_paths = ["lib"]
+
+  gem.version       = WpRpc::VERSION
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: wp_rpc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alex Ferreira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-26 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby library to interact with the Wordpress XMLRPC interface
+email:
+- alex@dsol.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/wp_rpc.rb
+- lib/wp_rpc/attachment.rb
+- lib/wp_rpc/base.rb
+- lib/wp_rpc/blog.rb
+- lib/wp_rpc/category.rb
+- lib/wp_rpc/collections/attachments.rb
+- lib/wp_rpc/collections/categories.rb
+- lib/wp_rpc/collections/posts.rb
+- lib/wp_rpc/post.rb
+- lib/wp_rpc/version.rb
+- spec/blog_spec.rb
+- spec/category_collection_spec.rb
+- spec/category_spec.rb
+- spec/spec_helper.rb
+- wp_rpc.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Ruby library to interact with the Wordpress XMLRPC interface
+test_files:
+- spec/blog_spec.rb
+- spec/category_collection_spec.rb
+- spec/category_spec.rb
+- spec/spec_helper.rb