preserves 0.1.0

data/lib/preserves/mapper/belongs_to.rb

@@ -0,0 +1,25 @@
+require "preserves/mapper/relation"
+
+module Preserves
+  class Mapper
+    class BelongsTo < Relation
+
+      def map!
+        assign_attribute(object, relation_name, relation_repo.map_one(relation_result_for_this_object))
+      end
+
+      def relation_result_for_this_object
+        @relation_result_for_this_object ||= relation_result_set.find{ |r| r[relation_repo.mapping.primary_key] == record.fetch(relation_foreign_key) }
+      end
+
+      def relation_foreign_key
+        @relation_foreign_key ||= relation_settings.fetch(:foreign_key) { "#{relation_name.downcase}_id" }
+      end
+
+      def relation_settings
+        @relation_settings ||= mapping.belongs_to_mappings.fetch(relation_name)
+      end
+
+    end
+  end
+end

data/lib/preserves/mapper/has_many.rb

@@ -0,0 +1,25 @@
+require "preserves/mapper/relation"
+
+module Preserves
+  class Mapper
+    class HasMany < Relation
+
+      def map!
+        assign_attribute(object, relation_name, relation_repo.map(relation_results_for_this_object))
+      end
+
+      def relation_results_for_this_object
+        @relation_results_for_this_object ||= relation_result_set.select{ |r| r[relation_foreign_key] == record.fetch(mapping.primary_key) }
+      end
+
+      def relation_foreign_key
+        @relation_foreign_key ||= relation_settings.fetch(:foreign_key) { "#{mapping.model_class.to_s.downcase}_id" }
+      end
+
+      def relation_settings
+        @relation_settings ||= mapping.has_many_mappings.fetch(relation_name)
+      end
+
+    end
+  end
+end

data/lib/preserves/mapper/relation.rb

@@ -0,0 +1,25 @@
+module Preserves
+  class Mapper
+    class Relation
+
+      attr_reader :object, :record, :relation_name, :relation_result_set, :mapping
+
+      def initialize(object, record, relation_name, relation_result_set, mapping)
+        @object = object
+        @record = record
+        @relation_name = relation_name
+        @relation_result_set = relation_result_set
+        @mapping = mapping
+      end
+
+      def relation_repo
+        @relation_repo ||= relation_settings.fetch(:repository) # TODO: Need a default.
+      end
+
+      def assign_attribute(object, attribute_name, value)
+        object.send("#{attribute_name}=", value)
+      end
+
+    end
+  end
+end

data/lib/preserves/mapping.rb

@@ -0,0 +1,73 @@
+module Preserves
+  class Mapping
+
+    attr_accessor :repository
+    attr_accessor :model_class
+    attr_accessor :name_mappings
+    attr_accessor :type_mappings
+    attr_accessor :has_many_mappings
+    attr_accessor :belongs_to_mappings
+
+    def initialize(repository, model_class, &block)
+      table_name pluralize(model_class.name.downcase)
+      primary_key "id"
+      self.repository = repository
+      self.model_class = model_class
+      self.name_mappings = {}
+      self.type_mappings = {}
+      self.has_many_mappings = {}
+      self.belongs_to_mappings = {}
+      self.instance_eval(&block)
+    end
+
+    # Note that this works to set or get the table name.
+    # TODO: We don't want to allow publicly setting this, but we need to publicly get it.
+    def table_name(name=nil)
+      @table_name = name unless name.nil?
+      @table_name
+    end
+
+    # Note that this works to set or get the primary key.
+    # TODO: We don't want to allow publicly setting this, but we need to publicly get it.
+    def primary_key(key_name=nil)
+      @primary_key = key_name unless key_name.nil?
+      @primary_key
+    end
+
+  protected
+
+    def map(*args)
+      if args[0].is_a?(Hash)
+        database_field_name = args[0].values.first
+        model_attribute_name = args[0].keys.first
+        self.name_mappings[database_field_name] = model_attribute_name
+      elsif args[0].is_a?(Symbol)
+        model_attribute_name = args[0]
+      end
+
+      if args[1].is_a?(Class)
+        self.type_mappings[model_attribute_name] = args[1]
+      end
+    end
+
+    def has_many(related_attribute_name, options)
+      self.has_many_mappings[related_attribute_name] = options
+    end
+
+    def belongs_to(related_attribute_name, options)
+      self.belongs_to_mappings[related_attribute_name] = options
+    end
+
+    def pluralize(string)
+      case string
+      when /(x|ch|ss|sh)$/i
+        string + "es"
+      when /s$/i
+        string
+      else
+        string + "s"
+      end
+    end
+
+  end
+end

