memorydb 0.0.1

data/lib/memorydb.rb

@@ -0,0 +1,9 @@
+require 'memorydb/db'
+
+module MemoryDb
+
+  def self.new(model_klass, options={})
+    Db.new(model_klass, options)
+  end
+
+end

data/lib/memorydb/base.rb

@@ -0,0 +1,55 @@
+require 'time'
+require 'memorydb/cursor'
+require 'memorydb/filter_factory'
+
+module MemoryDb
+  class Base
+
+    def find
+      cursor
+    end
+
+    def filter
+      @filter_factory ||= FilterFactory.new
+    end
+
+    def remove_by_id!(id)
+      if model = find_by_id(id)
+        remove_model!(model)
+      else
+        raise ArgumentError.new("Could not remove record with id: #{id} because it does not exist")
+      end
+    end
+
+    def remove!(model=nil)
+      if model
+        remove_by_id!(model.send(primary_key))
+      else
+        cursor.remove!
+      end
+    end
+
+    private
+
+    attr_reader :model_klass
+
+    def cursor
+      Cursor.new(self)
+    end
+
+    def model_or_hash_as_attrs(model_or_hash)
+      if model_or_hash
+        if model_or_hash.is_a?(Hash)
+          model_or_hash
+        elsif model_or_hash.is_a?(model_klass)
+          model_or_hash.attributes
+        else
+          raise ArgumentError.new("A hash or a #{model_klass} must be given to create a record")
+        end
+      else
+        {}
+      end
+    end
+
+  end
+end

data/lib/memorydb/cursor.rb

@@ -0,0 +1,168 @@
+require 'memorydb/filter'
+require 'memorydb/sort'
+require 'memorydb/filter_factory'
+
+module MemoryDb
+  class Cursor
+
+    def initialize(query_executor)
+      @query_executor = query_executor
+      @filters = []
+      @sorts   = []
+    end
+
+    def eq(field, value)
+      @filters << filter_factory.eq(field, value)
+      self
+    end
+
+    def not_eq(field, value)
+      @filters << filter_factory.not_eq(field, value)
+      self
+    end
+
+    def lt(field, value)
+      @filters << filter_factory.lt(field, value)
+      self
+    end
+
+    def lte(field, value)
+      @filters << filter_factory.lte(field, value)
+      self
+    end
+
+    def gt(field, value)
+      @filters << filter_factory.gt(field, value)
+      self
+    end
+
+    def gte(field, value)
+      @filters << filter_factory.gte(field, value)
+      self
+    end
+
+    def in(field, value)
+      @filters << filter_factory.in(field, value)
+      self
+    end
+
+    def not_in(field, value)
+      @filters << filter_factory.not_in(field, value)
+      self
+    end
+
+    def like(field, value)
+      @filters << filter_factory.like(field, value)
+      self
+    end
+
+    def or(*filters)
+      @filters << filter_factory.or(*filters)
+      self
+    end
+
+    def sort(field, order)
+      assert_field!(field)
+      assert_order!(order)
+      @sorts << Sort.new(field, order.to_sym)
+      self
+    end
+
+    def limit(limit)
+      if limit
+        assert_int!('Limit', limit)
+        @limit = limit.to_i
+      end
+      self
+    end
+
+    def offset(offset)
+      if offset
+        assert_int!('Offset', offset)
+        @offset = offset.to_i
+      end
+      self
+    end
+
+    def count
+      query_executor.execute_count(query)
+    end
+
+    def all
+      query_executor.execute_find(query)
+    end
+
+    def first
+      query_executor.execute_find(
+        query.merge(
+          sorts: sorts_for_first,
+          limit: 1
+        )).first
+    end
+
+    def last
+      query_executor.execute_find(
+        query.merge(
+          sorts: sorts_for_last,
+          limit: 1
+        )).first
+    end
+
+    def remove!
+      query_executor.execute_remove!(query)
+    end
+
+    def first
+      query_executor.execute_find(
+        query.merge(
+          limit: 1
+        )).first
+    end
+
+    def query
+      {
+        :type    => @type,
+        :filters => @filters,
+        :sorts   => @sorts,
+        :offset  => @offset,
+        :limit   => @limit
+      }
+    end
+
+    private
+
+    attr_reader :query_executor
+
+    def filter_factory
+      @filter_factory ||= FilterFactory.new
+    end
+
+    def sorts_for_first
+      @sorts
+    end
+
+    def sorts_for_last
+      sorts_for_first.map do |sort|
+        Sort.new(sort.field, sort.order == :asc ? :desc : :asc)
+      end
+    end
+
+    def assert_field!(field)
+      unless field.is_a?(String) || field.is_a?(Symbol)
+        raise ArgumentError.new "Field name must be a String or Symbol but you gave #{PP.pp(field, '')}"
+      end
+    end
+
+    def assert_order!(order)
+      unless [:asc, :desc, 'asc', 'desc'].include?(order)
+        raise ArgumentError.new "Sort order must be 'asc' or 'desc' but you gave #{PP.pp(order, '')}"
+      end
+    end
+
+    def assert_int!(name, num)
+      unless num.is_a?(Integer) || (num.is_a?(String) && num =~ /\d+/)
+        raise ArgumentError.new "#{name} must be an integer but you gave #{PP.pp(num, '')}"
+      end
+    end
+  end
+end

