rom-repository 1.4.0 → 2.0.0.beta1

data/lib/rom/repository/relation_proxy/wrap.rb

@@ -1,78 +0,0 @@
-module ROM
-  class Repository
-    class RelationProxy
-      # Provides convenient methods for producing wrapped relations
-      #
-      # @api public
-      module Wrap
-        # Wrap other relations
-        #
-        # @example
-        #   tasks.wrap(owner: [users, user_id: :id])
-        #
-        # @param [Hash] options
-        #
-        # @return [RelationProxy]
-        #
-        # @api public
-        def wrap(*names, **options)
-          new_wraps = wraps_from_names(names) + wraps_from_options(options)
-
-          relation = new_wraps.reduce(self) { |a, e|
-            name = e.meta[:wrap_from_assoc] ? e.meta[:combine_name] : e.base_name.relation
-            a.relation.for_wrap(e.meta.fetch(:keys), name)
-          }
-
-          __new__(relation, meta: { wraps: wraps + new_wraps })
-        end
-
-        # Shortcut to wrap parents
-        #
-        # @example
-        #   tasks.wrap_parent(owner: users)
-        #
-        # @return [RelationProxy]
-        #
-        # @api public
-        def wrap_parent(options)
-          wrap(
-            options.each_with_object({}) { |(name, parent), h|
-              keys = combine_keys(parent, relation, :children)
-              h[name] = [parent, keys]
-            }
-          )
-        end
-
-        # Return a wrapped representation of a loading-proxy relation
-        #
-        # This will carry meta info used to produce a correct AST from a relation
-        # so that correct mapper can be generated
-        #
-        # @return [RelationProxy]
-        #
-        # @api private
-        def wrapped(name, keys, wrap_from_assoc = false)
-          with(
-            name: name,
-            meta: {
-              keys: keys, wrap_from_assoc: wrap_from_assoc, wrap: true, combine_name: name
-            }
-          )
-        end
-
-        # @api private
-        def wraps_from_options(options)
-          options.map { |(name, (relation, keys))| relation.wrapped(name, keys) }
-        end
-
-        # @api private
-        def wraps_from_names(names)
-          names.map { |name|
-            assoc = associations[name]
-            registry[assoc.target.relation].wrapped(name, assoc.combine_keys(__registry__), true)
-          }
-        end
-      end
-    end
-  end
-end

data/lib/rom/repository/struct_builder.rb

@@ -1,83 +0,0 @@
-require 'dry/core/inflector'
-require 'dry/core/cache'
-require 'dry/core/class_builder'
-
-require 'rom/struct'
-require 'rom/open_struct'
-require 'rom/schema/attribute'
-
-module ROM
-  class Repository
-    # @api private
-    class StructBuilder
-      extend Dry::Core::Cache
-
-      def call(*args)
-        fetch_or_store(*args) do
-          name, header = args
-          attributes = visit(header).compact
-
-          if attributes.empty?
-            ROM::OpenStruct
-          else
-            build_class(name, ROM::Struct) do |klass|
-              attributes.each do |(name, type)|
-                klass.attribute(name, type)
-              end
-            end
-          end
-        end
-      end
-      alias_method :[], :call
-
-      attr_reader :namespace
-
-      def initialize(namespace = nil)
-        @namespace = namespace || ROM::Struct
-      end
-
-      private
-
-      def visit(ast)
-        name, node = ast
-        __send__("visit_#{name}", node)
-      end
-
-      def visit_header(node)
-        node.map(&method(:visit))
-      end
-
-      def visit_relation(node)
-        relation_name, meta, header = node
-        name = meta[:combine_name] || relation_name.relation
-
-        model = meta.fetch(:model) { call(name, header) }
-
-        member =
-          if model < Dry::Struct
-            model
-          else
-            Dry::Types::Definition.new(model).constructor(&model.method(:new))
-          end
-
-        if meta[:combine_type] == :many
-          [name, Types::Array.member(member)]
-        else
-          [name, member.optional]
-        end
-      end
-
-      def visit_attribute(attr)
-        [attr.aliased? && !attr.wrapped? ? attr.alias : attr.name, attr.to_read_type]
-      end
-
-      def build_class(name, parent, &block)
-        Dry::Core::ClassBuilder.new(name: class_name(name), parent: parent, namespace: namespace).call(&block)
-      end
-
-      def class_name(name)
-        Dry::Core::Inflector.classify(Dry::Core::Inflector.singularize(name))
-      end
-    end
-  end
-end

