memstore 1.2.1 → 2.0.1

data/lib/memstore.rb

@@ -1,30 +1,4 @@
-# encoding: utf-8
-
 require "memstore/version"
-require "memstore/objectstore"
-require "memstore/hashstore"
+require "memstore/refinements"
+require "memstore/core"
 require "memstore/queries"
-
-module MemStore
-
-  # Shortcut to ObjectStore::new
-  def self.new(key=nil, items={})
-    ObjectStore.new(key, items)
-  end
-
-  # Shortcut to ObjectStore::from_binary
-  def self.from_binary(binary)
-    ObjectStore.from_binary(binary)
-  end
-
-  # Shortcut to ObjectStore::from_file
-  def self.from_file(file)
-    ObjectStore.from_file(file)
-  end
-
-  # Shortcut to ObjectStore::with_file
-  def self.with_file(file, key=nil, items={}, &block)
-    ObjectStore.with_file(file, key, items, &block)
-  end
-
-end

data/lib/memstore/core.rb

@@ -0,0 +1,129 @@
+class MemStore
+
+  # Initializes an MemStore.
+  #
+  # key    - optional String/Symbol to be sent or Proc/lambda/method to be called
+  # access - optional String/Symbol to be sent or Proc/lambda/method to be called
+  # items  - optional Array of items to be added
+  #
+  # Returns initialized MemStore.
+  def initialize(key: nil, access: nil, items: nil)
+
+    @items = {}
+
+    define_singleton_method :access_key,
+      if key.nil?
+        -> item { item.hash }
+      elsif key.respond_to?(:call)
+        -> item { key.call(item) }
+      else
+        -> item { access_attribute(item, key) }
+      end
+
+    define_singleton_method :access_attribute,
+      if access.nil?
+        -> item, attribute { item.send(attribute) }
+      elsif [Symbol, String].include?(access.class)
+        -> item, attribute { item.send(access, attribute) }
+      elsif access.respond_to?(:call)
+        -> item, attribute { access.call(item, attribute) }
+      else
+        raise "No usable access method."
+      end
+    
+    add(*items) unless items.nil?
+
+  end
+
+  # Provides access to internal items collection (which is simply a Hash).
+  attr_accessor :items
+
+  # Returns all items as an Array.
+  def all
+    @items.values
+  end
+
+  # Returns total number of items in the data store.
+  def size
+    @items.length
+  end
+
+  # Adds one item to the data store.
+  #
+  # item - item to add
+  #
+  # Returns the data store itself.
+  #
+  # Raises NoMethodError when an item does’t respond to the key attribute method.
+  def <<(item)
+    @items[access_key(item)] = item
+    self
+  end
+
+  # Adds one or more items to the data store.
+  #
+  # items - items to be added
+  #
+  # Returns the data store itself.
+  #
+  # Raises NoMethodError when an item does’t respond to the key attribute method.
+  def add(*items)
+    items.each { |item| self << item }
+    self
+  end
+
+  # Retrieves one item by key.
+  #
+  # key - key of item to be retrieved
+  #
+  # Returns item if it exists, otherwise nil.
+  def [](key)
+    @items[key]
+  end
+
+  # Retrieves one or more items by key.
+  #
+  # keys - keys of items to be retrieved
+  #
+  # Returns an array of items with nil where no item with that key exists.
+  def get(*keys)
+    keys.collect { |key| @items[key] }
+  end
+
+  # Deletes one item by reference.
+  #
+  # item - item to be deleted
+  #
+  # Returns the item that was deleted or nil if it doesn’t exist.
+  def delete_item(item)
+    @items.delete(access_key(item))
+  end
+
+  # Deletes one or more items by reference.
+  #
+  # items - items to be deleted
+  #
+  # Returns an array of items that were deleted with nil where an item doesn’t exist.
+  def delete_items(*items)
+    items.collect { |item| @items.delete(access_key(item)) }
+  end
+
+  # Deletes one item by key.
+  #
+  # key - key of item to be deleted
+  #
+  # Returns the item that was deleted or nil if it doesn’t exist.
+  def delete_key(key)
+    @items.delete(key)
+  end
+
+  # Deletes one or more items by key.
+  #
+  # keys - keys of items to be deleted
+  #
+  # Returns an array of items that were deleted with nil where no item with that key exists.
+  def delete_keys(*keys)
+    keys.collect { |key| @items.delete(key) }
+  end
+
+end

data/lib/memstore/queries.rb

@@ -1,144 +1,184 @@
-# encoding: utf-8
+class MemStore
 
-module MemStore
+  using Refinements
 
