vorpal 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjI3OWU1NDlmYjJjZjAyOTZkZmU5NThmZjJjMDI4NzVlNGE1MjFjZA==
+  data.tar.gz: !binary |-
+    ZGJlYjljY2ViYTk0MzdhMWYxZjEyMWU5NmZjMGUxMzU2YTI3MzRmMw==
+SHA512:
+  metadata.gz: !binary |-
+    ZDAzMmU1MmVlNzYwYTlmNTk0NGIxMGExZTgwMDIwN2I5YzQ4NTNiNTQ5ZGRi
+    ZjRiYjhjNDJiM2RmN2I4MGRiMzY3NTNiOTE0ZGUwMzhjZGE5ZWE1Y2EyZTk2
+    Y2JmMmY3YzUyZDZkODYxYzVlMzhkNTg3ZThiMDIzY2ZlNzNhYzU=
+  data.tar.gz: !binary |-
+    ZTZhZWExODIxYWQzNTlkNDJkMzg0OWI4NWVlOTMxYzZlNzk1ZTQzZmZlYjEz
+    NGRhM2Q1MjIxYjQ4N2M5NWRiMjc4YmNmMjQ5MWNiYTEwZWU3NGYwYjhjNzkx
+    OTc0YzFiODY3NWNkZTMyOWJiODVhYzQyZGJkYjRlYzAwMGFiMjk=

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.idea/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.yardopts

