dirt-core 2.2.3

data/lib/dirt/contexts/context.rb

@@ -0,0 +1,15 @@
+module Dirt
+  class Context
+    def self.run(*args)
+      new(*args).call()
+    end
+
+    # Override and save state here.
+    def initialize(*args)
+    end
+
+    # Override to perform the actual command
+    def call
+    end
+  end
+end

data/lib/dirt/core.rb

@@ -0,0 +1,36 @@
+#--
+# Copyright (c) 2014 Tenjin Inc.
+#
+# 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.
+#++
+
+require 'dirt/persisters/persister'
+require 'dirt/persisters/memory_persister'
+
+require 'dirt/contexts/context'
+
+require 'dirt/models/model_behaviour'
+
+require 'dirt/roles/persisting'
+require 'dirt/roles/validating'
+require 'dirt/roles/validation/presence_validator'
+require 'dirt/roles/validation/existence_validator'
+require 'dirt/roles/validation/self_existence_validator'
+require 'dirt/roles/validation/closure_validator'

data/lib/dirt/errors/missing_record_error.rb

@@ -0,0 +1,4 @@
+module Dirt
+  class MissingRecordError < StandardError
+  end
+end

data/lib/dirt/errors/no_persister_error.rb

@@ -0,0 +1,4 @@
+module Dirt
+  class NoPersisterError < StandardError
+  end
+end

data/lib/dirt/errors/too_many_records_error.rb

@@ -0,0 +1,4 @@
+module Dirt
+  class TooManyRecordsError < StandardError
+  end
+end

data/lib/dirt/errors/transaction_error.rb

@@ -0,0 +1,4 @@
+module Dirt
+  class TransactionError < StandardError
+  end
+end

data/lib/dirt/models/model_behaviour.rb

@@ -0,0 +1,47 @@
+module Dirt
+# Common class for all model objects within the system.
+  module ModelBehaviour
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Initializes a new instance of the class. The parameter hash takes whatever properties of the
+      # specific model type as keys.
+      def new(*args)
+        obj = nil
+        begin
+          obj = super
+        rescue ArgumentError
+          obj = super()
+        end
+        obj.update(args[0]) if args[0].is_a? Hash
+        obj
+      end
+    end
+
+    # Updates the properties of this instance. The parameter hash takes whatever properties of the
+    # specific model type as keys.
+    def update(params)
+      params.keys.each do |key|
+        self.send("#{key}=", params[key])
+      end
+    end
+
+    # The hash representation of any model object maps attribute names as symbols to their values, like the following:
+    #   {attr1: val1, attr2: val2, ...}
+    def to_hash
+      instance_variables.each_with_object({}) do |var, hash|
+        hash[var[1..-1].to_sym] = instance_variable_get(var)
+      end
+    end
+
+    def ==(other)
+      return instance_variables.all? do |var|
+        instance_variable_get(var) == other.instance_variable_get(var)
+      end
+
+      false
+    end
+  end
+end

data/lib/dirt/persisters/memory_persister.rb

