wordpress-xmlrpc 0.0.9 → 0.0.10

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.0.10

data/lib/blog.rb

@@ -28,26 +28,58 @@ module Wordpress
 
     def recent_posts(number_of_posts)
       blog_api_call("metaWeblog.getRecentPosts", number_of_posts).collect do |struct|
-        Post.from_struct(struct)
+        Post.from_struct(:metaWeblog, struct)
       end
     end #recent_posts
 
-    def publish(post)
-      process_post_images(post)
-      post.id = blog_api_call("metaWeblog.newPost", post.to_struct, true).to_i
-      post.published = true
+    def publish(item)
+      process_images(item) unless item.images.nil?
+      case item
+      when Wordpress::Post
+        item.id = blog_api_call("metaWeblog.newPost", item.to_struct(:metaWeblog), true).to_i
+        item.published = true
+      when Wordpress::Page
+        item.id = blog_api_call("wp.newPage", item.to_struct(:wp), true).to_i
+      else
+        raise "Unknown item type: #{item}"
+      end
     end #publish
 
-    # TODO: rename to "update"
-    def update_post(post)
-      process_post_images(post)
-      return api_call("metaWeblog.editPost", post.id, @user, @password, post.to_struct, post.published)
-    end #update_post
-
-    def delete(post)
-      return api_call("blogger.deletePost", "", post.id, @user, @password, true)
+    def update(item)
+      process_images(item) unless item.images.nil?
+      case item
+      when Post
+        return api_call("metaWeblog.editPost", item.id, @user, @password, item.to_struct(:metaWeblog), item.published)
+      when Page
+        return api_call("wp.editPage", @id, item.id, @user, @password, item.to_struct(:wp), item.published)
+      else
+        raise "Unknown item type: #{item}"
+      end
+    end #update
+
+    def delete(item)
+      case item
+      when Wordpress::Post
+        return api_call("blogger.deletePost", "", item.id, @user, @password, true)
+      when Wordpress::Page
+        return blog_api_call("wp.deletePage", item.id)
+      else
+        raise "Unknown item type: #{item}"
+      end
     end
 
