ruby-wpdb 1.0.beta1

data/lib/ruby-wpdb/comments.rb

@@ -0,0 +1,32 @@
+Sequel.inflections do |inflect|
+  # Unless we tell Sequel otherwise, it will try to inflect the singular
+  # of "commentmeta" using the "data" -> "datum" rule, leaving us with the
+  # bizarre "commentmetum".
+  inflect.uncountable 'commentmeta'
+end
+
+module WPDB
+  class Comment < Sequel::Model(:"#{WPDB.prefix}comments")
+    plugin :validation_helpers
+
+    many_to_one :post, :key => :comment_post_ID, :class => :'WPDB::Post'
+    one_to_many :commentmeta, :class => :'WPDB::CommentMeta'
+
+    def validate
+      super
+      validates_presence [:comment_author, :comment_author_email, :comment_date, :comment_date_gmt, :comment_parent, :comment_approved]
+    end
+
+    def before_validation
+      self.comment_date     ||= Time.now
+      self.comment_date_gmt ||= Time.now.utc
+      self.comment_parent   ||= 0
+      self.comment_approved ||= 1
+      super
+    end
+  end
+
+  class CommentMeta < Sequel::Model(:"#{WPDB.prefix}commentmeta")
+    many_to_one :comment, :class => :'WPDB::Comment'
+  end
+end

data/lib/ruby-wpdb/gravityforms.rb