data/lib/memorydb/db.rb

@@ -0,0 +1,206 @@
+require 'multi_json'
+require 'memorydb/base'
+require 'memorydb/cursor'
+
+# for sorting on booleans
+class FalseClass
+  def <(other)
+    other
+  end
+
+  def >(other)
+    false
+  end
+end
+
+class TrueClass
+  def <(other)
+    other
+  end
+
+  def >(other)
+    true
+  end
+end
+
+module MemoryDb
+  class Db < Base
+
+    def initialize(model_klass, options={})
+      @model_klass = model_klass
+      @id = 0
+      @store = {}
+      @primary_key = options[:primary_key]
+    end
+
+    def create!(attrs={})
+      _id = id
+      attrs = model_or_hash_as_attrs(attrs)
+      verify_attributes!(attrs)
+      attributes = attrs.merge(primary_key => _id)
+      store!(_id, attributes)
+      model_klass.new(attributes)
+    end
+
+    def update!(model_or_id, attributes={})
+      attributes ||= {}
+      model = case
+              when model_or_id.is_a?(model_klass)
+                if model = find_by_id(model_or_id.send(primary_key))
+                  model_or_id
+                else
+                  raise ArgumentError.new("Could not update record with id: #{model_or_id.send(primary_key)} because it does not exist") unless model
+                end
+
+              else
+                if model = find_by_id(model_or_id)
+                  model
+                else
+                  raise ArgumentError.new("Could not update record with id: #{model_or_id} because it does not exist") unless model
+                end
+              end
+      updated_attrs = model.attributes.merge(attributes_without_pkey(attributes))
+      store!(model.send(primary_key), updated_attrs)
+      model_klass.new(updated_attrs)
+    end
+
+    def find_by_id(id)
+      find.eq(primary_key, id).first
+    end
+
+    ###########################
+    # These methods are called by the cursor. Do not call them directly. Or call them. Whatever. Either one.
+
+    def raw_find(query)
+      models = all_models
+      models = apply_transforms models, query[:transforms]
+      models = filter_models    models, query[:filters]
+      models = sort_models      models, query[:sorts]
+      models = offset_models    models, query[:offset]
+      models = limit_models     models, query[:limit]
+    end
+
+    def execute_find(query)
+      models = raw_find(query)
+      models.map { |h| model_klass.new(h) }
+    end
+
+    def execute_count(query)
+      execute_find(query).size
+    end
+
+    def execute_remove!(query)
+      execute_find(query).each do |model|
+        remove_model!(model)
+      end
+    end
+
+    ###########################
+
+    private
+
+    attr_reader :primary_key
+
+    def verify_attributes!(attrs)
+      null_model = model_klass.new
+      allowed_attributes = null_model.attributes.keys.map(&:to_sym)
+      attrs.each do |key, value|
+        unless allowed_attributes.include?(key.to_sym)
+          raise ArgumentError.new("Unknown attribute: #{key}")
+        end
+      end
+    end
+
+    def attributes_without_pkey(attributes)
+      attributes.reject { |k, v| k == primary_key }
+    end
+
+    def apply_transforms(models, transforms)
+      models.map do |model|
+        (transforms || []).reduce(model) do |model, transform|
+          transform.call(model)
+        end
+      end
+    end
+
+    def filter_models(models, filters)
+      models.select do |model|
+        (filters || []).all? do |filter|
+          filter_matches?(filter, model)
+        end
+      end
+    end
+
+    def filter_matches?(filter, model)
+      value = model[filter.field]
+      case filter.operator
+      when '='; value == filter.value
+      when '!='; value != filter.value
+      when '<'; value && value < filter.value
+      when '<='; value && value <= filter.value
+      when '>'; value && value > filter.value
+      when '>='; value && value >= filter.value
+      when 'in'; filter.value.include?(value)
+      when '!in'; !filter.value.include?(value)
+      when 'or'; filter.value.any? do |sub_filter|
+        filter_matches?(sub_filter, model)
+      end
+      when 'like'; value =~ /#{filter.value}/i
+      end
+    end
+
+    def sort_models(models, sorts)
+      models.sort { |model1, model2| compare_models(model1, model2, sorts) }
+    end
+
+    def compare_models(model1, model2, sorts)
+      sorts.each do |sort|
+        result = compare_model(model1, model2, sort)
+        return result if result
+      end
+      0
+    end
+
+    def compare_model(model1, model2, sort)
+      field1, field2 = model1[sort.field], model2[sort.field]
+      field1 == field2                         ?  nil :
+        field1 < field2 && sort.order == :asc  ?  -1  :
+        field1 > field2 && sort.order == :desc ?  -1  : 1
+    end
+
+    def limit_models(models, limit)
+      if limit
+        models.take(limit)
+      else
+        models
+      end
+    end
+
+    def offset_models(models, offset)
+      if offset
+        models.drop(offset)
+      else
+        models
+      end
+    end
+
+    def all_models
+      @store.values.map do |raw_record|
+        model_klass.new(MultiJson.load(raw_record)).attributes
+      end
+    end
+
+    def store!(id, attributes)
+      @store[id] = MultiJson.dump(attributes)
+    end
+
+    def remove_model!(model)
+      @store.delete(model.send(primary_key))
+      nil
+    end
+
+    def id
+      @id += 1
+    end
+  end
+end