+    def get_page_list
+      page_list = blog_api_call("wp.getPageList").collect do |struct|
+        Wordpress::Page.from_struct(:wp, struct)
+      end
+      # link pages list with each other
+      page_list.each do |page|
+        page.parent = page_list.find{|p| p.id == page.parent_id} if page.parent_id
+      end
+
+      page_list
+    end #get_page_list
+
     def upload_file(file)
       struct = {
         :name => File.basename(file.path),
@@ -59,9 +91,9 @@ module Wordpress
     end
 
     private
-    def process_post_images(post)
-      doc = Nokogiri::HTML::DocumentFragment.parse(post.content)
-      post.images.each do |image|
+    def process_images(item)
+      doc = Nokogiri::HTML::DocumentFragment.parse(item.content)
+      item.images.each do |image|
 
         raise ArgumentError, "Image not found (path: #{image[:file_path]})" unless File.exist?(image[:file_path])
 
@@ -72,8 +104,8 @@ module Wordpress
           img['src'] = uploaded_image['url'] if img['src'].include?(basename)
         end
       end
-      post.content = doc.to_html
-    end #process_post_images
+      item.content = doc.to_html
+    end #process_images
 
     def api_call(method_name, *args)
       begin

data/lib/content_item.rb

@@ -0,0 +1,74 @@
+module Wordpress
+  module ContentItem
+    module ClassMethods
+      def from_struct(api, struct)
+        content_item = self.new
+
+        self::ATTRIBUTE_MATCHES[api].each do |struct_attribute, item_attribute|
+          value = struct[struct_attribute.to_s]
+          value = value.to_date if value.kind_of?XMLRPC::DateTime
+          content_item.send("#{item_attribute}=", value) unless value.nil?
+        end
+
+        content_item
+      end #self.from_struct
+    end
+
+    module InstanceMethods
+      def initialize(attributes = {})
+        super()
+        self.images = []
+        apply_attributes(attributes)
+      end #initialize
+
+      def to_struct(api)
+        struct = {}
+        self.class::ATTRIBUTE_MATCHES[api].each do |struct_attribute, item_attribute|
+          value = self.send(item_attribute)
+          struct[struct_attribute] = value if value
+        end
+        struct
+      end #to_struct
+
+      def creation_date=(value)
+        case value
+        when String
+          @creation_date = Date.parse(value)
+        when Date
+          @creation_date = value
+        when nil
+          @creation_date = value
+        else
+          raise ArgumentError, "Date or String expected instead of #{value.class.name}"
+        end
+      end #creation_date=
+
+      protected
+
+      def apply_attributes(attributes)
+        attributes.each do |attribute, value|
+          accessor_name = "#{attribute}="
+          send(accessor_name, value) if respond_to?(accessor_name)
+        end
+      end
+    end
+
+    def self.included(host)
+      host.send :include, InstanceMethods
+
+      host.class_eval do
+        attr_accessor(
+                      :id,
+                      :title,
+                      :content,
+                      :excerpt,
+                      :images
+                      )
+        attr_reader(:creation_date)
+      end
+
+      host.extend ClassMethods
+    end #included
+
+  end
+end

data/lib/page.rb

@@ -0,0 +1,34 @@
+module Wordpress
+  class Page
+    include ContentItem
+
+    ATTRIBUTE_MATCHES = {
+      :metaWeblog => {
+      },
+      :wp => {
+        :page_id => :id,
+        :title => :title,
+        :page_title => :title,
+        :description => :content,
+        :mt_excerpt => :excerpt,
+        :dateCreated => :creation_date,
+        :page_parent_id => :parent_id,
+        :wp_page_parent_id => :parent_id
+      }
+    }
+
+    attr_accessor(:parent_id, :published)
+    attr_reader(:parent)
+
+    def parent=(page)
+      if page.nil?
+        @parent_id = @parent = nil
+      else
+        raise "Page expected instead of #{page}" unless page.kind_of? Wordpress::Page
+        @parent = page
+        @parent_id = page.id
+      end
+    end #parent=
+
+  end
+end

data/lib/post.rb

@@ -1,60 +1,31 @@
 module Wordpress
   class Post
+    include ContentItem
+
     ATTRIBUTE_MATCHES = {
-      :title => :title,
-      :content => :description,
-      :excerpt => :mt_excerpt,
-      :creation_date => :dateCreated,
-      :id => :postid
+      :metaWeblog => {
+        :postid         => :id,
+        :title          => :title,
+        :description    => :content,
+        :mt_excerpt     => :excerpt,
+        :dateCreated    => :creation_date,
+        :post_state     => :struct_published
+      },
+      :wp => {
+      }
     }
 
-    attr_accessor(
-                  :id,
-                  :title,
-                  :content,
-                  :excerpt,
-                  :creation_date,
-                  :published,
-                  :images
-                  )
-
-    def initialize(attributes = {})
-      self.images = []
-      attributes.each do |attribute, value|
-        accessor_name = "#{attribute}="
-        send(accessor_name, value) if respond_to?(accessor_name)
-      end
-    end #initialize
+    attr_accessor(:published)
 
-    def self.from_struct(struct)
-      post = Post.new
-      ATTRIBUTE_MATCHES.each do |post_attribute, struct_attribute|
-        post.send("#{post_attribute}=", struct[struct_attribute])
-      end
-      post.published = struct[:post_state] == "publish"
-      post
-    end #self.from_struct
+    def struct_published=(value)
+      @published = value if [true, false].include? value
+      @published = value == "publish" if value.kind_of? String
+    end
 
-    def to_struct
-      struct = {}
-      ATTRIBUTE_MATCHES.each do |post_attribute, struct_attribute|
-        value = self.send(post_attribute)
-        struct[struct_attribute] = value if value
-      end
-      struct
-    end #to_struct
+    def struct_published()
+      return "publish" if @published == true
+      return nil
+    end #struct_published
 
-    def creation_date=(value)
-      case value
-      when String
-        @creation_date = Date.parse(value)
-      when Date
-        @creation_date = value
-      when nil
-        @creation_date = value
-      else
-        raise ArgumentError, "Date or String expected instead of #{value.class.name}"
-      end
-    end #publish_date=
   end
 end

data/lib/wordpress-xmlrpc.rb

@@ -7,7 +7,9 @@ require 'loggable'
 
 require 'exceptions'
 require 'blog'
+require 'content_item'
 require 'post'
+require 'page'
 
 
 

data/spec/blog_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Wordpress::Blog do
+
   describe "initialize" do
     before(:each) do
       @valid_params = {
@@ -56,56 +57,166 @@ describe Wordpress::Blog do
                                    )
     end
 
-    describe "delete_post" do
-      it "should make appropriate call to xmlrpc api" do
-        @client_mock.should_receive(:call).with("blogger.deletePost", "", 123, "admin", "wordpress-xmlrpc", true).and_return(true)
+    describe "delete" do
+      context "when post passed as param" do
+        it "should make appropriate call to XMLRPC API" do
+          @client_mock.should_receive(:call).with("blogger.deletePost", "", 123, "admin", "wordpress-xmlrpc", true).and_return(true)
+
+          post = Wordpress::Post.new(:id => 123)
+          @blog.delete(post).should be_true
+        end
+      end
+
+      context "when page passed as param" do
+        it "should make appropriate call to XMLRPC API" do
+          @client_mock.should_receive(:call).with("wp.deletePage", 0, "admin", "wordpress-xmlrpc", 123).and_return(true)
+
+          page = Wordpress::Page.new(:id => 123)
+          @blog.delete(page).should be_true
+        end
+      end
+
+    end
+
+    describe "get_page_list" do
+      it "should return list of pages" do
+        page_structs = [
+                        {
+                          "page_id" => 1,
+                          "page_title" => "Page one",
+                          "page_parent_id" => 2,
+                          "dateCreated" => Date.parse("01.08.2010")
+                        },
+                        {
+                          "page_id" => 2,
+                          "page_title" => "Page two",
+                          "page_parent_id" => nil,
+                          "dateCreated" => Date.parse("01.08.2010")
+                        }
+                       ]
+        @client_mock.should_receive(:call).with("wp.getPageList", 0, "admin", "wordpress-xmlrpc").and_return(page_structs)
+
+        page_two = Wordpress::Page.new(
+                                       :id => 2,
+                                       :title => "Page two",
+                                       :creation_date => Date.parse("01.08.2010"),
+                                       :parent => nil
+                                       )
+        page_one = Wordpress::Page.new(
+                                       :id => 1,
+                                       :title => "Page one",
+                                       :creation_date => Date.parse("01.08.2010"),
+                                       :parent_id => 2
+                                       )
+        page_list = [page_one, page_two]
+
+        result_page_list = @blog.get_page_list
+        result_page_list.size.should == 2
+
+        result_page_list[0].id.should == 1
+        result_page_list[0].title.should == "Page one"
+        result_page_list[0].parent_id == 2
+        result_page_list[0].parent.should == result_page_list[1]
+        result_page_list[0].creation_date.should == Date.parse("01.08.2010")
+
+        result_page_list[1].id.should == 2
+        result_page_list[1].title.should == "Page two"
+        result_page_list[1].parent_id.should be_nil
+        result_page_list[1].creation_date.should == Date.parse("01.08.2010")
 
-        post = Wordpress::Post.new(:id => 123)
-        @blog.delete(post).should be_true
       end
     end
 
     describe "publish" do
-      it "should make appropriate call to xmlrpc api" do
-        images = [{:file_path => File.expand_path("./spec/support/files/post_picture.jpg")}]
-        post = Wordpress::Post.new(
-                                   :title => "Hey ho",
-                                   :content => "Content <img src=\"http://otherhost/post_picture.jpg?1231231123\">",
-                                   :excerpt => "Excerpt",
-                                   :images => images,
-                                   :publish_date => Date.parse("01.08.2010"))
-
-
-        required_post_struct = {
-          :title=>"Hey ho",
-          :description=>"Content <img src=\"http://localhost/post_picture.jpg\">",
-          :mt_excerpt=>"Excerpt"
-        }
+      context "when Page passed as param" do
+        it "should make appropriate calls to XMLRPC API" do
+          images = [{:file_path => File.expand_path("./spec/support/files/post_picture.jpg")}]
 
-        @client_mock.should_receive(:call).with(
-                                                "wp.uploadFile",
-                                                0, "admin", "wordpress-xmlrpc",
-                                                {
-                                                  :name => "post_picture.jpg",
-                                                  :type => "image/jpeg",
-                                                  :bits => "encoded file content",
-                                                  :overwrite => true
-                                                }).and_return({
-                                                               'file' => "post_picture.jpg",
-                                                               'url' => "http://localhost/post_picture.jpg",
-                                                               'type' => "image/jpeg"
-                                                             })
+          page = Wordpress::Page.new(
+                                     :title => "new Page",
+                                     :content => "Page content",
+                                     :excerpt => "Page excerpt",
+                                     :creation_date => Date.parse("01.08.2010"),
+                                     :images => images
+                                     )
+          @client_mock.should_receive(:call).with("wp.newPage",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  {
+                                                    :title => "new Page",
+                                                    :page_title => "new Page",
+                                                    :description => "Page content",
+                                                    :mt_excerpt => "Page excerpt",
+                                                    :dateCreated => Date.parse("01.08.2010")
+                                                  }, true).and_return(123)
 
-        @client_mock.should_receive(:call).with(
-                                                "metaWeblog.newPost",
-                                                0, "admin", "wordpress-xmlrpc",
-                                                required_post_struct, true).and_return("123")
+          file_struct = {
+            :name => "post_picture.jpg",
+            :type => "image/jpeg",
+            :bits => "encoded file content",
+            :overwrite => true
+          }
+          @client_mock.should_receive(:call).with(
+                                                  "wp.uploadFile",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  file_struct).and_return({
+                                                                  'file' => "post_picture.jpg",
+                                                                  'url' => "http://localhost/post_picture.jpg",
+                                                                  'type' => "image/jpeg"
+                                                                })
+
+          XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
 
-        XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
 
-        @blog.publish(post).should be_true
-        post.id.should == 123
-        post.published.should be_true
+          @blog.publish(page).should be_true
+          page.id.should == 123
+        end
+      end
+
+      context "when Post passed as param" do
+        it "should make appropriate call to XMLRPC API" do
+          images = [{:file_path => File.expand_path("./spec/support/files/post_picture.jpg")}]
+          post = Wordpress::Post.new(
+                                     :title => "Hey ho",
+                                     :content => "Content <img src=\"http://otherhost/post_picture.jpg?1231231123\">",
+                                     :excerpt => "Excerpt",
+                                     :images => images,
+                                     :creation_date => Date.parse("01.08.2010"))
+
+
+          required_post_struct = {
+            :title => "Hey ho",
+            :description => "Content <img src=\"http://localhost/post_picture.jpg\">",
+            :mt_excerpt => "Excerpt",
+            :dateCreated => Date.parse("01.08.2010")
+          }
+
+
+          file_struct = {
+            :name => "post_picture.jpg",
+            :type => "image/jpeg",
+            :bits => "encoded file content",
+            :overwrite => true
+          }
+          @client_mock.should_receive(:call).with(
+                                                  "wp.uploadFile",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  file_struct).and_return({
+                                                                  'file' => "post_picture.jpg",
+                                                                  'url' => "http://localhost/post_picture.jpg",
+                                                                  'type' => "image/jpeg"
+                                                                })
+
+          @client_mock.should_receive(:call).with(
+                                                  "metaWeblog.newPost",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  required_post_struct, true).and_return("123")
+
+          XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
+
+          @blog.publish(post).should be_true
+          post.id.should == 123
+          post.published.should be_true
+        end
       end
     end
 
@@ -113,11 +224,14 @@ describe Wordpress::Blog do
       it "should make appropriate call to xmlrpc api and return list of posts" do
         post_structs = (1..10).collect do |index|
           {
-            :title => "Post #{index}"
+            "title" => "Post #{index}"
           }
         end
 
-        @client_mock.should_receive(:call).with("metaWeblog.getRecentPosts", 0, "admin", "wordpress-xmlrpc", 10).and_return(post_structs)
+        @client_mock.should_receive(:call).with(
+                                                "metaWeblog.getRecentPosts",
+                                                0, "admin", "wordpress-xmlrpc",
+                                                10).and_return(post_structs)
 
         recent_posts = @blog.recent_posts(10)
         recent_posts.size.should == 10
@@ -137,38 +251,83 @@ describe Wordpress::Blog do
       end
     end
 
-    describe "update_post" do
-      it "should submit post update" do
-        images = [{:file_path => File.expand_path("./spec/support/files/post_picture.jpg")}]
-        post = Wordpress::Post.new(:id => 54, :title => "Updated post", :content => "Content <img src=\"http://otherhost/post_picture.jpg\">",  :published => true, :images => images)
+    describe "update" do
+      before(:each) do
+        @images = [{:file_path => File.expand_path("./spec/support/files/post_picture.jpg")}]
 
-        required_post_struct = {
-          :title=>"Updated post",
-          :description=>"Content <img src=\"http://localhost/post_picture.jpg\">",
-          :postid => 54
-        }
-        @client_mock.should_receive(:call).with("metaWeblog.editPost",
-                                                54, "admin", "wordpress-xmlrpc",
-                                                required_post_struct, true).and_return(true)
+      end
 
-        @client_mock.should_receive(:call).with("wp.uploadFile",
-                                                0, "admin", "wordpress-xmlrpc",
-                                                {
-                                                  :name => "post_picture.jpg",
-                                                  :type => "image/jpeg",
-                                                  :bits => "encoded file content",
-                                                  :overwrite => true
-                                                }).and_return({
-                                                               'file' => "post_picture.jpg",
-                                                               'url' => "http://localhost/post_picture.jpg",
-                                                               'type' => "image/jpeg"
-                                                             })
-        XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
-
-        @blog.update_post(post).should be_true
+      context "when page passed as param" do
+        it "should submit page update" do
+          page = Wordpress::Page.new(
+                                     :id => 123,
+                                     :title => "Updated page",
+                                     :content => "Content <img src=\"http://otherhost/post_picture.jpg\">",
+                                     :published => true,
+                                     :images => @images
+                                     )
+          required_page_struct = {
+            :title => "Updated page",
+            :page_title => "Updated page",
+            :description => "Content <img src=\"http://localhost/post_picture.jpg\">",
+            :page_id => 123
+          }
+          @client_mock.should_receive(:call).with("wp.editPage", 0, 123, "admin", "wordpress-xmlrpc", required_page_struct, true).and_return true
+          @client_mock.should_receive(:call).with("wp.uploadFile",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  {
+                                                    :name => "post_picture.jpg",
+                                                    :type => "image/jpeg",
+                                                    :bits => "encoded file content",
+                                                    :overwrite => true
+                                                  }).and_return({
+                                                                  'file' => "post_picture.jpg",
+                                                                  'url' => "http://localhost/post_picture.jpg",
+                                                                  'type' => "image/jpeg"
+                                                                })
+          XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
+
+          @blog.update(page).should be_true
+        end
       end
-    end
 
+      context "when post passed as param" do
+        it "should submit post update" do
+          post = Wordpress::Post.new(
+                                     :id => 54,
+                                     :title => "Updated post",
+                                     :content => "Content <img src=\"http://otherhost/post_picture.jpg\">",
+                                     :published => true,
+                                     :images => @images)
+
+          required_post_struct = {
+            :title => "Updated post",
+            :description => "Content <img src=\"http://localhost/post_picture.jpg\">",
+            :postid => 54,
+            :post_state => "publish"
+          }
+          @client_mock.should_receive(:call).with("metaWeblog.editPost",
+                                                  54, "admin", "wordpress-xmlrpc",
+                                                  required_post_struct, true).and_return(true)
+
+          @client_mock.should_receive(:call).with("wp.uploadFile",
+                                                  0, "admin", "wordpress-xmlrpc",
+                                                  {
+                                                    :name => "post_picture.jpg",
+                                                    :type => "image/jpeg",
+                                                    :bits => "encoded file content",
+                                                    :overwrite => true
+                                                  }).and_return({
+                                                                  'file' => "post_picture.jpg",
+                                                                  'url' => "http://localhost/post_picture.jpg",
+                                                                  'type' => "image/jpeg"
+                                                                })
+          XMLRPC::Base64.should_receive(:new).and_return("encoded file content")
+
+          @blog.update(post).should be_true
+        end
+      end
+      end
   end
 end
 

data/spec/page_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Wordpress::Page do
+  subject {Wordpress::Page}
+
+  it_should_behave_like "Blog item"
+
+  describe "matching attributes" do
+    it "should match attributes as defined in wp API" do
+      matches = Wordpress::Page::ATTRIBUTE_MATCHES[:wp]
+      matches[:page_id].should == :id
+      matches[:title].should == :title
+      matches[:page_title].should == :title
+      matches[:description].should == :content
+      matches[:mt_excerpt].should == :excerpt
+      matches[:dateCreated].should == :creation_date
+      matches[:page_parent_id].should == :parent_id
+      matches[:wp_page_parent_id].should == :parent_id
+    end
+
+    it "should not match for metaWeblog API at all" do
+      matches = Wordpress::Page::ATTRIBUTE_MATCHES[:metaWeblog]
+      matches.should be_empty
+    end
+  end
+
+  describe "parent=" do
+    it "should assign parent_id when parent page assigned" do
+      parent_page = Wordpress::Page.new(:title => "parent page", :id => 123)
+      child_page = Wordpress::Page.new(:title => "child page")
+      child_page.parent = parent_page
+      child_page.parent_id.should == 123
+    end
+  end
+
+end

data/spec/post_spec.rb

@@ -1,91 +1,24 @@
 require 'spec_helper'
 
 describe Wordpress::Post do
-  describe "initialize" do
-    it "should populate title from params" do
-      post = Wordpress::Post.new(:title => "Hey ho")
-      post.title.should == "Hey ho"
-    end
-    it "should populate content from params" do
-      post = Wordpress::Post.new(:content => "This is a content")
-      post.content.should == "This is a content"
-    end
-  end
-
-  describe "to_struct" do
-    it "should return struct hash reflecting all post params" do
-      post = Wordpress::Post.new(
-                                 :id => 99,
-                                 :title => "Post title",
-                                 :content => "Post content",
-                                 :excerpt => "Post excerpt",
-                                 :creation_date => Date.parse("01.08.2010")
-                                 )
-      post.to_struct.should == {
-        :postid => 99,
-        :title => "Post title",
-        :description => "Post content",
-        :mt_excerpt => "Post excerpt",
-        :dateCreated => Date.parse("01.08.2010")
-      }
-    end
-    it "should return incomplete struct for params without params that are nil" do
-      post = Wordpress::Post.new(:title => "Post title")
-      post.to_struct.should == {
-        :title => "Post title"
-      }
-    end
-  end
-
-  describe "from_struct" do
-    it "should create post from RPC struct" do
-      post = Wordpress::Post.from_struct({
-                                           :postid => 99,
-                                           :title => "Post title",
-                                           :description => "Post content",
-                                           :mt_excerpt => "Post excerpt",
-                                           :dateCreated => "01.08.2010",
-                                           :post_state => "publish"
-                                         })
-      post.id.should == 99
-      post.title.should == "Post title"
-      post.content.should == "Post content"
-      post.excerpt.should == "Post excerpt"
-      post.creation_date.should == Date.parse("01.08.2010")
-      post.published.should be_true
-    end
-  end
+  subject {Wordpress::Post}
 
-  describe "creation_date=" do
-    before(:each) do
-      @post = Wordpress::Post.new
-    end
+  it_should_behave_like "Blog item"
 
-    it "should convert string to date" do
-      @post.creation_date = "01.08.2010"
-      @post.creation_date.should == Date.parse("01.08.2010")
+  describe "matching attributes" do
+    it "should match attributes as defined in metaWeblog API" do
+      matches = Wordpress::Post::ATTRIBUTE_MATCHES[:metaWeblog]
+      matches[:postid].should == :id
+      matches[:title].should == :title
+      matches[:description].should == :content
+      matches[:mt_excerpt].should == :excerpt
+      matches[:post_state].should == :struct_published
     end
-
-    it "should assign date as is if kind_of? Date provided" do
-      date = Date.parse("01.08.2010")
-      @post.creation_date = date
-      @post.creation_date.should == date
-    end
-
-    it "should raise error if string could not be parsed to date" do
-      lambda{
-        @post.creation_date = "abracadabra"
-      }.should raise_error ArgumentError, "invalid date"
-    end
-
-    it "should raise exception if object is not a string and not a date" do
-      lambda{
-        @post.creation_date = Integer(10)
-      }.should raise_error ArgumentError, "Date or String expected instead of Fixnum"
+    it "should not match for wp API at all" do
+      matches = Wordpress::Post::ATTRIBUTE_MATCHES[:wp]
+      matches.should be_empty
     end
   end
 
-
-
 end
 

data/spec/spec.opts

@@ -1 +1,2 @@
 --color
+--format specdoc

data/spec/spec_helper.rb

@@ -13,6 +13,10 @@ require 'spec/autorun'
 
 require 'wordpress-xmlrpc'
 
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
 Spec::Runner.configure do |config|
 
 end

data/spec/support/models/blog_item_shared.rb

@@ -0,0 +1,86 @@
+shared_examples_for "Blog item" do
+  before(:each) do
+    @api_standard = subject == Wordpress::Post ? :metaWeblog : :wp
+  end
+
+
+
+  describe "initialize" do
+    it "should populate title from params" do
+      item = subject.new(:title => "Hey ho")
+      item.title.should == "Hey ho"
+    end
+    it "should populate content from params" do
+      item = subject.new(:content => "This is a content")
+      item.content.should == "This is a content"
+    end
+  end
+
+  describe "to_struct" do
+    it "should return struct hash reflecting matching item params" do
+      item = subject.new(
+                         :content => "item content",
+                         :excerpt => "item excerpt",
+                         :creation_date => Date.parse("01.08.2010")
+                         )
+      item.to_struct(@api_standard).should == {
+        :description => "item content",
+        :mt_excerpt => "item excerpt",
+        :dateCreated => Date.parse("01.08.2010")
+      }
+    end
+
+    it "should return incomplete struct for params without params that are nil" do
+      item = subject.new(:content => "item content")
+      item.to_struct(@api_standard).should == {
+        :description => "item content"
+      }
+    end
+  end
+
+  describe "from_struct" do
+    it "should create item from RPC struct" do
+      item = subject.from_struct(@api_standard,
+                                 {
+                                   "description" => "item content",
+                                   "mt_excerpt" => "item excerpt",
+                                   "dateCreated" => "01.08.2010"
+                                 })
+      item.content.should == "item content"
+      item.excerpt.should == "item excerpt"
+      item.creation_date.should == Date.parse("01.08.2010")
+    end
+  end
+
+  describe "creation_date=" do
+    before(:each) do
+      @item = subject.new
+    end
+
+    it "should convert string to date" do
+      @item.creation_date = "01.08.2010"
+      @item.creation_date.should == Date.parse("01.08.2010")
+    end
+
+    it "should assign date as is if kind_of? Date provided" do
+      date = Date.parse("01.08.2010")
+      @item.creation_date = date
+      @item.creation_date.should == date
+    end
+
+    it "should raise error if string could not be parsed to date" do
+      lambda{
+        @item.creation_date = "abracadabra"
+      }.should raise_error ArgumentError, "invalid date"
+    end
+
+    it "should raise exception if object is not a string and not a date" do
+      lambda{
+        @item.creation_date = Integer(10)
+      }.should raise_error ArgumentError, "Date or String expected instead of Fixnum"
+    end
+  end
+
+
+
+end

data/wordpress-xmlrpc.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{wordpress-xmlrpc}
-  s.version = "0.0.9"
+  s.version = "0.0.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alexander Naumenko"]
-  s.date = %q{2010-09-20}
+  s.date = %q{2010-10-05}
   s.description = %q{Please do not fork it before directly contacint}
   s.email = %q{alecnmk@gmail.com}
   s.extra_rdoc_files = [
@@ -29,16 +29,20 @@ Gem::Specification.new do |s|
      "features/step_definitions/mysql_steps.rb",
      "features/support/env.rb",
      "lib/blog.rb",
+     "lib/content_item.rb",
      "lib/exceptions.rb",
      "lib/loggable.rb",
+     "lib/page.rb",
      "lib/params_check.rb",
      "lib/post.rb",
      "lib/wordpress-xmlrpc.rb",
      "spec/blog_spec.rb",
+     "spec/page_spec.rb",
      "spec/post_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/support/files/post_picture.jpg",
+     "spec/support/models/blog_item_shared.rb",
      "wordpress-xmlrpc.gemspec"
   ]
   s.homepage = %q{http://github.com/alecnmk/wordpress-xmlrpc}
@@ -47,8 +51,10 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{This gem is supposed to simplify wordpress xmlrpc interaction}
   s.test_files = [
-    "spec/spec_helper.rb",
+    "spec/page_spec.rb",
+     "spec/spec_helper.rb",
      "spec/blog_spec.rb",
+     "spec/support/models/blog_item_shared.rb",
      "spec/post_spec.rb"
   ]
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wordpress-xmlrpc
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 0
   - 0
-  - 9
-  version: 0.0.9
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - Alexander Naumenko
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-20 00:00:00 +03:00
+date: 2010-10-05 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,16 +105,20 @@ files:
 - features/step_definitions/mysql_steps.rb
 - features/support/env.rb
 - lib/blog.rb
+- lib/content_item.rb
 - lib/exceptions.rb
 - lib/loggable.rb
+- lib/page.rb
 - lib/params_check.rb
 - lib/post.rb
 - lib/wordpress-xmlrpc.rb
 - spec/blog_spec.rb
+- spec/page_spec.rb
 - spec/post_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/support/files/post_picture.jpg
+- spec/support/models/blog_item_shared.rb
 - wordpress-xmlrpc.gemspec
 has_rdoc: true
 homepage: http://github.com/alecnmk/wordpress-xmlrpc
@@ -151,6 +155,8 @@ signing_key:
 specification_version: 3
 summary: This gem is supposed to simplify wordpress xmlrpc interaction
 test_files: 
+- spec/page_spec.rb
 - spec/spec_helper.rb
 - spec/blog_spec.rb
+- spec/support/models/blog_item_shared.rb
 - spec/post_spec.rb