wordpress-client 0.0.6 → 0.1.0

data/lib/wordpress/object/base.rb

@@ -0,0 +1,94 @@
+require 'wordpress/base'
+require 'wordpress/request'
+require 'wordpress/ostruct'
+require 'date'
+
+module Wordpress::Object
+  class Base < Wordpress::Base
+    attr_reader :client, :request
+
+    class << self
+      def options
+        @options ||= {}
+      end
+
+      private
+
+      def attr_parameter(*args)
+        opt = args[-1].is_a?(Hash) ? args.pop : {}
+        args.each do |arg|
+          options[arg.to_s] = opt.dup
+        end
+      end
+    end
+
+    def initialize(client = Wordpress.client, response = {})
+      @client = client
+      assign(response)
+    end
+
+    def assign(response)
+      @response = Hash[response.map{ |k, v| [k.to_s.downcase, v] }]
+      self
+    end
+
+    def [](name)
+      name = name.to_s
+      get_object(name) if available_object?(name)
+    end
+
+    def to_hash
+      @response.dup
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      name = method_name.to_s
+      is_setter = name.to_s[-1] == '=' ? !!name.pop : false
+      (is_setter && available_object?(name[0..-1])) || available_object?(name) || super
+    end
+
+    private
+
+    def method_missing(method_name, *arguments, &block)
+      name = method_name.to_s
+      is_setter = name.to_s[-1] == '='
+      if is_setter
+        return set_object(name[0...-1], *arguments) if available_object?(name[0...-1])
+      else
+        return get_object(name) if available_object?(name)
+      end
+      super(method_name, *arguments, &block)
+    end
+
+    def available_object?(name)
+      name = name.to_s
+      options.include?(name)
+    end
+
+    def get_object(name)
+      name = name.to_s
+      v = @response[name]
+      if options && options[name] && (as = options[name][:as])
+        if as.is_a?(Proc)
+          as.call(client, v)
+        elsif as.is_a?(String)
+          Wordpress::Object.const_get(as).new(client, v)
+        else
+          as.new(v)
+        end
+      elsif v.is_a?(Hash)
+        Wordpress::OpenStruct.new(v)
+      else
+        v
+      end
+    end
+
+    def set_object(name, v)
+      @response[name] = v
+    end
+
+    def options
+      self.class.options.freeze
+    end
+  end
+end

data/lib/wordpress/object/comment.rb

@@ -0,0 +1,11 @@
+require_relative 'meta_object'
+
+module Wordpress::Object
+  class Comment < MetaObject
+    attr_parameter :id, :url, :short_url, :content, :status, :parent, :string
+    attr_parameter :date, :as => lambda { |c, v| DateTime.iso8601(v) }
+    attr_parameter :post, :as => 'Post'
+    attr_parameter :author, :as => 'User'
+    attr_meta_object :site => 'Site', :post => 'Post', :replies => 'Comments'
+  end
+end

data/lib/wordpress/object/comments.rb

@@ -0,0 +1,8 @@
+require_relative 'base'
+
+module Wordpress::Object
+  class Comments < Array
+    attr_parameter :found
+    attr_array :comments, 'Comment'
+  end
+end

data/lib/wordpress/object/meta_object.rb

@@ -0,0 +1,62 @@
+require_relative 'base'
+
+module Wordpress::Object
+  class MetaObject < Base
+    class_attribute :meta_objects
+
+    class << self
+      def inherited(base)
+        base.class_eval do
+          attr_parameter :meta
+        end
+      end
+
+      def attr_meta_object(params)
+        self.meta_objects = (meta_objects || {}).merge(Hash[params.map{ |k, v| [k.to_s, v] }])
+      end
+    end
+
+    def assign(response)
+      @cached_objects = {}
+      super
+    end
+
+    def reload
+      if meta && meta.links && meta.links.self
+        request = Wordpress::Request.new(:get, meta.links.self)
+        client.object_from_response(self, request)
+      end
+    end
+
+    def save
+      raise NotImplementedError
+    end
+
+    def delete
+      raise NotImplementedError
+    end
+
+    private
+
+    def associated_object?(name)
+      name = name.to_s
+      @response['meta'] && @response['meta']['links'] && @response['meta']['links'].include?(name) && meta_objects.include?(name)
+    end
+
+    def available_object?(name)
+      associated_object?(name) || super
+    end
+
+    def get_object(name)
+      name = name.to_s
+      if associated_object?(name)
+        @cached_objects[name] ||= begin
+          request = Wordpress::Request.new(:get, meta.links.send(name))
+          client.object_from_response(Wordpress::Object.const_get(meta_objects[name]).new(client), request)
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/wordpress/{post.rb → object/post.rb}

@@ -1,12 +1,10 @@
-require 'wordpress/object'
-require 'wordpress/user'
-require 'wordpress/ostruct'
+require_relative 'meta_object'
 