@@ -0,0 +1,86 @@
+module Dirt
+  require 'dirt/errors/missing_record_error'
+  require 'ostruct'
+
+  # An in-memory implementation of persistence.
+  class MemoryPersister
+    def initialize(type, &block)
+      @type = type
+      @next_id = 0
+      @records = {}
+      @new_maker = block
+    end
+
+    def new(*args)
+      raise RuntimeError.new('Cannot create a new instance without a block given to init.') unless @new_maker
+      @new_maker.yield(*args)
+    end
+
+    # Saves the record to the array either under the given id, or a new one if none is provided,
+    def save(data, id=nil)
+      assert_exists(id)
+
+      id ||= @next_id += 1
+
+      @records[id] = data
+
+      MemoryRecord.new(data.to_hash.merge(id: id))
+    end
+
+    # Returns the record with the given id.
+    def load(id)
+      assert_exists(id)
+
+      record = @records[id]
+
+      record ? MemoryRecord.new(record.to_hash.merge(id: id)) : nil
+    end
+
+    # Returns the list of all records.
+    def all
+      @records.collect do |id, r|
+        MemoryRecord.new(r.to_hash.merge(id: id))
+      end
+    end
+
+    # Removes the record with the given id.
+    def delete(id)
+      if @records.has_key?(id)
+        MemoryRecord.new(@records.delete(id).to_hash.merge(id: id))
+      end
+    end
+
+    # determines whether a record exists with the given id
+    def exists?(id)
+      @records[id] != nil
+    end
+
+    def find(params)
+      where(params).first
+    end
+
+    def where(params)
+      matches = @records.select do |id, record|
+        same_id = (params.delete(:id) || id) == id
+
+        params.all? { |attr, val| record.send(attr) == val } && same_id
+      end.collect do |id, record|
+        MemoryRecord.new(record.to_hash.merge(id: id))
+      end
+
+      Relation.new(matches)
+    end
+
+    private
+    def assert_exists(id)
+      raise MissingRecordError.new("That #{@type} (id: #{id}) does not exist.") if id && !@records[id]
+    end
+  end
+
+  class MemoryRecord < OpenStruct
+    alias_method :to_hash, :marshal_dump
+  end
+
+# This must be at the bottom to work around the circular dependency with Relation.
+  require 'dirt/persisters/relation'
+end

data/lib/dirt/persisters/persister.rb

@@ -0,0 +1,54 @@
+require 'active_support/all'
+require 'dirt/errors/transaction_error'
+require 'dirt/errors/no_persister_error'
+
+# This Persister registry is the source for all persisters in the system. Register persisters here with
+# #for.
+#
+# == Persisters
+# All persisters must respond to the following:
+#
+# * +all+            Returns all records.
+# * +find(id)+       Returns the record with the given id.
+# * +exists?(id)+    Determines whether a record exists with the given id
+# * +save(data)+     Saves a new record.
+# * +save(data, id)+ Saves a record at the given id.
+# * +transaction(&block)+ Rolls back changes brought about during :yeild, and re-raises a TransactionError iff that error is raised in the yeild.
+# * delete(id)       Deletes the record with the given id.
+class Persister
+  # If persister is supplied, then this sets the persister for the given class,
+  # otherwise it returns the previously set persister for that class.
+  # If the first argument is a class, it is converted to a symbol.
+  def self.for(klass, persister=nil)
+    if klass.is_a? Class
+      klass = klass.to_s.demodulize.underscore.to_sym
+    end
+
+    @@persisters ||= {}
+    @@persisters[klass] ||= persister if persister
+
+    @@persisters[klass] || raise(Dirt::NoPersisterError.new("There is no persister for \"#{klass.to_s.pluralize}\"."))
+  end
+
+  # Forgets about all previously saved persisters.
+  def self.clear
+    @@persisters = nil
+  end
+
+  #
+  def self.transaction(persister_list=[], &block)
+    begin
+      if persister_list.size < 1
+        yeild
+      elsif persister_list.size == 1
+        persister_list.first.transaction &block
+      else
+        self.transaction(persister_list[1..(persister_list.size-1)]) do
+          persister_list.first.transaction &block
+        end
+      end
+    rescue Dirt::TransactionError => e
+      {errors: e.message.split("\n")}
+    end
+  end
+end

data/lib/dirt/persisters/relation.rb

@@ -0,0 +1,38 @@
+module Dirt
+  require 'dirt/persisters/memory_persister'
+
+  class Relation < MemoryPersister
+    @records = []
+
+    def initialize(records)
+      @records = records
+    end
+
+    def first
+      @records.first
+
+      #match = @records.first
+      #match ? match : nil
+    end
+
+    def collect(&block)
+      @records.collect(&block)
+    end
+
+    def each(&block)
+      @records.each(&block)
+    end
+
+    def empty?
+      @records.empty?
+    end
+
+    def all?(&block)
+      every = true
+
+      @records.each do |record|
+        every &= yield record
+      end
+    end
+  end
+end

data/lib/dirt/roles/persisting.rb