@@ -0,0 +1,208 @@
+require 'php_serialize'
+require 'csv'
+
+module WPDB
+  module GravityForms
+    class Form < Sequel::Model(:"#{WPDB.prefix}rg_form")
+      one_to_many :leads, :class => :'WPDB::GravityForms::Lead'
+
+      one_to_one :meta, :class => :'WPDB::GravityForms::FormMeta'
+
+      def fields
+        display_meta = PHP.unserialize(meta.display_meta)
+        display_meta['fields']
+      end
+
+      def field_name(number)
+        number = number.to_f
+        number = number.to_i if number.round == number
+        number = number.to_s
+
+        field = fields.find { |f| f['id'].to_s == number } || {}
+        field['label']
+      end
+
+      def to_csv(io)
+        io.puts(CSV.generate_line(leads.first.values.keys))
+
+        leads.each do |lead|
+          io.puts(lead.to_csv)
+        end
+
+        nil
+      end
+
+      class << self
+        def from_title(title)
+          self.first(:title => title)
+        end
+      end
+    end
+
+    class FormMeta < Sequel::Model(:"#{WPDB.prefix}rg_form_meta")
+      one_to_one :form, :class => :'WPDB::GravityForms::Form'
+    end
+
+    class Lead < Sequel::Model(:"#{WPDB.prefix}rg_lead")
+      many_to_one :form, :class => :'WPDB::GravityForms::Form'
+
+      one_to_many :details, :class => :'WPDB::GravityForms::Detail'
+
+      def values
+        details.each_with_object({}) do |detail, values|
+          key = form.field_name(detail.field_number) || detail.field_number
+          values[key] = detail.value
+        end
+      end
+
+      def to_csv
+        CSV.generate_line(values.values)
+      end
+    end
+
+    class Detail < Sequel::Model(:"#{WPDB.prefix}rg_lead_detail")
+      many_to_one :lead, :class => :'WPDB::GravityForms::Lead'
+
+      one_to_one :long_value, :key => :lead_detail_id, :class => :'WPDB::GravityForms::DetailLong'
+    end
+
+    class DetailLong < Sequel::Model(:"#{WPDB.prefix}rg_lead_detail_long")
+      one_to_one :lead_detail, :class => :'WPDB::GravityForms::DetailLong'
+    end
+
+    # For each form that we have, define a class for accessing its
+    # leads. So, if you have a form called "User Registration", we'll
+    # define a class called UserRegistration, allowing you to do
+    # things like:
+    #
+    # WPDB::GravityForms::UserRegistration.where(:date_registered => '2013-01-01').each do { |l| puts "#{l.first_name} #{l.last_name}" }
+    #
+    # All fields in the form are available as accessors.
+    class ModelGenerator
+      attr_reader :models
+
+      def initialize(forms = nil)
+        @forms = Array(forms) || Form.all
+        @models = []
+      end
+
+      def generate
+        @forms.each do |form|
+          form_name = WPDB.camelize(form.title)
+          form_class = build_class(form)
+
+          @models << WPDB::GravityForms.const_set(form_name, form_class)
+        end
+      end
+
+      private
+
+      # Constructs a new Ruby class, inherited from Sequel::Model, that
+      # will hold our model-like functionality. Sequel gives us most of
+      # this for free, by virtue of defining a dataset.
+      def build_class(form)
+        @labels = []
+
+        dataset = WPDB.db[:"#{WPDB.prefix}rg_lead___l"]
+          .where(:"l__form_id" => form.id)
+
+        dataset = join_fields(dataset, form.fields)
+        dataset = dataset.select_all(:l)
+        dataset = select_fields(dataset, form.fields)
+        dataset = dataset.from_self
+
+        Class.new(Sequel::Model) do
+          set_dataset dataset
+        end
+      end
+
+      def sanitise_label(original_label)
+        original_label = original_label.to_s
+        return unless original_label.length > 0
+
+        i = 1
+
+        label = WPDB.underscoreize(original_label)
+        while @labels.include?(label)
+          label = WPDB.underscoreize(original_label + i.to_s)
+          i += 1
+        end
+
+        @labels << label
+
+        label
+      end
+
+      def ignored_fields
+        ["html_block"]
+      end
+
+      def join_fields(dataset, fields)
+        fields.each_with_index do |field, i|
+          next unless field && field['label']
+          next if ignored_fields.include?(field['label'])
+
+          dataset = dataset.join_table(
+            :left,
+            :"#{WPDB.prefix}rg_lead_detail___ld#{i}",
+            { :field_number => field['id'], :lead_id => :"l__id" }
+          )
+        end
+
+        dataset
+      end
+
+      def select_fields(dataset, fields)
+        fields.each_with_index do |field, i|
+          next unless field && field['label']
+          next if ignored_fields.include?(field['label'])
+
+          field_name = sanitise_label(field['label'])
+
+          next if field_name.blank?
+
+          dataset = dataset.select_append(:"ld#{i}__value___#{field_name}")
+        end
+
+        dataset
+      end
+    end
+
+    # When a request is made to, for example,
+    # WPDB::GravityForms::SomeClass, this method will fire. If there's
+    # a GravityForm whose title, when camelised, is "SomeClass", a model
+    # will be created for that form.
+    #
+    # After the first time, the constant for that form will have been
+    # created, and so this hook will no longer fire.
+    def self.const_missing(name)
+      Form.each do |form|
+        if name.to_s == WPDB.camelize(form.title)
+          ModelGenerator.new(form).generate
+          return WPDB::GravityForms.const_get(name)
+        end
+      end
+
+      raise "Form not found: #{name}"
+    end
+  end
+
+  # Given a string, will convert it to a camel case suitable for use in
+  # a Ruby constant (which means no non-alphanumeric characters and no
+  # leading numbers).
+  def self.camelize(string)
+    string.gsub(/[^a-z0-9 ]/i, '')
+      .gsub(/^[0-9]+/, '')
+      .split(/\s+/)
+      .map { |t| t.strip.capitalize }
+      .join('')
+  end
+
+  # Given a string, will convert it an_underscored_value suitable for
+  # use in a Ruby variable name/symbol.
+  def self.underscoreize(string)
+    string.downcase
+      .gsub(' ', '_')
+      .gsub(/[^a-z0-9_]/, '')
+  end
+end

data/lib/ruby-wpdb/links.rb

@@ -0,0 +1,8 @@
+module WPDB
+  class Link < Sequel::Model(:"#{WPDB.prefix}links")
+    include Termable
+
+    one_to_many :termrelationships, :key => :object_id, :key_method => :obj_id, :class => 'WPDB::TermRelationship'
+    many_to_many :termtaxonomy, :left_key => :object_id, :right_key => :term_taxonomy_id, :join_table => :"#{WPDB.prefix}term_relationships", :class => 'WPDB::TermTaxonomy'
+  end
+end

data/lib/ruby-wpdb/options.rb

@@ -0,0 +1,24 @@
+module WPDB
+  class Option < Sequel::Model(:"#{WPDB.prefix}options")
+    plugin :validation_helpers
+
+    def validate
+      super
+      validates_presence [:option_name]
+    end
+
+    def before_validation
+      self.autoload ||= "yes"
+      super
+    end
+
+    # Given the name of an option, will return the option value for that
+    # option - or nil of no option with that name exists.
+    #
+    # @param [String] name The option_name to fetch
+    # @return String
+    def self.get_option(name)
+      Option.where(:option_name => name).get(:option_value)
+    end
+  end
+end