@@ -0,0 +1 @@
+--no-private -m markdown lib/**/*.*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vorpal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sean Kirby
+
+MIT License
+
+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,167 @@
+# Vorpal
+
+Separate your domain model from your delivery mechanism.
+
+## Overview
+Vorpal is a [Data Mapper](http://martinfowler.com/eaaCatalog/dataMapper.html)-style ORM (object relational mapper) framelet that persists POROs (plain old Ruby objects) to a relational DB.
+
+We say 'framelet' because it doesn't attempt to give you all the goodies that ORMs usually provide. Instead, it layers on top of an existing ORM and allows you to use the simplicity of the Active Record pattern where appropriate and the power of the Data Mapper pattern when you need it.
+
+3 things set it apart from existing Ruby ORMs (ActiveRecord and Datamapper):
+
+1. It keeps persistence concerns separate from domain logic. In other words, your domain models don't have to extend ActiveRecord::Base (or something else) in order to get saved to a DB.
+1. It works with [Aggregates](http://martinfowler.com/bliki/DDD_Aggregate.html) rather than individual objects.
+1. It plays nicely with ActiveRecord objects!
+
+[Perpetuity](https://github.com/jgaskins/perpetuity) has a great introduction.
+
+Talk about EDR? Victor has a good explanation of why domain model and delivery mechanism should be separated.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vorpal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vorpal
+
+## Usage
+Start with a domain model of POROs that form an aggregate:
+
+```ruby
+class Tree; end
+
+class Trunk
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :length, Decimal
+  attribute :tree, Tree
+end
+
+class Branch
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :length, Decimal
+  attribute :tree, Tree
+end
+
+class Tree
+  include Virtus.model
+
+  attribute :id, Integer
+  attribute :name, String
+  attribute :trunk, Trunk
+  attribute :branches, Array[Branch]
+end
+```
+
+Along with a relational model:
+
+```sql
+CREATE TABLE trees
+(
+  id serial NOT NULL,
+  name text,
+  trunk_id integer
+)
+
+CREATE TABLE trunks
+(
+  id serial NOT NULL,
+  length numeric
+)
+
+CREATE TABLE branches
+(
+  id serial NOT NULL,
+  length numeric,
+  tree_id integer
+)
+```
+
+Create a repository configured to persist the aggregate to the relational model:
+
+```ruby
+repository = Persistence::Configuration.define do
+  map Tree do
+    fields :name
+    belongs_to :trunk
+    has_many :branches
+  end
+
+  map Trunk do
+    fields :length
+    has_one :tree
+  end
+  
+  map Branch do
+    fields :length
+    belongs_to :tree
+  end
+end
+```
+Why don't we use DDD language? I see no mention of aggregates and entities!
+
+And use it:
+
+```ruby
+repository.persist(big_tree)
+
+small_tree = repository.load(small_tree_id, Tree)
+
+repository.destroy(dead_tree)
+```
+
+Show implementation of a repository using the aggregate repository!!!
+
+Talk about aggregate boundary.
+
+### With ActiveRecord
+TBD
+
+## API Documentation
+
+(http://rubydoc.info/github/nulogy/vorpal/master/frames)
+
+## Caveats
+It also does not do some things that you might expect from other ORMs:
+
+1. There is no lazy loading of associations. This might sound like a big deal, but with [correctly designed aggregates](http://dddcommunity.org/library/vernon_2011/) it turns out to be very minor.
+1. There is no managing of transactions. It is the strong opinion of the authors that managing transactions is an application-level concern.
+1. No support for validations. Validations are not a persistence concern.
+1. Only supports primary keys called `id`.
+1. Only supports PostgreSQL.
+1. Requires domain entities to have a special implementation of `#initialize`.
+1. Has a dependency on ActiveRecord.
+1. No facilities for querying the DB.
+1. Identity map only applies to a single `#load` or `#load_all` call.
+1. Clients cannot specify primary key values.
+
+## Future Enhancements
+* Aggregate updated_at.
+* Support for other DBMSs.
+* Identity map for an entire application transaction.
+* Value objects.
+* Remove dependency on ActiveRecord (optimistic locking? connection pooling?)
+* Application-generated primary key ids.
+* More efficient object loading (use fewer queries.)
+* Do not require special `#initialize` method? Provide a hook for an instance factory?
+* Single table inheritance?
+
+## Contributing
+
+1. Fork it ( https://github.com/nulogy/vorpal/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/simple_serializer/simple_deserializer.rb

@@ -0,0 +1,67 @@
+# Simple framelet for deserialization
+#
+#    class SomeDeserializer < SimpleDeserializer
+#      data_attributes :site_id, :name, :category_id, :integration_key
+#
+#      def integration_key(old_integration_key)
+#        "XX#{@data[:other_attr]}XX#{old_integration_key}XX"
+#      end
+#
+#      def set_category_id(category_id)
+#        object.category = InventoryStatusCategory.from_id(category_id)
+#      end
+#    end
+#
+# Usage:
+#
+#    SomeDeserializer.deserialize(object, data)
+#    SomeDeserializer.new(object, data).deserialize
+#
+#    SomeDeserializer.deserialize_array([object1, object2, ...], [data1, data2, ...])
+#
+class SimpleDeserializer
+  class << self
+    attr_accessor :_attributes
+
+    def inherited(base)
+      base._attributes = []
+    end
+
+    def data_attributes(*attrs)
+      @_attributes.concat attrs
+
+      attrs.each do |attr|
+        define_method attr do |datum|
+          datum
+        end unless method_defined?(attr)
+
+        define_method "set_#{attr}" do |datum|
+          object.send("#{attr}=", send(attr, datum))
+        end unless method_defined?("set_#{attr}")
+      end
+    end
+
+    def deserialize_array(objects, data)
+      objects.zip(data).map { |obj, datum| deserialize(obj, datum) }
+    end
+
+    def deserialize(object, data)
+      self.new(object, data).deserialize
+    end
+  end
+
+  attr_accessor :object
+
+  def initialize(object, data)
+    @object = object
+    @data = data
+  end
+
+  def deserialize
+    self.class._attributes.dup.each do |name|
+      next unless @data.has_key?(name)
+      send("set_#{name}", @data[name])
+    end
+    object
+  end
+end

data/lib/simple_serializer/simple_serializer.rb

@@ -0,0 +1,72 @@
+# Simple framelet for serialization.
+#
+# API compatible with ActiveModel::Serializer but without all the complexity
+# and dependence on ActiveModel
+#
+#    class SomeSerializer < SimpleSerializer
+#      attributes :id, :name, :category_id, :errors
+#
+#      def category_id
+#        object.category.try(:id)
+#      end
+#
+#      def errors
+#        ActiveModelErrorsSerializer.serialize_errors(object.errors, true) if object.errors.any?
+#      end
+#    end
+#
+# Usage:
+#
+#    SomeSerializer.serialize(object)
+#    SomeSerializer.new(object).serialize
+#
+#    SomeSerializer.serialize_array([object])
+#
+class SimpleSerializer
+  class << self
+    attr_accessor :_attributes
+
+    def inherited(base)
+      base._attributes = []
+    end
+
+    def attributes(*attrs)
+      @_attributes.concat attrs
+
+      attrs.each do |attr|
+        define_method attr do
+          object.send(attr)
+        end unless method_defined?(attr)
+      end
+    end
+
+    def serialize_array(objects)
+      objects.map { |obj| serialize(obj) }
+    end
+
+    def serialize(object)
+      self.new(object).serialize
+    end
+
+    alias :as_json :serialize
+  end
+
+  attr_accessor :object
+
+  def initialize(object, _={})
+    @object = object
+  end
+
+  def attributes
+    self.class._attributes.dup.each_with_object({}) do |name, hash|
+      hash[name] = send(name)
+    end
+  end
+
+  def serialize(_={})
+    return nil if object.nil?
+    attributes
+  end
+  alias :as_json :serialize
+end
+