@@ -0,0 +1,73 @@
+require 'dirt/roles/role'
+require 'dirt/persisters/persister'
+
+# Role for adding persistability to model objects.
+class Persisting < Dirt::Role
+  attr_reader :id
+
+  def initialize(decorated, id=nil)
+    super(decorated)
+    @id = id
+  end
+
+  # Saves the decorated object with the appropriate persister.
+  def save()
+    saved = persister.save(@decorated, @id)
+
+    if saved
+      @id = saved.id
+      self
+    end
+  end
+
+  # Loads persisted data into the decorated object
+  def load(id)
+    assert_exists(id)
+
+    loaded = persister.load(id)
+
+    chameleonize(loaded)
+
+    self
+  end
+
+  # Loads from the first record that matches the given attributes.
+  def load_by(attrs)
+    record = Persister.for(@decorated.class).find(attrs)
+
+    unless record
+      raise Dirt::MissingRecordError.new("No record matches #{attrs.collect { |pair| pair.join(' == ') }.join(', ')}.")
+    end
+
+    chameleonize(record)
+
+    self
+  end
+
+  # Removes the decorated object from the appropriate persister.
+  def delete(id)
+    assert_exists(id)
+
+    persister.delete(id)
+  end
+
+  def ==(other)
+    super && other.id == @id
+  end
+
+  private
+  def chameleonize(record)
+    @id = record.id
+    @decorated.update(record.to_hash.except(:id))
+  end
+
+  def persister
+    Persister.for(@decorated.class)
+  end
+
+  def assert_exists(id)
+    unless persister.exists?(id)
+      raise Dirt::MissingRecordError.new("That #{@decorated.class.to_s.demodulize.downcase} (id: #{id || 'nil'}) does not exist.")
+    end
+  end
+end

data/lib/dirt/roles/role.rb

@@ -0,0 +1,32 @@
+module Dirt
+  # Roles are part of the DCI system design paradigm. They decorate a model object to extend its
+  # behaviour for the context of a single interaction.
+  class Role
+    # Takes the decorated object.
+    def initialize(decorated)
+      @decorated = decorated
+    end
+
+    # Attempts to run the missing method on the decorated object before exploding as normal,
+    # with a light tingling sensation.
+    def method_missing(method, *args, &block)
+      # if @decorated.respond_to?(method)
+        @decorated.send(method, *args, &block)
+      # else
+      #   super
+      # end
+    end
+
+    def class
+      @decorated.class
+    end
+
+    def respond_to?(method, privates = false)
+      super || @decorated.respond_to?(method, privates)
+    end
+
+    def ==(other)
+      other && (other.instance_variable_get(:@decorated) == @decorated || other == @decorated)
+    end
+  end
+end

data/lib/dirt/roles/validating.rb

@@ -0,0 +1,27 @@
+# A Role for testing whether the wrapped object is valid, using the list of validators provided in the constructor,
+#
+# == Validators
+# Each validator must respond to
+# * +valid?+        to return whether that validator passes, and
+# * +error_message+ to return any errors found when +valid?+ is +false+.
+class Validating < Dirt::Role
+  # Takes the decorated object and then the list of validators. See Role for more on decoration.
+  def initialize(decorated, validators)
+    super(decorated)
+    @validators = validators
+  end
+
+  # Returns +true+ _iff_ every validator passes.
+  def valid?
+    @validators.all? do |v|
+      v.valid?(@decorated)
+    end
+  end
+
+  # Returns a list of the string messages returned from the validators that have failed.
+  def errors
+    @validators.collect do |v|
+      v.error_message(@decorated) unless v.valid?(@decorated)
+    end.reject { |m| m.nil? }
+  end
+end

data/lib/dirt/roles/validation/closure_validator.rb

@@ -0,0 +1,15 @@
+# Takes a block, and uses it to determine validity,
+class ClosureValidator
+  def initialize(block, message_block)
+    @block = block
+    @message_block = message_block
+  end
+
+  def valid?(validated)
+    @block.call(validated)
+  end
+
+  def error_message(validated)
+    @message_block.call(validated)
+  end
+end