-module Wordpress
-  class Post < Wordpress::Object
+module Wordpress::Object
+  class Post < MetaObject
     attr_parameter :id, :modified, :title, :url, :short_url, :content, :excerpt, :slug, :status, :password, :parent, :type, :comments_open, :pings_open, :comment_count, :like_count, :i_like, :is_reblogged, :is_following, :featured_image, :format, :geo, :publicize_urls, :tags, :categories, :attachments, :metadata
-    attr_parameter :date, :as => lambda { |t| DateTime.iso8601(t) }
-    attr_parameter :author, :as => Wordpress::User
-    attr_parameter :meta, :as => Wordpress::OpenStruct
+    attr_parameter :date, :as => lambda { |c, v| DateTime.iso8601(v) }
+    attr_parameter :author, :as => 'User'
+    attr_meta_object :site => 'Site', :replies => 'Comments'
   end
 end

data/lib/wordpress/object/posts.rb

@@ -0,0 +1,8 @@
+require_relative 'array'
+
+module Wordpress::Object
+  class Posts < Array
+    attr_parameter :found
+    attr_array :posts, 'Post'
+  end
+end

data/lib/wordpress/object/site.rb

@@ -0,0 +1,8 @@
+require_relative 'meta_object'
+
+module Wordpress::Object
+  class Site < MetaObject
+    attr_parameter :id, :name, :description, :url, :jetpack, :post_count, :lang
+    attr_meta_object :posts => 'Posts', :comments => 'Comments'
+  end
+end

data/lib/wordpress/{test.rb → object/test.rb}

@@ -1,7 +1,7 @@
-require 'wordpress/object'
+require_relative 'base'
 
-module Wordpress
-  class Test < Wordpress::Object
+module Wordpress::Object
+  class Test < Base
     attr_parameter :method_id_matches_query_id, :method_id, :id, :default_string, :default_int, :boolean_whitelist_defaults_to_false, :boolean_whitelist_defaults_to_true, :string_whitelist_defaults_to_foo, :url, :datetime
   end
 end

data/lib/wordpress/object/user.rb

@@ -0,0 +1,8 @@
+require_relative 'meta_object'
+
+module Wordpress::Object
+  class User < MetaObject
+    attr_parameter :id, :display_name, :username, :email, :primary_blog, :avatar_url, :profile_url, :verified
+    attr_meta_object :site => 'Site'
+  end
+end

data/lib/wordpress/ostruct.rb

@@ -1,62 +1,54 @@
 require 'wordpress/base'
 
 module Wordpress
-  class OpenStruct < Wordpress::Base
+  class OpenStruct < Base
     def_delegators :@hash, :map, :each
 
-    def initialize(hash = {})
-      @hash = Hash[hash.map do |key, value|
-        key = key.to_s
-        unless respond_to?(key)
-          metaclass.send(:define_method, key, Proc.new do
-            v = @hash[key]
-            @hash[key] = (v.is_a?(Hash) ? Wordpress::OpenStruct.new(v) : v)
-          end)
-        end
-        unless respond_to?("#{key}=")
-          metaclass.send(:define_method, "#{key}=", Proc.new do |v|
-            @hash[key] = (v.is_a?(Hash) ? Wordpress::OpenStruct.new(v) : v)
-            @hash[key]
-          end)
-        end
-        [key, (value.is_a?(Hash) ? Wordpress::OpenStruct.new(value) : value)]
-      end]
-    end
-
-=begin
+    def initialize(hash)
+      assign(hash)
+    end
+
+    def assign(hash)
+      @hash = Hash[hash.map{ |k, v| [k.to_s, v] }]
+    end
+
     def respond_to_missing?(method_name, include_private = false)
-      method_name = method_name.to_s
-      @hash.include?(method_name) || super
+      key = method_name.to_s
+      @hash.include?(key) || super
     end
-=end
+
     def to_s
       "#<#{self.class.name} #{map { |k, v| "#{k}=#{v}" }.join(" ")}>"
     end
 
     def [](k)
-      send(k)
+      send(k.to_s)
     end
 
     def []=(k, v)
       send("#{k}=", v)
     end
 
+    def to_hash
+      @hash
+    end
+
     private
-=begin
+
     def method_missing(method_name, *args, &block)
       key = method_name.to_s
-      if key[-1] == '='
-        key = key[0..-2]
-        if @hash.include?(key)
-          v = args[0]
-          return @hash[key] = (v.is_a?(Hash) ? Wordpress::OpenStruct.new(v) : v)
-        end
-      else
-        v = @hash[key]
-        return @hash[key] = (v.is_a?(Hash) ? Wordpress::OpenStruct.new(v) : v)
+      key = key[-1] == '=' ? key[0...-1] : key
+      if @hash.include?(key)
+        metaclass.send(:define_method, key, Proc.new{
+          v = @hash[key]
+          v.is_a?(Hash) ? Wordpress::OpenStruct.new(v) : v
+        })
+        metaclass.send(:define_method, "#{key}=", Proc.new{ |v|
+          @hash[key] = v
+        })
+        return send(method_name, *args, &block)
       end
       super
     end
