repository 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+*.rbc
+.DS_Store
+.bundle
+.rvmrc
+.yardoc
+Gemfile.lock
+doc/*
+log/*
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--format=documentation
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby
+  - rbx
+  - ree

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Alex Chaffee
+Copyright (c) 2012 Nikita Fedyashev
+
+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.

data/README.md

@@ -0,0 +1,76 @@
+
+![travis-ci](http://travis-ci.org/nfedyashev/repository.png)
+
+Description
+--------
+
+A Ruby implementation of the Repository Pattern, as described in many OO/Patterns books but notably martinfowler.com/eaaCatalog/repository.html and www.infoq.com/resource/minibooks/domain-driven-design-quickly/en/pdf/DomainDrivenDesignQuicklyOnline.pdf (p.51)
+
+From Fowler/Hieatt/Mee: “A system with a complex domain model often benefits from a layer, such as the one provided by Data Mapper, that isolates domain objects from details of the database access code. In such systems it can be worthwhile to build another layer of abstraction over the mapping layer where query construction code is concentrated. This becomes more important when there are a large number of domain classes or heavy querying. In these cases particularly, adding this layer helps minimize duplicate query logic. A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection.”
+
+In Repository, queries are specified using a DSL and turn into Criterion objects, which are then passed to the Repository for matching against the data store.
+
+Examples
+--------
+
+``` ruby
+require 'ostruct'
+=> true
+
+class User < OpenStruct
+end
+=> nil
+
+user = User.new(id: 1, name: 'John')
+=> #<User id=1, name="John">
+
+Repository[User].store(user)
+=> [#<User id=1, name="John">]
+
+Repository[User].search(user.id)
+=> [#<User id=1, name="John">]
+
+```
+
+Check out specs for more examples.
+
+Installation
+-------
+
+Install the gem:
+
+``` bash
+$ gem install repository
+```
+
+Add it to your Gemfile:
+
+``` ruby
+gem 'repository'
+```
+
+Submitting a Pull Request
+-------
+
+1. Fork the project.
+2. Create a topic branch.
+3. Implement your feature or bug fix.
+4. Add specs for your feature or bug fix.
+5. Run `bundle exec rake spec`. If your changes are not 100% covered, go back to step 4.
+6. Commit and push your changes.
+7. Submit a pull request. Please do not include changes to the gemspec,
+   version, or history file. (If you want to create your own version for some
+   reason, please do so in a separate commit.)
+
+
+Credits
+-------
+
+That is a simplified version of the https://github.com/alexch/treasury which supports only in-memory database with minimum features and overhead. If you need more features or support of other storage methods you may check out the original repo.
+
+
+Copyright © 2009 Alex Chaffee
+Copyright © 2012 Nikita Fedyashev
+
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec
+

data/lib/repository.rb

@@ -0,0 +1,78 @@
+$:.unshift File.join(File.dirname(__FILE__), '.')
+
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+
+require 'repository/criterion'
+require 'repository/repository'
+require 'repository/storage'
+require 'repository/stash'
+require 'repository/stash_storage'
+
+module Repository
+  
+  def self.repositories
+    (@@repositories ||= {})
+  end
+  
+  def self.repository(klass)
+    self.repositories[klass] ||= Repository.new(klass)
+  end
+  
+  def self.[](klass)
+    self.repository(klass)
+  end
+
+  def self.clear_all
+    self.repositories.values.each do |r|
+      r.clear
+    end
+  end
+
+  def self.[]=(klass, repository)
+    self.repositories[klass] = repository
+  end
+  
+  # methods on Repository-enabled model classes that extend Repository
+
+  def repository
+    Repository[self]
+  end
+  
+  def repository_size
+    repository.size
+  end
+  
+  def store(*args)
+    repository.store(*args)
+  end
+
+  def search(*args, &block)
+    repository.search(*args, &block)
+  end
+  
+  def clear_repository
+    repository.clear
+  end
+  
+  def <<( *treasure )
+    store( *treasure )
+  end
+  
+  def [](arg)
+    repository[arg]
+  end
+
+  def self.extended( klass )
+    klass.class_eval do
+      include InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    def store
+      self.class.store(self)
+    end
+  end
+  
+end

data/lib/repository/criterion.rb

@@ -0,0 +1,192 @@
+module Repository
+  class Criterion
+    
+    attr_reader :subject, :descriptor, :value, :property_name
+
+    def initialize(options)
+      @subject = (options[:subject] || "id").to_s
+      @descriptor = options[:descriptor] || "#{@subject} #{default_descriptor}"
+      @value = options[:value]
+      @value = nil if @value.blank?
+      @property_name = options[:property_name] || @subject
+    end
+    
+    def ==(other)
+      self.class == other.class &&
+      self.subject == other.subject &&
+      self.descriptor == other.descriptor &&
+      self.value == other.value &&
+      self.property_name == other.property_name
+    end
+
+    def description
+      "#{descriptor} #{described_value}"
+    end
+    
+    def default_descriptor
+      self.class.name.gsub(/[A-Z]/, " \\0").gsub(/.*::/, '').downcase.strip
+    end
+
+    def described_value
+      if value.blank?
+        "any"
+      elsif value == 0
+        "none"
+      else
+        value
+      end
+    end
+    
+    def match?(object)
+      object_value = object.send(property_name)
+      if value.is_a? Array
+        value.detect{|criterion_value| match_value?(criterion_value, object_value)}
+      else
+        match_value?(value, object_value)
+      end
+    end
+
+    def +(other)
+      And.new(self, other)
+    end
+
+    alias_method :&, :+
+
+    def |(other)
+      Or.new(self, other)
+    end
+
+    def find_in(storage)
+      storage.find(self)
+    end
+
+protected
+    def match_value?(criterion_value, object_value)
+      false
+    end
+
+public
+
+    class Factory
+      # methods are defined inside the relevant Criterion subclasses
+    end
+
+    class Equals < Criterion
+      def Factory.equals(subject, value)
+        Equals.new(:subject => subject, :value => value)
+      end
+
+      def match_value?(criterion_value, object_value)
+        if object_value.is_a? Fixnum
+          object_value == criterion_value.to_i
+        else
+          object_value == criterion_value
+        end
+      end
+
+      def value
+        case @value
+        when Criterion
+          @value.value
+        else
+          @value
+        end
+      end
+    end
+
+    class Key < Equals
+      def Factory.key(*args)
+        if args.length == 1
+          subject = :key
+          value = args.first
+        else
+          subject = args.shift
+          value = args.shift
+        end
+        Key.new(:subject => subject, :value => value)
+      end
+      
+      def initialize(options)
+        options[:value] = case options[:value]
+        when Fixnum
+          [options[:value]]
+        when String
+          [options[:value].to_i]
+        when Array
+          options[:value].map{|v|v.to_i} # todo: allow arrays of Criteria too
+        else
+          options[:value]
+        end
+        options[:descriptor] ||= "#"
+        super(options)
+      end
+      
+      def match?(object)
+        object_value = object.send(property_name)
+        value.detect{|criterion_value| match_value?(criterion_value, object_value)} || false
+      end
+      
+      def match_value?(criterion_value, object_value)
+        object_value == criterion_value
+      end
+    end
+
+    class Contains < Criterion
+      def Factory.contains(subject, value)
+        Contains.new(:subject => subject, :value => value)
+      end
+
+      protected
+      def match_value?(criterion_value, object_value)
+        /#{Regexp.escape(criterion_value)}/i =~ object_value
+      end
+    end
+
+    class Conjunction < Criterion
+      attr_reader :criteria
+      def initialize(*criteria)
+        super(:subject => nil)
+        @criteria = criteria
+      end
+    end
+
+    class And < Conjunction
+      def match?(object)
+        @criteria.each do |criterion|
+          return false unless criterion.match?(object)
+        end
+        return true
+      end
+    end
+
+    class Or < Conjunction
+      def match?(object)
+        @criteria.each do |criterion|
+          return true if criterion.match?(object)
+        end
+        return false
+      end
+    end
+
+    class Join < Criterion
+      attr_reader :referent_class
+
+      def initialize(options)
+        super
+        @nested_criterion = options[:criterion]
+        @referent_class = options[:referent_class]
+      end
+
+      def find_in(storage)
+        objects = storage.find(@nested_criterion)
+        objects.map(&:id)
+      end
+
+      def value
+        @value ||= begin
+          Repository[@referent_class].search(self)
+        end
+      end
+    end
+  end
+end

data/lib/repository/repository.rb

@@ -0,0 +1,126 @@
+# http://martinfowler.com/eaaCatalog/repository.html
+# http://www.infoq.com/resource/minibooks/domain-driven-design-quickly/en/pdf/DomainDrivenDesignQuicklyOnline.pdf p.51
+module Repository
+  class Repository
+
+    attr_reader :klass
+    attr_accessor :storage
+
+    def initialize(klass)
+      @klass = klass
+      @stash = Stash.new
+      @storage = StashStorage.new(klass)
+    end
+
+    def size
+      @stash.size
+    end
+
+    # todo: clean up ambiguity between clearing the stash and clearing the storage
+    def clear
+      @stash.clear
+    end
+
+    def <<(args)
+      store(args)
+    end
+
+    def store(*arg)
+      arg.flatten!
+      arg = arg.select do |object|
+        if object.is_a?(Fixnum)
+          false
+        elsif !object.is_a?(klass)
+          raise ArgumentError, "expected #{@klass} but got #{object.class}"
+        else
+          true
+        end
+      end
+      storage.store(arg)
+      @stash.put(arg)
+    end
+
+    def [](key)
+      objects = search(key)
+      if objects.empty?
+        nil
+      else
+        objects.first
+      end
+    end
+
+    def search(arg = nil, &block)
+      if (arg.nil? && !block_given?) || (block_given? && !arg.nil?)
+        raise "Must pass either an argument or a block to Repository#search"
+      end
+
+      arg = criterion_from &block if block_given?
+
+      case arg
+      when Array
+        find_keys(arg)
+      when Fixnum
+        find_keys([arg])
+      when Criterion::Key
+        find_keys_in_criterion(arg)
+      when String
+        find_keys([arg.to_i])
+      when Criterion
+        find_by_criterion(arg)
+      else
+        raise "???"
+      end
+    end
+    
+    def extract(arg = nil, &block)
+      search(arg, &block).map{ |o| o.id }
+    end
+
+    # This is the method that's called when you pass a block into search.
+    # It passes the Criterion::Factory as a block parameter. 
+    def criterion_from
+      yield Criterion::Factory
+    end
+    
+    protected
+
+    def find_keys_in_criterion(criterion)
+      find_keys(criterion.value)
+    end
+    
+    def find_keys(keys)
+      raise "Nil argument" if keys.nil?
+      
+      found = []
+      needed = []
+      keys.each do |key|
+        raise ArgumentError, "illegal argument #{key.inspect}" if key.to_i == 0
+        key = key.to_i
+        unless (object = @stash[key])
+          needed << key
+        end
+      end
+
+      unless needed.empty?
+        needed.sort!.uniq! # the sort is just to make debugging easier
+
+        found_in_storage = storage.find(needed).compact
+
+        if found_in_storage.size != needed.size
+          missing = (needed - found_in_storage.map(&:key))
+          #raise "Warning: couldn't find #{missing.size} out of #{needed.size} #{klass.name.pluralize}: missing keys #{missing.join(',')}"
+        end
+
+        store(found_in_storage)
+      end
+      keys.map{|key| @stash[key]} # find again so they come back in order
+    end
+    
+    def find_by_criterion(criterion)
+      results = criterion.find_in(storage)
+      self << results
+      results
+    end
+
+  end
+end