terrestrial 0.1.1 → 0.3.0

data/features/step_definitions/example_steps.rb

@@ -6,11 +6,11 @@ Given(/^a database connection is established$/) do |code_sample|
   example_eval(code_sample)
 end
 
-Given(/^the associations are defined in the mapper configuration$/) do |code_sample|
+Given(/^the associations are defined in the configuration$/) do |code_sample|
   example_eval(code_sample)
 end
 
-Given(/^a mapper is instantiated$/) do |code_sample|
+Given(/^a object store is instantiated$/) do |code_sample|
   example_eval(code_sample)
 end
 

data/lib/terrestrial/adapters/memory_adapter.rb

@@ -0,0 +1,241 @@
+module Terrestrial
+  module Adapters
+  end
+end
+
+class Terrestrial::Adapters::MemoryAdapter
+  def self.build_from_schema(schema, raw_storage)
+    schema.each { |name, _| raw_storage[name] = [] }
+
+    relations = Hash[schema.map { |name, columns|
+      [name, Relation.new(columns, raw_storage.fetch(name))]
+    }]
+
+    new(schema, relations)
+  end
+
+  def initialize(schema, relations)
+    @schema = schema
+    @relations = relations
+  end
+
+  attr_reader :relations
+  private     :relations
+
+  def schema(table_name)
+    @schema.fetch(table_name).map { |column_info|
+      [
+        column_info.fetch(:name),
+        column_info.fetch(:options, { primary_key: false }),
+      ]
+    }
+  end
+
+  def tables
+    @relations.keys
+  end
+
+  def rename_table(name, new_name)
+    relations[new_name] = relations[name]
+    relations.delete(name)
+    @schema[new_name] = @schema[name]
+    @schema.delete(name)
+    self
+  end
+
+  def transaction(&block)
+    old_state = Marshal.load(Marshal.dump(relations))
+    block.call
+  rescue Object => e
+    rollback(old_state)
+    raise e
+  end
+
+  def [](table_name)
+    @relations.fetch(table_name)
+  end
+
+  private
+
+  def rollback(relations)
+    @relations = relations
+  end
+
+  class Query
+    def initialize(criteria: {}, order: [], reverse: false, &block)
+      if block
+        raise NotImplementedError.new("Block filtering not implemented")
+      end
+
+      @criteria = criteria
+      @order_columns = order
+      @reverse_order = reverse
+    end
+
+    attr_reader :criteria, :order_columns
+
+    def where(new_criteria, &block)
+      self.class.new(
+        criteria: criteria.merge(new_criteria),
+        order: order,
+        reverse: reverse,
+        &block
+      )
+    end
+
+    def order(columns)
+      self.class.new(
+        criteria: criteria,
+        order: columns,
+      )
+    end
+
+    def reverse
+      self.class.new(
+        criteria: criteria,
+        order: order_columns,
+        reverse: true,
+      )
+    end
+
+    def reverse_order?
+      !!@reverse_order
+    end
+  end
+
+  class Relation
+    include Enumerable
+
+    def initialize(schema, all_rows, selected_columns: nil, applied_query: Query.new)
+      @schema = schema
+      @all_rows = all_rows
+      @applied_query = applied_query
+      @selected_columns = selected_columns || all_column_names
+    end
+
+    attr_reader :schema
+    attr_reader :all_rows, :selected_columns, :applied_query
+    private     :all_rows, :selected_columns, :applied_query
+
+    def columns
+      all_column_names
+    end
+
+    def where(criteria, &block)
+      new_with_query(Query.new(criteria: criteria, &block))
+    end
+
+    def select(*new_selected_columns)
+      selected_columns = new_selected_columns & all_column_names
+      self.class.new(columns, all_rows, selected_columns: selected_columns, applied_query: applied_query)
+    end
+
+    def order(*columns)
+      new_with_query(applied_query.order(columns.flatten))
+    end
+
+    def reverse
+      new_with_query(@applied_query.reverse)
+    end
+
+    def each(&block)
+      matching_rows.each(&block)
+    end
+
+    def delete
+      matching_rows.each do |row_to_delete|
+        all_rows.delete(row_to_delete)
+      end
+    end
+
+    def insert(new_row)
+      new_row_with_empty_fields = empty_row.merge(clone(new_row))
+
+      all_rows.push(new_row_with_empty_fields)
+    end
+
+    def update(attrs)
+      all_rows
+        .select { |row| matching_rows.include?(row) }
+        .each do |row|
+          attrs.each do |k, v|
+            row[clone(k)] = clone(v)
+          end
+        end
+        .count
+    end
+
+    def empty?
+      matching_rows.empty?
+    end
+
+    protected
+
+    def extract_values_for_sub_select(expected_columns: 1)
+      unless selected_columns.size == expected_columns
+        raise "Expected dataset with #{expected_columns} columns. Got #{selected_columns.size} columns."
+      end
+
+      matching_rows.flat_map(&:values)
+    end
+
+    private
+
+    def matching_rows
+      apply_sort(
+        equality_filter(all_rows, applied_query.criteria),
+        applied_query.order_columns,
+        applied_query.reverse_order?,
+      )
+        .map { |row| row.select { |k, _v| selected_columns.include?(k) } }
+        .map { |row| Marshal.load(Marshal.dump(row)) }
+    end
+
+    def apply_sort(rows, order_columns, reverse_order)
+      sorted_rows = rows.sort_by{ |row|
+        order_columns.map { |col| row.fetch(col) }
+      }
+
+      if reverse_order
+        sorted_rows.reverse
+      else
+        sorted_rows
+      end
+    end
+
+    def equality_filter(rows, criteria)
+      rows.select { |row|
+        criteria.all? { |k, v| match(row.fetch(k), v) }
+      }
+    end
+
+    def match(value, comparitor)
+      case comparitor
+      when Relation
+        comparitor.extract_values_for_sub_select.include?(value)
+      when Enumerable
+        comparitor.include?(value)
+      when Regexp
+        comparitor === value
+      else
+        comparitor == value
+      end
+    end
+
+    def empty_row
+      Hash[all_column_names.map { |name| [ name, nil ] }]
+    end
+
+    def all_column_names
+      schema.map { |f| f.fetch(:name) }
+    end
+
+    def new_with_query(query)
+      self.class.new(schema, all_rows, selected_columns: selected_columns, applied_query: query)
+    end
+
+    def clone(object)
+      Marshal.load(Marshal.dump(object))
+    end
+  end
+end

