computed_model 0.2.2 → 0.3.0

data/README.ja.md

@@ -0,0 +1,168 @@
+# ComputedModel
+
+ComputedModelは依存解決アルゴリズムを備えた普遍的なバッチローダーです。
+
+- 依存解決アルゴリズムの恩恵により、抽象化を損なわずに以下の3つを両立させることができます。
+  - ActiveRecord等から読み込んだデータを加工して提供する。
+  - ActiveRecord等からのデータの読み込みを一括で行うことでN+1問題を防ぐ。
+  - 必要なデータだけを読み込む。
+- 複数のデータソースからの読み込みにも対応。
+- データソースに依存しない普遍的な設計。HTTPで取得した情報とActiveRecordから取得した情報の両方を使う、といったこともできます。
+
+[English version](README.md)
+
+## 解決したい問題
+
+モデルが複雑化してくると、単にデータベースから取得した値を返すだけではなく、加工した値を返したくなることがあります。
+
+```ruby
+class User < ApplicationRecord
+  has_one :preference
+  has_one :profile
+
+  def display_name
+    "#{preference.title} #{profile.name}"
+  end
+end
+```
+
+ところがこれをそのまま使うと N+1 問題が発生することがあります。
+
+```ruby
+# N+1 問題!
+User.where(id: friend_ids).map(&:display_name)
+```
+
+N+1問題を解決するには、 `#display_name` が何に依存していたかを調べ、それをpreloadしておく必要があります。
+
+```ruby
+User.where(id: friend_ids).preload(:preference, :profile).map(&:display_name)
+#                                  ^^^^^^^^^^^^^^^^^^^^^ display_name の抽象化が漏れてしまう
+```
+
+これではせっかく `#display_name` を抽象化した意味が半減してしまいます。
+
+ComputedModelは依存解決アルゴリズムをバッチローダーに接続することでこの問題を解消します。
+
+```ruby
+class User
+  define_primary_loader :raw_user do ... end
+  define_loader :preference do ... end
+  define_loader :profile do ... end
+
+  dependency :preference, :profile
+  computed def display_name
+    "#{preference.title} #{profile.name}"
+  end
+end
+```
+
+## インストール
+
+Gemfileに以下の行を追加:
+
+```ruby
+gem 'computed_model', '~> 0.3.0'
+```
+
+その後、以下を実行:
+
+    $ bundle
+
+または直接インストール:
+
+    $ gem install computed_model
+
+## 動かせるサンプルコード
+
+```ruby
+require 'computed_model'
+
+# この2つを外部から取得したデータとみなす (ActiveRecordやHTTPで取得したリソース)
+RawUser = Struct.new(:id, :name, :title)
+Preference = Struct.new(:user_id, :name_public)
+
+class User
+  include ComputedModel::Model
+
+  attr_reader :id
+  def initialize(raw_user)
+    @id = raw_user.id
+    @raw_user = raw_user
+  end
+
+  def self.list(ids, with:)
+    bulk_load_and_compute(Array(with), ids: ids)
+  end
+
+  define_primary_loader :raw_user do |_subfields, ids:, **|
+    # ActiveRecordの場合:
+    # raw_users = RawUser.where(id: ids).to_a
+    raw_users = [
+      RawUser.new(1, "Tanaka Taro", "Mr. "),
+      RawUser.new(2, "Yamada Hanako", "Dr. "),
+    ].filter { |u| ids.include?(u.id) }
+    raw_users.map { |u| User.new(u) }
+  end
+
+  define_loader :preference, key: -> { id } do |user_ids, _subfields, **|
+    # ActiveRecordの場合:
+    # Preference.where(user_id: user_ids).index_by(&:user_id)
+    {
+      1 => Preference.new(1, true),
+      2 => Preference.new(2, false),
+    }.filter { |k, _v| user_ids.include?(k) }
+  end
+
+  delegate_dependency :name, to: :raw_user
+  delegate_dependency :title, to: :raw_user
+  delegate_dependency :name_public, to: :preference
+
+  dependency :name, :name_public
+  computed def public_name
+    name_public ? name : "Anonymous"
+  end
+
+  dependency :public_name, :title
+  computed def public_name_with_title
+    "#{title}#{public_name}"
+  end
+end
+
+# あらかじめ要求したフィールドにだけアクセス可能
+users = User.list([1, 2], with: [:public_name_with_title])
+users.map(&:public_name_with_title) # => ["Mr. Tanaka Taro", "Dr. Anonymous"]
+users.map(&:public_name) # => error (ForbiddenDependency)
+
+users = User.list([1, 2], with: [:public_name_with_title, :public_name])
+users.map(&:public_name_with_title) # => ["Mr. Tanaka Taro", "Dr. Anonymous"]
+users.map(&:public_name) # => ["Tanaka Taro", "Anonymous"]
+
+# 次のような場合は preference は読み込まれない。
+users = User.list([1, 2], with: [:title])
+users.map(&:title) # => ["Mr. ", "Dr. "]
+```
+
+## 次に読むもの
+
+- [基本概念と機能](CONCEPTS.ja.md)
+
+## License
+
+This library is distributed under MIT license.
+
+Copyright (c) 2020 Masaki Hara
+
+Copyright (c) 2020 Masayuki Izumi
+
+Copyright (c) 2020 Wantedly, Inc.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wantedly/computed_model.

