rom 0.1.2 → 0.2.0

data/lib/rom/session/state/transient.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Transient < self
+        include Concord::Public.new(:object, :mapper)
+
+        # @api private
+        def save(relation)
+          Created.new(object, mapper, relation)
+        end
+
+      end # Transient
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/state/updated.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+    class State
+
+      # @api private
+      class Updated < self
+        include Adamantium::Flat
+        include Concord::Public.new(:object, :mapper, :relation)
+
+        # @api private
+        def commit
+          relation.update(object, original_tuple)
+          Persisted.new(object, mapper)
+        end
+
+        private
+
+        # @api private
+        def original_tuple
+          mapper.identity_map.fetch_tuple(mapper.identity(object))
+        end
+
+      end # Updated
+
+    end # State
+  end # Session
+end # ROM

data/lib/rom/session/tracker.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module ROM
+  class Session
+
+    # @api private
+    class Tracker
+      attr_reader :objects, :changelog
+      private :objects, :changelog
+
+      # @api private
+      def initialize
+        @objects   = {}
+        @changelog = []
+      end
+
+      # @api private
+      def commit
+        @changelog.each { |state| update(state.commit) }
+        @changelog = []
+      end
+
+      # @api private
+      def fetch(identity)
+        @objects.fetch(identity) { raise ObjectNotTrackedError, identity }
+      end
+
+      # @api private
+      def include?(identity)
+        @objects.key?(identity)
+      end
+
+      # @api private
+      def clean?
+        changelog.empty?
+      end
+
+      # @api private
+      def queue(state)
+        @changelog << state
+        update(state)
+      end
+
+      # @api private
+      def update(state)
+        @objects[state.identity] = state
+      end
+
+      # @api private
+      def store_transient(object, mapper)
+        update(State::Transient.new(object, mapper))
+      end
+
+      # @api private
+      def store_persisted(object, mapper)
+        update(State::Persisted.new(object, mapper))
+      end
+
+    end # Tracker
+
+  end # Session
+end # ROM

data/lib/rom/support/axiom/adapter.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Raised when passing an +uri+ with an unregistered scheme to {Adapter.new}
+  UnknownAdapterError = Class.new(StandardError)
+
+  # Provides base functionality for every axiom adapter
+  #
+  # @todo think about making this a (base) class
+  #
+  # @example
+  #
+  #   class MyAdapter
+  #     extend Axiom::Adapter
+  #     uri_scheme :foo
+  #   end
+  #
+  module Adapter
+
+    # The registry of adapters
+    #
+    # @return [Hash<String, Object>]
+    #   a hash of adapters, keyed by uri scheme
+    #
+    # @api private
+    REGISTRY = {}
+
+    # Return the adapter to use for the given +uri+
+    #
+    # @param [Addressable::URI] uri
+    #   the uri to initialize the adapter with
+    #
+    # @return [Object]
+    #   a axiom adapter
+    #
+    # @raise [UnknownAdapterError]
+    #   when the given +uri+'s scheme is not registered
+    #
+    # @api private
+    def self.build(uri)
+      require_adapter(uri)
+
+      klass = get(uri)
+
+      if klass.name == 'Axiom::Adapter::Memory'
+        klass.new
+      else
+        klass.new(uri)
+      end
+    end
+
+    # Return the adapter class registered for +uri+
+    #
+    # @param [Addressable::URI] uri
+    #   the uri that identifies the adapter class
+    #
+    # @return [Class]
+    #   a axiom adapter class
+    #
+    # @raise [UnknownAdapterError]
+    #   when the given +uri+'s scheme is not registered
+    #
+    # @api private
+    def self.get(uri)
+      uri_scheme = uri.scheme
+
+      REGISTRY.fetch(uri_scheme) {
+        raise(
+          UnknownAdapterError,
+          "#{uri_scheme.inspect} is no registered uri scheme"
+        )
+      }
+    end
+
+    # Try to load an adapter using a standard path
+    #
+    # @api private
+    def self.require_adapter(uri)
+      require "rom/support/axiom/adapter/#{uri.scheme}"
+    rescue LoadError
+    end
+    private_class_method :require_adapter
+
+    # Set the uri scheme for an adapter class
+    #
+    # @example for a DataObjects adapter
+    #
+    #   class Postgres < Axiom::Adapter::DataObjects
+    #     uri_scheme :postgres
+    #   end
+    #
+    # @example for an arbitrary adapter
+    #
+    #   class InMemory
+    #     extend Axiom::Adapter
+    #     uri_scheme :in_memory
+    #   end
+    #
+    # @param [#to_s] name
+    #   the name of the uri scheme
+    #
+    # @return [self]
+    #
+    # @api public
+    def uri_scheme(name)
+      REGISTRY[name.to_s] = self
+    end
+
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter/data_objects.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'axiom-do-adapter'
+
+module Axiom
+  module Adapter
+
+    # Reopenend to add functionality that should eventually
+    # be puhsed down to Adapter::DataObjects proper, or whatever
+    # will be the base class.
+    #
+    class DataObjects
+      extend Adapter
+
+      include Equalizer.new(:uri)
+
+      # The URI this adapter uses for establishing a connection
+      #
+      # @return [Addressable::URI]
+      #
+      # @api private
+      attr_reader :uri
+
+      # Wrap the given +relation+ with a gateway
+      #
+      # @param [Axiom::Relation] relation
+      #   the relation to wrap with a gateway
+      #
+      # @return [Axiom::Relation::Gateway]
+      #
+      # @api private
+      def gateway(relation)
+        Axiom::Relation::Gateway.new(self, relation)
+      end
+
+    end # DataObjects
+  end # Adapter
+end # Axiom