data/lib/terrestrial/collection_mutability_proxy.rb

@@ -1,10 +1,10 @@
 require "forwardable"
-require "terrestrial/short_inspection_string"
+require "terrestrial/inspection_string"
 
 module Terrestrial
   class CollectionMutabilityProxy
     extend Forwardable
-    include ShortInspectionString
+    include InspectionString
     include Enumerable
 
     def initialize(collection)
@@ -45,11 +45,16 @@ module Terrestrial
     end
 
     def push(node)
+      force_load
       @added_nodes.push(node)
     end
 
     private
 
+    def force_load
+      to_a
+    end
+
     def loaded_enum
       Enumerator.new do |yielder|
         collection.each_loaded do |element|

data/lib/terrestrial/dirty_map.rb

@@ -7,6 +7,11 @@ module Terrestrial
     attr_reader :storage
     private     :storage
 
+    def load_if_new(record)
+      storage.fetch(hash_key(record)) { self.load(record) }
+      record
+    end
+
     def load(record)
       storage.store(hash_key(record), deep_clone(record))
       record

data/lib/terrestrial/error.rb

@@ -0,0 +1,69 @@
+module Terrestrial
+  Error = Module.new
+
+  class UpsertError < RuntimeError
+    include Error
+
+    def initialize(relation_name, record, original_error)
+      @relation_name = relation_name
+      @record = record
+      @original_error = original_error
+    end
+
+    attr_reader :relation_name, :record, :original_error
+    private :relation_name, :record, :original_error
+
+    def message
+      [
+        "Error upserting record into `#{relation_name}` with data `#{record.inspect}`.",
+        "Got Error: #{original_error.class.name} #{original_error.message}",
+      ].join("\n")
+    end
+  end
+
+  class LoadError < RuntimeError
+    include Error
+
+    def initialize(relation_name, factory, record, original_error)
+      @relation_name = relation_name
+      @factory = factory
+      @record = record
+      @original_error = original_error
+    end
+
+    attr_reader :relation_name, :factory, :record, :original_error
+    private :relation_name, :factory, :record, :original_error
+
+    def message
+      [
+        "Error loading record from `#{relation_name}` relation `#{record.inspect}`.",
+        "Using: `#{factory.inspect}`.",
+        "Check that the factory is compatible.",
+        "Got Error: #{original_error.class.name} #{original_error.message}",
+      ].join("\n")
+    end
+  end
+
+  class SerializationError < RuntimeError
+    include Error
+
+    def initialize(relation_name, serializer, object, original_error)
+      @relation_name = relation_name
+      @serializer = serializer
+      @object = object
+      @original_error = original_error
+    end
+
+    attr_reader :relation_name, :serializer, :object, :original_error
+    private :relation_name, :serializer, :object, :original_error
+
+    def message
+      [
+        "Error serializing object with mapping `#{relation_name}` `#{object.inspect}`.",
+        "Using serializer: `#{serializer.inspect}`.",
+        "Check the specified serializer can transform objects into a Hash.",
+        "Got Error: #{original_error.class.name} #{original_error.message}",
+      ].join("\n")
+    end
+  end
+end

