ormivore 0.0.1

data/app/entities/account.rb

@@ -0,0 +1,20 @@
+module App
+  class Account
+    include ORMivore::Entity
+
+    STATUSES = %w(active inactive deleted).map(&:to_sym).freeze
+
+    attributes(
+      firstname: String,
+      lastname: String,
+      email: String,
+      status: Symbol
+    )
+
+    private
+
+    def validate
+      raise "Invalid status #{status}" unless STATUSES.include?(status)
+    end
+  end
+end

data/app/entities/address.rb

@@ -0,0 +1,24 @@
+module App
+  class Address
+    include ORMivore::Entity
+
+    attributes(
+      street_1: String,
+      street_2: String,
+      city: String,
+      postal_code: String,
+      country_code: String,
+      region_code: String,
+      type: Symbol,
+      account_id: Integer
+    )
+
+    optional :street_2, :region_code, :account_id
+
+    private
+
+    def validate
+      raise "Invalid type #{type}" unless %w(shipping billing).include?(type.to_s)
+    end
+  end
+end

data/app/ports/account_storage_port.rb

@@ -0,0 +1,5 @@
+module App
+  class AccountStoragePort
+    include ORMivore::Port
+  end
+end

data/app/ports/address_storage_port.rb

@@ -0,0 +1,5 @@
+module App
+  class AddressStoragePort
+    include ORMivore::Port
+  end
+end

data/app/repos/account_repo.rb

@@ -0,0 +1,7 @@
+module App
+  class AccountRepo
+    include ORMivore::Repo
+
+    self.default_entity_class = App::Account
+  end
+end

data/app/repos/address_repo.rb

@@ -0,0 +1,7 @@
+module App
+  class AddressRepo
+    include ORMivore::Repo
+
+    self.default_entity_class = App::Address
+  end
+end

data/app/require_helpers.rb

