guacamole 0.0.1 → 0.1.0

data/lib/guacamole/identity_map.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+
+require 'hamster/hash'
+
+module Guacamole
+  # This class implements the 'Identity Map' pattern
+  # ({http://www.martinfowler.com/eaaCatalog/identityMap.html Fowler, EAA, 195}) to
+  # ensure only one copy of the same database document is present in memory within
+  # the same session. Internally a `Hamster::Hash` is used. This hash implementation
+  # is immutable and thus it is safe to use the current `IdentityMap`
+  # implementation in concurrent situations.
+  #
+  # The `IdentityMap` should be purged after any unit of work (i.e. a request).
+  # If used in Rails the {IdentityMap::Session} middleware will automatically
+  # be registered. For other Rack-based use cases you must register it yourself.
+  # For all other use cases you need to take when to call {Guacamole::IdentityMap.reset} all
+  # by yourself.
+  class IdentityMap
+    # The `IdentityMap::Session` acts as Rack middleware to reset the {IdentityMap}
+    # before each request.
+    class Session
+      # Create a new instance of the `Session` middleware
+      #
+      # You must pass an object that responds to `call` in the constructor. This
+      # will be the called after the `IdentityMap` has been purged.
+      #
+      # @param [#call] app Any object that responds to `call`
+      def initialize(app)
+        @app = app
+      end
+
+      # Run the concrete middleware
+      #
+      # This satisfies the Rack interface and will be called to reset the `IdentityMap`
+      # before each request. In the end the `@app` will be called.
+      #
+      # @param [Hash] env The environment of the Rack request
+      # @return [Array] a Rack compliant response array
+      def call(env)
+        Guacamole.logger.debug '[SESSION] Resetting the IdentityMap'
+        IdentityMap.reset
+
+        @app.call(env)
+      end
+    end
+
+    class << self
+      # Purges all stored object from the map by setting the internal structure to `nil`
+      #
+      # @return [nil]
+      def reset
+        @identity_map_instance = nil
+      end
+
+      # Add an object to the map
+      #
+      # The object must implement a `key` method. There is *no* check if that method is present.
+      #
+      # @param [Object#key] object Any object that implements the `key` method (and has a `class`)
+      # @return [Object#key] the object which just has been stored
+      def store(object)
+        @identity_map_instance = identity_map_instance.put(key_for(object), object)
+        object
+      end
+
+      # Retrieves a stored object from the map
+      #
+      # @param [Class] klass The class of the object you want to get
+      # @param [Object] key Whatever is the key of that object
+      # @return [Object] the stored object
+      def retrieve(klass, key)
+        identity_map_instance.get key_for(klass, key)
+      end
+
+      # Retrieves a stored object or adds it based on the block if it is not already present
+      #
+      # This can be used to retrieve and store in one step. See {Guacamole::DocumentModelMapper#document_to_model}
+      # for an example.
+      #
+      # @param [Class] klass The class of the object you want to get
+      # @param [Object] key Whatever is the key of that object
+      # @yield A block if the object is not already present
+      # @yieldreturn [Object#read] the object to store. The `key` and `class` should match with input params
+      # @return [Object] the stored object
+      def retrieve_or_store(klass, key, &block)
+        return retrieve(klass, key) if include?(klass, key)
+
+        store block.call
+      end
+
+      # Tests if the map contains some object
+      #
+      # The method accepts either a `class` and `key` or just any `Object` that responds to
+      # `key`. Supporting both is made for your convenience.
+      #
+      # @param [Object#read, Class] object_or_class Either the object to check or the `class`
+      #                                             of the object you're looking for
+      # @param [Object, nil] key In case you provided a `Class` as first parameter you must
+      #                          provide the key for the object here
+      # @return [true, false] does the map contain the object or not
+      def include?(object_or_class, key = nil)
+        identity_map_instance.key? key_for(object_or_class, key)
+      end
+
+      # Constructs the key used internally by the map
+      #
+      # @param [Object#read, Class] object_or_class Either an object or a `Class`
+      # @param [Object, nil] key In case you provided a `Class` as first parameter you must
+      #                          provide the key for the object here
+      # @return [Array(Class, Object)] the created key
+      def key_for(object_or_class, key = nil)
+        key ? [object_or_class, key] : [object_or_class.class, object_or_class.key]
+      end
+
+      # The internally used map
+      #
+      # @api private
+      # @return [Hamster::Hash] an instance of an immutable hash
+      def identity_map_instance
+        @identity_map_instance ||= Hamster.hash
+      end
+    end
+  end
+end

