wordpress_client 0.0.1

data/lib/wordpress_client/errors.rb

@@ -0,0 +1,10 @@
+module WordpressClient
+  Error = Class.new(::StandardError)
+
+  UnauthorizedError = Class.new(Error)
+
+  TimeoutError = Class.new(Error)
+  ServerError = Class.new(Error)
+  NotFoundError = Class.new(Error)
+  ValidationError = Class.new(Error)
+end

data/lib/wordpress_client/media.rb

@@ -0,0 +1,37 @@
+module WordpressClient
+  class Media
+    attr_accessor(
+      :id, :slug, :title_html, :description,
+      :date, :updated_at,
+      :guid, :link, :media_details
+    )
+
+    def self.parse(data)
+      MediaParser.parse(data)
+    end
+
+    def initialize(
+      id: nil,
+      slug: nil,
+      title_html: nil,
+      description: nil,
+      date: nil,
+      updated_at: nil,
+      guid: nil,
+      link: nil,
+      media_details: {}
+    )
+      @id = id
+      @slug = slug
+      @title_html = title_html
+      @date = date
+      @updated_at = updated_at
+      @description = description
+      @guid = guid
+      @link = link
+      @media_details = media_details
+    end
+
+    alias source_url guid
+  end
+end

data/lib/wordpress_client/media_parser.rb

@@ -0,0 +1,48 @@
+module WordpressClient
+  class MediaParser
+    include RestParser
+
+    def self.parse(data)
+      new(data).to_media
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def to_media
+      media = Media.new
+
+      assign_basic(media)
+      assign_dates(media)
+      assign_rendered(media)
+      assign_guid(media)
+
+      media
+    end
+
+    private
+    attr_reader :data
+
+    def assign_basic(media)
+      media.id = data.fetch("id")
+      media.slug = data.fetch("slug")
+      media.link = data.fetch("link")
+      media.description = data["description"]
+      media.media_details = data["media_details"]
+    end
+
+    def assign_dates(media)
+      media.date = read_date("date")
+      media.updated_at = read_date("modified")
+    end
+
+    def assign_rendered(media)
+      media.title_html = rendered("title")
+    end
+
+    def assign_guid(media)
+      media.guid = rendered("guid") || data["source_url"]
+    end
+  end
+end

data/lib/wordpress_client/paginated_collection.rb

@@ -0,0 +1,53 @@
+require "delegate"
+
+module WordpressClient
+  class PaginatedCollection < DelegateClass(Array)
+    attr_reader :total, :current_page, :per_page
+
+    def initialize(entries, total:, current_page:, per_page:)
+      super(entries)
+      @total = total
+      @current_page = current_page
+      @per_page = per_page
+    end
+
+    #
+    # Pagination methods. Fulfilling will_paginate protocol
+    #
+
+    alias total_entries total
+
+    def total_pages
+      if total.zero? || per_page.zero?
+        0
+      else
+        (total / per_page.to_f).ceil
+      end
+    end
+
+    def next_page
+      if current_page < total_pages
+        current_page + 1
+      end
+    end
+
+    def previous_page
+      if current_page > 1
+        current_page - 1
+      end
+    end
+
+    def out_of_bounds?
+      current_page < 1 || current_page > total_pages
+    end
+
+    # will_paginate < 3.0 has this method
+    def offset
+      if current_page > 0
+        (current_page - 1) * per_page
+      else
+        0
+      end
+    end
+  end
+end

data/lib/wordpress_client/post.rb