@@ -0,0 +1,34 @@
+module RequireHelpers
+  class << self
+    def root
+      File.expand_path('../..', __FILE__)
+    end
+
+    def augment_load_path
+      $LOAD_PATH.unshift(File.join(root, 'lib'))
+      $LOAD_PATH.unshift(File.join(root, 'app'))
+      $LOAD_PATH.unshift(root)
+    end
+
+    def require_independent_files_in_dir(dir)
+      Dir.glob(File.join(root, dir, '*.rb')).each do |absolute_path|
+        short_path = absolute_path.sub(/^#{root}\/lib\/(.*)\.rb$/, '\1')
+        require short_path
+      end
+    end
+
+    def require_all
+      augment_load_path
+
+      require 'init'
+
+      require 'app/connection_manager'
+
+      require_independent_files_in_dir 'app/converters'
+      require_independent_files_in_dir 'app/adapters'
+      require_independent_files_in_dir 'app/ports'
+      require_independent_files_in_dir 'app/entities'
+      require_independent_files_in_dir 'app/repos'
+    end
+  end
+end

data/db/database.yml

@@ -0,0 +1,7 @@
+test:
+  adapter: sqlite3
+  database: db/db.test.sqlite3
+
+dev:
+  adapter: sqlite3
+  database: db/db.dev.sqlite3

data/lib/console.rb

@@ -0,0 +1,13 @@
+# Allows running a lightweight version of rails console
+# Start it like this:
+#
+# irb -r ./lib/console.rb
+
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require(:sinatra)
+
+require_relative 'app'
+
+MobileCheckout::ConnectionManager.establish_connection :development

data/lib/init.rb

@@ -0,0 +1,9 @@
+#root = File.expand_path('..', __FILE__)
+#$LOAD_PATH.unshift(File.join(root))
+
+require 'ormivore/errors'
+require 'ormivore/entity'
+require 'ormivore/port'
+require 'ormivore/repo'
+require 'ormivore/ar_adapter'
+require 'ormivore/memory_adapter'

data/lib/ormivore/ar_adapter.rb

@@ -0,0 +1,111 @@
+# TODO ArAdapter is really ugly; replace it with some simple Sql adapter without AR 'goodness'
+module ORMivore
+  module ArAdapter
+    module ClassMethods
+      attr_reader :default_converter_class
+      attr_reader :table_name
+
+      def ar_class
+        finalize
+        self::ArRecord
+      end
+
+      private
+      attr_writer :default_converter_class
+      attr_writer :table_name
+
+      def expand_on_create(&block)
+        @expand_on_create = block
+      end
+
+      def finalize
+        unless @finalized
+          @finalized = true
+
+          file, line = caller.first.split(':', 2)
+          line = line.to_i
+
+          module_eval(<<-EOS, file, line - 1)
+            class ArRecord < ActiveRecord::Base
+              self.table_name = '#{table_name}'
+              self.inheritance_column = :_type_disabled
+              def attributes_protected_by_default; []; end
+            end
+          EOS
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(converter = nil)
+      @converter = converter || self.class.default_converter_class.new
+    end
+
+    def find(conditions, attributes_to_load, options = {})
+      order = options.fetch(:order, {})
+
+      ar_class.all(
+        select: converter.attributes_list_to_storage(attributes_to_load),
+        conditions: conditions,
+        order: order_by_clause(order)
+      ).map { |r| entity_attributes(r) }
+    end
+
+    def create(attrs)
+      record = ar_class.create!(
+        extend_with_defaults(
+          converter.to_storage(attrs))) { |o| o.id = attrs[:id] }
+       attrs.merge(id: record.id)
+    rescue ActiveRecord::ActiveRecordError => e
+      raise StorageError.new(e)
+    end
+
+    def update(attrs, conditions)
+      ar_class.update_all(converter.to_storage(attrs), conditions)
+    rescue ActiveRecord::ActiveRecordError => e
+      raise StorageError.new(e)
+    end
+
+    private
+
+    attr_reader :converter
+
+    def extend_with_defaults(attrs)
+      expansion = self.class.instance_variable_get(:@expand_on_create)
+      if expansion
+        attrs.merge(expansion.call(attrs))
+      else
+        attrs
+      end
+    end
+
+    def order_by_clause(order)
+      return '' if order.empty?
+
+      order.map { |k, v|
+        direction =
+          case v
+          when :ascending
+            'asc'
+          when :descending
+            'desc'
+          else
+            raise BadArgumentError, "Order direction #{v} is invalid"
+          end
+
+        "#{k} #{direction}"
+      }.join(', ')
+    end
+
+    def ar_class
+      self.class.ar_class
+    end
+
+    def entity_attributes(record)
+      converter.from_storage(record.attributes.symbolize_keys)
+    end
+  end
+end

data/lib/ormivore/entity.rb

@@ -0,0 +1,199 @@
+# TODO figure out how to add validation in a nice way
+module ORMivore
+  module Entity
+    module ClassMethods
+      ALLOWED_ATTRIBUTE_TYPES = [String, Symbol, Integer, Float].freeze
+
+      attr_reader :attributes_declaration
+      attr_reader :optional_attributes_list
+
+      def attributes_list
+        attributes_declaration.keys
+      end
+
+      def construct(attrs, id)
+        id = coerce_id(id)
+
+        coerced_attrs = attrs.symbolize_keys.tap { |h| coerce(h) }.freeze
+
+        base_attributes = coerced_attrs
+        dirty_attributes = {}.freeze
+
+        validate_presence_of_proper_attributes(base_attributes, dirty_attributes)
+
+        obj = allocate
+
+        obj.instance_variable_set(:@id, id)
+        obj.instance_variable_set(:@base_attributes, base_attributes)
+        obj.instance_variable_set(:@dirty_attributes, dirty_attributes)
+
+        # TODO how to do custom validation?
+        # validate
+
+        obj
+      end
+
+      def validate_presence_of_proper_attributes(base, dirty)
+        # doing complicated way first because it is much more memory efficient
+        # but it does not allow for good error messages, so if something is
+        # wrong, need to proceed to inefficient validation that produces nice
+        # messages
+        missing = 0
+        known_counts = attributes_list.each_with_object([0, 0]) { |attr, acc|
+          acc[0] += 1 if base[attr]
+          acc[1] += 1 if dirty[attr]
+          missing +=1 unless optional_attributes_list.include?(attr) || base[attr] || dirty[attr]
+        }
+
+        if missing > 0 || [base.length, dirty.length] != known_counts
+          expensive_validate_presence_of_proper_attributes(
+            base.merge(dirty)
+          )
+        end
+      end
+
+      def coerce(attrs)
+        attrs.each do |name, type|
+          attr_value = attrs[name]
+          declared_type = attributes_declaration[name]
+          if declared_type && !attr_value.is_a?(declared_type)
+            attrs[name] = Kernel.public_send(declared_type.name.to_sym, attr_value)
+          end
+        end
+      rescue ArgumentError => e
+        raise ORMivore::BadArgumentError.new(e)
+      end
+
+      private
+
+      def attributes(declaration)
+        @attributes_declaration = declaration.symbolize_keys.freeze
+        validate_attributes_declaration
+        # @attributes_list = methods.map(&:to_sym)
+        @optional_attributes_list ||= []
+
+        attributes_list.map(&:to_s).each do |attr|
+          module_eval(<<-EOS)
+            def #{attr}
+              @dirty_attributes[:#{attr}] || @base_attributes[:#{attr}]
+            end
+          EOS
+          self::Builder.module_eval(<<-EOS)
+            def #{attr}
+              attributes[:#{attr}]
+            end
+            def #{attr}=(value)
+              attributes[:#{attr}] = value
+            end
+          EOS
+        end
+      end
+
+      def optional(*methods)
+        @optional_attributes_list = methods.map(&:to_sym)
+      end
+
+      # now, really private methods, not part of API
+
+      # TODO figure out how to differenciate private methods that are part of
+      # ORMivore API from those that are NOT
+      def expensive_validate_presence_of_proper_attributes(attrs)
+        attributes_list.each do |attr|
+          unless attrs.delete(attr) || optional_attributes_list.include?(attr)
+            raise BadAttributesError, "Missing attribute '#{attr}'"
+          end
+        end
+
+        raise BadAttributesError, "Unknown attributes #{attrs.inspect}" unless attrs.empty?
+      end
+
+      def validate_attributes_declaration
+        attributes_declaration.each do |name, type|
+          unless ALLOWED_ATTRIBUTE_TYPES.include?(type)
+            raise ORMivore::BadArgumentError, "Invalid attribute type #{type.inspect}"
+          end
+        end
+      end
+
+      def coerce_id(value)
+        value ? Integer(value) : nil
+      rescue ArgumentError
+        raise ORMivore::BadArgumentError, "Not a valid id: #{value.inspect}"
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.module_eval(<<-EOS)
+        class Builder
+          def initialize
+            @attributes = {}
+          end
+
+          def id
+            attributes[:id]
+          end
+
+          def adapter=(value)
+            @adapter = value
+          end
+
+          # FactoryGirl integration point
+          def save!
+            @attributes = @adapter.create(attributes)
+          end
+
+          attr_reader :attributes
+        end
+      EOS
+    end
+
+    attr_reader :id
+
+    def attributes
+      all_attributes
+    end
+
+    def changes
+      @dirty_attributes
+    end
+
+    def apply(attrs)
+      self.dup.tap { |other|
+        other.expand_changes(attrs)
+      }
+    end
+
+    protected
+
+    # to be used only by #change
+    def expand_changes(attrs)
+      attrs = attrs.symbolize_keys.tap { |h| self.class.coerce(h) }
+      @dirty_attributes = @dirty_attributes.merge(attrs).freeze # melt and freeze, huh
+      @all_attributes = nil # it is not valid anymore
+
+      self.class.validate_presence_of_proper_attributes(@base_attributes, @dirty_attributes)
+    end
+
+    private
+
+    def all_attributes
+      # memory / performance tradeoff can be played with here by keeping
+      # all_attributes around or generating it each time
+      @all_attributes = @base_attributes.merge(@dirty_attributes)
+    end
+
+    def initialize(attrs)
+      coerced_attrs = attrs.symbolize_keys.tap { |h| self.class.coerce(h) }.freeze
+
+      @base_attributes = {}.freeze
+      @dirty_attributes = coerced_attrs
+
+      self.class.validate_presence_of_proper_attributes(@base_attributes, @dirty_attributes)
+
+      # TODO how to do custom validation?
+      # validate
+    end
+  end
+end