data/lib/rom/support/axiom/adapter/memory.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'axiom-memory-adapter'
+require 'rom/support/axiom/adapter'
+
+module Axiom
+  module Adapter
+
+    # A axiom in memory adapter
+    #
+    # This is basically a "null adapter"
+    # as it doesn't make use of it's uri
+    # and only passes through the given
+    # +relation+ in {#gateway}
+    #
+    class Memory
+      extend Adapter
+
+      include Equalizer.new(:schema)
+
+      uri_scheme :memory
+
+    end # class Memory
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter/postgres.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'do_postgres'
+
+require 'rom/support/axiom/adapter'
+require 'rom/support/axiom/adapter/data_objects'
+
+module Axiom
+  module Adapter
+
+    # A Axiom adapter for postgres
+    #
+    class Postgres < DataObjects
+
+      uri_scheme :postgres
+
+    end # class Postgres
+  end # module Adapter
+end # module Axiom

data/lib/rom/support/axiom/adapter/sqlite3.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'do_sqlite3'
+
+require 'rom/support/axiom/adapter'
+require 'rom/support/axiom/adapter/data_objects'
+
+module Axiom
+  module Adapter
+
+    # A axiom adapter for sqlite3
+    #
+    class Sqlite3 < DataObjects
+
+      uri_scheme :sqlite3
+
+    end # Sqlite3
+
+  end # Adapter
+end # Axiom

data/lib/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/rom.gemspec

@@ -15,7 +15,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_dependency 'rom-relation', '~> 0.1.2'
-  gem.add_dependency 'rom-mapper',   '~> 0.1.1'
-  gem.add_dependency 'rom-session',  '~> 0.1.1'
+  gem.add_dependency 'addressable',     '~> 2.3', '>= 2.3.3'
+  gem.add_dependency 'concord',         '~> 0.1'
+  gem.add_dependency 'adamantium',      '~> 0.2'
+  gem.add_dependency 'axiom',           '~> 0.2'
+  gem.add_dependency 'axiom-optimizer', '~> 0.2'
+  gem.add_dependency 'charlatan',       '~> 0.1'
+  gem.add_dependency 'morpher',         '~> 0.2'
 end

data/spec/integration/environment_setup_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Setting up environment' do
+  let(:env) do
+    ROM::Environment.setup(memory: 'memory://test') do
+      schema do
+        base_relation :users do
+          repository :memory
+
+          attribute :id,   Integer
+          attribute :name, String
+
+          key :id
+        end
+      end
+    end
+  end
+
+  it 'registers relations within repositories' do
+    expect(env.schema[:users]).to be_instance_of(Axiom::Relation::Variable::Materialized)
+  end
+end

data/spec/integration/grouped_mappers_spec.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Grouped mappers' do
+  let(:env) do
+    Environment.setup(test: 'memory://test') do
+      schema do
+        base_relation :users do
+          repository :test
+
+          attribute :id,   Integer
+          attribute :name, String
+
+          key :id
+        end
+
+        base_relation :tasks do
+          repository :test
+
+          attribute :id, Integer
+          attribute :title, String
+
+          key :id
+        end
+      end
+
+      mapping do
+        relation(:users) do
+          model User
+          map :id, :name
+        end
+
+        relation(:tasks) do
+          model Task
+          map :id, :title
+        end
+      end
+    end
+  end
+
+  before do
+    User = mock_model(:id, :name, :tasks)
+    Task = mock_model(:id, :title)
+  end
+
+  after do
+    Object.send(:remove_const, :User) if defined?(User)
+    Object.send(:remove_const, :Task) if defined?(Task)
+  end
+
+  subject(:mapper) { env[:users].mapper.group(:tasks => env[:tasks].mapper) }
+
+  specify 'loading grouped tuples' do
+    tuple = {
+      :id => 1,
+      :name => 'Jane',
+      :tasks => [
+        { :id => 2, :title => 'Task 1' },
+        { :id => 3, :title => 'Task 2' }
+      ]
+    }
+
+    task1 = Task.new(tuple[:tasks].first)
+    task2 = Task.new(tuple[:tasks].last)
+    user = User.new(:id => tuple[:id], :name => tuple[:name], :tasks => [task1, task2])
+
+    expect(mapper.load(tuple)).to eql(user)
+  end
+
+  specify 'dumping grouped tuples' do
+    tuple = {
+      :id => 1,
+      :name => 'Jane',
+      :tasks => [
+        { :id => 2, :title => 'Task 1' },
+        { :id => 3, :title => 'Task 2' }
+      ]
+    }
+
+    task1 = Task.new(tuple[:tasks].first)
+    task2 = Task.new(tuple[:tasks].last)
+    user = User.new(:id => tuple[:id], :name => tuple[:name], :tasks => [task1, task2])
+
+    expect(mapper.dump(user)).to eql([1, 'Jane', [[2, 'Task 1'], [3, 'Task 2']]])
+  end
+end