chassis_repo 0.1.0

data/lib/chassis/repo/maglev_repo.rb

@@ -0,0 +1,51 @@
+module Chassis
+  class MaglevRepo < BaseRepo
+    class MaglevMap
+      def initialize store
+        @store = store
+      end
+
+      def set(record)
+        record_map(record)[record.id] = record
+        Maglev.commit
+      end
+
+      def get(klass, id)
+        class_map(klass).fetch id do
+          fail RecordNotFoundError.new(klass, id)
+        end
+      end
+
+      def delete(record)
+        record_map(record).delete record.id
+        Maglev.commit
+      end
+
+      def all(klass)
+        class_map(klass).values
+      end
+
+      def clear
+        store.clear
+        Maglev.commit
+      end
+
+      private
+      def store
+        @store
+      end
+
+      def class_map(klass)
+        store[klass] ||= { }
+      end
+
+      def record_map(record)
+        class_map record.class
+      end
+    end
+
+    def initialize store
+      @map = MaglevMap.new store
+    end
+  end
+end

data/lib/chassis/repo/memory_repo.rb

@@ -0,0 +1,7 @@
+module Chassis
+  class MemoryRepo < BaseRepo
+    def initialize
+      @map = Repo::RecordMap.new
+    end
+  end
+end

data/lib/chassis/repo/null_repo.rb

@@ -0,0 +1,64 @@
+module Chassis
+  class NullRepo
+    def initialize
+      @counter = 0
+    end
+
+    def create(record)
+      @counter = @counter + 1
+      record.id ||= @counter
+    end
+
+    def update(*)
+
+    end
+
+    def delete(*)
+
+    end
+
+    def find(*)
+
+    end
+
+    def first(*)
+
+    end
+
+    def last(*)
+
+    end
+
+    def sample(*)
+
+    end
+
+    def clear
+
+    end
+
+    def count(*)
+      0
+    end
+
+    def first(*)
+
+    end
+
+    def all(klass)
+      [ ]
+    end
+
+    def query(*)
+      [ ]
+    end
+
+    def graph_query(*)
+      [ ]
+    end
+
+    def initialize_storage
+
+    end
+  end
+end

data/lib/chassis/repo/record_map.rb

@@ -0,0 +1,44 @@
+module Chassis
+  class Repo
+    class RecordMap
+      def initialize
+        @hash = { }
+      end
+
+      def set(record)
+        record_map(record)[record.id] = record
+      end
+
+      def get(klass, id)
+        class_map(klass).fetch id do
+          fail RecordNotFoundError.new(klass, id)
+        end
+      end
+
+      def delete(record)
+        record_map(record).delete record.id
+      end
+
+      def all(klass)
+        class_map(klass).values
+      end
+
+      def clear
+        hash.clear
+      end
+
+      private
+      def hash
+        @hash
+      end
+
+      def class_map(klass)
+        hash[klass] ||= { }
+      end
+
+      def record_map(record)
+        class_map record.class
+      end
+    end
+  end
+end

data/lib/chassis/string_utils.rb

