rom-repository 0.2.0 → 0.3.0

data/lib/rom/repository/root.rb

@@ -0,0 +1,110 @@
+module ROM
+  class Repository
+    # A specialized repository type dedicated to work with a root relation
+    #
+    # This repository type builds commands and aggregates for its root relation
+    #
+    # @example
+    #   class UserRepo < ROM::Repository[:users]
+    #     commands :create, update: :by_pk, delete: :by_pk
+    #   end
+    #
+    #   rom = ROM.container(:sql, 'sqlite::memory') do |conf|
+    #     conf.default.create_table(:users) do
+    #       primary_key :id
+    #       column :name, String
+    #     end
+    #   end
+    #
+    #   user_repo = UserRepo.new(rom)
+    #
+    #   user = user_repo.create(name: "Jane")
+    #
+    #   changeset = user_repo.changeset(user.id, name: "Jane Doe")
+    #   user_repo.update(user.id, changeset)
+    #
+    #   user_repo.delete(user.id)
+    #
+    # @api public
+    class Root < Repository
+      extend ClassMacros
+
+      defines :root
+
+      # @!attribute [r] root
+      #   @return [RelationProxy] The root relation
+      attr_reader :root
+
+      # Sets descendant root relation
+      #
+      # @api private
+      def self.inherited(klass)
+        super
+        klass.root(root)
+      end
+
+      # @see Repository#initialize
+      def initialize(container)
+        super
+        @root = relations[self.class.root]
+      end
+
+      # Compose a relation aggregate from the root relation
+      #
+      # @overload aggregate(*associations)
+      #   Composes an aggregate from configured associations on the root relation
+      #
+      #   @example
+      #     user_repo.aggregate(:tasks, :posts)
+      #
+      #   @param *associations [Array<Symbol>] A list of association names
+      #
+      # @overload aggregate(options)
+      #   Composes an aggregate by delegating to combine_children method.
+      #
+      #   @param options [Hash] An option hash
+      #
+      #   @see RelationProxy::Combine#combine_children
+      #
+      # @return [RelationProxy]
+      #
+      # @api public
+      def aggregate(*args)
+        if args[0].is_a?(Hash) && args.size == 1
+          root.combine_children(args[0])
+        else
+          root.combine(*args)
+        end
+      end
+
+      # @overload changeset(name, *args)
+      #   Delegate to Repository#changeset
+      #   @see Repository#changeset
+      #
+      # @overload changeset(data)
+      #   Builds a create changeset for the root relation
+      #   @example
+      #     user_repo.changeset(name: "Jane")
+      #   @param data [Hash] New data
+      #   @return [Changeset::Create]
+      #
+      # @overload changeset(restriction_arg, data)
+      #   Builds an update changeset for the root relation
+      #   @example
+      #     user_repo.changeset(1, name: "Jane Doe")
+      #   @param restriction_arg [Object] An argument for the restriction view
+      #   @return [Changeset::Update]
+      #
+      # @override Repository#changeset
+      #
+      # @api public
+      def changeset(*args)
+        if args.first.is_a?(Symbol) && relations.key?(args.first)
+          super
+        else
+          super(root.name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/rom/repository/struct_attributes.rb

@@ -0,0 +1,46 @@
+module ROM
+  class Repository
+    # @api private
+    class StructAttributes < Module
+      def initialize(attributes)
+        super()
+
+        define_constructor(attributes)
+
+        module_eval do
+          include Dry::Equalizer.new(*attributes)
+
+          attr_reader(*attributes)
+
+          define_method(:to_h) do
+            attributes.each_with_object({}) do |attribute, h|
+              h[attribute] = __send__(attribute)
+            end
+          end
+        end
+      end
+
+      def define_constructor(attributes)
+        module_eval do
+          def __missing_keyword__(keyword)
+            raise ArgumentError.new("missing keyword: #{keyword}")
+          end
+          private :__missing_keyword__
+        end
+
+        kwargs = attributes.map { |a| "#{a}: __missing_keyword__(:#{a})" }.join(', ')
+
+        ivs = attributes.map { |a| "@#{a}" }.join(', ')
+        values = attributes.join(', ')
+
+        assignment = attributes.size > 0 ? "#{ivs} = #{values}" : EMPTY_STRING
+
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def initialize(#{kwargs})
+            #{assignment}
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rom/repository/struct_builder.rb

@@ -1,30 +1,47 @@
-require 'anima'
-
 require 'rom/struct'
 
+require 'rom/support/cache'
+require 'rom/support/constants'
+require 'rom/support/class_builder'
+
+require 'rom/repository/struct_attributes'
+
 module ROM
   class Repository
     # @api private
     class StructBuilder
-      attr_reader :registry
+      extend Cache
+
+      def call(*args)
+        fetch_or_store(*args) do
+          name, header = args
+
+          build_class(name) { |klass|
+            klass.send(:include, StructAttributes.new(visit(header)))
+          }
+        end
+      end
+      alias_method :[], :call
+
+      private
 
-      def self.registry
-        @__registry__ ||= {}
+      def visit(ast)
+        name, node = ast
+        __send__("visit_#{name}", node)
       end
 
-      def initialize
-        @registry = self.class.registry
+      def visit_header(node)
+        node.map(&method(:visit))
       end
 
-      def call(*args)
-        name, columns = args
-        registry[args.hash] ||= build_class(name) { |klass|
-          klass.send(:include, Anima.new(*columns))
-        }
+      def visit_relation(node)
+        relation_name, meta, * = node
+        meta[:combine_name] || relation_name.relation
       end
-      alias_method :[], :call
 
-      private
+      def visit_attribute(node)
+        node
+      end
 
       def build_class(name, &block)
         ROM::ClassBuilder.new(name: class_name(name), parent: Struct).call(&block)

data/lib/rom/repository/version.rb

@@ -1,5 +1,5 @@
 module ROM
   class Repository
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/lib/rom/repository.rb

@@ -1,60 +1,221 @@
 require 'rom/support/deprecations'
 require 'rom/support/options'
 
+require 'rom/repository/class_interface'
 require 'rom/repository/mapper_builder'
-require 'rom/repository/loading_proxy'
+require 'rom/repository/relation_proxy'
+require 'rom/repository/command_compiler'
+
+require 'rom/repository/root'
+require 'rom/repository/changeset'
 
 module ROM
+  # Abstract repository class to inherit from
+  #
+  # A repository provides access to composable relations and commands. Its job is
+  # to provide application-specific data that is already materialized, so that
+  # relations don't leak into your application layer.
+  #
+  # Typically, you're going to work with Repository::Root that are configured to
+  # use a single relation as its root, and compose aggregates and use commands
+  # against the root relation.
+  #
+  # @example
+  #   class MyRepo < ROM::Repository[:users]
+  #     relations :users, :tasks
+  #
+  #     def users_with_tasks
+  #       users.combine_children(tasks: tasks).to_a
+  #     end
+  #   end
+  #
+  #   rom = ROM.container(:sql, 'sqlite::memory') do |conf|
+  #     conf.default.create_table(:users) do
+  #       primary_key :id
+  #       column :name, String
+  #     end
+  #
+  #     conf.default.create_table(:tasks) do
+  #       primary_key :id
+  #       column :user_id, Integer
+  #       column :title, String
+  #     end
+  #   end
+  #
+  #   my_repo = MyRepo.new(rom)
+  #   my_repo.users_with_tasks
+  #
+  # @see Repository::Root
+  #
+  # @api public
   class Repository
-    # Abstract repository class to inherit from
+    # @deprecated
+    class Base < Repository
+      def self.inherited(klass)
+        super
+        Deprecations.announce(self, 'inherit from Repository instead')
+      end
+    end
+
+    extend ClassInterface
+
+    # @!attribute [r] container
+    #   @return [ROM::Container] The container used to set up a repo
+    attr_reader :container
+
+    # @!attribute [r] relations
+    #   @return [RelationRegistry] The relation proxy registry used by a repo
+    attr_reader :relations
+
+    # @!attribute [r] mappers
+    #   @return [MapperBuilder] The auto-generated mappers for repo relations
+    attr_reader :mappers
+
+    # Initializes a new repo by establishing configured relation proxies from
+    # the passed container
     #
-    # TODO: rename this to Repository once deprecated Repository from rom core is gone
+    # @param container [ROM::Container] The rom container with relations and optional commands
     #
     # @api public
-    include Options
+    def initialize(container)
+      @container = container
+      @mappers = MapperBuilder.new
+      @relations = RelationRegistry.new do |registry, relations|
+        self.class.relations.each do |name|
+          relation = container.relation(name)
 
-    option :mapper_builder, reader: true, default: proc { MapperBuilder.new }
+          proxy = RelationProxy.new(
+            relation, name: name, mappers: mappers, registry: registry
+          )
+
+          instance_variable_set("@#{name}", proxy)
+
+          relations[name] = proxy
+        end
+      end
+    end
 
-    # Define which relations your repository is going to use
+    # @overload command(type, relation)
+    #   Returns a command for a relation
+    #
+    #   @example
+    #     repo.command(:create, repo.users)
+    #
+    #   @param type [Symbol] The command type (:create, :update or :delete)
+    #   @param relation [RelationProxy] The relation for which command should be built for
+    #
+    # @overload command(options)
+    #   Builds a command for a given relation identifier
+    #
+    #   @example
+    #     repo.command(create: :users)
+    #
+    #   @param options [Hash<Symbol=>Symbol>] A type => rel_name map
+    #
+    # @overload command(rel_name)
+    #   Returns command registry for a given relation identifier
+    #
+    #   @example
+    #     repo.command(:users)[:my_custom_command]
     #
-    # @example
-    #   class MyRepo < ROM::Repository::Base
-    #     relations :users, :tasks
-    #   end
+    #   @param rel_name [Symbol] The relation identifier from the container
     #
-    #   my_repo = MyRepo.new(rom_env)
+    #   @return [CommandRegistry]
     #
-    #   my_repo.users
-    #   my_repo.tasks
+    # @overload command(rel_name, &block)
+    #   Yields a command graph composer for a given relation identifier
     #
-    # @return [Array<Symbol>]
+    #   @param rel_name [Symbol] The relation identifier from the container
+    #
+    # @return [ROM::Command]
     #
     # @api public
-    def self.relations(*names)
-      if names.any?
-        attr_reader(*names)
-        @relations = names
+    def command(*args, **opts, &block)
+      all_args = args + opts.to_a.flatten
+
+      if all_args.size > 1
+        commands.fetch_or_store(all_args.hash) do
+          compile_command(*args, **opts)
+        end
       else
-        @relations
+        container.command(*args, &block)
       end
     end
 
-    # @api private
-    def initialize(env, options = {})
-      super
-      self.class.relations.each do |name|
-        proxy = LoadingProxy.new(
-          env.relation(name), name: name, mapper_builder: mapper_builder
-        )
-        instance_variable_set("@#{name}", proxy)
+    # @overload changeset(name, attributes)
+    #   Returns a create changeset for a given relation identifier
+    #
+    #   @example
+    #     repo.changeset(:users, name: "Jane")
+    #
+    #   @param name [Symbol] The relation container identifier
+    #   @param attributes [Hash]
+    #
+    #   @return [Changeset::Create]
+    #
+    # @overload changeset(name, restriction_arg, attributes)
+    #   Returns an update changeset for a given relation identifier
+    #
+    #   @example
+    #     repo.changeset(:users, 1, name: "Jane Doe")
+    #
+    #   @param name [Symbol] The relation container identifier
+    #   @param restriction_arg [Object] The argument passed to restricted view
+    #
+    #   @return [Changeset::Update]
+    #
+    # @api public
+    def changeset(*args)
+      if args.size == 2
+        name, data = args
+      elsif args.size == 3
+        name, pk, data = args
+      else
+        raise ArgumentError, 'Repository#changeset accepts 2 or 3 arguments'
+      end
+
+      relation = relations[name]
+
+      if pk
+        Changeset::Update.new(relation, data, primary_key: pk)
+      else
+        Changeset::Create.new(relation, data)
       end
     end
 
-    class Base < Repository
-      def self.inherited(klass)
-        super
-        Deprecations.announce(self, 'inherit from Repository instead')
+    private
+
+    # Local command cache
+    #
+    # @api private
+    def commands
+      @__commands__ ||= Concurrent::Map.new
+    end
+
+    # Build a new command or return existing one
+    #
+    # @api private
+    def compile_command(*args, mapper: nil, use: nil, **opts)
+      type, name = args + opts.to_a.flatten(1)
+
+      relation = name.is_a?(Symbol) ? relations[name] : name
+
+      ast = relation.to_ast
+      adapter = relations[relation.name].adapter
+
+      if mapper
+        mapper_instance = container.mappers[relation.name.relation][mapper]
+      else
+        mapper_instance = mappers[ast]
       end
+
+      command = CommandCompiler[container, type, adapter, ast, use]
+      command >> mapper_instance
+    end
+
+    # @api private
+    def map_tuple(relation, tuple)
+      relations[relation.name].mapper.([tuple]).first
     end
   end
 end

data/lib/rom/struct.rb

@@ -1,7 +1,3 @@
-require 'anima'
-
-require 'rom/support/class_builder'
-
 module ROM
   # Simple data-struct
   #
@@ -9,7 +5,7 @@ module ROM
   #
   # @api public
   class Struct
-    # Coerce to hash
+    # Coerces a struct to a hash
     #
     # @return [Hash]
     #
@@ -18,15 +14,24 @@ module ROM
       to_h
     end
 
-    # Access attribute value
+    # Reads an attribute value
     #
-    # @param [Symbol] name The name of the attribute
+    # @param name [Symbol] The name of the attribute
     #
     # @return [Object]
     #
     # @api public
     def [](name)
-      instance_variable_get("@#{name}")
+      __send__(name)
+    end
+
+    # Returns a short string representation
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_s
+      "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
     end
   end
 end

data/rom-repository.gemspec

@@ -4,22 +4,21 @@ require File.expand_path('../lib/rom/repository/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = 'rom-repository'
-  gem.summary       = 'Repository for ROM with auto-mapping and relation extensions'
-  gem.description   = gem.summary
+  gem.summary       = 'Repository abstraction for rom-rb'
+  gem.description   = 'rom-repository adds support for auto-mapping and commands on top of rom-rb relations'
   gem.author        = 'Piotr Solnica'
-  gem.email         = 'piotr.solnica@gmail.com'
+  gem.email         = 'piotr.solnica+oss@gmail.com'
   gem.homepage      = 'http://rom-rb.org'
   gem.require_paths = ['lib']
   gem.version       = ROM::Repository::VERSION.dup
-  gem.files         = `git ls-files`.split("\n").reject { |name| name.include?('benchmarks') }
+  gem.files         = `git ls-files`.split("\n").reject { |name| name.include?('benchmarks') || name.include?('examples') || name.include?('bin') }
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_runtime_dependency 'anima', '~> 0.2', '>= 0.2'
-  gem.add_runtime_dependency 'rom', '~> 1.0.0'
-  gem.add_runtime_dependency 'rom-support', '~> 1.0.0'
-  gem.add_runtime_dependency 'rom-mapper', '~> 0.3.0'
+  gem.add_runtime_dependency 'rom', '~> 2.0'
+  gem.add_runtime_dependency 'rom-support', '~> 2.0'
+  gem.add_runtime_dependency 'rom-mapper', '~> 0.4'
 
-  gem.add_development_dependency 'rake', '~> 10.3'
-  gem.add_development_dependency 'rspec', '~> 3.3'
+  gem.add_development_dependency 'rake', '~> 11.2'
+  gem.add_development_dependency 'rspec', '~> 3.5'
 end

data/spec/integration/changeset_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe 'Using changesets' do
+  include_context 'database'
+  include_context 'relations'
+
+  describe 'Create' do
+    subject(:repo) do
+      Class.new(ROM::Repository[:users]) {
+        relations :books, :posts
+        commands :create, update: :by_pk
+      }.new(rom)
+    end
+
+    it 'can be passed to a command' do
+      changeset = repo.changeset(name: "Jane Doe")
+      command = repo.command(:create, repo.users)
+      result = command.(changeset)
+
+      expect(result.id).to_not be(nil)
+      expect(result.name).to eql("Jane Doe")
+    end
+
+    it 'can be passed to a command graph' do
+      changeset = repo.changeset(
+        name: "Jane Doe", posts: [{ title: "Just Do It", alien: "or sutin" }]
+      )
+
+      command = repo.command(:create, repo.aggregate(:posts))
+      result = command.(changeset)
+
+      expect(result.id).to_not be(nil)
+      expect(result.name).to eql("Jane Doe")
+      expect(result.posts.size).to be(1)
+      expect(result.posts[0].title).to eql("Just Do It")
+    end
+
+    it 'preprocesses data using changeset pipes' do
+      changeset = repo.changeset(:books, title: "rom-rb is awesome").map(:add_timestamps)
+      command = repo.command(:create, repo.books)
+      result = command.(changeset)
+
+      expect(result.id).to_not be(nil)
+      expect(result.title).to eql("rom-rb is awesome")
+      expect(result.created_at).to be_instance_of(Time)
+      expect(result.updated_at).to be_instance_of(Time)
+    end
+  end
+
+  describe 'Update' do
+    subject(:repo) do
+      Class.new(ROM::Repository[:books]) {
+        commands :create, update: :by_pk
+      }.new(rom)
+    end
+
+    it 'can be passed to a command' do
+      book = repo.create(title: 'rom-rb is awesome')
+
+      changeset = repo
+        .changeset(book.id, title: 'rom-rb is awesome for real')
+        .map(:touch)
+
+      expect(changeset.diff).to eql(title: 'rom-rb is awesome for real')
+
+      result = repo.update(book.id, changeset)
+
+      expect(result.id).to be(book.id)
+      expect(result.title).to eql('rom-rb is awesome for real')
+      expect(result.updated_at).to be_instance_of(Time)
+    end
+
+    it 'skips update execution with no diff' do
+      book = repo.create(title: 'rom-rb is awesome')
+
+      changeset = repo
+        .changeset(book.id, title: 'rom-rb is awesome')
+
+      expect(changeset).to_not be_diff
+
+      result = repo.update(book.id, changeset)
+
+      expect(result.id).to be(book.id)
+      expect(result.title).to eql('rom-rb is awesome')
+      expect(result.updated_at).to be(nil)
+    end
+  end
+end