data/lib/memorydb/filter.rb

@@ -0,0 +1,13 @@
+module MemoryDb
+  class Filter
+
+    attr_reader :field, :operator, :value
+
+    def initialize(field, operator, value)
+      @field = field
+      @operator = operator
+      @value = value
+    end
+
+  end
+end

data/lib/memorydb/filter_factory.rb

@@ -0,0 +1,87 @@
+require 'memorydb/filter'
+
+module MemoryDb
+  class FilterFactory
+
+    def eq(field, value)
+      assert_field!(field)
+      Filter.new(field, '=', value)
+    end
+
+    def not_eq(field, value)
+      assert_field!(field)
+      Filter.new(field, '!=', value)
+    end
+
+    def lt(field, value)
+      assert_field!(field)
+      assert_not_nil!('Less than', value)
+      Filter.new(field, '<', value)
+    end
+
+    def lte(field, value)
+      assert_field!(field)
+      assert_not_nil!('Less than or equal to', value)
+      Filter.new(field, '<=', value)
+    end
+
+    def gt(field, value)
+      assert_field!(field)
+      assert_not_nil!('Greater than', value)
+      Filter.new(field, '>', value)
+    end
+
+    def gte(field, value)
+      assert_field!(field)
+      assert_not_nil!('Greater than or equal to', value)
+      Filter.new(field, '>=', value)
+    end
+
+    def in(field, value)
+      assert_field!(field)
+      assert_to_a!('Inclusion', value)
+      Filter.new(field, 'in', value.to_a)
+    end
+
+    def not_in(field, value)
+      assert_field!(field)
+      assert_to_a!('Exclusion', value)
+      Filter.new(field, '!in', value.to_a)
+    end
+
+    def like(field, value)
+      assert_field!(field)
+      assert_str_or_sym!(value, 'Value')
+      Filter.new(field, 'like', value)
+    end
+
+    def or(*filters)
+      Filter.new(nil, 'or', filters)
+    end
+
+    private
+
+    def assert_to_a!(name, value)
+      unless value.respond_to?(:to_a)
+        raise ArgumentError.new "#{name} filter value must respond to to_a but #{PP.pp(value, '')} does not"
+      end
+    end
+
+    def assert_not_nil!(name, value)
+      if value.nil?
+        raise ArgumentError.new "#{name} filter value cannot be nil"
+      end
+    end
+
+    def assert_field!(field)
+      assert_str_or_sym!(field, 'Field name')
+    end
+
+    def assert_str_or_sym!(value, name)
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise ArgumentError.new "#{name} must be a String or Symbol but you gave #{PP.pp(value, '')}"
+      end
+    end
+
+  end
+end

data/lib/memorydb/sort.rb

@@ -0,0 +1,12 @@
+module MemoryDb
+  class Sort
+
+    attr_reader :field, :order
+
+    def initialize(field, order)
+      @field = field
+      @order = order
+    end
+
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: memorydb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Myles Megyesi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.6
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+description: An in memory database
+email:
+- myles.megyesi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/memorydb/db.rb
+- lib/memorydb/base.rb
+- lib/memorydb/filter_factory.rb
+- lib/memorydb/sort.rb
+- lib/memorydb/filter.rb
+- lib/memorydb/cursor.rb
+- lib/memorydb.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: An in memory database
+test_files: []