chassis 0.1.0

data/lib/chassis/repo/delegation.rb

@@ -0,0 +1,78 @@
+module Chassis
+  UnknownObjectClassError = Chassis.error do
+    "Rename class to end in Repo or define object_class"
+  end
+
+  class Repo
+    module Delegation
+      def all
+        backend.all object_class
+      end
+
+      def count
+        backend.count object_class
+      end
+
+      def find(id)
+        backend.find object_class, id
+      end
+
+      def save(record)
+        backend.save(record)
+      end
+
+      def delete(record)
+        backend.delete record
+      end
+
+      def first
+        backend.first object_class
+      end
+
+      def last
+        backend.last object_class
+      end
+
+      def query(selector)
+        backend.query object_class, selector
+      end
+
+      def query!(selector, &block)
+        backend.query! object_class, selector, &block
+      end
+
+      def sample
+        backend.sample object_class
+      end
+
+      def empty?
+        backend.empty? object_class
+      end
+
+      def graph(id)
+        backend.graph object_class, id
+      end
+
+      def graph_query(selector)
+        backend.graph_query object_class, selector
+      end
+
+      def lazy(id)
+        LazyAssociation.new self, id
+      end
+
+      def object_class
+        @object_class ||= begin
+          fail UnknownObjectClassError unless name
+          match = name.match(/^(.+)Repo$/)
+          fail UnknownObjectClassError unless match
+          StringUtils.constantize match[1]
+        end
+      end
+
+      def backend
+        Repo.default
+      end
+    end
+  end
+end

data/lib/chassis/repo/lazy_association.rb

@@ -0,0 +1,57 @@
+module Chassis
+  class Repo
+    class LazyAssociation < Proxy
+      def initialize(repo, id)
+        @repo, @id = repo, id
+      end
+
+      def id
+        @id
+      end
+
+      def class
+        @repo.object_class
+      end
+
+      def repo
+        @repo
+      end
+
+      def instance_of?(klass)
+        self.class == klass
+      end
+
+      def is_a?(klass)
+        instance_of?(klass) || self.class > klass
+      end
+
+      def kind_of?(klass)
+        is_a? klass
+      end
+
+      def ==(other)
+        if other.instance_of? self.class
+          other.id == id
+        else
+          other.repo == repo && other.id == id
+        end
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def materialize
+        @object ||= repo.find id
+      end
+
+      def __getobj__
+        materialize
+      end
+
+      def inspect
+        "#<LazyAssociation:#{object_id} @repo=#{repo} @id=#{id}>"
+      end
+    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/pstore_repo.rb

@@ -0,0 +1,54 @@
+module Chassis
+  class PStoreRepo < BaseRepo
+    class AccessProxy < Chassis::Proxy
+      def map
+        __getobj__[:map] ||= Chassis::Repo::RecordMap.new
+      end
+    end
+
+    class PStoreMap
+      def initialize(pstore)
+        @pstore = AccessProxy.new pstore
+      end
+
+      def clear
+        pstore.transaction do
+          pstore.map.clear
+        end
+      end
+
+      def all(klass)
+        pstore.transaction do
+          pstore.map.all klass
+        end
+      end
+
+      def get(klass, id)
+        pstore.transaction do
+          pstore.map.get klass, id
+        end
+      end
+
+      def set(record)
+        pstore.transaction do
+          pstore.map.set record
+        end
+      end
+
+      def delete(record)
+        pstore.transaction do
+          pstore.map.delete record
+        end
+      end
+
+      private
+      def pstore
+        @pstore
+      end
+    end
+
+    def initialize(pstore)
+      @map = PStoreMap.new pstore
+    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/repo/redis_repo.rb

@@ -0,0 +1,55 @@
+module Chassis
+  class RedisRepo < Chassis::BaseRepo
+    class RedisMap
+      def initialize(redis)
+        @redis = redis
+      end
+
+      def clear
+        redis.del key
+      end
+
+      def all(klass)
+        read.all klass
+      end
+
+      def get(klass, id)
+        read.get klass, id
+      end
+
+      def set(record)
+        map = read
+        map.set record
+        write map
+      end
+
+      def delete(record)
+        map = read
+        map.delete record
+        write map
+      end
+
+      private
+      def key
+        'repo'
+      end
+
+      def redis
+        @redis
+      end
+
+      def read
+        value = redis.get key
+        value ? Marshal.load(value) : Repo::RecordMap.new
+      end
+
+      def write(map)
+        redis.set key, Marshal.dump(map)
+      end
+    end
+
+    def initialize(redis)
+      @map = RedisMap.new redis
+    end
+  end
+end

data/lib/chassis/serializable.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'yaml'
+
+module Chassis
+  module Serializable
+    module ClassMethods
+      def from_hash(hash)
+        new.from_hash(hash)
+      end
+
+      def from_json(json)
+        from_hash JSON.load(json)
+      end
+
+      def from_yaml(yaml)
+        from_hash YAML.load(yaml)
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend ClassMethods
+      end
+    end
+
+    def marshal_dump
+      fail NotImplementedError, 'subclass must implement marshal_dump'
+    end
+
+    def marshal_load(hash)
+      fail NotImplementedError, 'subclass must implement marshal_load'
+    end
+
+    def to_hash
+      marshal_dump
+    end
+    alias_method :to_h, :to_hash
+
+    def to_json
+      JSON.dump marshal_dump
+    end
+
+    def to_yaml
+      YAML.dump marshal_dump
+    end
+
+    def from_hash(hash)
+      marshal_load HashUtils.symbolize(hash)
+      self
+    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