-=end
   end
 end

data/lib/wordpress/request.rb

@@ -0,0 +1,24 @@
+require 'uri'
+
+module Wordpress
+  class Request < Base
+    END_POINT = "https://public-api.wordpress.com/"
+    attr_accessor :method, :url, :params, :body
+
+    def initialize(method, url, params = {}, body = {})
+      @method = method
+      @url = URI.join(end_point, url).to_s
+      @params = params.dup
+      @body = body.dup
+    end
+
+    def initialize_copy(other)
+      other.params = params.dup
+      other.body = body.dup
+    end
+
+    def end_point
+      END_POINT.freeze
+    end
+  end
+end

data/lib/wordpress/version.rb

@@ -1,8 +1,8 @@
 module Wordpress
   class Version
     MAJOR = 0 unless defined? Wordpress::Version::MAJOR
-    MINOR = 0 unless defined? Wordpress::Version::MINOR
-    PATCH = 6 unless defined? Wordpress::Version::PATCH
+    MINOR = 1 unless defined? Wordpress::Version::MINOR
+    PATCH = 0 unless defined? Wordpress::Version::PATCH
     PRE = nil unless defined? Wordpress::Version::PRE
 
     class << self

data/spec/spec_helper.rb

@@ -1,9 +1,22 @@
 require 'rubygems'
 require 'bundler/setup'
 
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter do |src|
+      src.filename !~ /#{File.join(root, 'lib')}\//
+    end
+  end
+end
+
 require 'wordpress-client'
 
 RSpec.configure do |config|
+  config.mock_with :rspec
 
+  config.before :each do
+    Wordpress.logger = Logger.new("/dev/null") 
+  end
 end
 

data/spec/wordpress-client_spec.rb

@@ -1,7 +1,25 @@
 require "spec_helper"
 
 describe Wordpress do
-  it "should return client instance" do
-    Wordpress.client.should be_an_instance_of(Wordpress::Client)
+  describe "client" do
+    it "should return client instance" do
+      Wordpress.client.should be_an_instance_of(Wordpress::Client)
+    end
+
+    it "should return the same instance" do
+      client = Wordpress.client
+      Wordpress.client.should === client
+    end
+  end
+
+  describe "logger" do
+    it "should have default logger" do
+      Wordpress.logger.should be_an(Logger)
+    end
+
+    it "should have accessor" do
+      Wordpress.logger = 'logger'
+      Wordpress.logger.should == 'logger'
+    end
   end
 end

data/spec/wordpress/base_spec.rb

@@ -2,19 +2,62 @@ require "spec_helper"
 require "wordpress/base"
 
 describe Wordpress::Base do
-  it 'should overwrite attr_accessor class method' do
-    klass = Class.new(Wordpress::Base)
+  describe "attr_accessor class method" do
+    it 'should overwrite attr_accessor class method' do
+      klass = Class.new(Wordpress::Base)
+    end
+
+    it 'should return default value' do
+      klass = Class.new(Wordpress::Base) do
+        attr_accessor :key => :default_value
+      end
+      ins = klass.new
+      ins.key.should == :default_value
+      ins.key = :new_value
+      ins.key.should == :new_value
+      ins.key = nil
+      ins.key.should be_nil
+    end
   end
 
-  it 'should return default value' do
-    klass = Class.new(Wordpress::Base) do
-      attr_accessor :key => :default_value
+  describe "logger instance" do
+    let :instance do
+      Wordpress::Base.new
+    end
+
+    it "should have logger accessor" do
+      instance.should respond_to(:logger)
+    end
+
+    it "should have logger method accessor" do
+      instance.should respond_to(:debug)
+      instance.should respond_to(:info)
+      instance.should respond_to(:warn)
+      instance.should respond_to(:error)
+      instance.should respond_to(:fatal)
+    end
+  end
+
+  describe "class_attribute" do
+
+    it "should define class attribute" do
+      klass1 = Class.new(Wordpress::Base) do
+        class_attribute :boo
+      end
+      klass1.boo = 1
+      klass2 = Class.new(klass1)
+      klass2.boo = 2
+      klass1.boo.should == 1
+      klass2.boo.should == 2
+    end
+
+    it "should define reader instance method to get the class attribute" do
+      klass1 = Class.new(Wordpress::Base) do
+        class_attribute :boo
+      end
+      klass1.boo = 1
+      klass1.boo.should == 1
+      klass1.new.boo.should == 1
     end
-    ins = klass.new
-    ins.key.should == :default_value
-    ins.key = :new_value
-    ins.key.should == :new_value
-    ins.key = nil
-    ins.key.should be_nil
   end
 end