data/lib/preserves/repository.rb

@@ -0,0 +1,69 @@
+require "preserves/selection"
+require "preserves/mapping"
+require "preserves/mapper"
+
+
+module Preserves
+  class Repository
+
+    attr_accessor :model_class
+
+    def initialize(options={})
+      self.model_class = options[:model]
+    end
+
+    def fetch(primary_key_value)
+      select(fetch_query, primary_key_value).only
+    end
+
+    def fetch!(primary_key_value)
+      select(fetch_query, primary_key_value).only!
+    end
+
+    alias_method :[], :fetch
+
+    def map(result, relations={})
+      mapper.map(result, relations)
+    end
+
+    def map_one(result, relations={})
+      mapper.map_one(result, relations)
+    end
+
+    def mapping(&block)
+      @mapping ||= Mapping.new(self, model_class, &block)
+    end
+
+  protected
+
+    def query(sql_string, *params)
+      pg_result = data_store.exec_params(sql_string, params)
+      SQL::ResultSet.new(pg_result)
+    end
+
+    def select(sql_string, *params)
+      if params && params.last.is_a?(Hash)
+        relations = params.pop
+      else
+        relations = {}
+      end
+      Selection.new(map(query(sql_string, *params), relations))
+    end
+
+  private
+
+    def mapper
+      @mapper ||= Mapper.new(@mapping)
+    end
+
+    # NOTE: We'll allow overriding this default on a per-repository basis later.
+    def data_store
+      Preserves.data_store
+    end
+
+    def fetch_query
+      "SELECT * FROM \"#{mapping.table_name}\" WHERE #{mapping.primary_key} = $1"
+    end
+
+  end
+end

data/lib/preserves/selection.rb

@@ -0,0 +1,65 @@
+module Preserves
+  class Selection
+
+    include Enumerable
+
+    attr_accessor :domain_objects
+
+    def initialize(domain_objects)
+      self.domain_objects = domain_objects
+    end
+
+    def each(&block)
+      domain_objects.each(&block)
+    end
+
+    def size
+      domain_objects.size
+    end
+
+    def first
+      domain_objects.first
+    end
+
+    def first!
+      fail "expected at least 1 result" if size == 0
+      domain_objects.first
+    end
+
+    def second
+      domain_objects.second
+    end
+
+    def second!
+      fail "expected at least 1 result" if size == 0
+      domain_objects.second
+    end
+
+    def last
+      domain_objects.last
+    end
+
+    def last!
+      fail "expected at least 1 result" if size == 0
+      domain_objects.last
+    end
+
+    def only
+      fail "expected only 1 result" if size > 1
+      domain_objects.first
+    end
+
+    def only!
+      fail "expected exactly 1 result" if size != 1
+      domain_objects.first
+    end
+
+    alias_method :one, :only
+    alias_method :one!, :only!
+
+    def [](index)
+      domain_objects[index]
+    end
+
+  end
+end

data/lib/preserves/sql.rb

@@ -0,0 +1,12 @@
+require "pg"
+require "preserves/sql/result_set"
+
+
+module Preserves
+  module SQL
+    def self.connection(*args)
+      @connection ||= {}
+      @connection[args] ||= PG.connect(*args)
+    end
+  end
+end

data/lib/preserves/sql/result_set.rb

@@ -0,0 +1,21 @@
+module Preserves
+  module SQL
+    class ResultSet
+
+      include Enumerable
+
+      def initialize(pg_result)
+        @pg_result = pg_result
+      end
+
+      def size
+        @pg_result.ntuples == 0 ? @pg_result.cmd_tuples : @pg_result.ntuples
+      end
+
+      def each(&block)
+        @pg_result.each(&block)
+      end
+
+    end
+  end
+end

data/lib/preserves/version.rb

@@ -0,0 +1,3 @@
+module Preserves
+  VERSION = "0.1.0"
+end

data/preserves.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'preserves/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "preserves"
+  spec.version       = Preserves::VERSION
+  spec.authors       = ["Craig Buchek"]
+  spec.email         = ["craig@boochtek.com"]
+  spec.summary       = %q{Minimalist ORM, using the Data Mapper pattern}
+  spec.description   = %q{Experimental, opinionated, minimalist ORM (object-relational mapper) for Ruby, using the Data Mapper pattern.}
+  spec.homepage      = "https://github.com/boochtek/ruby_preserves"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "pg", "~> 0.18.3"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "rubygems-tasks", "~> 0.2"
+end