@@ -0,0 +1,50 @@
+module Chassis
+  module StringUtils
+    def demodulize(path)
+      path = path.to_s
+      if i = path.rindex('::')
+        path[(i+2)..-1]
+      else
+        path
+      end
+    end
+    module_function :demodulize
+
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.gsub('::', '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+    module_function :underscore
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+    module_function :constantize
+  end
+end

data/lib/chassis/version.rb

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

data/test/array_utils_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class ArrayUtilsTest < Minitest::Test
+  def utils
+    Chassis::ArrayUtils
+  end
+
+  def test_extract_options_removes_options_hash_if_present
+    args = ['foo', { bar: 'baz' }]
+    options = utils.extract_options! args
+
+    assert_equal({ bar: 'baz' }, options)
+    assert_equal(%w(foo), args)
+  end
+
+  def test_extract_options_does_nothing_if_no_options
+    args = %w(foo)
+    options = utils.extract_options! args
+
+    assert_equal({}, options)
+    assert_equal(%w(foo), args)
+  end
+end

data/test/chassis_test.rb

@@ -0,0 +1,7 @@
+require_relative 'test_helper'
+
+class ChassisTest < Minitest::Test
+  def test_it_should_define_a_version
+    assert Chassis::VERSION
+  end
+end

data/test/core_ext/array_test.rb

@@ -0,0 +1,8 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/array'
+
+class ArrayCoreExtTest < Minitest::Test
+  def test_extract_options!
+    assert_equal({}, [].extract_options!)
+  end
+end

data/test/core_ext/hash_test.rb

@@ -0,0 +1,8 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/hash'
+
+class HashCoreExtTest < Minitest::Test
+  def test_symbolize
+    assert_equal({ foo: 'bar' }, { 'foo' => 'bar' }.symbolize)
+  end
+end

data/test/core_ext/string_test.rb

@@ -0,0 +1,16 @@
+require_relative '../test_helper'
+require 'chassis/core_ext/string'
+
+class StringCoreExtTest < Minitest::Test
+  def test_underscore
+    assert_equal('foo_bar', 'FooBar'.underscore)
+  end
+
+  def test_demodulize
+    assert_equal('Bar', 'Foo::Bar'.demodulize)
+  end
+
+  def test_constantize
+    assert_equal self.class, self.class.name.constantize
+  end
+end

data/test/delegate_test.rb

@@ -0,0 +1,41 @@
+require_relative 'test_helper'
+
+class DelegateTest < Minitest::Test
+  class Delegator
+    include Chassis.delegate(:add, to: :object)
+
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+  end
+
+  def test_methods_are_delegated
+    delegate = Class.new do
+      def add(number)
+        number + 5
+      end
+    end.new
+
+    delegator = Delegator.new delegate
+
+    assert_equal 10, delegator.add(5)
+  end
+
+  def test_raises_an_error_if_no_object_to_delegate_to
+    delegator = Delegator.new nil
+
+    assert_raises Chassis::DelegationError do
+      delegator.add 1
+    end
+  end
+
+  def test_fails_with_an_error_if_nothing_to_delegate_to
+    assert_raises ArgumentError do
+      Class.new do
+        include Chassis.delegate(:foo, :bar)
+      end
+    end
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+class ErrorTest < Minitest::Test
+  def test_delegates_to_tnt
+    klass = Chassis.error do |foo|
+      "#{foo} bar"
+    end
+
+    error = klass.new "Adam"
+    assert_equal "Adam bar", error.message
+  end
+end

data/test/hash_utils_test.rb

@@ -0,0 +1,17 @@
+require_relative 'test_helper'
+
+class HashUtilsTest < Minitest::Test
+  def utils
+    Chassis::HashUtils
+  end
+
+  def test_symbolize_keys_converts_keys_to_symbols
+    result = utils.symbolize({ 'foo' => 'bar' })
+    assert_equal({ foo: 'bar'}, result)
+  end
+
+  def test_symbolize_keys_recursises_into_objects
+    result = utils.symbolize({ 'foo' => { 'bar' => 'baz' }})
+    assert_equal({ foo: { bar: 'baz' }}, result)
+  end
+end

data/test/initializable_test.rb

@@ -0,0 +1,7 @@
+require_relative 'test_helper'
+
+class InitializableTest < Minitest::Test
+  def test_uses_lift
+    assert_equal Lift, Chassis::Initializable
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,43 @@
+require_relative 'test_helper'
+
+class LoggerTest < Minitest::Test
+  #def test_log_level_defaults_to_env_variable
+  #  with_env :warn do
+  #    logger = Chassis::Logger.new $stdout
+  #    assert_equal Logger::WARN, logger.level
+  #  end
+  #end
+
+  def test_log_deafults_debug_without_env_variable
+    refute ENV['LOG_LEVEL'], "Precondition: LOG_LEVEL must be blank"
+
+    logger = Chassis::Logger.new $stdout
+    assert_equal Logger::DEBUG, logger.level
+  end
+
+  def test_log_dev_defaults_to_chassis_stream
+    Chassis.stream = StringIO.new
+
+    logger = Chassis::Logger.new
+    logger.debug 'test'
+
+    Chassis.stream.rewind
+    content = Chassis.stream.read
+
+    assert_includes content, 'test'
+  end
+
+  private
+  def with_env(name)
+    original_env = ENV['LOG_LEVEL']
+    ENV['LOG_LEVEL'] = name.to_s
+
+    yield
+  ensure
+    if original_env
+      ENV['LOG_LEVEL'] = original_env
+    else
+      ENV.delete 'LOG_LEVEL'
+    end
+  end
+end

data/test/persistence_test.rb

@@ -0,0 +1,112 @@
+require_relative "test_helper"
+
+class PersistenceTest < Minitest::Test
+  class FakeRepo
+
+  end
+
+  class Model
+    include Chassis::Persistence
+
+    class << self
+      def repo
+        FakeRepo
+      end
+    end
+  end
+
+  def test_models_can_be_initialize_with_a_hash
+    assert_includes Model.ancestors, Chassis::Initializable
+  end
+
+  def test_class_has_a_create_factory
+    FakeRepo.expects(:save)
+    Model.create id: 5
+  end
+
+  def test_delegates_save_to_the_repo
+    model = Model.new id: 5
+    FakeRepo.expects(:save).with(model)
+    model.save
+  end
+
+  def test_delegates_delete_to_the_repo
+    model = Model.new id: 5
+    FakeRepo.expects(:delete).with(model)
+    model.delete
+  end
+
+  def test_is_new_record_when_id_is_nil
+    model = Model.new id: 5
+    refute model.new_record?
+
+    model.id = nil
+    assert model.new_record?
+  end
+
+  def test_implements_double_equals
+    m1 = Model.new(id: 1)
+    m2 = Model.new(id: 2)
+    m3 = Model.new(id: 1)
+
+    assert (m1 == m1)
+    assert (m1 == m3)
+    refute (m1 == m2)
+  end
+
+  def test_implements_triple_equals
+    m1 = Model.new(id: 1)
+    m2 = Model.new(id: 2)
+    m3 = Model.new(id: 1)
+
+    assert (m1 === m1)
+    assert (m1 === m3)
+    refute (m1 === m2)
+  end
+
+  def test_implements_eql?
+    m1 = Model.new(id: 1)
+    m2 = Model.new(id: 2)
+    m3 = Model.new(id: 1)
+
+    assert (m1 == m1)
+    assert (m1 == m3)
+    refute (m1 == m2)
+  end
+
+  def test_acts_has_a_hash_key
+    m1 = Model.new(id: 1)
+    m2 = Model.new(id: 2)
+    m3 = Model.new(id: 1)
+
+    hash = { }
+    hash[m1] = 'm1'
+
+    assert_includes hash, m1
+    assert_includes hash, m3
+    refute_includes hash, m2
+  end
+
+  def test_acts_well_in_arrays
+    m1 = Model.new(id: 1)
+    m2 = Model.new(id: 2)
+    m3 = Model.new(id: 1)
+
+    array = [ m1 ]
+
+    assert_includes array, m1
+    assert_includes array, m3
+    refute_includes array, m2
+  end
+
+  def test_save_takes_a_block_of_changes
+    FakeRepo.expects(:save)
+
+    model = Model.new id: 5
+    model.save do |m|
+      m.id = 6
+    end
+
+    assert_equal 6, model.id
+  end
+end