data/README.md

@@ -1,137 +1,153 @@
 # ComputedModel
 
-ComputedModel is a helper for building a read-only model (sometimes called a view)
-from multiple sources of models.
-It comes with batch loading and dependency resolution for better performance.
+ComputedModel is a universal batch loader which comes with a dependency-resolution algorithm.
 
-It is designed to be universal. It's as easy as pie to pull data from both
-ActiveRecord and remote server (such as ActiveResource).
+- Thanks to the dependency resolution, it allows you to the following trifecta at once, without breaking abstraction.
+  - Process information gathered from datasources (such as ActiveRecord) and return the derived one.
+  - Prevent N+1 problem via batch loading.
+  - Load only necessary data.
+- Can load data from multiple datasources.
+- Designed to be universal and datasource-independent.
+  For example, you can gather data from both HTTP and ActiveRecord and return the derived one.
 
-## Installation
+[日本語版README](README.ja.md)
 
-Add this line to your application's Gemfile:
+## Problems to solve
+
+As models grow, they cannot simply return the database columns as-is.
+Instead, we want to process information obtained from the database and return the derived value.
 
 ```ruby
-gem 'computed_model', '~> 0.2.2'
+class User < ApplicationRecord
+  has_one :preference
+  has_one :profile
+
+  def display_name
+    "#{preference.title} #{profile.name}"
+  end
+end
 ```
 
-And then execute:
+However, it can lead to N+1 without care.
 
-    $ bundle
+```ruby
+# N+1 problem!
+User.where(id: friend_ids).map(&:display_name)
+```
 
-Or install it yourself as:
+To solve the N+1 problem, we need to enumerate dependencies of `#display_name` and preload them.
 
-    $ gem install computed_model
+```ruby
+User.where(id: friend_ids).preload(:preference, :profile).map(&:display_name)
+#                                  ^^^^^^^^^^^^^^^^^^^^^ breaks abstraction of display_name
+```
 
-## Usage
+This partially defeats the purpose of `#display_name`'s abstraction.
 
-Include `ComputedModel` in your model class. You may also need an `attr_reader` for the primary key.
+Computed solves the problem by connection the dependency-resolution to the batch loader.
 
 ```ruby
 class User
-  attr_reader :id
-
-  include ComputedModel
+  define_primary_loader :raw_user do ... end
+  define_loader :preference do ... end
+  define_loader :profile do ... end
 
-  def initialize(id)
-    @id = id
+  dependency :preference, :profile
+  computed def display_name
+    "#{preference.title} #{profile.name}"
   end
 end
 ```
 
