ambry 0.1.0

data/ambry.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path("../lib/ambry/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors           = "Norman Clarke"
+  s.email             = "norman@njclarke.com"
+  s.files             = `git ls-files`.split("\n").reject {|f| f =~ /^\./}
+  s.homepage          = "http://github.com/norman/ambry"
+  s.name              = "ambry"
+  s.platform          = Gem::Platform::RUBY
+  s.rubyforge_project = "[none]"
+  s.summary           = "An ActiveModel-compatible ORM-like library for storing model instances in an in-memory Hash."
+  s.test_files        = Dir.glob "test/**/*_test.rb"
+  s.version           = Ambry::Version::STRING
+  s.description       = <<-EOD
+    Ambry is not an ORM, man! It's a database and ORM replacement for (mostly)
+    static models and small datasets. It provides ActiveModel compatibility, and
+    flexible searching and storage.
+  EOD
+  s.add_development_dependency "ffaker"
+  s.add_development_dependency "minitest", "~> 2.2.2"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "activesupport", "~> 3.0"
+  s.add_development_dependency "activemodel", "~> 3.0"
+  s.add_development_dependency "rake"
+end

data/extras/bench.rb

@@ -0,0 +1,107 @@
+require "rubygems"
+require "bundler/setup"
+require "benchmark"
+require "ffaker"
+require "ambry"
+
+N = 500
+
+Ambry::Adapter.new
+
+class Person
+  extend Ambry::Model
+  field :email, :name, :age
+
+  def self.younger_than(age)
+    with_index("younger_than_#{age}") do
+      find {|person| person[:age] < age}
+    end
+  end
+
+  filters do
+    def older_than(age)
+      find {|person| person[:age] > age}
+    end
+
+    def email_matches(regexp)
+      find {|person| person[:email] =~ regexp}
+    end
+
+  end
+end
+
+until Person.count == 1000 do
+  Person.create \
+    :name  => Faker::Name.name,
+    :email => Faker::Internet.email,
+    :age   => rand(100)
+end
+
+keys = Person.all.keys.sort do |a, b|
+  rand(100) <=> rand(100)
+end[0,10]
+
+Benchmark.bmbm do |x|
+
+  puts "Benchmarking #{N} times:\n\n"
+
+  x.report("Count records") do
+    N.times do
+      Person.count {|p| p[:email] =~ /\.com/}
+    end
+  end
+
+  x.report("Count scoped records") do
+    N.times do
+      Person.older_than(50).count
+    end
+  end
+
+  x.report("Get 10 random keys") do
+    N.times do
+      keys.each {|k| Person.get(k)}
+    end
+  end
+
+  x.report("Find records iterating on values") do
+    N.times do
+      Person.find {|p| p[:email] =~ /\.com/}
+    end
+  end
+
+  x.report("Find records using proxy method") do
+    N.times do
+      Person.find {|p| p.email =~ /\.com/}
+    end
+  end
+
+  x.report("Find records iterating on keys") do
+    N.times do
+      Person.find_by_key {|k| k =~ /\.com/}
+    end
+  end
+
+  x.report("Find scoped people without index") do
+    N.times do
+      Person.find {|p| p[:age] < 50 && p[:email] =~ /\.com/}
+    end
+  end
+
+  x.report("Find scoped people with index") do
+    N.times do
+      Person.younger_than(50).find {|p| p[:email] =~ /\.com/}
+    end
+  end
+
+  x.report("Find with chained filters") do
+    N.times do
+      Person.older_than(50).email_matches(/\.com/)
+    end
+  end
+
+  x.report("Find records iterating on keys and using scope") do
+    N.times do
+      Person.find_by_key {|k| k =~ /\.com/}.older_than(50)
+    end
+  end
+end

data/extras/cookie_demo.rb

@@ -0,0 +1,111 @@
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.uniq!
+
+require "rubygems"
+require "sinatra"
+require "haml"
+require "babosa"
+require "date"
+require "ambry"
+require "ambry/adapters/cookie"
+require "rack/ambry"
+
+set :session, false
+
+use Rack::Cookies
+use Rack::Ambry, :name => :cookie, :secret => "Sssshhhh! This is a secret."
+
+class Book
+  extend Ambry::Model
+  field :slug, :title, :author
+  use :cookie
+
+  def title=(value)
+    @slug  = value.to_slug.normalize.to_s
+    @title = value
+  end
+end
+
+get "/" do
+  @header = "Books"
+  @books  = Book.all
+  haml :index
+end
+
+get "/books/new" do
+  @header = "Add a Book"
+  @action = "/books"
+  haml :new
+end
+
+get "/books/:slug/edit" do |slug|
+  @book           = Book.get(slug)
+  @action         = "/books"
+  @header         = @book.title
+  params[:title]  = @book.title
+  params[:author] = @book.author
+  haml :edit
+end
+
+get "/books/:slug" do |slug|
+  @book   = Book.get(slug)
+  @header = @book.title
+  haml :book
+end
+
+post "/books" do
+  Book.delete params[:slug] unless params[:slug].blank?
+  @book = Book.create params unless params[:title].blank?
+  redirect "/"
+end
+
+__END__
+@@layout
+!!! 5
+%html
+  %head
+    %meta(http-equiv="Content-Type" content="text/html; charset=utf-8")
+    %title Ambry Cookie Adapter Demo
+  %body
+    %h2= @header
+    = yield
+
+@@edit
+= haml(:form, :layout => false)
+
+@@index
+%ul
+  - @books.each do |book|
+    %li= '<a href="/books/%s">%s</a>' % [book.slug, book.title, book.author]
+%p.controls
+  <a href="/books/new">New book</a>
+
+@@new
+= haml(:form, :layout => false)
+%p.controls
+  <a href="/">Books</a>
+
+@@book
+by #{@book.author}
+%p.controls
+  <a href="/">Books</a>
+  <a href="/books/#{@book.slug}/edit">Edit</a>
+
+@@form
+%form(method="post" enctype="utf-8" action=@action)
+  %p
+    - if @book
+      %input#slug{:type => "hidden", :value => @book.slug, :name => "slug"}
+    %label(for="title") Title:
+    %br
+    %input#title{:type => "text", :value => params[:title], :name => "title"}
+  %p
+    %label(for="author") Author:
+    %br
+    %input#author{:type => "text", :value => params[:author], :name => "author"}
+  %p
+    %input(type="submit" value="save it")
+- if @book
+  %form{:method => "post", :enctype => "utf-8", :action => "/books"}
+    %input#slug{:type => "hidden", :value => @book.slug, :name => "slug"}
+    %input(type="submit" value="or delete it")

data/extras/countries.rb

@@ -0,0 +1,70 @@
+# A demo of Ambry's filters
+
+require "bundler/setup"
+require "ambry"
+
+Ambry::Adapter.new
+
+class Country
+  extend Ambry::Model
+  field :tld, :name, :population, :region
+
+  filters do
+    def african
+      find {|p| p.region == :africa}
+    end
+
+    def european
+      find {|p| p.region == :europe}
+    end
+
+    def population(op, num)
+      find {|p| p.population.send(op, num)}.sort {|a, b| b.population <=> a.population}
+    end
+  end
+end
+
+# Population data from: http://en.wikipedia.org/wiki/List_of_countries_by_population
+[
+  {:tld => "br", :name => "Brazil",     :population => 190_732_694,   :region => :america},
+  {:tld => "bw", :name => "Botswana",   :population => 1_839_833,     :region => :africa},
+  {:tld => "cn", :name => "China",      :population => 1_342_740_000, :region => :asia},
+  {:tld => "dz", :name => "Algeria",    :population => 33_333_216,    :region => :africa},
+  {:tld => "eg", :name => "Egypt",      :population => 80_335_036,    :region => :africa},
+  {:tld => "et", :name => "Ethiopia",   :population => 85_237_338,    :region => :africa},
+  {:tld => "fr", :name => "France",     :population => 65_821_885,    :region => :europe},
+  {:tld => "ma", :name => "Morocco",    :population => 33_757_175,    :region => :africa},
+  {:tld => "mc", :name => "Monaco",     :population => 33_000,        :region => :europe},
+  {:tld => "mz", :name => "Mozambique", :population => 20_366_795,    :region => :africa},
+  {:tld => "ng", :name => "Nigeria",    :population => 154_729_000,   :region => :africa},
+  {:tld => "sc", :name => "Seychelles", :population => 80_654,        :region => :africa}
+].each {|c| Country.create(c)}
+
+@african_countries              = Country.african
+@bigger_countries               = Country.population(:>=, 50_000_000)
+@smaller_countries              = Country.population(:<=, 5_000_000)
+@european_countries             = Country.european
+@bigger_african_countries       = Country.african.population(:>=, 50_000_000)
+@bigger_non_african_countries   = @bigger_countries - @african_countries
+@bigger_or_european_countries   = @bigger_countries + @european_countries
+@smaller_or_european_countries  = @smaller_countries + @european_countries
+@smaller_european_countries     = @smaller_countries & @european_countries
+
+instance_variables.each do |name|
+  puts "%s: %s" % [
+    name.to_s.gsub("_", " ").gsub("@", ""),
+    instance_variable_get(name).all.map(&:name).join(", ")
+  ]
+end
+
+# Output:
+#
+# african countries: Algeria, Botswana, Egypt, Ethiopia, Nigeria, Seychelles, Mozambique, Morocco
+# bigger countries: China, Brazil, Nigeria, Ethiopia, Egypt, France
+# smaller countries: Botswana, Seychelles, Monaco
+# european countries: France, Monaco
+# bigger african countries: Egypt, Ethiopia, Nigeria
+# bigger non african countries: China, Brazil, France
+# bigger or european countries: China, Brazil, Nigeria, Ethiopia, Egypt, France, Monaco
+# smaller and european countries: Botswana, Seychelles, Monaco, France
+# smaller european countries: Monaco

data/lib/ambry.rb

@@ -0,0 +1,54 @@
+require "forwardable"
+require "thread"
+require "ambry/adapter"
+require "ambry/abstract_key_set"
+require "ambry/mapper"
+require "ambry/model"
+require "ambry/hash_proxy"
+require "ambry/adapters/file"
+
+# Ambry is a database and ORM replacement for small, mostly static models.
+#
+# Ambry is free software released under the terms of the MIT License.
+# @author Norman Clarke
+module Ambry
+  extend self
+
+  @lock = Mutex.new
+
+  # The default adapter name.
+  attr_reader   :default_adapter_name
+  @default_adapter_name = :main
+
+  # A hash of all instantiated Ambry adapters.
+  attr_reader :adapters
+  @adapters = {}
+
+  # Registers an adapter with Ambry. This facilitates allowing models to
+  # specify an adapter by name rather than class or instance.
+  #
+  # @param [Symbol] adapter The adapter name.
+  # @see Ambry::Model::ClassMethods#use
+  def register_adapter(adapter)
+    name = adapter.name.to_sym
+    if adapters[name]
+      raise AmbryError, "Adapter #{name.inspect} already registered"
+    end
+    @lock.synchronize do
+      adapters[name] = adapter
+    end
+  end
+
+  # Base error for Ambry.
+  class AmbryError < StandardError ; end
+
+  # Raised when a single instance is expected but could not be found.
+  class NotFoundError < AmbryError
+
+    # @param [String] klass The class from which the error originated.
+    # @param [String] key The key whose lookup trigged the error.
+    def initialize(*args)
+      super('Could not find %s with key "%s"' % args)
+    end
+  end
+end

data/lib/ambry/abstract_key_set.rb

@@ -0,0 +1,106 @@
+module Ambry
+
+  # @abstract
+  class AbstractKeySet
+    extend Forwardable
+    include Enumerable
+
+    attr_accessor  :keys, :mapper
+    def_delegators :keys, :empty?, :length, :size
+    def_delegators :to_enum, :each
+
+    # Create a new KeySet from an array of keys and a mapper.
+    def initialize(keys = nil, mapper = nil)
+      @keys = keys || [].freeze
+      # Assume that if a frozen array is passed in, it's already been compacted
+      # and uniqued in order to improve performance.
+      unless @keys.frozen?
+        @keys.uniq!
+        @keys.compact!
+        @keys.freeze
+      end
+      @mapper = mapper
+    end
+
+    def +(key_set)
+      self.class.new(keys + key_set.keys, mapper)
+    end
+    alias | +
+
+    def -(key_set)
+      self.class.new((keys - key_set.keys).freeze, mapper)
+    end
+
+    def &(key_set)
+      self.class.new((keys & key_set.keys).compact.freeze, mapper)
+    end
+
+    # With no block, returns an instance for the first key. If a block is given,
+    # it returns the first instance yielding a true value.
+    def first(&block)
+      block_given? ? all.detect(&block) : all.first
+    end
+
+    # With no block, returns the number of keys. If a block is given, counts the
+    # number of elements yielding a true value.
+    def count(&block)
+      return keys.count unless block_given?
+      proxy = HashProxy.new
+      keys.inject(0) do |count, key|
+        proxy.with(mapper[key], &block) ? count.succ : count
+      end
+    end
+
+    def find(id = nil, &block)
+      return mapper.get(id) if id
+      return self unless block_given?
+      proxy = HashProxy.new
+      self.class.new(keys.inject([]) do |found, key|
+        found << key if proxy.with(mapper[key], &block)
+        found
+      end, mapper)
+    end
+
+    def to_enum
+      KeyIterator.new(keys) {|k| @mapper.get(k)}
+    end
+    alias all to_enum
+
+    def find_by_key(&block)
+      return self unless block_given?
+      self.class.new(keys.inject([]) do |set, key|
+        set << key if yield(key); set
+      end, mapper)
+    end
+
+    def sort(&block)
+      proxies = HashProxySet.new
+      self.class.new(@keys.sort do |a, b|
+        begin
+          yield(*proxies.using(mapper[a], mapper[b]))
+        ensure
+          proxies.clear
+        end
+      end, mapper)
+    end
+
+    def limit(length)
+      self.class.new(@keys.first(length).freeze, mapper)
+    end
+  end
+
+  class KeyIterator
+    include Enumerable
+
+    attr_reader :keys, :callable
+
+    def initialize(keys, &callable)
+      @keys     = keys
+      @callable = callable
+    end
+
+    def each(&block)
+      block_given? ? keys.each {|k| yield callable.call(k)} : to_enum
+    end
+  end
+end