data/lib/rom/struct.rb

@@ -1,113 +0,0 @@
-require 'dry/struct'
-
-module ROM
-  # Simple data-struct class
-  #
-  # ROM structs are plain data structures loaded by repositories.
-  # They implement Hash protocol which means that they can be used
-  # in places where Hash-like objects are supported.
-  #
-  # Repositories define subclasses of ROM::Struct automatically, they are
-  # defined in the ROM::Struct namespace by default, but you set it up
-  # to use your namespace/module as well.
-  #
-  # Structs are based on dry-struct gem, they include `schema` with detailed information
-  # about attribute types returned from relations, thus can be introspected to build
-  # additional functionality when desired.
-  #
-  # There is a caveat you should know about when working with structs. Struct classes
-  # have names but at the same time they're anonymous, i.e. you can't get the User struct class
-  # with ROM::Struct::User. ROM will create as many struct classes for User as needed,
-  # they all will have the same name and ROM::Struct::User will be the common parent class for
-  # them. Combined with the ability to provide your own namespace for structs this enables to
-  # pre-define the parent class.
-  #
-  # @example accessing relation struct model
-  #   rom = ROM.container(:sql, 'sqlite::memory') do |conf|
-  #     conf.default.create_table(:users) do
-  #       primary_key :id
-  #       column :name, String
-  #     end
-  #   end
-  #
-  #   class UserRepo < ROM::Repository[:users]
-  #   end
-  #
-  #   user_repo = UserRepo.new(rom)
-  #
-  #   # get auto-generated User struct
-  #   model = user_repo.users.mapper.model
-  #   # => ROM::Struct::User
-  #
-  #   # see struct's schema attributes
-  #
-  #   # model.schema[:id]
-  #   # => #<Dry::Types::Constrained type=#<Dry::Types::Definition primitive=Integer options={}> options={:rule=>#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#gt?> options={:args=>[0]}>, :meta=>{:primary_key=>true, :name=>:id, :source=>ROM::Relation::Name(users)}} rule=#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#gt?> options={:args=>[0]}>>
-  #
-  #   model.schema[:name]
-  #   # => #<Dry::Types::Sum left=#<Dry::Types::Constrained type=#<Dry::Types::Definition primitive=NilClass options={}> options={:rule=>#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[NilClass]}>} rule=#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[NilClass]}>> right=#<Dry::Types::Definition primitive=String options={}> options={:meta=>{:name=>:name, :source=>ROM::Relation::Name(users)}}>
-  #
-  # @example passing a namespace with an existing parent class
-  #   module Entities
-  #     class User < ROM::Struct
-  #       def upcased_name
-  #         name.upcase
-  #       end
-  #     end
-  #   end
-  #
-  #   class UserRepo < ROM::Repository[:users]
-  #     struct_namespace Entities
-  #   end
-  #
-  #   user_repo = UserRepo.new(rom)
-  #   user = user_repo.users.by_pk(1).one!
-  #   user.name # => "Jane"
-  #   user.upcased_name # => "JANE"
-  #
-  # @see http://dry-rb.org/gems/dry-struct dry-struct
-  # @see http://dry-rb.org/gems/dry-types dry-types
-  #
-  # @api public
-  class Struct < Dry::Struct
-    MissingAttribute = Class.new(NameError)
-
-    # Returns a short string representation
-    #
-    # @return [String]
-    #
-    # @api public
-    def to_s
-      "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
-    end
-
-    # Return attribute value
-    #
-    # @param [Symbol] name The attribute name
-    #
-    # @api public
-    def fetch(name)
-      __send__(name)
-    end
-
-    if RUBY_VERSION < '2.3'
-      # @api private
-      def respond_to?(*)
-        super
-      end
-    else
-      # @api private
-      def respond_to_missing?(*)
-        super
-      end
-    end
-
-    private
-
-    def method_missing(method, *)
-      super
-    rescue NameError => error
-      raise MissingAttribute.new("#{ error.message } (not loaded attribute?)")
-    end
-  end
-end