data/lib/ruby-wpdb/posts.rb

@@ -0,0 +1,67 @@
+Sequel.inflections do |inflect|
+  # Unless we tell Sequel otherwise, it will try to inflect the singular
+  # of "postmeta" using the "data" -> "datum" rule, leaving us with the
+  # bizarre "postmetum".
+  inflect.uncountable 'postmeta'
+end
+
+module WPDB
+  class Post < Sequel::Model(:"#{WPDB.prefix}posts")
+    include Termable
+
+    plugin :validation_helpers
+    plugin :sluggable, :source => :post_title, :target => :post_name
+
+    many_to_one :parent, :class => self, :key => :post_parent
+    one_to_many :children,
+      :key   => :post_parent,
+      :class => self do |ds|
+        ds.where(:post_type => ['attachment', 'revision']).invert
+          .where(:post_parent => self.ID)
+      end
+    one_to_many :revisions,
+      :key        => :post_parent,
+      :class      => self,
+      :conditions => { :post_type => 'revision' }
+    one_to_many :attachments,
+      :key        => :post_parent,
+      :class      => self,
+      :conditions => { :post_type => 'attachment' }
+
+    one_to_many :postmeta, :class => :'WPDB::PostMeta'
+    many_to_one :author, :key => :post_author, :class => :'WPDB::User'
+    one_to_many :comments, :key => :comment_post_ID, :class => :'WPDB::Comment'
+
+    one_to_many :termrelationships,
+      :key        => :object_id,
+      :key_method => :obj_id,
+      :class      => 'WPDB::TermRelationship'
+    many_to_many :termtaxonomy,
+      :left_key   => :object_id,
+      :right_key  => :term_taxonomy_id,
+      :join_table => :"#{WPDB.prefix}term_relationships",
+      :class      => 'WPDB::TermTaxonomy'
+
+    def validate
+      super
+      validates_presence [:post_title, :post_type, :post_status]
+      validates_unique :post_name
+    end
+
+    def before_validation
+      self.post_type      ||= "post"
+      self.post_status    ||= "draft"
+      self.post_parent    ||= 0
+      self.menu_order     ||= 0
+      self.comment_status ||= "open"
+      self.ping_status    ||= WPDB::Option.get_option("default_ping_status")
+      self.post_date      ||= Time.now
+      self.post_date_gmt  ||= Time.now.utc
+      super
+    end
+  end
+
+  class PostMeta < Sequel::Model(:"#{WPDB.prefix}postmeta")
+    many_to_one :posts, :class => :'WPDB::Post'
+  end
+end

data/lib/ruby-wpdb/terms.rb

@@ -0,0 +1,49 @@
+module WPDB
+  class Term < Sequel::Model(:"#{WPDB.prefix}terms")
+    plugin :validation_helpers
+    plugin :sluggable, :source => :name, :target => :slug
+
+    one_to_many :termtaxonomies, :class => 'WPDB::TermTaxonomy'
+
+    def validate
+      super
+      validates_presence :name
+    end
+  end
+
+  class TermTaxonomy < Sequel::Model(:"#{WPDB.prefix}term_taxonomy")
+    many_to_one :terms, :class => 'WPDB::Term'
+    one_to_many :termrelationships, :class => 'WPDB::TermRelationship'
+    many_to_many :posts, :left_key => :term_taxonomy_id, :right_key => :object_id, :join_table => :"#{WPDB.prefix}term_relationships", :class => 'WPDB::Post'
+    many_to_many :links, :left_key => :term_taxonomy_id, :right_key => :object_id, :join_table => :"#{WPDB.prefix}term_relationships", :class => 'WPDB::Link'
+  end
+
+  class TermRelationship < Sequel::Model(:"#{WPDB.prefix}term_relationships")
+    def_column_alias(:obj_id, :object_id)
+
+    many_to_one :termtaxonomy, :class => 'WPDB::TermTaxonomy'
+    many_to_one :posts, :class => 'WPDB::Post'
+    many_to_one :links, :class => 'WPDB::Link'
+  end
+
+  module Termable
+    # For objects that have a relationship with termtaxonomies, this
+    # module can be mixed in and gives the ability to add a term
+    # directly to the model, rather than creating the relationship
+    # yourself. Used by Post and Link.
+    def add_term(term, taxonomy)
+      if term.respond_to?(:term_id)
+        term_id = term.term_id
+      else
+        term_id = term.to_i
+      end
+
+      term_taxonomy = WPDB::TermTaxonomy.where(:term_id => term_id, :taxonomy => taxonomy).first
+      unless term_taxonomy
+        term_taxonomy = WPDB::TermTaxonomy.create(:term_id => term_id, :taxonomy => taxonomy)
+      end
+
+      add_termtaxonomy(term_taxonomy)
+    end
+  end
+end

