blogrpc 1.0.0

data/.document

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

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "builder", "~> 3.0.0"
+
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rdoc", "~> 3.12"
+  gem "jeweler", "~> 1.8.4"
+  gem "flexmock", "~>0.8"
+  gem "rack-test"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    flexmock (0.9.0)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.4)
+    rack (1.4.1)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  builder (~> 3.0.0)
+  flexmock (~> 0.8)
+  jeweler (~> 1.8.4)
+  rack-test
+  rdoc (~> 3.12)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Julik Tarkhanov
+
+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,57 @@
+= blogrpc
+
+BlogRPC is a set of XML RPC server facilities which allow you to easily create a blogging XML-RPC backend in your Ruby web application.
+Your application can then be used with blog clients like BlogJet and MarsEdit.
+
+== Quickly defining a blog RPC handler
+
+You can also define your blog handler right in the rackup file or elsewhere:
+
+	rpc_endpoint = BlogRPC.generate_endpoint do | handler |
+	    handler.rpc "mt.publishPost", :in => [:int, :string, :string], :out => :bool do | postid, user, pw |
+	      login!(user, pw)
+	      get_entry(postid).update_attributes :draft => false
+	      true
+	    end
+	end
+
+	run rpc_endpoint
+	
+
+== More involved examples
+
+The gem consists of two parts. The first part is a Rack application that will handle XML-RPC requests and respond to them. It handles things like
+wrapping exceptions properly, detecting the needed parameters and configuring all of the IO so that Ruby's XML-RPC facilities can get at it.
+You use it like this:
+
+	rpc_endpoint = BlogRPC::RackApp.new(MyBlogHandler.new)
+	rpc_endpoint.blog_url = "http://site.com"
+	rpc_endpoint.rpc_endpoint_url = "/secret-rpc-url.xml"
+	rpc_endpoint.call(env)
+
+The BlogHandler object should be a more or less complete subclass of BlogHandler that you provide. When the RPC application receives a GET request
+it will respond with the RSD fragment that will auto-configure your blogging client (like MarsEdit or BlogJet).
+
+The second part of the solution is a blog handler. The handler is responsible for saving and loading entries and images, creating pages and categories
+and so on. Unfortunately, you have to write this handler yourself since no two blogging systems are alike. However, we provide a SampleHandler
+to get you started.
+
+IMPORTANT: It is absolutely imperative that you review the sample handler *very thoroughly* and rewrite and double-check it ad nauseam.
+We do not recommend that you inherit from the SampleHandler. Instead, make your own copy and define your methods there, and inherit your
+handler class from BlogRPC::BasicHandler
+	
+== Contributing to blogrpc
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Julik Tarkhanov. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require File.dirname(__FILE__) + "/lib/blogrpc"
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.version = BlogRPC::VERSION
+  gem.name = "blogrpc"
+  gem.homepage = "http://github.com/julik/blogrpc"
+  gem.license = "MIT"
+  gem.summary = %Q{ Easily construct MT and MetaWeblog XML-RPC backends}
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "blogrpc #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/blogrpc.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "blogrpc"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2012-08-11"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "blogrpc.gemspec",
+    "lib/blogrpc.rb",
+    "lib/blogrpc/basic_handler.rb",
+    "lib/blogrpc/rack_app.rb",
+    "lib/blogrpc/sample_handler.rb",
+    "test/helper.rb",
+    "test/http_simulator.rb",
+    "test/test_blogapi.rb",
+    "test/test_rpc_handler_method_definitions.rb"
+  ]
+  s.homepage = "http://github.com/julik/blogrpc"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Easily construct MT and MetaWeblog XML-RPC backends"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<builder>, ["~> 3.0.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<flexmock>, ["~> 0.8"])
+      s.add_development_dependency(%q<rack-test>, [">= 0"])
+    else
+      s.add_dependency(%q<builder>, ["~> 3.0.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<flexmock>, ["~> 0.8"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<builder>, ["~> 3.0.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<flexmock>, ["~> 0.8"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+  end
+end
+

data/lib/blogrpc/basic_handler.rb

@@ -0,0 +1,98 @@
+# -*- encoding : utf-8 -*-
+require 'xmlrpc/server'
+require 'fileutils'
+require 'builder'
+
+# XML writer with proper escaping. Unfortunately XMLRPC in Ruby
+# has issues escaping non-UTF-8 characters, so we need to take care of that.
+# The best solution is to make use of the XChar facility from Builder.
+c = Class.new(XMLRPC::XMLWriter::Simple) do
+  def text(string)
+    Builder::XChar.encode(string)
+  end
+end
+
+# Inject the proper writer into the XML-RPC module. There is no way
+# to do that properly so it seems.
+begin
+  $VERBOSE, yuck = nil, $VERBOSE
+  XMLRPC::Config.send(:const_set, :DEFAULT_WRITER, c)
+ensure
+  $VERBOSE  = yuck
+end
+
+# A very simple RPC interface where you can declare methods by calling rpc "methodThis" :in => [:bool], :out => :bool { truth }
+# and it creates method_this(some_bool) in Ruby and wires it in
+class BlogRPC::BasicHandler < XMLRPC::Service::BasicInterface
+  
+  # Will contain the Rack application environment
+  attr_accessor :env
+  
+  # The standard initializer for such a service accepts a prefix,
+  # but we will override that
+  def initialize(prefix = nil)
+    @prefix = 'mt'
+  end
+    
+  # Will return a union of all of the methods defined using rpc() in this class
+  # and all of it's ancestors.
+  def self.rpc_methods_and_signatures
+    # Climb up the class chain
+    methods_and_signatures_in_ancestor_chain = {}
+    ancestors.reverse.each do | ancestor_module |
+      in_ancestor = ancestor_module.instance_variable_get('@rpc_methods_and_signatures') || {}
+      methods_and_signatures_in_ancestor_chain.merge!(in_ancestor)
+    end
+    methods_and_signatures_in_ancestor_chain.merge(@rpc_methods_and_signatures || {})
+  end
+  
+  # Pass your XML request here and get the result (the request is the
+  # raw HTTP POST body, the way to get to it differs per framework/server)
+  #
+  #  huge_xml_blob = MiniInterface.new.handle_request(StringIO.new(post_data))
+  #
+  def handle_request(post_payload)
+    s = XMLRPC::BasicServer.new
+    s.add_handler self
+    s.process(post_payload.respond_to?(:read) ? post_payload : StringIO.new(post_payload) )
+  end
+  
+  # Generate an RPC method uisng a block. Accepts two parameters :in is for the input argument types (should be array)
+  # and :out for what it will return.
+  # The block defines the method.
+  def self.rpc(methName, options, &blk)
+    ruby_method = methName.split(/\./).pop.gsub(/([A-Z])/) { |m| '_' + m.downcase }
+    define_method(ruby_method, &blk)
+    
+    options = {:in => []}.merge(options)
+    iface, method = methName.split(/\./)
+    @rpc_methods_and_signatures ||= {}
+    @rpc_methods_and_signatures[ruby_method] = [ methName, "#{options[:out]} #{method}(#{options[:in].join(', ')})" ]
+  end
+  
+  # This is the magic wand. The docs of XMLRPC never explain where the fuck does obj actually ever come from,
+  # moreover - here WE are the object (the server sends a nil, anyways). What is important is that this method
+  # returns a set of method signatures that XMLRPC will call on our object when processing the request.
+  # Delim is omitted since internally we differentiate our namespaced methods anyway (mt. prefix for MovableType
+  # and wp. for Wordpress..)
+  def get_methods(obj, delim)
+    meths = []
+    self.class.rpc_methods_and_signatures.each_pair do | ruby_method, details |
+      # And bind the method
+      meths.unshift [
+        details[0], # method name (in XMLRPC terms) including prefix, like "mt.getPost"
+        method(ruby_method).to_proc, # the method itself, a callable Proc
+        details[1], # signature, like "getPost(string, string, int)"
+        (details[2] || "Just a method") # method help
+      ]
+    end
+    meths
+  end
+  
+  # The only default RPC method we declare. Returns the list of supported XML-RPC methods. This implementation can be
+  # left in it's default form.
+  rpc "mt.supportedMethods", :out => :array do
+    self.class.rpc_methods_and_signatures.values.map {|iface| iface[0] }
+  end
+  
+end

data/lib/blogrpc/rack_app.rb

@@ -0,0 +1,112 @@
+# -*- encoding : utf-8 -*-
+
+# An embeddable Rack handler for RPC servers
+class BlogRPC::RackApp
+  
+  # The root URL of the blog
+  attr_accessor :blog_url
+
+  # The URL of the blog API endpoint (like /backend.rpc)
+  attr_accessor :rpc_endpoint_url
+  
+  # All the XML-RPC handlers that can respond to the request,
+  # if it so happens that you have more than one
+  attr_accessor :handlers
+  
+  def initialize(blog_handler)
+    @handlers = [blog_handler]
+  end
+
+  def call(env)
+    @env = env
+    req = Rack::Request.new(env)
+    # If the request is a GET return the autodiscovery RSD fragment
+    if req.get?
+      return endpoint_xml
+    else
+      return post_request
+    end
+  end
+  
+  private
+  
+  def all_supported_method_names
+    method_names = []
+    @handlers.map do |h| 
+      methods_of_handler = h.get_methods(nil, nil)
+      methods_of_handler.each do | m |
+        method_names << m[0]
+      end
+    end
+    method_names
+  end
+  
+  def supports_mt?
+    all_supported_method_names.grep(/^mt\./).any?
+  end
+  
+  def supports_metaweblog?
+    all_supported_method_names.grep(/^metaWeblog\./).any?
+  end
+  
+  def supports_wordpress?
+    all_supported_method_names.grep(/^wp\./).any?
+  end
+  
+  # Returns the endpoint information that smart blogging clients
+  # can use to detect which APIs you support.
+  def endpoint_xml
+    b = Builder::XmlMarkup.new
+    b.rsd :version => '1.0', :xmlns => "http://archipelago.phrasewise.com/rsd" do; b.service do
+      b.engineName "MovableType" # It's better to pose as MT
+      b.homePageLink(blog_url)
+      b.apis do
+        b.api( :name=>"MovableType", :preferred => "true", :apiLink => rpc_endpoint_url, :blogID => 1) if supports_mt?
+        b.api( :name=>"MetaWeblog", :apiLink => rpc_endpoint_url, :blogID => 1)  if supports_metaweblog?
+        b.api( :name=>"WordPress", :apiLink => rpc_endpoint_url, :blogID => 1)  if supports_wordpress?
+      end
+    end;end
+    [200, {"Content-Length"=> Rack::Utils.bytesize(b.target!), "Content-Type" => 'application/rsd+xml'}, b.target!]
+  end
+  
+  def post_request
+    body = begin
+      # Ruby's XMLRPC does not love rack.input wrappers,
+      # it wants a bona-fide IO. Also, different rack input
+      # wrappers work differently (some are better than others),
+      # so to protect us from extra grief we will rebuffer everything
+      # in a Tempfile
+      @temp = Tempfile.new("rxrpc")
+      @env['rack.input'].each(&@temp.method(:write))
+      @temp.rewind
+      s = XMLRPC::BasicServer.new(self)
+      # Here we initialize the handlers
+      @handlers.each do |handler| 
+        # Inject the Rack environment into the handler
+        handler.env = @env
+        s.add_handler(handler)
+      end
+      
+      # AND PROZESSS!
+      s.process(@temp)
+    rescue Exception => e # Transform all errors, even LoadError, into a properly formatted XML-RPC fault struct
+      # Supports captivity logger by default
+      @env["captivity.logger"].fatal([e.message, e.backtrace].join("\n")) if @env['captivity.logger']
+      b = Builder::XmlMarkup.new
+      b.methodResponse do |b|; b.fault do; b.value do; b.struct do
+        b.member {  b.name("faultCode"); b.value { b.int 1 } }
+        b.member {  b.name("faultString"); b.value { b.string(format_exception(e)) }}
+      end;end;end;end
+      b.target!
+    ensure
+      @temp.close!
+    end
+    
+    [200, {"Content-Length"=> Rack::Utils.bytesize(body), "Content-Type" => 'text/xml; charset=utf-8'}, body]
+  end
+  
+  def format_exception(e)
+    first_line = [e.class.to_s, e.message].join(' : ')
+    ([first_line] + e.backtrace.to_a).join("\n")
+  end
+end

data/lib/blogrpc/sample_handler.rb

@@ -0,0 +1,282 @@
+# A sample MetaWeblog RPC handler. Bear in mind that you will need to rewrite most of it.
+#
+# Define the standard methods for MetaWeblog API here. If you have a valiation problem or somesuch
+# within the method just raise from there, exceptions will be translated into RPC fault codes.
+#
+# You will need to take a look at (and override) get_entry and friends to retrofit that to your own engine.
+#
+# Entry struct
+#
+# A fundamental unit of the MT/MW API is the Entry struct (a Hash). Return that Hash
+# anytime an entry struct is required. Here a short intro on the fields of the struct (you can use
+# both symbols and strings for keys):
+#   title, for the title of the entry;
+#   description, for the body of the entry;
+#   dateCreated, to set the created-on date of the entry;
+#   In addition, Movable Type’s implementation allows you to pass in values for five other keys:
+#   int mt_allow_comments, the value for the allow_comments field;
+#   int mt_allow_pings, the value for the allow_pings field;
+#   String mt_convert_breaks, the value for the convert_breaks field;
+#   String mt_text_more, the value for the additional entry text;
+#   String mt_excerpt, the value for the excerpt field;
+#   String mt_keywords, the value for the keywords field;
+#   String mt_basename, the value for the slug field;
+#   array mt_tb_ping_urls, the list of TrackBack ping URLs for this entry;
+#
+# If specified, dateCreated should be in ISO.8601 format.
+# Also note that most blogging clients will have BIG issues if you supply non-UTC timestamps, so if you
+# are using ActiveRecord timezone support (and you should!) take care to do all of your RPC operations
+# with all timezones switched to UTC.
+class BlogRPC::SampleHandler < BlogRPC::BasicHandler
+  
+  # An example mapping for the XMLRPC fieldnames to ActiveRecord fields.
+  STRUCT_TO_ENTRY = {
+    "title" => "title", 
+    "description" => "body",
+    "dateCreated" => "created_at",
+    "mt_text_more" => "more",
+    "mt_basename" => "slug",
+    "mt_allow_comments" => "allow_comments",
+    "permalink" => "permalink",
+    "link" => "permalink",
+    "postId" => "id"
+  }
+  
+  STRUCT_TO_CATEGORY = {
+    "categoryId" => "id",
+    "categoryName" => "title",
+  }
+  
+  # Should return something like [{:key => '__markdown__', :label => "Markdown"}]
+  # This is used to form a formatting menu in blog clients that allow choices in formatting
+  rpc "mt.supportedTextFilters", :out => :array do
+    [
+      {:key => '__default__', :label => "Convert Line Breaks"},
+      {:key => '__markdown__', :label => "Markdown"}
+    ]
+  end
+  
+  # Toggle the draft flag and return true.
+  rpc "mt.publishPost", :in => [:int, :string, :string], :out => :bool do | postid, user, pw |
+    login!(user, pw)
+    get_entry(postid).update_attributes :draft => false
+    true
+  end
+  
+  # Delete the post. Appkey can be ignored since it's Google specific.
+  rpc "blogger.deletePost", :in => [:string, :int, :string, :string, :bool], :out => :bool do | appkey, postid, user, pw, void |
+    login! user, pw
+    get_entry(postid).destroy
+    true
+  end
+  
+  # Return an Array of Hashes from here that define available categories.
+  # Category hashes look like this: {categoryId: 1, categoryTitle: "Bad RPC practices"}
+  rpc "mt.getCategoryList", :in => [:int, :string, :string], :out => :array do | blogid, user, pw |
+    login! user, pw
+    check_blog_permission! user, blogid
+    find_all_categories.map do | c |
+      category_to_struct(c)
+    end
+  end
+  
+  # Get the categories of a specific entry.
+  # Return an Array of Hashes from here - categories assigned to the passed post.
+  # You can also set {isPrimary: false} or true to denote the primary category.
+  rpc "mt.getPostCategories", :in => [:int, :string, :string], :out => :array do | postid, user, pw |
+    login! user, pw
+    cats = get_entry(postid).categories
+    cats.map {|c| category_to_struct(c).merge(:isPrimary => false) }
+  end
+  
+  # Sets the post categories. The last argument is an Array of category Hashes, see above.
+  rpc "mt.setPostCategories", :in => [:int, :string, :string, :array], :out => :bool do | postid, user,pw, categories |
+    login! user, pw
+    entry = get_entry(postid)
+    set_category_ids(entry, categories.map{|c| c["categoryId"]})
+    true
+  end
+  
+  # Returns the recent post titles. This is used by blog clients to speed up listings of entries since
+  # this only retreives some information. By default, this method should send the following data about an entry:
+  #   userId, dateCreated, postId, title 
+  rpc "mt.getRecentPostTitles", :in => [:int, :string, :string, :int], :out => :array do | blogid, user, pw, num |
+    login! user, pw
+    defaults = {:userId => 1}
+    short_keys = %w( dateCreated postId title userid)
+    latest_entries(num).map do | entry |
+      struct = {}
+      short_keys.each { | k | struct[k] = entry[STRUCT_TO_ENTRY[k]] }
+      defaults.merge(struct)
+      struct
+    end
+  end
+  
+  # Returns the trackback pings of the entry. Most likely you will not be using this.
+  # { 
+  #   pingTitle  string  -- the title of the entry sent in the ping
+  #   pingURL string  -- the URL of the entry
+  #   pingIP  string  -- the IP address of the host that sent the ping
+  # }
+# rpc "mt.getTrackbackPings", :in => [:int, :string, :string], :out => :array do | entry_id, user, pw |
+#   login! user, pw
+#   []
+# end
+
+  # Create a new post. The entry Hash has all the standard fields. Should return the ID of the entry created as a String
+  rpc "metaWeblog.newPost", :in => [:int, :string, :string, :struct, :bool], :out => :string do | blogid, user, pw, entry_struct, publish_bit |
+    login! user, pw
+    e = make_new_entry
+    change_entry(e, entry_struct, publish_bit)
+    e[e.class.primary_key].to_s
+  end
+  
+  # Change an entry replacing fields in the passed Hash. The last argument is the "publish bit" - whether the entry is published or draft.
+  # Return true when change succeeded.
+  rpc "metaWeblog.editPost", :in => [:int, :string, :string, :struct, :bool], :out => :bool do | entry_id, user, pw, entry_struct, publish_bit |
+    login! user, pw
+    change_entry(get_entry(entry_id), entry_struct, publish_bit)
+    true
+  end
+  
+  # Returns an array of blogs [{:url => blog_url, :blogid => "1", :blogName => "The only blog here"}]
+  # The irony is that this is the way MT supports many blog RPCs on one install, so it's a good idea
+  # to handle that at least as a bogus function. We will provide a reasonable default.
+  rpc "blogger.getUsersBlogs", :in => [:string, :string, :string], :out => :array do | void, user, pw |
+    login! user, pw
+    blog = {:url => blog_url, :blogid => "1", :blogName => "The only blog here"}
+    [blog]
+  end
+  
+  # Retreive an entry by ID. Should return the entry struct.
+  rpc "metaWeblog.getPost", :in => [:int, :string, :string], :out => :struct do | entry, user, pw |
+    login! user, pw
+    entry_to_struct( get_entry(entry) )
+  end
+    
+  # Retreive N last posts, but in their complete form (unlinke getRecentPostTitles)
+  rpc "metaWeblog.getRecentPosts", :in => [:int, :string, :string, :int], :out => :array do | blogid, user, pw, num |
+    login! user, pw
+    check_blog_permission! user, blogid
+    latest_entries(num).map {|e| entry_to_struct(e) }
+  end
+  
+  # Creates a file on the server. The passed file Hash has:
+  #   bits: the byte content of the upload, in a String
+  #   name: the path to put the file to relative to the site root
+  # It should return a struct like {url: "http://z.com/img.png"}
+  # Note that at least for MarsEdit the URL of the uploaded image should be canonical (with host data)
+  # for the preview to display properly.
+  # Remember the Rack env object is available for resolving hosts and such!
+  rpc "metaWeblog.newMediaObject", :in => [:int, :string, :string, :struct], :out => :struct do | blogid, user, pw, file_struct |
+    login! user, pw
+    check_blog_permission! user, blogid
+    
+    file_struct['name'] = file_struct["name"].gsub(/\.\./, '').squeeze('/').gsub(/\s/, '_')
+    sanitized_name = File.expand_path(File.join(site_root, file_struct["name"]))
+    FileUtils.mkdir_p(File.dirname(sanitized_name))
+    
+    # Wind the file name if such a file exists
+    dir, file = File.dirname(sanitized_name), File.basename(sanitized_name)
+    parts = file.split(/\./)
+    ext = parts.pop
+    counter = 2
+    #dbg "Detected sanitized name #{sanitized_name}"
+    while File.exist?(sanitized_name)
+     #dbg "Already uploaded, winding counter"
+      sanitized_name = File.join(dir, [parts, counter, ext].join('.'))
+      #puts "Made #{sanitized_name}"
+      counter += 1
+    end
+    
+    File.open(sanitized_name, 'w') { |o| o << file_struct["bits"] }
+    
+    return {:url => File.join(env["HOST"], sanitized_name), :saved_to => sanitized_name }
+  end
+  
+  private
+  
+  # The following methods are just an example of how you would approach such a handler.
+  # Normally you would rewrite almost all of the rpc method implementations.
+  
+  # Get the site root
+  def site_root
+    File.dirname(__FILE__)
+  end
+  
+  # Get an entry by ID
+  def get_entry(id)
+    Entry.find(id)
+  end
+  
+  # Get categories of the entry. The entry passed will be one recieved from one of your own methods
+  def get_categories_of(entry)
+    entry.categories.map{|c| category_to_struct(c) }
+  end
+  
+  # Assign category ids to an entry
+  def set_category_ids(entry, ids)
+    entry.category_ids = ids
+    entry.save!
+  end
+  
+  # Convert a category to RPC struct (hash)
+  def category_to_struct(c)
+    STRUCT_TO_CATEGORY.inject({}) do | struct, kv |
+      struct[kv[0]] = c[kv[1]].to_s
+      struct
+    end
+  end
+  
+  def find_all_categories
+    Category.find(:all)
+  end
+  
+  # Get a fresh entry
+  def make_new_entry
+    Entry.new
+  end
+  
+  # Change an entry with data in the entry_struct, honoring the publish bit
+  def change_entry(entry_obj, entry_struct, publish_bit)
+    entry_struct.each_pair do | k, v |
+      # ActiveRecord YAMLifies that if we are not careful. XML-RPC gives us Time.to_gm by default
+      v = v.to_time if(v.is_a?(XMLRPC::DateTime))
+      model_field = STRUCT_TO_ENTRY[k]
+      entry_obj.send("#{model_field}=", v) if model_field
+    end
+    entry_obj.save!
+  end
+  
+  # Return the latest N entries
+  def latest_entries(n)
+    Entry.find(:all, :order => 'created_at DESC', :limit => n)
+  end
+    
+  # Transform an entry into a struct
+  def entry_to_struct(entry)
+    STRUCT_TO_ENTRY.inject({}) do | struct, kv |
+      k, v = kv
+      
+      # Dates and times have to pass through unscathed, converted to utc (!)
+      struct[k] = if entry[v].respond_to?(:strftime)
+        entry[v].utc
+      else
+        entry[v].to_s
+      end
+      struct
+    end
+  end
+
+  # Raise from here if the user is illegal
+  def login!(user, pass)
+  end
+  
+  # Return your blog url from here
+  def blog_url
+  end
+  
+  # Raise from here if the user cannot post to this specific blog
+  def check_blog_permission!(blog_id, user)
+  end
+end

data/lib/blogrpc.rb

@@ -0,0 +1,15 @@
+module BlogRPC
+  VERSION = "1.0.0"
+  
+  # Generate an RPC Rack application and yield it's only handler class to the passed block.
+  # Call rpc(...) on the yielded class to define methods
+  def self.generate_endpoint(&blk)
+    handler_class = Class.new(BlogRPC::BasicHandler)
+    yield(handler_class)
+    BlogRPC::RackApp.new(handler_class.new)
+  end
+end
+
+require File.dirname(__FILE__) + "/blogrpc/rack_app"
+require File.dirname(__FILE__) + "/blogrpc/basic_handler"
+require File.dirname(__FILE__) + "/blogrpc/sample_handler"

data/test/helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'bundler'
+require 'http_simulator'
+require 'test/unit'
+require 'flexmock'
+require 'flexmock/test_unit'
+require 'net/http'
+
+# http://redmine.ruby-lang.org/issues/4882
+# https://github.com/jimweirich/flexmock/issues/4
+# https://github.com/julik/flexmock/commit/4acea00677e7b558bd564ec7c7630f0b27d368ca
+class FlexMock::PartialMockProxy
+  def singleton?(method_name)
+    @obj.singleton_methods.include?(method_name.to_s)
+  end
+end
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'blogrpc'
+
+class Test::Unit::TestCase
+end

data/test/http_simulator.rb

@@ -0,0 +1,62 @@
+# A barebones HTTP simulator for using with XML-RPC
+class HTTPSimulator
+  attr_reader :path
+  
+  class MockResponse
+    attr_reader :status, :headers, :body
+    def initialize(s, h, b)
+      @status, @headers, @body = s, h, b
+    end
+    
+    def code
+      @status
+    end
+    
+    def method_missing(*a)
+      puts "KALLED #{a.inspect}"
+      super
+    end
+    
+    def get_fields(field)
+      self[field]
+    end
+    
+    def [](k)
+      @headers[k]
+    end
+  end
+  
+  def initialize(test_case, endpoint_url)
+    @path = endpoint_url
+    @test_case = test_case
+    raise "The passed TestCase should support response()" unless @test_case.respond_to?(:response)
+    raise "The passed TestCase should support request()" unless @test_case.respond_to?(:request)
+  end
+  
+  def version_1_2; end
+  
+  def post2(port, request_body, headers)
+    @test_case.post(path, params = {}, headers.merge("rack.input" => StringIO.new(request_body)))
+    MockResponse.new(@test_case.response.status.to_s, @test_case.response.headers, @test_case.response.body)
+  end
+  
+  def get(path, request_body, headers)
+    headers.each_pair{|k,v,| @test_case.request[k] = v }
+    @test_case.get path, request_body
+    MockResponse.new(@test_case.response.status.to_s, @test_case.response.headers, @test_case.response.body)
+  end
+
+  def head(path, request_body, headers)
+    headers.each_pair{|k,v,| @test_case.request[k] = v }
+    @test_case.head path, request_body
+    MockResponse.new(@test_case.response.status.to_s, @test_case.response.headers, @test_case.response.body)
+  end
+  
+  def start(*a)
+    yield(*a) if block_given?
+  end
+  
+  def method_missing(m, *args)
+    # puts "Called #{m}"
+  end
+end

data/test/test_blogapi.rb

@@ -0,0 +1,40 @@
+require 'helper'
+require 'xmlrpc/client'
+require 'rack/test'
+
+class TestRackHandler < Test::Unit::TestCase
+  include Rack::Test::Methods
+  
+  def response
+    last_response
+  end
+  
+  def app
+    BlogRPC.generate_endpoint do | handler |
+      handler.rpc "mt.getPostCategories", :in => [:int, :string, :string], :out => :array do | postid, user, pw |
+        [{categoryId: 1, categoryName: "Awesome posts"}]
+      end
+      
+      handler.rpc "junk.processJunk", :in => [], :out => :boolean do
+        true
+      end
+    end
+  end
+  
+  def test_method_table
+    # Make sure Net::HTTP makes that request into the testcase instead of the Interwebs
+    http = HTTPSimulator.new(self, "/rpc.xml")
+    flexmock(Net::HTTP) { |mock| mock.should_receive(:new).once.and_return(http) }
+    client = XMLRPC::Client.new("localhost", "/rpc.xml", 80)
+    
+    methods_via_rpc = client.call("mt.supportedMethods")
+    assert_equal %w( mt.supportedMethods mt.getPostCategories junk.processJunk ), methods_via_rpc
+    assert_equal "text/xml; charset=utf-8", last_response['Content-Type']
+  end
+  
+  def test_get_returns_rsd
+    get '/rpc.xml'
+    assert_equal "application/rsd+xml", last_response['Content-Type']
+    assert last_response.body.include?('api name="MovableType" preferred="true"')
+  end
+end

data/test/test_rpc_handler_method_definitions.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class TesRpcHandlerMethodDefinitions < Test::Unit::TestCase
+  
+  class Sub < BlogRPC::BasicHandler
+    rpc "julik.testMethod", :in => [:int], :out => :array do
+      []
+    end
+  end
+  
+  class SubSub < Sub
+    rpc "julik.anotherMethod", :in => [:int, :struct], :out => :array do
+      []
+    end
+  end
+  
+  def test_methods_propagated_on_inheritance_chain
+    basics = BlogRPC::BasicHandler.rpc_methods_and_signatures
+    only_supported = {"supported_methods" => ["mt.supportedMethods", "array supportedMethods()"] }
+    assert_equal only_supported, basics
+  end
+  
+  def test_methods_on_inherited_class_included_into_table
+    all_rpc_methods = Sub.rpc_methods_and_signatures
+    spliced_from_two_classes = {
+      "supported_methods" => ["mt.supportedMethods", "array supportedMethods()"],
+      "test_method"=>["julik.testMethod", "array testMethod(int)"]
+    }
+    assert_equal spliced_from_two_classes, all_rpc_methods
+  end
+  
+  def test_methods_on_inherited_sub_sub_class_included_into_table
+    all_rpc_methods = SubSub.rpc_methods_and_signatures
+    spliced_from_two_classes = {
+      "supported_methods" => ["mt.supportedMethods", "array supportedMethods()"],
+      "test_method" => ["julik.testMethod", "array testMethod(int)"],
+      "another_method" => ["julik.anotherMethod", "array anotherMethod(int, struct)"]
+    }
+    assert_equal spliced_from_two_classes, all_rpc_methods
+  end
+  
+  def test_method_introspection_called_by_xmlrpc
+    sub = SubSub.new
+    method_table = sub.get_methods(nil, '.')
+    assert_equal 3, method_table.length, "The method table should include 3 method signatures"
+    first_method = method_table[0]
+    assert_equal "julik.anotherMethod", first_method[0], "The first item in the method description should be a namespaced name"
+    assert_kind_of Proc, first_method[1], "The second item should be the proc handling the call"
+    assert_equal 'array anotherMethod(int, struct)', first_method[2], "The last item should a C-like method signature with types"
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: blogrpc
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- blogrpc.gemspec
+- lib/blogrpc.rb
+- lib/blogrpc/basic_handler.rb
+- lib/blogrpc/rack_app.rb
+- lib/blogrpc/sample_handler.rb
+- test/helper.rb
+- test/http_simulator.rb
+- test/test_blogapi.rb
+- test/test_rpc_handler_method_definitions.rb
+homepage: http://github.com/julik/blogrpc
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -815078792002993529
+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: Easily construct MT and MetaWeblog XML-RPC backends
+test_files: []