@@ -0,0 +1,62 @@
+require "time"
+
+module WordpressClient
+  class Post
+    attr_accessor(
+      :id, :slug, :url, :guid, :status,
+      :title_html, :excerpt_html, :content_html,
+      :updated_at, :date,
+      :categories, :tags, :meta, :featured_image
+    )
+
+    def self.parse(data)
+      PostParser.parse(data)
+    end
+
+    def initialize(
+      id: nil,
+      slug: nil,
+      url: nil,
+      guid: nil,
+      status: "unknown",
+      title_html: nil,
+      excerpt_html: nil,
+      content_html: nil,
+      updated_at: nil,
+      date: nil,
+      categories: [],
+      tags: [],
+      featured_image: nil,
+      meta: {},
+      meta_ids: {}
+    )
+      @id = id
+      @slug = slug
+      @url = url
+      @guid = guid
+      @status = status
+      @title_html = title_html
+      @excerpt_html = excerpt_html
+      @content_html = content_html
+      @updated_at = updated_at
+      @date = date
+      @categories = categories
+      @tags = tags
+      @featured_image = featured_image
+      @meta = meta
+      @meta_ids = meta_ids
+    end
+
+    def category_ids() categories.map(&:id) end
+
+    def tag_ids() tags.map(&:id) end
+
+    def featured_image_id
+      featured_image && featured_image.id
+    end
+
+    def meta_id_for(key)
+      @meta_ids[key] || raise(ArgumentError, "Post does not have meta #{key.inspect}")
+    end
+  end
+end

data/lib/wordpress_client/post_parser.rb

@@ -0,0 +1,113 @@
+module WordpressClient
+  class PostParser
+    include RestParser
+
+    def self.parse(data)
+      new(data).to_post
+    end
+
+    def initialize(data)
+      @data = data
+      @embedded = data.fetch("_embedded", {})
+    end
+
+    def to_post
+      meta, meta_ids = parse_metadata
+      post = Post.new(meta: meta, meta_ids: meta_ids)
+
+      assign_basic(post)
+      assign_dates(post)
+      assign_rendered(post)
+      assign_categories(post)
+      assign_tags(post)
+      assign_featured_image(post)
+
+      post
+    end
+
+    private
+    attr_reader :data, :embedded
+
+    def assign_basic(post)
+      post.id = data["id"]
+      post.slug = data["slug"]
+      post.url = data["link"]
+      post.status = data["status"]
+    end
+
+    def assign_dates(post)
+      post.updated_at = read_date("modified")
+      post.date = read_date("date")
+    end
+
+    def assign_rendered(post)
+      post.guid = rendered("guid")
+      post.title_html = rendered("title")
+      post.excerpt_html = rendered("excerpt")
+      post.content_html = rendered("content")
+    end
+
+    def assign_categories(post)
+      post.categories = embedded_terms("category").map do |category|
+        Category.parse(category)
+      end
+    end
+
+    def assign_tags(post)
+      post.tags = embedded_terms("post_tag").map do |tag|
+        Tag.parse(tag)
+      end
+    end
+
+    def assign_featured_image(post)
+      featured_id = data["featured_image"]
+      if featured_id
+        features = (embedded["https://api.w.org/featuredmedia"] || []).flatten
+        media = features.detect { |feature| feature["id"] == featured_id }
+        if media
+          post.featured_image = Media.parse(media)
+        end
+      end
+    end
+
+    def parse_metadata
+      embedded_metadata = (embedded["https://api.w.org/meta"] || []).flatten
+      validate_embedded_metadata(embedded_metadata)
+
+      meta = {}
+      meta_ids = {}
+
+      embedded_metadata.each do |entry|
+        meta[entry.fetch("key")] = entry.fetch("value")
+        meta_ids[entry.fetch("key")] = entry.fetch("id")
+      end
+
+      [meta, meta_ids]
+    end
+
+    def embedded_terms(type)
+      term_collections = embedded["https://api.w.org/term"] || []
+
+      # term_collections is an array of arrays with terms in them. We can see
+      # the type of the "collection" by inspecting the first child's taxonomy.
+      term_collections.detect { |terms|
+        terms.size > 0 && terms.is_a?(Array) && terms.first["taxonomy"] == type
+      } || []
+    end
+
+    def validate_embedded_metadata(embedded_metadata)
+      if embedded_metadata.size == 1 && embedded_metadata.first["code"]
+        error = embedded_metadata.first
+        case error["code"]
+        when "rest_forbidden"
+          raise UnauthorizedError, error.fetch(
+            "message", "You are not authorized to see meta for this post."
+          )
+        else
+          raise Error, "Could not retreive meta for this post: " \
+            "#{error["code"]} – #{error["message"]}"
+        end
+      end
+    end
+  end
+end