data/lib/ruby-wpdb/users.rb

@@ -0,0 +1,39 @@
+require 'digest/md5'
+
+Sequel.inflections do |inflect|
+  # Unless we tell Sequel otherwise, it will try to inflect the singular
+  # of "usermeta" using the "data" -> "datum" rule, leaving us with the
+  # bizarre "usermetum".
+  inflect.uncountable 'usermeta'
+end
+
+module WPDB
+  class User < Sequel::Model(:"#{WPDB.user_prefix}users")
+    plugin :validation_helpers
+
+    one_to_many :usermeta, :class => :'WPDB::UserMeta'
+    one_to_many :posts, :key => :post_author, :class => :'WPDB::Post'
+
+    def validate
+      super
+      validates_presence [:user_login, :user_pass, :user_email, :user_registered]
+      validates_unique :user_login, :user_email
+    end
+
+    def before_validation
+      self.user_registered ||= Time.now
+
+      # If the password we've been given isn't a hash, then MD5 it.
+      # Although WordPress no longer uses MD5 hashes, it will update
+      # them on successful login, so we're ok to create them here.
+      unless user_pass =~ /\$[A-Z]\$/ || user_pass =~ /[a-z0-9]{32}/
+        self.user_pass = Digest::MD5.hexdigest(user_pass.to_s)
+      end
+
+      super
+    end
+  end
+
+  class UserMeta < Sequel::Model(:"#{WPDB.user_prefix}usermeta")
+  end
+end

data/lib/ruby-wpdb/version.rb

@@ -0,0 +1,3 @@
+module WPDB
+  VERSION = "1.0.beta1"
+end

data/lib/ruby-wpdb.rb

@@ -0,0 +1,51 @@
+require 'bundler'
+Bundler.setup
+
+require 'sequel'
+require 'pry'
+require 'pry-debugger'
+
+module WPDB
+  class << self
+    attr_accessor :db, :prefix, :user_prefix
+
+    # Given the path to a YAML file, will initialise WPDB using the
+    # config files found in that file.
+    def from_config(file = nil)
+      file ||= File.dirname(__FILE__) + '/../config.yml'
+      config = YAML::load_file(file)
+
+      uri  = 'mysql2://'
+      uri += "#{config['username']}:#{config['password']}"
+      uri += "@#{config['hostname']}"
+      uri += ":#{config['port']}" if config['port']
+      uri += "/#{config['database']}"
+
+      init(uri, config['prefix'])
+    end
+
+    # Initialises Sequel, sets up some necessary variables (like
+    # WordPress's table prefix), and then includes our models.
+    #
+    # @param [String] A database connection uri, e.g.
+    #   mysql2://user:pass@host:port/dbname
+    # @param [String] The database table prefix used by the install of
+    #   WordPress you'll be querying. Defaults to wp_
+    # @param [String] The prefix of the users table; if not specified,
+    #   the general database table prefix will be used.
+    def init(uri, prefix = nil, user_prefix = nil)
+      WPDB.db          = Sequel.connect(uri)
+      WPDB.prefix      = prefix || 'wp_'
+      WPDB.user_prefix = user_prefix || WPDB.prefix
+
+      require_relative 'ruby-wpdb/options'
+      require_relative 'ruby-wpdb/users'
+      require_relative 'ruby-wpdb/terms'
+      require_relative 'ruby-wpdb/posts'
+      require_relative 'ruby-wpdb/comments'
+      require_relative 'ruby-wpdb/links'
+      require_relative 'ruby-wpdb/gravityforms'
+    end
+  end
+end
+

data/test/comments_test.rb