data/spec/repository_spec.rb

@@ -0,0 +1,260 @@
+require_relative "spec_helper"
+require "preserves"
+
+class Group
+  attr_accessor :name
+end
+
+class User
+  attr_accessor :id
+  attr_accessor :age
+  attr_accessor :addresses
+  attr_accessor :group
+end
+
+class Address
+  attr_accessor :city
+end
+
+
+AddressRepository = Preserves.repository(model: Address) do
+  mapping do
+    map :city, String
+  end
+end
+
+GroupRepository = Preserves.repository(model: Group) do
+  mapping do
+    map :name, String
+  end
+end
+
+UserRepository = Preserves.repository(model: User) do
+  mapping do
+    primary_key 'username'
+    map id: 'username'
+    map :age, Integer
+    has_many :addresses, repository: AddressRepository, foreign_key: 'username'
+    belongs_to :group, repository: GroupRepository
+  end
+end
+
+
+describe "Repository" do
+
+  subject(:repository) { UserRepository }
+
+  describe "executing a query" do
+    let(:query) { repository.send(:query, "INSERT INTO users (username, name, age) VALUES ($1, $2, $3)", 'booch', 'Craig', 43) }
+
+    # This can't be done with let(), because we don't want to cache it.
+    def number_of_rows_in_user_table
+      Preserves::SQL.connection(dbname: "preserves_test").exec("SELECT COUNT(*) FROM users")[0]["count"].to_i
+    end
+
+    it "hits the database" do
+      expect{ query }.to change{ number_of_rows_in_user_table }
+    end
+
+    it "returns the number of rows processed" do
+      expect(query.size).to eq(1)
+    end
+  end
+
+  describe "selecting results from a query to an object" do
+
+    describe "when DB has 0 users" do
+      let(:selection) { repository.send(:select, "SELECT username AS id FROM users") }
+
+      it "works when restricting with `only`" do
+        expect(selection.only).to eq(nil)
+      end
+
+      it "raises an exception when restricting with `only!`" do
+        expect{ selection.only! }.to raise_exception("expected exactly 1 result")
+      end
+
+      it "raises an exception when restricting with `first!`" do
+        expect{ selection.first! }.to raise_exception("expected at least 1 result")
+      end
+
+      it "raises an exception when restricting with `last!`" do
+        expect{ selection.last! }.to raise_exception("expected at least 1 result")
+      end
+
+    end
+
+    describe "when DB has 1 user" do
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+      end
+
+      let(:selection) { repository.send(:select, "SELECT username AS id FROM users") }
+
+      it "returns a set of 1 User object" do
+        expect(selection.size).to eq(1)
+        expect(selection.first.class).to eq(User)
+      end
+
+      it "sets the attributes on the object" do
+        expect(selection.first.id).to eq("booch")
+      end
+
+      it "works when restricting with `only`" do
+        expect(selection.only.id).to eq("booch")
+      end
+
+      it "works when restricting with `only!`" do
+        expect(selection.only!.id).to eq("booch")
+      end
+
+      it "works when restricting with `first!`" do
+        expect(selection.first!.id).to eq("booch")
+      end
+
+      it "works when restricting with `last!`" do
+        expect(selection.last!.id).to eq("booch")
+      end
+    end
+
+    describe "when DB has 2 users" do
+
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('beth', 'Beth', 39)")
+      end
+
+      let(:selection) { repository.send(:select, "SELECT username AS id FROM users") }
+
+      it "returns a set of 2 User objects" do
+        expect(selection.size).to eq(2)
+        expect(selection.first.class).to eq(User)
+        expect(selection.last.class).to eq(User)
+      end
+
+      it "sets the attributes on the objects" do
+        expect(selection.first.id).to eq("booch")
+        expect(selection.last.id).to eq("beth")
+      end
+
+      it "raises an exception when restricting with `only`" do
+        expect{ selection.only }.to raise_exception("expected only 1 result")
+      end
+
+      it "raises an exception when restricting with `only!`" do
+        expect{ selection.only! }.to raise_exception("expected exactly 1 result")
+      end
+
+      it "can fetch the objects by ID" do
+        expect(repository.fetch('booch').class).to eq(User)
+        expect(repository.fetch('booch').age).to eq(43)
+        expect(repository['booch'].class).to eq(User)
+        expect(repository['booch'].age).to eq(43)
+        expect(repository.fetch!('booch').class).to eq(User)
+        expect(repository.fetch!('booch').age).to eq(43)
+        expect{ repository.fetch!('unknown') }.to raise_exception("expected exactly 1 result")
+      end
+    end
+
+    describe "when mapping a field name to a different model attribute name" do
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+      end
+
+      let(:selection) { repository.send(:select, "SELECT username FROM users") }
+
+      it "sets the attribute on the object" do
+        expect(selection.first.id).to eq("booch")
+      end
+    end
+
+    describe "when mapping a field to an Integer" do
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+      end
+
+      let(:selection) { repository.send(:select, "SELECT age FROM users") }
+
+      it "sets the attribute on the object to the right type" do
+        expect(selection.first.age).to eq(43)
+      end
+    end
+
+    describe "when mapping a field to an Integer" do
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+      end
+
+      let(:selection) { repository.send(:select, "SELECT age FROM users") }
+
+      it "sets the attribute on the object to the right type" do
+        expect(selection.first.age).to eq(43)
+      end
+    end
+
+    describe "when mapping a has_many relation" do
+      before do
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('booch', 'Craig', 43)")
+        repository.send(:query, "INSERT INTO users (username, name, age) VALUES ('beth', 'Beth', 39)")
+        repository.send(:query, "INSERT INTO addresses (city, username) VALUES ('Overland', 'booch')")
+        repository.send(:query, "INSERT INTO addresses (city, username) VALUES ('Wildwood', 'booch')")
+        repository.send(:query, "INSERT INTO addresses (city, username) VALUES ('Ballwin', 'booch')")
+        repository.send(:query, "INSERT INTO addresses (city, username) VALUES ('Ballwin', 'beth')")
+        repository.send(:query, "INSERT INTO addresses (city, username) VALUES ('Keokuk', 'unknown')")
+      end
+
+      let(:address_query) { repository.send(:query, "SELECT * FROM addresses") }
+      let(:selection) { repository.send(:select, "SELECT * FROM users", addresses: address_query) }
+
+      it "gets the basic fields" do
+        expect(selection.first.id).to eq('booch')
+        expect(selection.first.age).to eq(43)
+        expect(selection.last.id).to eq('beth')
+        expect(selection.last.age).to eq(39)
+      end
+
+      it "gets all the related items" do
+        expect(selection.first.addresses).to_not be(nil)
+        expect(selection.first.addresses.size).to eq(3)
+        expect(selection.first.addresses.map(&:city)).to include("Overland")
+        expect(selection.first.addresses.map(&:city)).to include("Wildwood")
+        expect(selection.first.addresses.map(&:city)).to include("Ballwin")
+        expect(selection.last.addresses).to_not be(nil)
+        expect(selection.last.addresses.size).to eq(1)
+        expect(selection.last.addresses.map(&:city)).to include("Ballwin")
+      end
+
+    end
+
+    describe "when mapping a belongs_to relation" do
+      before do
+        repository.send(:query, "INSERT INTO groups (id, name) VALUES (1, 'admin')")
+        repository.send(:query, "INSERT INTO groups (id, name) VALUES (2, 'users')")
+        repository.send(:query, "INSERT INTO users (username, name, age, group_id) VALUES ('booch', 'Craig', 43, 1)")
+        repository.send(:query, "INSERT INTO users (username, name, age, group_id) VALUES ('beth', 'Beth', 39, 2)")
+      end
+
+      let(:group_query) { repository.send(:query, "SELECT * FROM groups") }
+      let(:selection) { repository.send(:select, "SELECT * FROM users", group: group_query) }
+
+      it "gets the basic fields" do
+        expect(selection.first.id).to eq('booch')
+        expect(selection.first.age).to eq(43)
+        expect(selection.last.id).to eq('beth')
+        expect(selection.last.age).to eq(39)
+      end
+
+      it "gets all the related items" do
+        expect(selection.first.group).to_not be(nil)
+        expect(selection.first.group).to be_a(Group)
+        expect(selection.first.group.name).to eq("admin")
+        expect(selection.last.group).to_not be(nil)
+        expect(selection.last.group).to be_a(Group)
+        expect(selection.last.group.name).to eq("users")
+      end
+
+    end
+
+  end
+
+end