movabletype 0.1.0

data/README

@@ -0,0 +1 @@
+* MovableType API for Ruby

data/lib/movabletype/entry.rb

@@ -0,0 +1,74 @@
+require 'xmlrpc/client'
+require 'movabletype/post'
+module MovableType
+  class Entry
+    class NoPostId < StandardError
+    end
+    Category = Struct.new('Category',:id,:name)
+
+    def initialize(entry,blogid,user,passwd)
+      @entry = XMLRPC::Client.new2 entry
+      @metaWeblog = @entry.proxy('metaWeblog')
+      @mt = @entry.proxy('mt')
+      @blogid = blogid
+      @user = user
+      @passwd = passwd
+    end
+
+    # create new article.
+    # and return new article.
+    def post(post,publish=true)
+      new_post = post.dup
+      post!(new_post,publish)
+      new_post
+    end
+
+    def post!(post,publish=true)
+      postid = @metaWeblog.newPost @blogid,@user,@passwd,
+               post.to_struct,publish
+      post.id = postid
+    end
+
+    def edit(post,publish=true)
+      post.id != nil or raise NoPostId.new
+      @metaWeblog.editPost post.id,@user,@passwd,post.to_struct,publish
+    end
+
+    def delete(post,publish=true)
+      post.id != nil or raise NoPostId.new
+      @entry.call 'blogger.deletePost','hoge',post.id,@user,@passwd,publish
+    end
+
+    def publish(post)
+      post.id != nil or raise NoPostId.new
+      @mt.publishPost post.id,@user,@passwd
+    end
+
+    def categories(post)
+      post.id != nil or raise NoPostId.new
+      @mt.getPostCategories(post.id,@user,@passwd).map{|category|
+        Category.new category['categoryId'],category['categoryName']
+      }
+    end
+
+    def set_categories(post,*categories)
+      post.id != nil or raise NoPostId.new
+      @mt.setPostCategories post.id,@user,@passwd,categories.map{|category|
+        {'categoryId'=>category.id}
+      }
+    end
+
+    def recent_post(size)
+      result = @metaWeblog.getRecentPosts @blogid,@user,@passwd,size
+      result.map{|content|
+        Post.new2 content
+      }
+    end
+    
+    def category_list
+      @mt.getCategoryList(@blogid,@user,@passwd).map{|struct|
+        Category.new(struct['categoryId'],struct['categoryName'])
+      }
+    end
+  end
+end

data/lib/movabletype/post.rb