@@ -0,0 +1,40 @@
+require_relative 'test_helper'
+
+describe WPDB::Comment do
+  before do
+    @comment = WPDB::Comment.create(
+      :comment_author => 'Testy Testerson',
+      :comment_author_email => 'testy@example.com',
+      :comment_content => 'Test'
+    )
+  end
+
+  it "creates a new comment" do
+    assert @comment.comment_ID
+  end
+
+  it "attaches comments to posts" do
+    post = WPDB::Post.create(:post_title => 'test', :post_author => 1)
+    assert post.ID
+
+    post.add_comment(@comment)
+    assert @comment.post
+    assert post.comments.length
+    assert_equal post.comments.first.comment_post_ID, post.ID
+
+    post.destroy
+  end
+
+  it "adds commentmeta" do
+    @comment.add_commentmeta(:meta_key => 'test', :meta_value => 'test')
+
+    comment = WPDB::Comment.where(:comment_ID => @comment.comment_ID).first
+    assert comment.commentmeta.length > 0
+    assert_equal 'test', comment.commentmeta.first.meta_key
+    assert_equal 'test', comment.commentmeta.first.meta_value
+  end
+
+  after do
+    @comment.destroy
+  end
+end

data/test/gravityforms_test.rb

@@ -0,0 +1,25 @@
+require_relative 'test_helper'
+
+describe WPDB::GravityForms do
+  before do
+    @form = WPDB::GravityForms::Form.first
+    @class_name = WPDB.camelize(@form.title).to_sym
+  end
+
+  it "fetches a form" do
+    assert @form.id
+  end
+
+  it "associates leads with a form" do
+    assert @form.leads.length
+  end
+
+  it "associates lead detail with a lead" do
+    assert @form.leads.first.details.length
+  end
+
+  it "lazily loads models for forms" do
+    klass = WPDB::GravityForms.const_get(@class_name)
+    assert_equal Class, klass.class
+  end
+end

data/test/links_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+describe WPDB::Link do
+  before do
+    @link = WPDB::Link.create(:link_url => 'http://example.com', :link_name => 'Example')
+  end
+
+  it "creates links" do
+    assert @link.link_id
+  end
+
+  it "can attach terms to links" do
+    term = WPDB::Term.create(:name => 'terming links')
+    @link.add_term(term, 'category')
+    @link.save
+
+    assert @link.link_id
+    assert @link.termtaxonomy.length
+    assert_equal term.term_id, @link.termtaxonomy.first.term_id
+    assert_equal 'category', @link.termtaxonomy.first.taxonomy
+
+    term.destroy
+  end
+
+  after do
+    @link.destroy
+  end
+end

data/test/options_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+describe WPDB::Option do
+  before do
+    @option = WPDB::Option.create(:option_name => 'test', :option_value => 'test')
+  end
+
+  it "creates options" do
+    assert @option.option_id
+  end
+
+  it "enforces the uniqueness of option names" do
+    assert_raises Sequel::UniqueConstraintViolation do
+      WPDB::Option.create(:option_name => 'test', :option_value => 'test')
+    end
+  end
+
+  it "has a shorthand for fetching options" do
+    assert_equal 'test', WPDB::Option.get_option('test')
+    assert_equal nil,    WPDB::Option.get_option('non-existent-key')
+  end
+
+  after do
+    @option.destroy
+  end
+end

data/test/posts_test.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+
+describe WPDB::Post do
+  before do
+    @post = WPDB::Post.create(:post_title => 'Hello world', :post_author => 1)
+  end
+
+  it "creates a new post" do
+    assert @post.ID
+  end
+
+  it "fetches all posts" do
+    assert WPDB::Post.all
+  end
+
+  it "manages postmeta" do
+    @post.add_postmeta(:meta_key => 'test', :meta_value => 'test')
+    @post.save
+
+    meta_value = @post.postmeta.first.meta_value
+    assert_equal 'test', meta_value
+  end
+
+  it "manages the hierarchy of posts" do
+    @post.add_child(WPDB::Post.create(:post_title => 'Child', :post_author => 1))
+    @post.save
+
+    assert_equal 'Child', @post.children.first.post_title
+
+    @post.children.first.destroy
+  end
+
+  it "fetches revisions of posts" do
+    revision = WPDB::Post.create(:post_type => 'revision', :post_title => 'Revision', :post_parent => @post.ID, :post_author => 1)
+    assert_equal 'Revision', @post.revisions.first.post_title
+
+    revision.destroy
+  end
+
+  it "fetches attachments to posts" do
+    attachment = WPDB::Post.create(:post_type => 'attachment', :post_title => 'Attachment', :post_parent => @post.ID, :post_author => 1)
+    assert_equal 'Attachment', @post.attachments.first.post_title
+
+    attachment.destroy
+  end
+
+  after do
+    @post.destroy
+  end
+end