rom-changeset 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b4010fdeeb763d04e4e1c0cd146bbfd123fc460
+  data.tar.gz: 2c25d797f66b6216627905972a354a2623cd032a
+SHA512:
+  metadata.gz: de4a0796579499bdd43cd62f7d027c6d7cb8dd8b9c28880e99b1aae447826ad66d1fd7b0cb597297a3d41cb55f2a34631b63a485f2f086d288ce010a6f175634
+  data.tar.gz: 0e11da9812bf7f6df158b42a47cea85dc6976d12df223ac008aed426460928c6f657ca58e57d7ba26552b541576fae27e057922eebb3400702b85df4fbf3aa8e

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# 1.0.0 to-be-released
+
+rom-changeset was extracted from rom-repository
+
+### Added
+
+- `#changeset` interfaced was ported to a relation plugin and now `Relation#changeset` is available (solnic)
+
+### Changed
+
+- Changesets are no longer coupled to repositories (solnic)
+- Changesets use relations to retrieve their commands (solnic)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013-2017 rom-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# rom-changeset
+
+Resources:
+
+## License
+
+See `LICENSE` file.

data/lib/rom/changeset/associated.rb

@@ -0,0 +1,100 @@
+require 'rom/initializer'
+
+module ROM
+  class Changeset
+    # Associated changesets automatically set up FKs
+    #
+    # @api public
+    class Associated
+      extend Initializer
+
+      # @!attribute [r] left
+      #   @return [Changeset::Create] Child changeset
+      param :left
+
+      # @!attribute [r] associations
+      #   @return [Array] List of association identifiers from relation schema
+      option :associations
+
+      # Infer association name from an object with a schema
+      #
+      # This expects other to be an object with a schema that includes a primary key
+      # attribute with :source meta information. This makes it work with both structs
+      # and relations
+      #
+      # @see Stateful#associate
+      #
+      # @api private
+      def self.infer_assoc_name(other)
+        schema = other.class.schema
+        attrs = schema.is_a?(Hash) ? schema.values : schema
+        pk = attrs.detect { |attr| attr.meta[:primary_key] }
+
+        if pk
+          pk.meta[:source]
+        else
+          raise ArgumentError, "can't infer association name for #{other}"
+        end
+      end
+
+      # Commit changeset's composite command
+      #
+      # @example
+      #   task_changeset = task_repo.
+      #     changeset(title: 'Task One').
+      #     associate(user, :user).
+      #     commit
+      #   # {:id => 1, :user_id => 1, title: 'Task One'}
+      #
+      # @return [Array<Hash>, Hash]
+      #
+      # @api public
+      def commit
+        command.call
+      end
+
+      # @api public
+      def associate(other, name = Associated.infer_assoc_name(other))
+        self.class.new(left, associations: associations.merge(name => other))
+      end
+
+      # Create a composed command
+      #
+      # @example using existing parent data
+      #   user_changeset = user_repo.changeset(name: 'Jane')
+      #   task_changeset = task_repo.changeset(title: 'Task One')
+      #
+      #   user = user_repo.create(user_changeset)
+      #   task = task_repo.create(task_changeset.associate(user, :user))
+      #
+      # @example saving both parent and child in one go
+      #   user_changeset = user_repo.changeset(name: 'Jane')
+      #   task_changeset = task_repo.changeset(title: 'Task One')
+      #
+      #   task = task_repo.create(task_changeset.associate(user, :user))
+      #
+      # This works *only* with parent => child(ren) changeset hierarchy
+      #
+      # @return [ROM::Command::Composite]
+      #
+      # @api public
+      def command
+        associations.reduce(left.command.curry(left)) do |a, (assoc, other)|
+          case other
+          when Changeset
+            a >> other.command.with_association(assoc).curry(other)
+          when Associated
+            a >> other.command.with_association(assoc)
+          else
+            a.with_association(assoc, parent: other)
+          end
+        end
+      end
+
+      # @api private
+      def relation
+        left.relation
+      end
+    end
+  end
+end