-  class ObjectStore
-
-    # All methods have the following signature:
-    #
-    # conditions - Hash mapping attributes to conditions.
-    #              Attributes can be Symbols or String for ObjectStore
-    #              and any kind of Object for HashStore.
-    #              Conditions can be any kind of Object that responds to #===.
-    # block - Optional block taking an item and returning a bool indicating
-    #         whether the item passed the tests within the block.
-    #
-    # Yields every item in the data store after the conditions were evaluated for it.
-
-    ### find ###
-
-    # Also available as #find.
-    # Returns an Array of items that fulfill all conditions.
-    def find_all(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-    alias_method :find, :find_all
-
-    # Returns an Array of items that fulfill at least one condition.
-    def find_any(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ANY) }
-    end
-
-    # Returns an Array of items that fulfill exactly one condition.
-    def find_one(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ONE) }
-    end
+  ### find ###
+  
+  # Finds items that fulfill all provided conditions.
+  #
+  # conditions - Hash mapping attributes to conditions (anything that responds to #===).
+  # block      - Optional block taking an item and returning a bool. Evaluated after conditions.
+  #
+  # Returns an Array of items that fulfill all conditions.
+  def find_all(conditions={}, &block)
+    all.select { |item| match_all(item, conditions, &block) }
+  end
+  alias_method :find, :find_all
+  
+  # Finds items that fulfill at least one of the provided conditions.
+  def find_any(conditions={}, &block)
+    all.select { |item| match_any(item, conditions, &block) }
+  end
+  
+  # Finds items that fulfill exactly one of the provided conditions.
+  def find_one(conditions={}, &block)
+    all.select { |item| match_one(item, conditions, &block) }
+  end
+  
+  # Finds items that violate at least one of the provided conditions.
+  def find_not_all(conditions={}, &block)
+    all.reject { |item| match_all(item, conditions, &block) }
+  end
+  
+  # Finds items that violate all provided conditions.
+  def find_none(conditions={}, &block)
+    all.select { |item| match_none(item, conditions, &block) }
+  end
+  
+  ### first ###
+  
+  # Finds the first item that fulfills all provided conditions.
+  #
+  # conditions - Hash mapping attributes to conditions (anything that responds to #===).
+  # block      - Optional block taking an item and returning a bool. Evaluated after conditions.
+  #
+  # Returns the first item that fulfills all conditions.
+  def first_all(conditions={}, &block)
+    all.detect { |item| match_all(item, conditions, &block) }
+  end
+  alias_method :first, :first_all
+  
+  # Finds the first item that fulfills at least one of the provided conditions.
+  def first_any(conditions={}, &block)
+    all.detect { |item| match_any(item, conditions, &block) }
+  end
 
-    # Returns an Array of items that violate at least one condition.
-    def find_not_all(conditions={}, &block)
-      all.reject { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
+  # Finds the first item that fulfills exactly one of the provided conditions.
+  def first_one(conditions={}, &block)
+    all.detect { |item| match_one(item, conditions, &block) }
+  end
 
-    # Returns an Array of items that violate all conditions.
-    def find_none(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_NONE) }
-    end
+  # Finds the first item that violates at least one of the provided conditions.
+  def first_not_all(conditions={}, &block)
+    all.detect { |item| !match_all(item, conditions, &block) }
+  end
 
-    ### first ###
+  # Finds the first item that violates all provided conditions.
+  def first_none(conditions={}, &block)
+    all.detect { |item| match_none(item, conditions, &block) }
+  end
 
-    # Also available as #first.
-    # Returns the first item that fulfills all conditions.
-    def first_all(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-    alias_method :first, :first_all
+  ### count ###
 
-    # Returns the first item that fulfills at least one condition.
-    def first_any(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ANY) }
-    end
+  # Counts the number of items that fulfill all provided conditions.
+  #
+  # conditions - Hash mapping attributes to conditions (anything that responds to #===).
+  # block      - Optional block taking an item and returning a bool. Evaluated after conditions.
+  #
+  # Returns the number of items that fulfill all conditions.
+  def count_all(conditions={}, &block)
+    all.count { |item| match_all(item, conditions, &block) }
+  end
+  alias_method :count, :count_all
 
-    # Returns the first item that fulfills exactly one condition.
-    def first_one(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ONE) }
-    end
+  # Counts the number of items that fulfill at least one of the provided conditions.
+  def count_any(conditions={}, &block)
+    all.count { |item| match_any(item, conditions, &block) }
+  end
 
-    # which is equivalent to: !condition || !condition || ... [|| !block]
-    # Returns the first item that violates at least one condition.
-    def first_not_all(conditions={}, &block)
-      all.detect { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
-    end
+  # Counts the number of items that fulfill exactly one of the provided conditions.
+  def count_one(conditions={}, &block)
+    all.count { |item| match_one(item, conditions, &block) }
+  end
 
-    # Returns the first item that violates all conditions.
-    def first_none(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_NONE) }
-    end
+  # Counts the number of items that violate at least one of the provided conditions.
+  def count_not_all(conditions={}, &block)
+    all.count { |item| !match_all(item, conditions, &block) }
+  end
 
-    ### count ###
+  # Counts the number of items that violate all provided conditions.
+  def count_none(conditions={}, &block)
+    all.count { |item| match_none(item, conditions, &block) }
+  end
 