-They your model class will be able to define the two kinds of special attributes:
-
-- **Loaded attributes** for external data. You define batch loading strategies for loaded attributes.
-  - Among them, there is a special **primary model** for listing up the models from certain criteria.
-- **Computed attributes** for data derived from loaded attributes or other computed attributes.
-  You define a usual `def` with special dependency annotations.
-
-## Loaded attributes
+## Installation
 
-Use `ComputedModel::ClassMethods#define_primary_loader`
-or `ComputedModel::ClassMethods#define_loader` to define loaded attributes.
+Add this line to your application's Gemfile:
 
 ```ruby
-# Create a User instance
-def initialize(raw_user)
-  @id = raw_user.id
-  @raw_user = raw_user
-end
+gem 'computed_model', '~> 0.3.0'
+```
 
-# Example: pulling data from ActiveRecord
-define_primary_loader :raw_user do |subdeps, ids:, **options|
-  RawUser.where(id: ids).preload(subdeps).map { |raw_user| User.new(raw_user) }
-end
+And then execute:
 
-# Example: pulling auxiliary data from ActiveRecord
-define_loader :user_aux_data, key: -> { id } do |user_ids, subdeps, **options|
-  UserAuxData.where(user_id: user_ids).preload(subdeps).group_by(&:id)
-end
-```
+    $ bundle
 
-### `define_primary_loader`
+Or install it yourself as:
 
-At most one primary loader can be defined on a model class.
+    $ gem install computed_model
 
-The primary loader's job is to list up models from user-defined criteria, along with
-requested data loaded to the primary attribute.
+## Working example
 
-Search criteria can be passed as a keyword argument to `bulk_load_and_compute`
-and it will be passed to the loader as-is.
+```ruby
+require 'computed_model'
 
-Most typically you receive `ids`, an array of integers, and use it like
-`.where(id: ids)`. Instead you may want to accept a non-primary-key criterion
-such as `group_ids` and `.where(group_id: group_ids)`.
+# Consider them external sources (ActiveRecord or resources obtained via HTTP)
+RawUser = Struct.new(:id, :name, :title)
+Preference = Struct.new(:user_id, :name_public)
 
-The loader must return an array of instances of the model being defined.
-Each instance must have the primary attribute assigned at that time.
-In the example above, the block for `define_primary_loader :raw_user`
-must return an array of `User`s, each of which already have `@raw_user`.
+class User
+  include ComputedModel::Model
 
-### `define_loader`
+  attr_reader :id
+  def initialize(raw_user)
+    @id = raw_user.id
+    @raw_user = raw_user
+  end
 
-The first argument to the block is an array of the model instances.
-The loader's job is to assign something to the corresponding field of each instance.
+  def self.list(ids, with:)
+    bulk_load_and_compute(Array(with), ids: ids)
+  end
 