data/lib/rom/changeset/create.rb

@@ -0,0 +1,16 @@
+module ROM
+  class Changeset
+    # Changeset specialization for create commands
+    #
+    # @see Changeset::Stateful
+    #
+    # @api public
+    class Create < Stateful
+      command_type :create
+
+      def command
+        super.new(relation)
+      end
+    end
+  end
+end

data/lib/rom/changeset/delete.rb

@@ -0,0 +1,17 @@
+require 'rom/changeset/restricted'
+
+module ROM
+  class Changeset
+    # Changeset specialization for delete commands
+    #
+    # Delete changesets will execute delete command for its relation, which
+    # means proper restricted relations should be used with this changeset.
+    #
+    # @api public
+    class Delete < Changeset
+      include Restricted
+
+      command_type :delete
+    end
+  end
+end

data/lib/rom/changeset/pipe.rb

@@ -0,0 +1,92 @@
+require 'transproc/all'
+require 'transproc/registry'
+require 'transproc/transformer'
+
+module ROM
+  class Changeset
+    # Transproc Registry useful for pipe
+    #
+    # @api private
+    module PipeRegistry
+      extend Transproc::Registry
+
+      import Transproc::HashTransformations
+
+      def self.add_timestamps(data)
+        now = Time.now
+        data.merge(created_at: now, updated_at: now)
+      end
+
+      def self.touch(data)
+        data.merge(updated_at: Time.now)
+      end
+    end
+
+    # Composable data transformation pipe used by default in changesets
+    #
+    # @api private
+    class Pipe < Transproc::Transformer[PipeRegistry]
+      extend Initializer
+
+      param :processor, default: -> { self.class.transproc }
+      option :diff_processor, optional: true
+      option :use_for_diff, optional: true, default: -> { true }
+
+      def self.[](name)
+        container[name]
+      end
+
+      def [](name)
+        self.class[name]
+      end
+
+      def bind(context)
+        if processor.is_a?(Proc)
+          self.class.new(Pipe[-> *args { context.instance_exec(*args, &processor) }])
+        else
+          self
+        end
+      end
+
+      def compose(other, for_diff: other.is_a?(Pipe) ? other.use_for_diff : false)
+        new_proc = processor ? processor >> other : other
+
+        if for_diff
+          diff_proc = diff_processor ? diff_processor >> other : other
+          new(new_proc, diff_processor: diff_proc)
+        else
+          new(new_proc)
+        end
+      end
+      alias_method :>>, :compose
+
+      def call(data)
+        if processor
+          processor.call(data)
+        else
+          data
+        end
+      end
+
+      def for_diff(data)
+        if diff_processor
+          diff_processor.call(data)
+        else
+          data
+        end
+      end
+
+      def with(opts)
+        if opts.empty?
+          self
+        else
+          Pipe.new(processor, options.merge(opts))
+        end
+      end
+
+      def new(processor, opts = EMPTY_HASH)
+        Pipe.new(processor, options.merge(opts))
+      end
+    end
+  end
+end

data/lib/rom/changeset/restricted.rb

@@ -0,0 +1,28 @@
+module ROM
+  class Changeset
+    module Restricted
+      # Return a command restricted by the changeset's relation
+      #
+      # @see Changeset#command
+      #
+      # @api private
+      def command
+        super.new(relation)
+      end
+
+      # Restrict changeset's relation by its PK
+      #
+      # @example
+      #   repo.changeset(UpdateUser).by_pk(1).data(name: "Jane")
+      #
+      # @param [Object] pk
+      #
+      # @return [Changeset]
+      #
+      # @api public
+      def by_pk(pk, data = EMPTY_HASH)
+        new(relation.by_pk(pk), __data__: data)
+      end
+    end
+  end
+end