-    # Also available as #count.
-    # Returns the number of items that fulfill all conditions.
-    def count_all(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ALL) }
+  ### delete ###
+
+  # Deletes items that fulfill all provided conditions.
+  #
+  # conditions - Hash mapping attributes to conditions (anything that responds to #===).
+  # block      - Optional block taking an item and returning a bool. Evaluated after conditions.
+  #
+  # Returns an Array of items that fulfill all conditions and were deleted.
+  def delete_all(conditions={}, &block)
+    @items.inject([]) do |items, (key, item)|
+      items << @items.delete(key) if match_all(item, conditions, &block)
+      items
     end
-    alias_method :count, :count_all
+  end
+  alias_method :delete, :delete_all
 
-    # Returns the number of items that fulfill at least one condition.
-    def count_any(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ANY) }
+  # Deletes items that fulfill at least one of the provided conditions.
+  def delete_any(conditions={}, &block)
+    @items.inject([]) do |items, (key, item)|
+      items << @items.delete(key) if match_any(item, conditions, &block)
+      items
     end
+  end
 
-    # Returns the number of items that fulfill exactly one condition.
-    def count_one(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ONE) }
+  # Deletes items that fulfill exactly one of the provided conditions.
+  def delete_one(conditions={}, &block)
+    @items.inject([]) do |items, (key, item)|
+      items << @items.delete(key) if match_one(item, conditions, &block)
+      items
     end
+  end
 
-    # which is equivalent to: !condition || !condition || ... [|| !block]
-    # Returns the number of items that violate at least one condition.
-    def count_not_all(conditions={}, &block)
-      all.count { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
+  # Deletes items that violate at least one of the provided conditions.
+  def delete_not_all(conditions={}, &block)
+    @items.inject([]) do |items, (key, item)|
+      items << @items.delete(key) if !match_all(item, conditions, &block)
+      items
     end
+  end
 
-    # Returns the number of items that violate all conditions.
-    def count_none(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_NONE) }
+  # Deletes items that violate all provided conditions.
+  def delete_none(conditions={}, &block)
+    @items.inject([]) do |items, (key, item)|
+      items << @items.delete(key) if match_none(item, conditions, &block)
+      items
     end
+  end
 
-    private
-    
-    # All blocks have the following signature:
-    #
-    # item - The item (Object for ObjectStore, Hash for HashStore) to be tested.
-    # conditions - Hash of conditions to be evaluated.
-    # block - Optional block that can test the item after the conditions are evaluated.
-    #
-    # Returns a bool indicating whether the item was a match
-    #   for the given conditions and matching logic.
-
-    # Internal: Evaluates conditions using AND, i.e. condition && condition && ... [&& block]
-    FIND_ALL = Proc.new do |item, conditions, block|
-        conditions.all? { |attribute, condition| condition === attr(item, attribute) } &&
-          if block then !!block.call(item) else true end
-      end
-  
-    # Internal: Evaluates conditions using OR, i.e. condition || condition || ... [|| block]
-    FIND_ANY = Proc.new do |item, conditions, block|
-        conditions.any? { |attribute, condition| condition === attr(item, attribute) } ||
-          if block then !!block.call(item) else false end
-      end
+  private
+
+  # Evaluates conditions using AND, i.e. condition && condition && ... [&& block]
+  #
+  # item       - The item to be tested.
+  # conditions - Hash of conditions to be evaluated.
+  # block      - Optional block that can test the item after the conditions are evaluated.
+  #
+  # Returns a bool indicating whether the item passed the conditions and/or block.
+  def match_all(item, conditions={}, &block)
+    conditions.all? { |attribute, condition| condition === access_attribute(item, attribute) } &&
+      if block_given? then yield(item) else true end
+  end
 
-    # Internal: Evaluates conditions using XOR, i.e. condition ^ condition ^ condition ... [^ block]
-    FIND_ONE = Proc.new do |item, conditions, block|
-        conditions.one? { |attribute, condition| condition === attr(item, attribute) } ^
-          if block then !!block.call(item) else false end
-      end
+  # Evaluates conditions using OR, i.e. condition || condition || ... [|| block]
+  def match_any(item, conditions={}, &block)
+    conditions.any? { |attribute, condition| condition === access_attribute(item, attribute) } ||
+      if block_given? then yield(item) else false end
+  end
 
-    # Internal: Evaluates condition using AND NOT, i.e. !condition && !condition && ... [&& !block]
-    FIND_NONE = Proc.new do |item, conditions, block|
-        conditions.none? { |attribute, condition| condition === attr(item, attribute) } &&
-          if block then !!!block.call(item) else true end
-      end
+  # Evaluates conditions using XOR, i.e. condition ^ condition ^ condition ... [^ block]
+  def match_one(item, conditions={}, &block)
+    conditions.one? { |attribute, condition| condition === access_attribute(item, attribute) } ^
+      if block_given? then yield(item) else false end
+  end
 
+  # Evaluates condition using AND NOT, i.e. !condition && !condition && ... [&& !block]
+  def match_none(item, conditions={}, &block)
+    conditions.none? { |attribute, condition| condition === access_attribute(item, attribute) } &&
+      if block_given? then !yield(item) else true end
   end
   
-end
+end