data/lib/guacamole/proxies/proxy.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+
+module Guacamole
+  module Proxies
+    # This is the base class for the association proxies. Proxies are only
+    # needed for non-embedded relations between objects. Embedded objects are
+    # taken care of by Virtus.
+    #
+    # The `Proxy` class undefines most methods and passes them to the
+    # `@target`.  The `@target` will be a lambda which will lazy query the
+    # requested objects from the database.
+    #
+    # Concrete proxy classes are:
+    #
+    #  * {Guacamole::Proxies::ReferencedBy}: This will handle one-to-many associations
+    #  * {Guacamole::Proxies::References}: This will handle many-to-one associations
+    class Proxy < BasicObject
+      # Despite using BasicObject we still need to remove some method to get a near transparent proxy
+      instance_methods.each do |method|
+        undef_method(method) unless method =~ /^__/
+      end
+
+      # Convenience method to setup the proxy. The subclasses need to care of creating
+      # the `target` correctly.
+      #
+      # @param [Object] base The class holding the reference. Currently not used.
+      # @param [#call] target The lambda for getting the required objects from the database.
+      def init(base, target)
+        @base = base
+        @target = target
+      end
+
+      def method_missing(meth, *args, &blk)
+        @target.call.send meth, *args, &blk
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @target.respond_to?(name, include_private)
+      end
+    end
+  end
+end

data/lib/guacamole/proxies/referenced_by.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+
+require 'guacamole/proxies/proxy'
+
+module Guacamole
+  module Proxies
+    # The {ReferencedBy} proxy is used to represent the 'one' in one-to-many relations.
+    class ReferencedBy < Proxy
+      def initialize(ref, model)
+        init model,
+             -> { DocumentModelMapper.collection_for(ref).by_example("#{model.class.name.underscore}_id" => model.key) }
+      end
+    end
+  end
+end

data/lib/guacamole/proxies/references.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+
+require 'guacamole/proxies/proxy'
+
+module Guacamole
+  module Proxies
+    # The {References} proxy is used to represent the 'many' in one-to-many relations.
+    class References < Proxy
+      def initialize(ref, document)
+        init nil,
+             -> { DocumentModelMapper.collection_for(ref).by_key(document["#{ref}_id"]) }
+      end
+    end
+  end
+end

data/lib/guacamole/query.rb

@@ -68,5 +68,16 @@ module Guacamole
       options[:skip] = skip
       self
     end
+
+    # Is this {Query} equal to another {Query}
+    #
+    # Two {Query} objects are equal if their examples are equal
+    #
+    # @param [Query] other The query to compare to
+    def ==(other)
+      other.instance_of?(self.class) &&
+        example == other.example
+    end
+    alias_method :eql?, :==
   end
 end

data/lib/guacamole/railtie.rb

@@ -9,13 +9,15 @@ module Guacamole
   # Class to hook into Rails configuration and initializer
   # @api private
   class Railtie < Rails::Railtie
-
     rake_tasks do
       load 'guacamole/railtie/database.rake'
     end
 
     config.guacamole = ::Guacamole::Configuration
 
+    # We're not doing migrations (yet)
+    config.send(:app_generators).orm :guacamole, migration: false
+
     initializer 'guacamole.load-config' do
       config_file = Rails.root.join('config', 'guacamole.yml')
       if config_file.file?
@@ -23,5 +25,8 @@ module Guacamole
       end
     end
 
+    initializer 'guacamole.append-identity-map-middleware' do |app|
+      app.middleware.use Guacamole::IdentityMap::Session
+    end
   end
 end

data/lib/guacamole/railtie/database.rake

@@ -1,5 +1,59 @@
+# -*- encoding : utf-8 -*-
+
+load 'guacamole/tasks/database.rake'
+
 namespace :db do