-The second argument to the block is called a "sub-dependency".
-The value of `subdeps` is an array, but further details are up to you
-(it's just a verbatim copy of what you pass to `ComputedModel::ClassMethods#dependency`).
-It's customary to take something ActiveRecord's `preload` accepts.
+  define_primary_loader :raw_user do |_subfields, ids:, **|
+    # In ActiveRecord:
+    # raw_users = RawUser.where(id: ids).to_a
+    raw_users = [
+      RawUser.new(1, "Tanaka Taro", "Mr. "),
+      RawUser.new(2, "Yamada Hanako", "Dr. "),
+    ].filter { |u| ids.include?(u.id) }
+    raw_users.map { |u| User.new(u) }
+  end
 
-The keyword arguments are also a verbatim copy of what you pass to `ComputedModel::ClassMethods#bulk_load_and_compute`.
+  define_loader :preference, key: -> { id } do |user_ids, _subfields, **|
+    # In ActiveRecord:
+    # Preference.where(user_id: user_ids).index_by(&:user_id)
+    {
+      1 => Preference.new(1, true),
+      2 => Preference.new(2, false),
+    }.filter { |k, _v| user_ids.include?(k) }
+  end
 
-## Computed attributes
+  delegate_dependency :name, to: :raw_user
+  delegate_dependency :title, to: :raw_user
+  delegate_dependency :name_public, to: :preference
 
-Use `ComputedModel::ClassMethods#computed` and `#dependency` to define computed attributes.
+  dependency :name, :name_public
+  computed def public_name
+    name_public ? name : "Anonymous"
+  end
 
-```ruby
-dependency raw_user: [:name], user_music_info: [:latest]
-computed def name_with_playing_music
-  if user_music_info.latest&.playing?
-    "#{user.name} (Now playing: #{user_music_info.latest.name})"
-  else
-    user.name
+  dependency :public_name, :title
+  computed def public_name_with_title
+    "#{title}#{public_name}"
   end
 end
-```
 
-## Batch loading
+# You can only access the field you requested ahead of time
+users = User.list([1, 2], with: [:public_name_with_title])
+users.map(&:public_name_with_title) # => ["Mr. Tanaka Taro", "Dr. Anonymous"]
+users.map(&:public_name) # => error (ForbiddenDependency)
 
-Once you defined loaded and computed attributes, you can batch-load them using `ComputedModel::ClassMethods#bulk_load_and_compute`.
+users = User.list([1, 2], with: [:public_name_with_title, :public_name])
+users.map(&:public_name_with_title) # => ["Mr. Tanaka Taro", "Dr. Anonymous"]
+users.map(&:public_name) # => ["Tanaka Taro", "Anonymous"]
 
-Typically you need to create a wrapper for the batch loader like:
-
-```ruby
-def self.list(ids, with:)
-  bulk_load_and_compute(Array(with), ids: ids)
-end
+# In this case, preference will not be loaded.
+users = User.list([1, 2], with: [:title])
+users.map(&:title) # => ["Mr. ", "Dr. "]
 ```
 
-They you can retrieve users with only a specified attributes in a batch:
+## Next read
 
-```ruby
-users = User.list([1, 2, 3], with: [:name, :name_with_playing_music, :premium_user])
-```
+- [Basic concepts and features](CONCEPTS.md)
 
 ## License
 

data/Rakefile

@@ -4,3 +4,17 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+namespace :db do
+  namespace :schema do
+    task :dump do
+      $LOAD_PATH.push(File.join(__dir__, 'spec'))
+      require 'active_record'
+      require 'support/db/connection'
+      require 'support/db/schema'
+      File.open(File.join(__dir__, 'spec/support/db/schema.rb'), 'w:utf-8') do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+  end
+end

data/computed_model.gemspec

@@ -35,7 +35,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  # For ActiveSupport::Concern
+  spec.add_development_dependency "activesupport"
+
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "activerecord", "~> 6.1"
+  spec.add_development_dependency "sqlite3", "~> 1.4"
+  spec.add_development_dependency "factory_bot", "~> 6.1"
+  spec.add_development_dependency "simplecov", "~> 0.21.2"
+  spec.add_development_dependency "simplecov-lcov", "~> 0.8.0"
 end

data/lib/computed_model.rb

@@ -1,326 +1,66 @@
 # frozen_string_literal: true
 
 require "computed_model/version"
-require 'set'
+require "computed_model/plan"
+require "computed_model/dep_graph"
+require "computed_model/model"
 
-# A mixin for batch-loadable compound models.
+# ComputedModel is a universal batch loader which comes with a dependency-resolution algorithm.
 #
-# @example typical structure of a computed model
-#   class User
-#     include ComputedModel
+# - Thanks to the dependency resolution, it allows you to the following trifecta at once, without breaking abstraction.
+#   - Process information gathered from datasources (such as ActiveRecord) and return the derived one.
+#   - Prevent N+1 problem via batch loading.
+#   - Load only necessary data.
+# - Can load data from multiple datasources.
+# - Designed to be universal and datasource-independent.
+#   For example, you can gather data from both HTTP and ActiveRecord and return the derived one.
 #
-#     attr_reader :id
-#     def initialize(id)
-#       @id = id
-#     end
-#
-#     define_loader do ... end
-#
-#     dependency :foo, :bar
-#     computed def something ... end
-#   end
+# See {ComputedModel::Model} for basic usage.
 module ComputedModel
   # An error raised when you tried to read from a loaded/computed attribute,
   # but that attribute isn't loaded by the batch loader.
   class NotLoaded < StandardError; end
 
-  # A return value from {ComputedModel::ClassMethods#computing_plan}.
-  Plan = Struct.new(:load_order, :subdeps_hash)
-
-  # An object for storing procs for loaded attributes.
-  Loader = Struct.new(:key_proc, :load_proc)
-
-  private_constant :Loader
-
-  # A set of class methods for {ComputedModel}. Automatically included to the
-  # singleton class when you include {ComputedModel}.
-  module ClassMethods
-    # Declares the dependency of a computed attribute. See {#computed} too.
-    #
-    # @param deps [Array<Symbol, Hash{Symbol=>Array}>]
-    #   Dependency description. If a symbol `:foo` is given,
-    #   it's interpreted as `{ foo: [] }`.
-    #   When the same symbol occurs multiple times, the array is concatenated.
-    #   The contents of the array (called "sub-dependency") is treated opaquely
-    #   by the `computed_model` gem. It is up to the user to design the format
-    #   of sub-dependencies.
-    # @return [void]
-    #
-    # @example declaring dependencies
-    #   dependency :user, :user_external_resource
-    #   computed def something
-    #     # Use user and user_external_resource ...
-    #   end
-    #
-    # @example declaring dependencies with sub-dependencies
-    #   dependency user: [:user_names, :premium], user_external_resource: [:received_stars]
-    #   computed def something
-    #     # Use user and user_external_resource ...
-    #   end
-    def dependency(*deps)
-      @__computed_model_next_dependency ||= []
-      @__computed_model_next_dependency.push(*deps)
-    end
-
-    # Declares a computed attribute. See {#dependency} too.
-    #
-    # @param meth_name [Symbol] a method name to promote to a computed attribute.
-    #   Typically used in the form of `computed def ...`.
-    # @return [Symbol] passes through the argument.
-    #
-    # @example define a field which is calculated from loaded models
-    #   dependency :user, :user_external_resource
-    #   computed def something
-    #     # Use user and user_external_resource ...
-    #   end
-    def computed(meth_name)
-      var_name = :"@#{meth_name}"
-      meth_name_orig = :"#{meth_name}_orig"
-      compute_meth_name = :"compute_#{meth_name}"
-
-      @__computed_model_dependencies[meth_name] = ComputedModel.normalize_dependencies(@__computed_model_next_dependency)
-      remove_instance_variable(:@__computed_model_next_dependency)
-
-      alias_method meth_name_orig, meth_name
-      define_method(meth_name) do
-        raise NotLoaded, "the field #{meth_name} is not loaded" unless instance_variable_defined?(var_name)
-        instance_variable_get(var_name)
-      end
-      define_method(compute_meth_name) do
-        instance_variable_set(var_name, send(meth_name_orig))
-      end
-      if public_method_defined?(meth_name_orig)
-        public meth_name
-      elsif protected_method_defined?(meth_name_orig)
-        protected meth_name
-      elsif private_method_defined?(meth_name_orig)
-        private meth_name
-      end
-
-      meth_name
-    end
-
-    # A shorthand for simple computed attributes.
-    #
-    # Use {#computed} for more complex definition.
-    #
-    # @param methods [Array<Symbol>] method names to delegate
-    # @param to [Symbol] which attribute to delegate the methods to.
-    #   This parameter is used for the dependency declaration too.
-    # @param allow_nil [nil, Boolean] If `true`,
-    #   nil receivers are is ignored, and nil is returned instead.
-    # @param prefix [nil, Symbol] A prefix for the delegating method name.
-    # @param include_subdeps [nil, Boolean] If `true`,
-    #   sub-dependencies are also included.
-    # @return [void]
-    #
-    # @example delegate name from raw_user
-    #   delegate_dependency :name, to: :raw_user
-    #
-    # @example delegate name from raw_user, but expose as user_name
-    #   delegate_dependency :name, to: :raw_user, prefix: :user
-    def delegate_dependency(*methods, to:, allow_nil: nil, prefix: nil, include_subdeps: nil)
-      method_prefix = prefix ? "#{prefix}_" : ""
-      methods.each do |meth_name|
-        pmeth_name = :"#{method_prefix}#{meth_name}"
-        if include_subdeps
-          dependency to=>meth_name
-        else
-          dependency to
-        end
-        if allow_nil
-          define_method(pmeth_name) do
-            send(to)&.public_send(meth_name)
-          end
-        else
-          define_method(pmeth_name) do
-            send(to).public_send(meth_name)
-          end
-        end
-        computed pmeth_name
-      end
-    end
-
-    # Declares a loaded attribute. See {#dependency} and {#define_primary_loader} too.
-    #
-    # `define_loader :foo do ... end` generates a reader `foo` and a writer `foo=`.
-    # The writer is only meant to be used in the loader.
-    #
-    # The responsibility of loader is to call `foo=` for all the given objects,
-    # or set `computed_model_error` otherwise.
-    #
-    # @param meth_name [Symbol] the name of the loaded attribute.
-    # @param key [Proc] The proc to collect keys.
-    # @return [void]
-    # @yield [keys, subdeps, **options]
-    # @yieldparam objects [Array] The ids of the loaded attributes.
-    # @yieldparam subdeps [Hash] sub-dependencies
-    # @yieldparam options [Hash] A verbatim copy of what is passed to {#bulk_load_and_compute}.
-    # @yieldreturn [Hash]
-    #
-    # @example define a loader for ActiveRecord-based models
-    #   define_loader :user_aux_data, key: -> { id } do |user_ids, subdeps, **options|
-    #     UserAuxData.where(user_id: user_ids).preload(subdeps).group_by(&:id)
-    #   end
-    def define_loader(meth_name, key:, &block)
-      raise ArgumentError, "No block given" unless block
-
-      var_name = :"@#{meth_name}"
-
-      @__computed_model_loaders[meth_name] = Loader.new(key, block)
-
-      define_method(meth_name) do
-        raise NotLoaded, "the field #{meth_name} is not loaded" unless instance_variable_defined?(var_name)
-        instance_variable_get(var_name)
-      end
-      attr_writer meth_name
-    end
-
-    # Declares a primary attribute. See {#define_loader} and {#dependency} too.
-    #
-    # `define_primary_loader :foo do ... end` generates a reader `foo` and
-    # a writer `foo=`.
-    # The writer is only meant to be used in the loader.
-    #
-    # The responsibility of the primary loader is to list up all the relevant
-    # primary models, and initialize instances of the subclass of ComputedModel
-    # with `@foo` set to the primary model which is just being found.
-    #
-    # @param meth_name [Symbol] the name of the loaded attribute.
-    # @return [void]
-    # @yield [**options]
-    # @yieldparam options [Hash] A verbatim copy of what is passed to {#bulk_load_and_compute}.
-    # @yieldreturn [void]
-    #
-    # @example define a loader for ActiveRecord-based models
-    #   define_loader :raw_user do |users, subdeps, **options|
-    #     user_ids = users.map(&:id)
-    #     raw_users = RawUser.where(id: user_ids).preload(subdeps).index_by(&:id)
-    #     users.each do |user|
-    #       # Even if it doesn't exist, you must explicitly assign nil to the field.
-    #       user.raw_user = raw_users[user.id]
-    #     end
-    #   end
-    def define_primary_loader(meth_name, &block)
-      raise ArgumentError, "No block given" unless block
-      raise ArgumentError, "Primary loader has already been defined" if @__computed_model_primary_attribute
-
-      var_name = :"@#{meth_name}"
-
-      @__computed_model_primary_loader = block
-      @__computed_model_primary_attribute = meth_name
-
-      define_method(meth_name) do
-        raise NotLoaded, "the field #{meth_name} is not loaded" unless instance_variable_defined?(var_name)
-        instance_variable_get(var_name)
-      end
-      attr_writer meth_name
-    end
-
-    # The core routine for batch-loading.
-    #
-    # @param deps [Array<Symbol, Hash{Symbol=>Array}>] A set of dependencies.
-    # @param options [Hash] An arbitrary hash to pass to loaders
-    #   defined by {#define_loader}.
-    # @return [Array<Object>] The array of the requested models.
-    #   Based on what the primary loader returns.
-    def bulk_load_and_compute(deps, **options)
-      unless @__computed_model_primary_attribute
-        raise ArgumentError, "No primary loader defined"
-      end
-
-      objs = orig_objs = nil
-      plan = computing_plan(deps)
-      plan.load_order.each do |dep_name|
-        if @__computed_model_primary_attribute == dep_name
-          orig_objs = @__computed_model_primary_loader.call(plan.subdeps_hash[dep_name], **options)
-          objs = orig_objs.dup
-        elsif @__computed_model_dependencies.key?(dep_name)
-          raise "Bug: objs is nil" if objs.nil?
-
-          objs.each do |obj|
-            obj.send(:"compute_#{dep_name}")
-          end
-        elsif @__computed_model_loaders.key?(dep_name)
-          raise "Bug: objs is nil" if objs.nil?
-
-          l = @__computed_model_loaders[dep_name]
-          keys = objs.map { |o| o.instance_exec(&(l.key_proc)) }
-          subobj_by_key = l.load_proc.call(keys, plan.subdeps_hash[dep_name], **options)
-          objs.zip(keys) do |obj, key|
-            obj.send(:"#{dep_name}=", subobj_by_key[key])
-          end
-        else
-          raise "No dependency info for #{self}##{dep_name}"
-        end
-        objs.reject! { |obj| !obj.computed_model_error.nil? }
-      end
-
-      orig_objs
-    end
-
-    # @param deps [Array]
-    # @return [Plan]
-    def computing_plan(deps)
-      normalized = ComputedModel.normalize_dependencies(deps)
-      load_order = []
-      subdeps_hash = {}
-      visiting = Set[]
-      visited = Set[]
-      if @__computed_model_primary_attribute
-        load_order << @__computed_model_primary_attribute
-        visiting.add @__computed_model_primary_attribute
-        visited.add @__computed_model_primary_attribute
-        subdeps_hash[@__computed_model_primary_attribute] ||= []
-      end
-      normalized.each do |dep_name, dep_subdeps|
-        computing_plan_dfs(dep_name, dep_subdeps, load_order, subdeps_hash, visiting, visited)
-      end
-
-      Plan.new(load_order, subdeps_hash)
-    end
-
-    # @param meth_name [Symbol]
-    # @param meth_subdeps [Array]
-    # @param load_order [Array<Symbol>]
-    # @param subdeps_hash [Hash{Symbol=>Array}]
-    # @param visiting [Set<Symbol>]
-    # @param visited [Set<Symbol>]
-    private def computing_plan_dfs(meth_name, meth_subdeps, load_order, subdeps_hash, visiting, visited)
-      (subdeps_hash[meth_name] ||= []).push(*meth_subdeps)
-      return if visited.include?(meth_name)
-      raise "Cyclic dependency for #{self}##{meth_name}" if visiting.include?(meth_name)
-      visiting.add(meth_name)
-
-      if @__computed_model_dependencies.key?(meth_name)
-        @__computed_model_dependencies[meth_name].each do |dep_name, dep_subdeps|
-          computing_plan_dfs(dep_name, dep_subdeps, load_order, subdeps_hash, visiting, visited)
-        end
-      elsif @__computed_model_loaders.key?(meth_name)
-      else
-        raise "No dependency info for #{self}##{meth_name}"
-      end
+  # An error raised when you tried to read from a loaded/computed attribute,
+  # but that attribute isn't listed in the dependencies list.
+  class ForbiddenDependency < StandardError; end
 
-      load_order << meth_name
-      visiting.delete(meth_name)
-      visited.add(meth_name)
-    end
-  end
+  # An error raised when the dependency graph contains a cycle.
+  class CyclicDependency < StandardError; end
 
-  # @param deps [Array<(Symbol, Hash)>, Hash, Symbol]
-  # @return [Hash{Symbol=>Array}]
+  # Normalizes dependency list as a hash.
+  #
+  # Normally you don't need to call it directly.
+  # {ComputedModel::Model::ClassMethods#dependency}, {ComputedModel::Model::ClassMethods#bulk_load_and_compute}, and
+  # {ComputedModel::NormalizableArray#normalized} will internally use this function.
+  #
+  # @param deps [Array<(Symbol, Hash)>, Hash, Symbol] dependency list
+  # @return [Hash{Symbol=>Array}] normalized dependency hash
+  # @raise [RuntimeError] if the dependency list contains values other than Symbol or Hash
+  # @example
+  #   ComputedModel.normalize_dependencies([:foo, :bar])
+  #   # => { foo: [true], bar: [true] }
+  #
+  # @example
+  #   ComputedModel.normalize_dependencies([:foo, bar: :baz])
+  #   # => { foo: [true], bar: [true, :baz] }
+  #
+  # @example
+  #   ComputedModel.normalize_dependencies(foo: -> (subfields) { true })
+  #   # => { foo: [#<Proc:...>] }
   def self.normalize_dependencies(deps)
     normalized = {}
     deps = [deps] if deps.is_a?(Hash)
     Array(deps).each do |elem|
       case elem
       when Symbol
-        normalized[elem] ||= []
+        normalized[elem] ||= [true]
       when Hash
         elem.each do |k, v|
           v = [v] if v.is_a?(Hash)
           normalized[k] ||= []
           normalized[k].push(*Array(v))
+          normalized[k].push(true) if v == []
         end
       else; raise "Invalid dependency: #{elem.inspect}"
       end
@@ -328,18 +68,35 @@ module ComputedModel
     normalized
   end
 
-  # An error field to prevent {ComputedModel::ClassMethods#bulk_load_and_compute}
-  # from loading remaining attributes.
+  # Removes `nil`, `true` and `false` from the given array.
   #
-  # @return [StandardError]
-  attr_accessor :computed_model_error
+  # Normally you don't need to call it directly.
+  # {ComputedModel::Model::ClassMethods#define_loader},
+  # {ComputedModel::Model::ClassMethods#define_primary_loader}, and
+  # {ComputedModel::NormalizableArray#normalized} will internally use this function.
+  #
+  # @param subfields [Array] subfield selector list
+  # @return [Array] the filtered one
+  # @example
+  #   ComputedModel.filter_subfields([false, {}, true, nil, { foo: :bar }])
+  #   # => [{}, { foo: :bar }]
+  def self.filter_subfields(subfields)
+    subfields.select { |x| x && x != true }
+  end
 
-  def self.included(klass)
-    super
-    klass.extend ClassMethods
-    klass.instance_variable_set(:@__computed_model_dependencies, {})
-    klass.instance_variable_set(:@__computed_model_loaders, {})
-    klass.instance_variable_set(:@__computed_model_primary_loader, nil)
-    klass.instance_variable_set(:@__computed_model_primary_attribute, nil)
+  # Convenience class to easily access normalized version of dependencies.
+  #
+  # You don't need to directly use it.
+  #
+  # - {ComputedModel::Model#current_subfields} returns NormalizableArray.
+  # - Procs passed to {ComputedModel::Model::ClassMethods#dependency} will receive NormalizeArray.
+  class NormalizableArray < Array
+    # Returns the normalized hash of the dependencies.
+    # @return [Hash{Symbol=>Array}] the normalized hash of the dependencies
+    # @raise [RuntimeError] if the list isn't valid as a dependency list.
+    #   See {ComputedModel.normalize_dependencies} for details.
+    def normalized
+      @normalized ||= ComputedModel.normalize_dependencies(ComputedModel.filter_subfields(self))
+    end
   end
 end