@@ -0,0 +1,136 @@
+require 'time'
+
+module MovableType
+  class Post
+    Method2Struct = {
+      :title=>'title',
+      :description => 'description',
+      :date => 'dateCreated',
+      'comment?'.intern => 'mt_allow_comments',
+      'trackback?'.intern => 'mt_allow_pings',
+      :break => 'mt_convert_breaks',
+      :text_more => 'mt_text_more',
+      :excerpt => 'mt_excerpt',
+      :keywords => 'mt_keywords',
+      :trackbacks => 'mt_tb_ping_urls'
+    }
+    Struct2Option = Method2Struct.invert
+    Struct2Option.delete('title')
+    Struct2Option.delete('description')
+    Struct2Option['mt_allow_comments'] = :comment
+    Struct2Option['mt_allow_pings'] = :trackback
+    Struct2Option['postid'] = :id
+
+
+    def self.new2(struct,id=nil)
+      title = struct['title']
+      description = struct['description']
+      option = {}
+      Struct2Option.each{|field,name|
+        res = struct[field]
+        option[name] = case res
+                       when 1
+                         true
+                       when 0
+                         false
+                       when 'none'
+                         :none
+                       when '0'
+                         :none
+                       when 'convert_breaks'
+                         :convert
+                       when '1'
+                         :convert
+                       when nil
+                       else
+                         if name == :keywords
+                           res.split ','
+                         else
+                           res
+                         end
+                       end
+      }
+      if id then
+        option[:id] =id
+      end
+      self.new title,description,option
+    end
+
+    def self.option_get(*ids)
+      for id in ids
+        module_eval <<-"END"
+        def #{id}
+          if @option.key? :#{id} then
+            @option[:#{id}]
+          else
+             nil
+          end
+        end
+        END
+      end
+    end
+
+    def self.option_is(*ids)
+      for id in ids
+        module_eval <<-"END"
+        def #{id}?
+          if @option.key? :#{id} then
+            @option[:#{id}]
+          else
+             nil
+          end
+        end
+        END
+      end
+    end
+
+    attr_reader :title,:description
+    attr_accessor :id
+    option_get :date,:break,:text_more,:excerpt,:keywords,:trackbacks
+    option_is :comment,:trackback
+    def initialize(title,description,option={:date=>Time.now})
+      @title = title
+      @description = description
+      @option = option
+      @id = option[:id]
+    end
+
+    def ==(o)
+      eq = [:class,:title,:description,:id,
+            :date,:break,:text_more,:excerpt,:keywords,:trackbacks,
+            'comment?','trackback?']
+
+      eq.each{|method|
+        unless o.send(method) == self.send(method) then
+          return false
+        end
+      }
+      return true
+    end
+
+    def to_struct
+      hash = {}
+      Method2Struct.each do |method,field|
+        res =  self.send method
+        case res
+        when true
+          hash[field] = 1
+        when false
+          hash[field] = 0
+        when :none
+          hash[field] = 'none'
+        when :convert
+          hash[field] = 'convert_breaks'
+        when nil
+        else
+          if method == :keywords
+            hash[field] = res.join(',')
+          else
+            hash[field] = res
+          end
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/movabletype.rb

@@ -0,0 +1,2 @@
+require 'movabletype/post'
+require 'movabletype/entry'

data/test/test_entry.rb

@@ -0,0 +1,130 @@
+require 'test/unit'
+require 'movabletype/entry'
+
+class XMLRPC::Client
+  alias_method :_initialize_,:initialize
+  @@history = []
+  def initalize(*args,&block)
+    _initialize_ *args,&block
+  end
+  
+  def getRecentPosts(blogid,username,password,size)
+    Array.new(size){|i|
+      MovableType::Post.new("title#{i}","body#{i}",{:id=>i.to_s}).to_struct
+    }
+  end
+
+  def getCategoryList(blogid,user,passwd)
+    [{'categoryId'=>'100','categoryName'=>'foo'},
+     {'categoryId'=>'101','categoryName'=>'bar'}]
+  end
+
+  def getPostCategories(postid,username,passwd)
+    [{'categoryId'=>'100','categoryName'=>'foo'},
+     {'categoryId'=>'101','categoryName'=>'bar'}]
+  end
+
+  def call(name,*args,&block)
+    mapping = {'metaWeblog.getRecentPosts'=> :getRecentPosts,
+      'mt.getCategoryList' => :getCategoryList,
+      'mt.getPostCategories'=>:getPostCategories}
+    @@history << [name,args].flatten
+    if mapping.key? name then
+      self.send mapping[name],*args
+    else
+      :hoge
+    end
+  end
+
+  def self.last
+    @@history[-1]
+  end
+
+  def self.last_method
+    @@history[-1][0]
+  end
+end
+
+class MovableTypeTest < Test::Unit::TestCase
+  Entry = 'http://example.com/mt.cgi'
+  BlogId = 4
+  Username = 'MIZUNO'
+  Passwd = 'Hiroki'
+
+  def setup
+    @post = MovableType::Post.new 'title','body' 
+    @mt = MovableType::Entry.new(Entry,BlogId,Username,Passwd)
+  end
+
+  def test_post
+    new_post = @mt.post @post,true
+    assert_equal 'metaWeblog.newPost',XMLRPC::Client.last_method
+    assert_not_equal nil,new_post.id
+    assert_equal nil,@post.id
+  end
+
+  def test_edit
+    assert_raise(MovableType::Entry::NoPostId){
+      @mt.edit @post
+    }
+    @mt.edit MovableType::Post.new2(@post.to_struct,'100')
+    assert_equal 'metaWeblog.editPost',XMLRPC::Client.last_method
+  end
+
+  def test_delete
+    assert_raise(MovableType::Entry::NoPostId){
+      @mt.delete @post
+    }
+    @mt.delete MovableType::Post.new(nil,nil,{:id=>'100'})
+    assert_equal 'blogger.deletePost',XMLRPC::Client.last_method
+  end
+
+  def test_recent
+    posts = @mt.recent_post 2
+    assert_equal 'metaWeblog.getRecentPosts',XMLRPC::Client.last_method
+    assert_equal 2,posts.size
+    assert_equal 'title0',posts[0].title
+    assert_equal 'body0',posts[0].description
+    assert_equal 'title1',posts[1].title
+    assert_equal 'body1',posts[1].description
+  end
+
+  def test_publish
+    assert_raise(MovableType::Entry::NoPostId){
+      @mt.delete @post
+    }
+    @mt.publish MovableType::Post.new(nil,nil,{:id=>'100'})
+    assert_equal 'mt.publishPost',XMLRPC::Client.last_method
+  end
+
+  def test_set_categories
+    assert_raise(MovableType::Entry::NoPostId){
+      @mt.set_categories @post,'100','200'
+    }
+    cat = @mt.set_categories(
+                             MovableType::Post.new(nil,nil,{:id=>'100'}),
+                             MovableType::Entry::Category.new('100','foo'),
+                             MovableType::Entry::Category.new('101','bar'))
+    assert_equal 'mt.setPostCategories',XMLRPC::Client.last_method
+  end
+
+  def test_categories
+    assert_raise(MovableType::Entry::NoPostId){
+      @mt.categories @post
+    }
+    cat = @mt.categories(MovableType::Post.new(nil,nil,{:id=>'100'})).sort{|a,b|
+      a.id <=> b.id}
+    assert_equal 'mt.getPostCategories',XMLRPC::Client.last_method
+    assert_equal 2,cat.size
+    assert_equal MovableType::Entry::Category.new('100','foo'),cat[0]
+    assert_equal MovableType::Entry::Category.new('101','bar'),cat[1]
+  end
+
+  def test_category_list
+    cat = @mt.category_list.sort{|a,b| a.id <=> b.id}
+    assert_equal 'mt.getCategoryList',XMLRPC::Client.last_method
+    assert_equal 2,cat.size
+    assert_equal MovableType::Entry::Category.new('100','foo'),cat[0]
+    assert_equal MovableType::Entry::Category.new('101','bar'),cat[1]
+  end
+end

data/test/test_post.rb

@@ -0,0 +1,149 @@
+require 'test/unit'
+require 'movabletype/post'
+class PostTest < Test::Unit::TestCase
+  def setup
+    @now = Time.now
+    @method = []
+    @struct = []
+    @klass  = []
+
+    @struct.push({'title'=>'hoge','description'=>'baz','dateCreated'=>@now})
+    @method.push({:id=>nil,:title=>'hoge',:description=>'baz',:date=>@now})
+    @klass.push MovableType::Post.new('hoge','baz',{:date=>@now})
+
+    @struct.push({'title'=>'hoge','description'=>'baz','dateCreated'=>@now,
+                 'mt_convert_breaks'=>'none'})
+    @method.push({:id=>nil,:title=>'hoge',:description=>'baz',:date=>@now,
+                 :break=>:none})
+    @klass.push MovableType::Post.new('hoge','baz',{:date=>@now,:break=>:none})
+
+    @struct.push({'title'=>'hoge','description'=>'baz','dateCreated'=>@now,
+                 'mt_convert_breaks'=>'convert_breaks'})
+    @method.push({:id=>nil,:title=>'hoge',:description=>'baz',:date=>@now,
+                 :break=>:convert})
+    @klass.push MovableType::Post.new('hoge','baz',{:date=>@now,:break=>:convert})
+
+    @struct.push({'title'=>'hoge',
+                   'description'=>'baz',
+                   'dateCreated'=>@now})
+    @method.push({:id=>'100',:title=>'hoge',:description=>'baz',:date=>@now})
+    @klass.push MovableType::Post.new('hoge','baz',{:date=>@now,:id=>'100'})
+
+    @struct.push({'title'=>'hoge',
+                   'description'=>'baz',
+                   'dateCreated'=>@now,
+                   'mt_text_more'=>'more'})
+    @method.push({:title=>'hoge',
+                   :description=>'baz',
+                   :date=>@now,
+                   :text_more=>'more',
+                   :id=>nil})
+    @klass.push MovableType::Post.new('hoge','baz',
+                                      {:date=>@now,:text_more=>'more'})
+
+    @struct.push({'title'=>'hoge',
+                   'description'=>'baz',
+                   'dateCreated'=>@now,
+                   'mt_allow_comments'=>1})
+    @method.push({:title=>'hoge',
+                   :description=>'baz',
+                   :date=>@now,
+                   'comment?'.intern=>true,
+                   :id=>nil})
+    @klass.push MovableType::Post.new('hoge','baz',
+                                      {:date=>@now,:comment=>true})
+
+    @struct.push({'title'=>'hoge',
+                   'description'=>'baz',
+                   'dateCreated'=>@now,
+                   'mt_allow_comments'=>1,
+                   'mt_allow_pings'=>0,
+                   'mt_convert_breaks'=>'none',
+                   'mt_text_more'=>'more',
+                   'mt_excerpt'=>'excerpt',
+                   'mt_keywords'=>'a,b,c',
+                   'mt_tb_ping_urls'=>['A','B','C']})
+    @method.push({:title=>'hoge',
+                   :description=>'baz',
+                   :date=>@now,
+                   'comment?'.intern=>true,
+                   'trackback?'.intern=>false,
+                   :break=>:none,
+                   :text_more=>'more',
+                   :excerpt=>'excerpt',
+                   :keywords=>['a','b','c'],
+                   :trackbacks=>['A','B','C'],
+                   :id=>nil})
+
+    @klass.push MovableType::Post.new('hoge','baz',
+                                      {:date=>@now,
+                                        :comment=>true,
+                                        :trackback=>false,
+                                        :break=>:none,
+                                        :text_more=>'more',
+                                        :excerpt=>'excerpt',
+                                        :keywords=>['a','b','c'],
+                                        :trackbacks=>['A','B','C']})
+  end
+
+  def test_to_struct
+    each_with(@struct,@klass){|s,k|
+      assert_equal_array s,k.to_struct
+    }
+  end
+
+  def assert_equal_array(expect,actual)
+    each_with(expect.to_a.sort,actual.to_a.sort){|e,a|
+      assert_equal e,a
+    }
+  end
+
+  def test_method
+    each_with(@klass,@method){|k,m|
+      m.each{|name,expect|
+        assert_equal expect,k.send(name)
+      }
+    }
+  end
+
+  def test_convert_none
+    struct = {'title'=>'hoge','description'=>'baz','dateCreated'=>@now,
+      'mt_convert_breaks'=>'0'}
+    post =  MovableType::Post.new('hoge','baz',{:date=>@now,:break=>:none})    
+    assert_equal post,MovableType::Post.new2(struct)
+  end
+
+  def test_convert_conv
+    struct = {'title'=>'hoge','description'=>'baz','dateCreated'=>@now,
+      'mt_convert_breaks'=>'1'}
+    post =  MovableType::Post.new('hoge','baz',{:date=>@now,:break=>:convert})    
+    assert_equal post,MovableType::Post.new2(struct)
+  end
+
+  def test_from_struct
+    each_with(@klass,@struct){|k,s|
+      assert_equal k,MovableType::Post.new2(s,k.id)
+    }
+  end
+
+  def each_with(klass1,klass2)
+    assert_equal klass1.length,klass2.length
+    klass1.each_index{|i|
+      yield klass1[i],klass2[i]
+    }
+  end
+
+  def test_date
+    post = MovableType::Post.new('tilte','description')
+    assert_not_equal nil,post.date
+
+    post = MovableType::Post.new('tilte','description')
+    assert_not_equal nil,post.to_struct['dateCreated']
+
+    post = MovableType::Post.new('tilte','description',{:date=>nil})
+    assert_equal nil,post.date
+
+    post = MovableType::Post.new('tilte','description',{:date=>nil})
+    assert_equal nil,post.to_struct['dateCreated']
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: movabletype
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-08-14 00:00:00 +09:00
+summary: MovableType API for Ruby
+require_paths: 
+- lib
+email: hiroki1124@gmail.com
+homepage: http://d.hatena.ne.jp/mzp/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- MIZUNO Hiroki
+files: 
+- test/test_entry.rb
+- test/test_post.rb
+- lib/movabletype.rb
+- lib/movabletype/entry.rb
+- lib/movabletype/post.rb
+- README
+test_files: 
+- test/test_entry.rb
+- test/test_post.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+