data/lib/wordpress_client/replace_metadata.rb

@@ -0,0 +1,81 @@
+require "set"
+
+module WordpressClient
+  class ReplaceMetadata
+    def self.apply(connection, post, meta)
+      instance = new(connection, post, meta)
+      instance.apply
+      instance.number_of_changes
+    end
+
+    attr_reader :number_of_changes
+
+    def initialize(connection, post, meta)
+      @connection = connection
+      @post = post
+      @existing_meta = post.meta
+      @new_meta = stringify_keys(meta)
+      @number_of_changes = 0
+    end
+
+    def apply
+      all_keys.each do |key|
+        action = determine_action(key)
+        send(action, key, new_meta[key])
+      end
+    end
+
+    private
+    attr_reader :connection, :post, :new_meta, :existing_meta
+
+    def meta_id(key)
+      post.meta_id_for(key)
+    end
+
+    def all_keys
+      (new_meta.keys + existing_meta.keys).to_set
+    end
+
+    def determine_action(key)
+      old_value = existing_meta[key]
+      new_value = new_meta[key]
+
+      if old_value.nil? && !new_value.nil?
+        :add
+      elsif old_value == new_value
+        :keep
+      elsif new_value.nil?
+        :remove
+      else
+        :replace
+      end
+    end
+
+    def add(key, value)
+      connection.create_without_response("posts/#{post.id}/meta", key: key, value: value)
+      @number_of_changes += 1
+    end
+
+    def remove(key, *)
+      connection.delete("posts/#{post.id}/meta/#{meta_id(key)}", force: true)
+      @number_of_changes += 1
+    end
+
+    def replace(key, value)
+      connection.patch_without_response(
+        "posts/#{post.id}/meta/#{meta_id(key)}", key: key, value: value
+      )
+      @number_of_changes += 1
+    end
+
+    def keep(*)
+      # Do nothing. This method is here to satisfy every action of #determine_action.
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) do |(key, value), new_hash|
+        new_hash[key.to_s] = value
+      end
+    end
+  end
+end

data/lib/wordpress_client/replace_terms.rb

@@ -0,0 +1,62 @@
+require "set"
+
+module WordpressClient
+  class ReplaceTerms
+    def self.apply_categories(connection, post, category_ids)
+      instance = new(
+        connection,
+        post.id,
+        post.category_ids,
+        category_ids
+      )
+      instance.replace("category")
+      instance.number_of_changes
+    end
+
+    def self.apply_tags(connection, post, tag_ids)
+      instance = new(
+        connection,
+        post.id,
+        post.tag_ids,
+        tag_ids
+      )
+      instance.replace("tag")
+      instance.number_of_changes
+    end
+
+    def initialize(connection, post_id, existing_ids, new_ids)
+      @connection = connection
+      @post_id = post_id
+      @existing_ids = existing_ids.to_set
+      @wanted_ids = new_ids.to_set
+    end
+
+    def replace(type)
+      ids_to_add.each { |id| add_term_id(id, type) }
+      ids_to_remove.each { |id| remove_term_id(id, type) }
+    end
+
+    def number_of_changes
+      ids_to_add.size + ids_to_remove.size
+    end
+
+    private
+    attr_reader :connection, :post_id, :wanted_ids, :existing_ids
+
+    def ids_to_add
+      wanted_ids - existing_ids
+    end
+
+    def ids_to_remove
+      existing_ids - wanted_ids
+    end
+
+    def add_term_id(id, type)
+      connection.create_without_response("posts/#{post_id}/terms/#{type}/#{id}", {})
+    end
+
+    def remove_term_id(id, type)
+      connection.delete("posts/#{post_id}/terms/#{type}/#{id}", force: true)
+    end
+  end
+end