A few methods have been deprecated which should be removed.

These are named constructors which are no longer necessary at all.

• Silk\Post\Model::fromWpPost - can use ::make(WpPost) or simply new Model(WpPost)
• Silk\Term\Model::fromWpTerm - can use ::make(WpTerm) or simply new Model(WpTerm)

As it is, using a Query Builder with a model will always return a collection of model instances.

This means doing a bunch of queries that may not be necessary if IDs are all that are needed.

This would likely be possible via a new alternate terminating method of the query builder, such as resultIds() and/or another builder method like ids().

Silk currently comes bundled with models for all initial post types, terms, and users.

These allow for users to start using Silk models right away for these initial types without the need to create model classes for them.

While these may be useful for some, they're better off being maintained apart from the core library.

In no particular order:

• Taxonomies & Terms
• Post Type registration
• Query Builder
• Post Relationships
• Actions & Filters
• Users
• Roles & capabilities
• Options & Transients
• Themes
• Plugins
• CLI

WP PHPUnit makes getting up and running with the WP core test library a breeze.

Add more methods to the query builder for posts.

A class dedicated to building up a new Taxonomy to be registered using a fluent api, similar to what we can do now with the PostTypeBuilder.

The Query\Builder class is specific to posts, it should probably be renamed to Post\PostQueryBuilder.

Post Type builders have open and closed methods for setting the public property of a type's registration args.

This should be present for the taxonomy builder as well for consistency.

As it is, the methods for setting the singular and plural post type labels only set two keys in the array of labels. Ideally, these methods (or others if it makes more sense) should allow for setting all of the other labels which use them while remaining mutable.

The biggest consideration here is probably making sure that i18n is not sacrificed in the process.

A class for modeling an individual Taxonomy. Should be able to do things like providing useful methods to query it's terms, and the PostTypes it holds relationships with.

As it is, the current methods for retrieving a model instance are all "hard" methods, in that they all throw a not found exception in the event that there is no record found for the given ID, slug, etc.

There are times however when an exception is not necessary and a simple falsy value would be more efficient. This would allow for more flexibility by not forcing the user to handle exceptions in all cases.

Update docs to include changes for 0.10

Items to document

• Conditional Hooks
• Taxonomy
• Taxonomy Builder
• Label handling with Post/Taxonomy Builders
• Term Models
• Term Query Builder
• Update class name references
• Meta all/collect methods

Right now there currently is no way to add query scopes via a Query\Builder.

The closest you can get is to define the scope all at once with a new query from the model like so:

class Thing extends Silk\Post\Model
{
    public static function published()
    {
        return static::query()->withStatus('published');
    }
}

This works, but doesn't allow for composition using multiple scopes as each call starts a new query.

Query scopes should be chainable methods to allow for composing a complex scope.

Update documentation for new release.

The ability to define relationships between models.

At a minimum, this should include:

• One to One
• One to Many
• Many to Many

The relationship should be polymorphic, so we can use the same syntax for all types:

PostModel <--> TermModel
TermModel <--> TermModel
PostModel <--> PostModel

Depends on #5.

We need some sexy branding. Nobody will ever use this unless something somewhere looks cool.

A class to model a single user.

Should provide CRUD methods, similar to Post and Term models, as well as methods for interacting with user meta, add/remove/check roles or capabilities.

Need more methods for building a more robust term query.

Easy targets for methods:

• orderby
• order
• include
• exclude
• hierarchical
• child_of

A class to model a term object, similar to Silk\Post\Model. Will have methods for CRUD operations, getting related taxonomies, post models, and term meta.

tightenco/collect which provides the Illuminate\Support\Collection class is currently locked to 5.2.* for compatibility.

The library has a breaking change as of 5.3 which affects a few methods.

From the docs:

Key / Value Order Change

The first, last, and contains collection methods all pass the "value" as the first parameter to their given callback Closure. For example:

$collection->first(function ($value, $key) {
    return ! is_null($value);
});

In previous versions of Laravel, the $key was passed first. Since most use cases are only interested in the $value it is now passed first. You should do a "global find" in your application for these methods to verify that you are expecting the $value to be passed as the first argument to your Closure.

Upgrading the library will provide access to newer methods as well as provide better compatibility with other illuminate packages, should you so desire.

In the future, this Collections in Silk may change to use a namespaced version rather than relying on a 3rd party dependency.