data/lib/rom/changeset/stateful.rb

@@ -0,0 +1,280 @@
+require 'rom/changeset/pipe'
+
+module ROM
+  class Changeset
+    # Stateful changesets carry data and can transform it into
+    # a different structure compatible with a persistence backend
+    #
+    # @abstract
+    class Stateful < Changeset
+      # Default no-op pipe
+      EMPTY_PIPE = Pipe.new.freeze
+
+      # @!attribute [r] __data__
+      #   @return [Hash] The relation data
+      #   @api private
+      option :__data__, optional: true
+
+      # @!attribute [r] pipe
+      #   @return [Changeset::Pipe] data transformation pipe
+      #   @api private
+      option :pipe, reader: false, optional: true
+
+      # Define a changeset mapping
+      #
+      # Subsequent mapping definitions will be composed together
+      # and applied in the order they way defined
+      #
+      # @example Transformation DSL
+      #   class NewUser < ROM::Changeset::Create
+      #     map do
+      #       unwrap :address, prefix: true
+      #     end
+      #   end
+      #
+      # @example Using custom block
+      #   class NewUser < ROM::Changeset::Create
+      #     map do |tuple|
+      #       tuple.merge(created_at: Time.now)
+      #     end
+      #   end
+      #
+      # @example Multiple mappings (executed in the order of definition)
+      #   class NewUser < ROM::Changeset::Create
+      #     map do
+      #       unwrap :address, prefix: true
+      #     end
+      #
+      #     map do |tuple|
+      #       tuple.merge(created_at: Time.now)
+      #     end
+      #   end
+      #
+      # @return [Array<Pipe>, Transproc::Function>]
+      #
+      # @see https://github.com/solnic/transproc Transproc
+      #
+      # @api public
+      def self.map(options = EMPTY_HASH, &block)
+        if block.parameters.empty?
+          pipes << Class.new(Pipe, &block).new(options)
+        else
+          pipes << Pipe.new(block, options)
+        end
+      end
+
+      # Define a changeset mapping excluded from diffs
+      #
+      # @see Changeset::Stateful.map
+      # @see Changeset::Stateful#extend
+      #
+      # @return [Array<Pipe>, Transproc::Function>]
+      #
+      # @api public
+      def self.extend(*, &block)
+        if block
+          map(use_for_diff: false, &block)
+        else
+          super
+        end
+      end
+
+      # Build default pipe object
+      #
+      # This can be overridden in a custom changeset subclass
+      #
+      # @return [Pipe]
+      def self.default_pipe(context)
+        pipes.size > 0 ? pipes.map { |p| p.bind(context) }.reduce(:>>) : EMPTY_PIPE
+      end
+
+      # @api private
+      def self.inherited(klass)
+        return if klass == ROM::Changeset
+        super
+        klass.instance_variable_set(:@__pipes__, pipes ? pipes.dup : EMPTY_ARRAY)
+      end
+
+      # @api private
+      def self.pipes
+        @__pipes__
+      end
+
+      # Pipe changeset's data using custom steps define on the pipe
+      #
+      # @overload map(*steps)
+      #   Apply mapping using built-in transformations
+      #
+      #   @example
+      #     changeset.map(:add_timestamps)
+      #
+      #   @param [Array<Symbol>] steps A list of mapping steps
+      #
+      # @overload map(&block)
+      #   Apply mapping using a custom block
+      #
+      #   @example
+      #     changeset.map { |tuple| tuple.merge(created_at: Time.now) }
+      #
+      # @overload map(*steps, &block)
+      #   Apply mapping using built-in transformations and a custom block
+      #
+      #   @example
+      #     changeset.map(:add_timestamps) { |tuple| tuple.merge(status: 'published') }
+      #
+      #   @param [Array<Symbol>] steps A list of mapping steps
+      #
+      # @return [Changeset]
+      #
+      # @api public
+      def map(*steps, &block)
+        extend(*steps, for_diff: true, &block)
+      end
+
+      # Pipe changeset's data using custom steps define on the pipe.
+      # You should use #map instead except updating timestamp fields.
+      # Calling changeset.extend builds a pipe that excludes certain
+      # steps for generating the diff. Currently the only place where
+      # it is used is update changesets with the `:touch` step, i.e.
+      # `changeset.extend(:touch).diff` will exclude `:updated_at`
+      # from the diff.
+      #
+      # @see Changeset::Stateful#map
+      #
+      # @return [Changeset]
+      #
+      # @api public
+      def extend(*steps, **options, &block)
+        if block
+          if steps.size > 0
+            extend(*steps, options).extend(options, &block)
+          else
+            with(pipe: pipe.compose(Pipe.new(block).bind(self), options))
+          end
+        else
+          with(pipe: steps.reduce(pipe.with(options)) { |a, e| a.compose(pipe[e], options) })
+        end
+      end
+
+      # Return changeset with data
+      #
+      # @param [Hash] data
+      #
+      # @return [Changeset]
+      #
+      # @api public
+      def data(data)
+        with(__data__: data)
+      end
+
+      # Coerce changeset to a hash
+      #
+      # This will send the data through the pipe
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        pipe.call(__data__)
+      end
+      alias_method :to_hash, :to_h
+
+      # Coerce changeset to an array
+      #
+      # This will send the data through the pipe
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_a
+        result == :one ? [to_h] : __data__.map { |element| pipe.call(element) }
+      end
+      alias_method :to_ary, :to_a
+
+      # Commit stateful changeset
+      #
+      # @see Changeset#commit
+      #
+      # @api public
+      def commit
+        command.call(self)
+      end
+
+      # Associate a changeset with another changeset or hash-like object
+      #
+      # @example with another changeset
+      #   new_user = user_repo.changeset(name: 'Jane')
+      #   new_task = user_repo.changeset(:tasks, title: 'A task')
+      #
+      #   new_task.associate(new_user, :users)
+      #
+      # @example with a hash-like object
+      #   user = user_repo.users.by_pk(1).one
+      #   new_task = user_repo.changeset(:tasks, title: 'A task')
+      #
+      #   new_task.associate(user, :users)
+      #
+      # @param [#to_hash, Changeset] other Other changeset or hash-like object
+      # @param [Symbol] assoc The association identifier from schema
+      #
+      # @api public
+      def associate(other, name = Associated.infer_assoc_name(other))
+        Associated.new(self, associations: { name => other })
+      end
+
+      # Return command result type
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      def result
+        __data__.is_a?(Array) ? :many : :one
+      end
+
+      # @api public
+      def command
+        relation.command(command_type, DEFAULT_COMMAND_OPTS.merge(result: result))
+      end
+
+      # Return string representation of the changeset
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        %(#<#{self.class} relation=#{relation.name.inspect} data=#{__data__}>)
+      end
+
+      # Data transformation pipe
+      #
+      # @return [Changeset::Pipe]
+      #
+      # @api private
+      def pipe
+        @pipe ||= self.class.default_pipe(self)
+      end
+
+      private
+
+      # @api private
+      def respond_to_missing?(meth, include_private = false)
+        super || __data__.respond_to?(meth)
+      end
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if __data__.respond_to?(meth)
+          response = __data__.__send__(meth, *args, &block)
+
+          if response.is_a?(__data__.class)
+            with(__data__: response)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rom/changeset/update.rb

@@ -0,0 +1,83 @@
+require 'rom/changeset/restricted'
+
+module ROM
+  class Changeset
+    # Changeset specialization for update commands
+    #
+    # Update changesets will only execute their commands when
+    # the data is different from the original tuple. Original tuple
+    # is fetched from changeset's relation using `by_pk` relation view.
+    # This means the underlying adapter must provide this view, or you
+    # you need to implement it yourself in your relations if you want to
+    # use Update changesets.
+    #
+    # @see Changeset::Stateful
+    #
+    # @api public
+    class Update < Stateful
+      include Restricted
+
+      command_type :update
+
+      # Commit update changeset if there's a diff
+      #
+      # This returns original tuple if there's no diff
+      #
+      # @return [Hash]
+      #
+      # @see Changeset#commit
+      #
+      # @api public
+      def commit
+        diff? ? super : original
+      end
+
+      # Return original tuple that this changeset may update
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def original
+        @original ||= relation.one
+      end
+
+      # Return true if there's a diff between original and changeset data
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api public
+      def diff?
+        ! diff.empty?
+      end
+
+      # Return if there's no diff between the original and changeset data
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api public
+      def clean?
+        diff.empty?
+      end
+
+      # Calculate the diff between the original and changeset data
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def diff
+        @diff ||=
+          begin
+            source = Hash(original)
+            data = pipe.for_diff(__data__)
+            data_tuple = data.to_a
+            data_keys = data.keys & source.keys
+
+            new_tuple = data_tuple.to_a.select { |(k, _)| data_keys.include?(k) }
+            ori_tuple = source.to_a.select { |(k, _)| data_keys.include?(k) }
+
+            Hash[new_tuple - (new_tuple & ori_tuple)]
+          end
+      end
+    end
+  end
+end

data/lib/rom/changeset/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  class Changeset
+    VERSION = '1.0.0.beta1'.freeze
+  end
+end

data/lib/rom/changeset.rb

@@ -0,0 +1,145 @@
+require 'dry/core/class_attributes'
+require 'dry/core/cache'
+
+require 'rom/constants'
+require 'rom/initializer'
+
+module ROM
+  # Abstract Changeset class
+  #
+  # If you inherit from this class you need to configure additional settings
+  #
+  # @example define a custom changeset using :upsert command
+  #   class NewTag < ROM::Changeset[:tags]
+  #     command_type :upsert
+  #   end
+  #
+  # @abstract
+  class Changeset
+    DEFAULT_COMMAND_OPTS = { mapper: false }.freeze
+
+    extend Initializer
+    extend Dry::Core::Cache
+    extend Dry::Core::ClassAttributes
+
+    # @!method self.command_type
+    #   Get or set changeset command type
+    #
+    #   @overload command_type
+    #     Return configured command_type
+    #     @return [Symbol]
+    #
+    #   @overload command_type(identifier)
+    #     Set relation identifier for this changeset
+    #     @param [Symbol] identifier The command type identifier
+    #     @return [Symbol]
+    defines :command_type
+
+    # @!method self.relation
+    #   Get or set changeset relation identifier
+    #
+    #   @overload relation
+    #     Return configured relation identifier for this changeset
+    #     @return [Symbol]
+    #
+    #   @overload relation(identifier)
+    #     Set relation identifier for this changeset
+    #     @param [Symbol] identifier The relation identifier from the ROM container
+    #     @return [Symbol]
+    defines :relation
+
+    # @!attribute [r] relation
+    #   @return [Relation] The changeset relation
+    param :relation
+
+    # @!attribute [r] command_type
+    #   @return [Symbol] a custom command identifier
+    option :command_type, default: -> { self.class.command_type }
+
+    # Create a changeset class preconfigured for a specific relation
+    #
+    # @example
+    #   class NewUserChangeset < ROM::Changeset::Create[:users]
+    #   end
+    #
+    #   user_repo.changeset(NewUserChangeset).data(name: 'Jane')
+    #
+    # @api public
+    def self.[](relation_name)
+      fetch_or_store([relation_name, self]) {
+        Class.new(self) { relation(relation_name) }
+      }
+    end
+
+    # Return a new changeset with updated options
+    #
+    # @example
+    #   class NewUser < ROM::Changeset::Create[:users]
+    #     option :token_generator
+    #   end
+    #
+    #   changeset = user_repo.changeset(NewUser).with(token_generator: my_token_gen)
+    #
+    # @param [Hash] new_options The new options
+    #
+    # @return [Changeset]
+    #
+    # @api public
+    def with(new_options)
+      self.class.new(relation, options.merge(new_options))
+    end
+
+    # Return a new changeset with provided relation
+    #
+    # New options can be provided too
+    #
+    # @param [Relation] relation
+    # @param [Hash] options
+    #
+    # @return [Changeset]
+    #
+    # @api public
+    def new(relation, new_options = EMPTY_HASH)
+      self.class.new(relation, new_options.empty? ? options : options.merge(new_options))
+    end
+
+    # Persist changeset
+    #
+    # @example
+    #   changeset = user_repo.changeset(name: 'Jane')
+    #   changeset.commit
+    #   # => { id: 1, name: 'Jane' }
+    #
+    # @return [Hash, Array]
+    #
+    # @api public
+    def commit
+      command.call
+    end
+
+    # Return string representation of the changeset
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      %(#<#{self.class} relation=#{relation.name.inspect}>)
+    end
+
+    # Return a command for this changeset
+    #
+    # @return [ROM::Command]
+    #
+    # @api private
+    def command
+      relation.command(command_type, DEFAULT_COMMAND_OPTS)
+    end
+  end
+end
+
+require 'rom/changeset/stateful'
+require 'rom/changeset/associated'
+
+require 'rom/changeset/create'
+require 'rom/changeset/update'
+require 'rom/changeset/delete'

data/lib/rom/plugins/relation/changeset.rb

@@ -0,0 +1,50 @@
+require 'rom/support/notifications'
+
+require 'rom/changeset/create'
+require 'rom/changeset/update'
+require 'rom/changeset/delete'
+
+module ROM
+  module Plugins
+    module Relation
+      module Changeset
+        TYPES = {
+          create: ROM::Changeset::Create,
+          update: ROM::Changeset::Update,
+          delete: ROM::Changeset::Delete
+        }.freeze
+
+        extend Notifications::Listener
+
+        subscribe('configuration.relations.class.ready') do |event|
+          event[:relation].include(InstanceMethods)
+        end
+
+        module InstanceMethods
+
+          # Create a changeset for a relation
+          #
+          # @return [Changeset]
+          #
+          # @api public
+          def changeset(type, data = EMPTY_HASH)
+            klass = type.is_a?(Symbol) ? TYPES.fetch(type) : type
+
+            unless klass < ROM::Changeset
+              raise ArgumentError, "+#{type.name}+ must be a Changeset descendant"
+            end
+
+            if klass < ROM::Changeset::Stateful
+              klass.new(self, __data__: data)
+            else
+              klass.new(self)
+            end
+          rescue KeyError
+            raise ArgumentError,
+                  "+#{type.inspect}+ is not a valid changeset type. Must be one of: #{TYPES.keys.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom-changeset.rb

@@ -0,0 +1,2 @@
+require 'rom/changeset'
+require 'rom/plugins/relation/changeset'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rom-changeset
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta1
+platform: ruby
+authors:
+- Piotr Solnica
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: transproc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: rom-changeset adds support for preprocessing data on top of rom-rb repositories
+email: piotr.solnica+oss@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/rom-changeset.rb
+- lib/rom/changeset.rb
+- lib/rom/changeset/associated.rb
+- lib/rom/changeset/create.rb
+- lib/rom/changeset/delete.rb
+- lib/rom/changeset/pipe.rb
+- lib/rom/changeset/restricted.rb
+- lib/rom/changeset/stateful.rb
+- lib/rom/changeset/update.rb
+- lib/rom/changeset/version.rb
+- lib/rom/plugins/relation/changeset.rb
+homepage: http://rom-rb.org
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Changeset abstraction for rom-rb
+test_files: []