data/rom-repository.gemspec

@@ -1,23 +0,0 @@
-require File.expand_path('../lib/rom/repository/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.name          = 'rom-repository'
-  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+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') || name.include?('examples') || name.include?('bin/console') }
-  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  gem.license       = 'MIT'
-
-  gem.add_runtime_dependency 'rom', '~> 3.3'
-  gem.add_runtime_dependency 'rom-mapper', '~> 0.5'
-  gem.add_runtime_dependency 'dry-core', '~> 0.3', '>= 0.3.1'
-  gem.add_runtime_dependency 'dry-struct', '~> 0.3'
-
-  gem.add_development_dependency 'rake', '~> 11.2'
-  gem.add_development_dependency 'rspec', '~> 3.5'
-end

data/spec/integration/changeset_spec.rb

@@ -1,193 +0,0 @@
-RSpec.describe 'Using changesets' do
-  include_context 'database'
-  include_context 'relations'
-
-  before do
-    module Test
-      class User < Dry::Struct
-        attribute :id, Dry::Types['strict.int']
-        attribute :name, Dry::Types['strict.string']
-      end
-    end
-
-    configuration.mappers do
-      define(:users) do
-        model Test::User
-        register_as :user
-      end
-    end
-  end
-
-  describe 'Create' do
-    subject(:repo) do
-      Class.new(ROM::Repository[:users]) {
-        relations :books, :posts
-        commands :create, update: :by_pk
-      }.new(rom)
-    end
-
-    let(:create_changeset) do
-      Class.new(ROM::Changeset::Create)
-    end
-
-    let(:add_book_changeset) do
-      Class.new(ROM::Changeset::Create[:books])
-    end
-
-    let(:update_changeset) do
-      Class.new(ROM::Changeset::Update)
-    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
-
-    it 'preprocesses data using custom block' do
-      changeset = repo.
-                    changeset(:books, title: "rom-rb is awesome").
-                    map { |tuple| tuple.merge(created_at: Time.now) }
-
-      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)
-    end
-
-    it 'preprocesses data using built-in steps and custom block' do
-      changeset = repo.
-                    changeset(:books, title: "rom-rb is awesome").
-                    extend(:touch) { |tuple| tuple.merge(created_at: Time.now) }
-
-      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
-
-    it 'preserves relation mappers with create' do
-      changeset = repo.
-                    changeset(create_changeset).
-                    new(repo.users.relation.as(:user)).
-                    data(name: 'Joe Dane')
-
-      expect(changeset.commit).to eql(Test::User.new(id: 1, name: 'Joe Dane'))
-    end
-
-    it 'creates changesets for non-root relations' do
-      repo.create(name: 'John Doe')
-      changeset = repo.changeset(add_book_changeset).data(title: 'The War of the Worlds')
-
-      expect(changeset.commit).
-        to include(
-             id: 1,
-             title: 'The War of the Worlds',
-             created_at: nil,
-             updated_at: nil
-           )
-    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')
-        .extend(: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')
-        .extend(:touch)
-
-      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
-
-    it 'works with mixed several class-level pipes' do
-      book = repo.create(title: 'rom-rb is awesome')
-
-      changeset_class = Class.new(ROM::Changeset::Update[:books]) do
-        map { |title: | { title: title.upcase } }
-        extend { |title: | { title: title.reverse } }
-      end
-
-      changeset = repo
-                    .changeset(changeset_class)
-                    .by_pk(book.id)
-                    .data(title: 'rom-rb is really awesome')
-
-      expect(changeset.diff).to eql(title: 'ROM-RB IS REALLY AWESOME')
-      expect(changeset.to_h).to eql(title: 'EMOSEWA YLLAER SI BR-MOR')
-    end
-
-    it 'works with mixed several instance-level pipes' do
-      book = repo.create(title: 'rom-rb is awesome')
-
-      changeset = repo.
-                    changeset(book.id, title: 'rom-rb is really awesome').
-                    map { |title: | { title: title.upcase } }.
-                    extend { |title: | { title: title.reverse } }
-
-      expect(changeset.diff).to eql(title: 'ROM-RB IS REALLY AWESOME')
-      expect(changeset.to_h).to eql(title: 'EMOSEWA YLLAER SI BR-MOR')
-    end
-  end
-end