data/lib/terrestrial/graph_loader.rb

@@ -8,56 +8,79 @@ module Terrestrial
 
     attr_reader :datasets, :mappings, :object_load_pipeline
 
-    def call(mapping_name, record, eager_data = {})
+    def call(mapping_name, record, eager_data_graph = {})
       mapping = mappings.fetch(mapping_name)
 
-      load_record(mapping, record, eager_data)
+      load_record(mapping, record, eager_data_graph)
     end
 
     private
 
-    def load_record(mapping, record, eager_data)
-      associations = load_associations(mapping, record, eager_data)
+    def load_record(mapping, record, eager_data_graph)
+      associations = load_associations(mapping, record, eager_data_graph)
 
       object_load_pipeline.call(mapping, record, Hash[associations])
     end
 
-    def load_associations(mapping, record, eager_data)
+    def load_associations(mapping, record, eager_data_graph)
       mapping.associations.map { |name, association|
-        assoc_eager_data = eager_data.fetch(name, {})
-
-        data_superset = assoc_eager_data.fetch(:superset) {
-          load_from_datasets(association)
-        }
-
-        [
-          name,
-          association.build_proxy(
-            record: record,
-            data_superset: data_superset,
-            loader: ->(associated_record, join_records = []) {
-              join_records.map { |jr|
-                join_mapping = mappings.fetch(association.join_mapping_name)
-                object_load_pipeline.call(join_mapping, jr)
-              }
-
-              call(
-                association.mapping_name,
-                associated_record,
-                assoc_eager_data.fetch(:associations, {})
-              )
-            },
-          )
-        ]
+        load_association(name, association, record, eager_data_graph)
       }
     end
 
-    def load_from_datasets(association)
+    def load_association(name, association, record, eager_data_graph)
+      association_superset, deeper_eager_data = eager_or_lazy_data(
+        name,
+        association,
+        eager_data_graph,
+      )
+
+      [
+        name,
+        association.build_proxy(
+          record: record,
+          data_superset: association_superset,
+          loader: recursive_loader(association, deeper_eager_data),
+        )
+      ]
+    end
+
+    def eager_or_lazy_data(name, association, eager_data_graph)
+      eager_data = eager_data_graph.fetch(name, {})
+
+      association_superset = eager_data.fetch(:superset) { default_dataset(association) }
+      deeper_eager_data = eager_data.fetch(:associations, {})
+
+      [association_superset, deeper_eager_data]
+    end
+
+    def default_dataset(association)
       association
-      .mapping_names
-      .map { |name| mappings.fetch(name) }
-      .map(&:namespace)
-      .map { |ns| datasets[ns] }
+        .mapping_names
+        .map { |name| mappings.fetch(name) }
+        .map(&:namespace)
+        .map { |ns| datasets[ns] }
+    end
+
+    def recursive_loader(association, eager_data_graph)
+      ->(associated_record, join_records = []) {
+        load_and_ignore_join_records(association, join_records)
+
+        call(
+          association.mapping_name,
+          associated_record,
+          eager_data_graph,
+        )
+      }
+    end
+
+    def load_and_ignore_join_records(association, join_records)
+      join_records.each do |jr|
+        mapping = mappings.fetch(association.join_mapping_name)
+        object_load_pipeline.call(mapping, jr)
+      end
+
+      nil
     end
   end
 end