-  # TODO: Add all the Rails-tasks.
-  #       If we cannot do something meaningful provide a noop.
-  #       Foremost the creation of databases should be provided.
+  unless Rake::Task.task_defined?("db:drop")
+    desc "Drops all the collections of the database for the current Rails.env"
+    task :drop => "guacamole:drop"
+  end
+
+  unless Rake::Task.task_defined?("db:purge")
+    desc "Purges all the collections of the database for the current Rails.env"
+    task :purge => "guacamole:purge"
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    desc "Load the seed data from db/seeds.rb"
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, "db", "seeds.rb")
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc "Create the database, and initialize with the seed data"
+    task :setup => [ "db:create", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:reset")
+    desc "Delete data and loads the seeds"
+    task :reset => [ "db:drop", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    desc "Create the database"
+    task :create => "guacamole:create"
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    desc "Run the migrations for the current Rails.env (not yet implemented)"
+    task :migrate => :environment do
+      raise "ArangoDB doesn't support migrations. If you need to migrate your data you must roll your own solution."
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        raise "ArangoDB is schema-less, thus we cannot load any schema."
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare => "guacamole:purge"
+    end
+  end
 end

data/lib/guacamole/tasks/database.rake

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+namespace :db do
+  namespace :guacamole do
+    desc "Purges all the collections of the database for the current environment"
+    task :purge => :environment do
+      puts "[ARANGODB] Purging all data from database '#{Guacamole.configuration.database.name}' ..."
+      Guacamole.configuration.database.truncate
+    end
+
+    desc "Drops all the collections of the database for the current environment"
+    task :drop => :environment do
+      puts "[ARANGODB] Dropping the database '#{Guacamole.configuration.database.name}' ..."
+      Guacamole.configuration.database.drop
+    end
+
+    desc "Create the database for the current environment"
+    task :create => :environment do
+      puts "[ARANGODB] Creating the database '#{Guacamole.configuration.database.name}' ..."
+      Guacamole.configuration.database.create
+    end
+  end
+end

data/lib/guacamole/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Guacamole
   # Current version of the gem
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/rails/generators/guacamole/collection/collection_generator.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/guacamole_generator'
+
+module Guacamole
+  module Generators
+    class CollectionGenerator < Base
+      desc 'Creates a Guacamole collection'
+
+      check_class_collision suffix: 'Collection'
+
+      def create_collection_file
+        template 'collection.rb.tt', File.join('app/collections', class_path, "#{file_name}_collection.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/guacamole/collection/templates/collection.rb.tt

@@ -0,0 +1,5 @@
+<% module_namespacing do -%>
+class <%= class_name %>Collection
+  include Guacamole::Collection
+end
+<% end -%>

data/lib/rails/generators/guacamole/config/config_generator.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/guacamole_generator'
+
+module Guacamole
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc 'Creates a Guacamole configuration file at config/guacamole.yml'
+
+      argument :database_name, type: :string, optional: true
+
+      def self.source_root
+        @_guacamole_source_root ||= File.expand_path('../templates', __FILE__)
+      end
+
+      def app_name
+        Rails.application.class.parent.to_s.underscore
+      end
+
+      def create_config_file
+        template 'guacamole.yml', File.join('config', 'guacamole.yml')
+      end
+    end
+  end
+end

data/lib/rails/generators/guacamole/config/templates/guacamole.yml

@@ -0,0 +1,15 @@
+development:
+  protocol: 'http'
+  host: 'localhost'
+  port: 8529
+  password: ''
+  username: ''
+  database: '<%= database_name || app_name %>_development'
+
+test:
+  protocol: 'http'
+  host: 'localhost'
+  port: 8529
+  password: ''
+  username: ''
+  database: '<%= database_name || app_name %>_test'

data/lib/rails/generators/guacamole/model/model_generator.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/guacamole_generator'
+
+module Guacamole
+  module Generators
+    class ModelGenerator < Base
+      desc 'Creates a Guacamole model'
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+      check_class_collision
+
+      class_option :parent, type: :string, desc: 'The parent class for the generated model'
+
+      def create_model_file
+        template 'model.rb.tt', File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+      hook_for :collection, aliases: '-c', type: :boolean, default: true do |instance, collection|
+        instance.invoke collection, [instance.name.pluralize]
+      end
+    end
+  end
+end

data/lib/rails/generators/guacamole/model/templates/model.rb.tt

@@ -0,0 +1,11 @@
+<% module_namespacing do -%>
+class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
+<% unless options[:parent] -%>
+  include Guacamole::Model
+<% end -%>
+
+<% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
+  attribute :<%= attribute.name %>, <%= attribute.type_class %>
+<% end -%>
+end
+<% end -%>