guacamole 0.0.1

data/lib/guacamole/configuration.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+
+require 'logger'
+require 'forwardable'
+require 'ashikawa-core'
+require 'active_support/core_ext'
+
+require 'guacamole/document_model_mapper'
+
+module Guacamole
+
+  class << self
+    # Configure Guacamole
+    #
+    # Takes a block in which you can configure Guacamole.
+    # @return [Configuration] the resulting configuration
+    def configure(&config_block)
+      config_block.call configuration
+
+      configuration
+    end
+
+    # Contains the configuration of Guacamole
+    #
+    # @return [Configuration]
+    def configuration
+      @configuration ||= Configuration
+    end
+  end
+
+  # Current configuration
+  #
+  # You can receive the configuration by calling Guacamole.configuration
+  #
+  # @!attribute self.database
+  #   The raw Database object
+  #
+  #   The Database implementation is part of Ashikawa::Core
+  #
+  #   @see http://rubydoc.info/gems/ashikawa-core/Ashikawa/Core/Database
+  #   @return [Ashikawa::Core::Database]
+  #
+  # @!attribute self.default_mapper
+  #   The Mapper class that is used by default. This defaults to
+  #   DocumentModelMapper
+  #
+  #   @return [Class] the default mapper class
+  #
+  # @!attribute self.logger
+  #   The logger
+  #
+  #   This defaults to the Rails logger
+  #
+  #   @return [Object] the logger
+  #
+  # @!attribute [r] self.current_environment
+  #   The current environment Guacamole is running in
+  #
+  #   If you are running in Rails, this will return the current Rails environment
+  #
+  #   @return [Object] current environment
+  class Configuration
+    # @!visibility protected
+    attr_accessor :database, :default_mapper, :logger
+
+    class << self
+      extend Forwardable
+
+      def_delegators :configuration, :database, :database=, :default_mapper=, :logger=
+
+      def default_mapper
+        configuration.default_mapper || (self.default_mapper = Guacamole::DocumentModelMapper)
+      end
+
+      def logger
+        configuration.logger ||= (rails_logger || default_logger)
+      end
+
+      # Load a YAML configuration file to configure Guacamole
+      #
+      # @param [String] file_name The file name of the configuration
+      def load(file_name)
+        config = YAML.load_file(file_name)[current_environment.to_s]
+
+        self.database = create_database_connection_from(config)
+      end
+
+      def current_environment
+        return Rails.env if defined?(Rails)
+        ENV['RACK_ENV'] || ENV['GUACAMOLE_ENV']
+      end
+
+      private
+
+      def configuration
+        @configuration ||= new
+      end
+
+      def create_database_connection_from(config)
+        Ashikawa::Core::Database.new do |arango_config|
+          arango_config.url      = db_url_from(config)
+          arango_config.username = config['username']
+          arango_config.password = config['password']
+          arango_config.logger   = logger
+        end
+      end
+
+      def db_url_from(config)
+        "#{config['protocol']}://#{config['host']}:#{config['port']}/_db/#{config['database']}"
+      end
+
+      def rails_logger
+        return Rails.logger if defined?(Rails)
+      end
+
+      def default_logger
+        default_logger       = Logger.new(STDOUT)
+        default_logger.level = Logger::INFO
+        default_logger
+      end
+    end
+  end
+end

data/lib/guacamole/document_model_mapper.rb

@@ -0,0 +1,95 @@
+# -*- encoding : utf-8 -*-
+
+module Guacamole
+  # This is the default mapper class to map between Ashikawa::Core::Document and
+  # Guacamole::Model instances.
+  #
+  # If you want to build your own mapper, you have to build at least the
+  # `document_to_model` and `model_to_document` methods.
+  class DocumentModelMapper
+    # The class to map to
+    #
+    # @return [class] The class to map to
+    attr_reader :model_class
+
+    # The arrays embedded in this model
+    #
+    # @return [Array] An array of embedded models
+    attr_reader :models_to_embed
+
+    # Create a new instance of the mapper
+    #
+    # You have to provide the model class you want to map to.
+    # The Document class is always Ashikawa::Core::Document
+    #
+    # @param [Class] model_class
+    def initialize(model_class)
+      @model_class = model_class
+      @models_to_embed = []
+    end
+
+    # Map a document to a model
+    #
+    # Sets the revision, key and all attributes on the model
+    #
+    # @param [Ashikawa::Core::Document] document
+    # @return [Model] the resulting model with the given Model class
+    def document_to_model(document)
+      model = model_class.new(document.hash)
+
+      model.key = document.key
+      model.rev = document.revision
+
+      model
+    end
+
+    # Map a model to a document
+    #
+    # This will include all embedded models
+    #
+    # @param [Model] model
+    # @return [Ashikawa::Core::Document] the resulting document
+    def model_to_document(model)
+      document = model.attributes.dup.except(:key, :rev)
+      models_to_embed.each do |attribute_name|
+        document[attribute_name] = model.send(attribute_name).map do |embedded_model|
+          embedded_model.attributes.except(:key, :rev)
+        end
+      end
+      document
+    end
+
+    # Declare a model to be embedded
+    #
+    # With embeds you can specify that the document in the
+    # collection embeds a document that should be mapped to
+    # a certain model. Your model has to specify an attribute
+    # with the type Array (of this model).
+    #
+    # @param [Symbol] model_name Pluralized name of the model class to embed
+    # @example A blogpost with embedded comments
+    #   class BlogpostsCollection
+    #     include Guacamole::Collection
+    #
+    #     map do
+    #       embeds :comments
+    #     end
+    #   end
+    #
+    #   class Blogpost
+    #     include Guacamole::Model
+    #
+    #     attribute :comments, Array[Comment]
+    #   end
+    #
+    #   class Comment
+    #     include Guacamole::Model
+    #   end
+    #
+    #   blogpost = BlogpostsCollection.find('12313121')
+    #   p blogpost.comments #=> An Array of Comments
+    def embeds(model_name)
+      @models_to_embed << model_name
+    end
+  end
+end

data/lib/guacamole/model.rb

@@ -0,0 +1,210 @@
+# -*- encoding : utf-8 -*-
+require 'active_support/concern'
+# Cherry Pick not possible
+require 'active_model'
+require 'virtus'
+
+module Guacamole
+  # A domain model of your application
+  #
+  # A Guacamole::Model represents a single entry in your collection or an embedded entry
+  # of another entry.
+  # You use this as a Mixin in your model classes.
+  #
+  # @note This is not a model according to the active record pattern. It does not know anything about the database.
+  #
+  # @!attribute [r] key
+  #   Key of the document in the collection
+  #
+  #   The key identifies a document distinctly within one collection.
+  #
+  #   @return [String] The key of the document
+  #   @note Only set when persisted
+  #
+  # @!attribute [r] rev
+  #   The revision of the document
+  #
+  #   ArangoDB keeps changes the revision of a document automatically, when it has changed.
+  #   With this functionality you can quickly find out if you have the most recent version
+  #   of the document.
+  #
+  #   @return [String] The revision of the document
+  #   @note Only set when persisted
+  #
+  # @!attribute [r] created_at
+  #   Timestamp of the creation of this document
+  #
+  #   This will automatically be set when the document was first saved to the database.
+  #
+  #   @return [Time] Timestamp of the creation of the model in the database
+  #   @note Only set when persisted
+  #
+  # @!attribute [r] updated_at
+  #   Timestamp of the last update of this document
+  #
+  #   This will automatically be changed whenever the document is saved.
+  #
+  #   @return [Time] Timestamp of the last update in the database
+  #   @note Only set when persisted
+  #
+  # @!method self.attribute(attribute_name, type)
+  #   Define an attribute for this model (Provided by Virtus)
+  #
+  #   @note Setting the value of an attribute leads to automatic coercion
+  #   @param attribute_name [Symbol] The name of the attribute to define
+  #   @param type [Class] The type of the attribute
+  #   @see https://github.com/solnic/virtus
+  #   @api public
+  #   @example Define an attribute of type String
+  #     class BlogPost
+  #       include Guacamole::Model
+  #
+  #       attribute :title, String
+  #     end
+  #
+  #   @example Define an attribute containing an array of Strings
+  #     class Repository
+  #       include Guacamole::Model
+  #
+  #       attribute :contributor_names, Array[String]
+  #     end
+  #
+  # @!method self.validates
+  #   This method is a shortcut to all default validators and any custom validator classes ending in 'Validator'
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #   @example Validate the presence of the name
+  #     class Person
+  #       include Guacamole::Model
+  #
+  #       attribute :name, String
+  #       validates :name, presence: true
+  #     end
+  #
+  # @!method self.validate
+  #   Adds a validation method or block to the class
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #   @example Validate that the person is awesome
+  #     class Person
+  #       include Guacamole::Model
+  #       validate :is_awesome
+  #
+  #       def is_awesome
+  #         # Check if the person is awesome
+  #       end
+  #     end
+  #
+  # @!method self.validates_with
+  #   Passes the record off to the class or classes specified
+  #
+  #   This and allows to add errors based on more complex conditions
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #   @example Validate that the person is awesome
+  #     class Person
+  #       include Guacamole::Model
+  #       validates_with PersonValidator
+  #     end
+  #
+  #     class PersonValidator < ActiveModel::Validator
+  #       def validate(record)
+  #         # check if the person is valid
+  #       end
+  #     end
+  #
+  # @!method persisted?
+  #   Checks if the object is persisted
+  #
+  #   @return [Boolean]
+  #   @api public
+  #
+  # @!method valid?
+  #   Runs all the specified validations and returns true if no errors were added otherwise false
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #
+  # @!method invalid?
+  #   Performs the opposite of `valid?`. Returns true if errors were added, false otherwise
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #
+  # @!method errors
+  #   Returns the Errors object that holds all information about attribute error messages
+  #
+  #   For further details see the documentation of ActiveModel
+  #   or the RailsGuide on Validations
+  #
+  #   @see http://guides.rubyonrails.org/active_record_validations.html
+  #   @api public
+  #
+  # @!method ==(other)
+  #   Check if the attributes are from the same model class and have equal attributes
+  #
+  #   @param [Model] other the model to compare with
+  #   @api public
+  module Model
+    extend ActiveSupport::Concern
+    # @!parse include ActiveModel::Validations
+    # @!parse extend ActiveModel::Naming
+    # @!parse include ActiveModel::Conversion
+    # I know that this is technically not true, but the reality is a parse error:
+    # @!parse include Virtus
+
+    included do
+      include ActiveModel::Validations
+      include ActiveModel::Naming
+      include ActiveModel::Conversion
+      include Virtus.model
+
+      attribute :key, String
+      attribute :rev, String
+      attribute :created_at, Time
+      attribute :updated_at, Time
+
+      def persisted?
+        key.present?
+      end
+
+      # For ActiveModel::Conversion compliance only, please use key
+      def id
+        key
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          attributes.all? do |attribute, value|
+            other_value = other.send(attribute)
+            case value
+            when DateTime, Time
+              value.to_s == other_value.to_s # :(
+            else
+              value == other_value
+            end
+          end
+      end
+      alias_method :eql?, :==
+
+    end
+  end
+end

data/lib/guacamole/query.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+
+module Guacamole
+  # Build a query for ArangoDB
+  class Query
+    include Enumerable
+
+    # Connection to the database
+    #
+    # @return [Ashikawa::Core::Collection]
+    attr_reader :connection
+
+    # The mapper class
+    #
+    # @return [Class]
+    attr_reader :mapper
+
+    # The example to search for
+    #
+    # @return [Hash] the example
+    attr_accessor :example
+
+    # Currently set options
+    #
+    # @return [Hash]
+    # @api private
+    attr_accessor :options
+
+    # Create a new Query
+    #
+    # @param [Ashikawa::Core::Collection] connection The collection to use to talk to the database
+    # @param [Class] mapper the class of the mapper to use
+    def initialize(connection, mapper)
+      @connection = connection
+      @mapper = mapper
+      @options = {}
+    end
+
+    # Iterate over the result of the query
+    #
+    # This will execute the query you have build
+    def each
+      return to_enum(__callee__) unless block_given?
+
+      iterator = ->(document) { yield mapper.document_to_model(document) }
+
+      if example
+        connection.by_example(example, options).each(&iterator)
+      else
+        connection.all(options).each(&iterator)
+      end
+    end
+
+    # Limit the results of the query
+    #
+    # @param [Fixnum] limit
+    # @return [self]
+    def limit(limit)
+      options[:limit] = limit
+      self
+    end
+
+    # The number of results to skip
+    #
+    # @param [Fixnum] skip
+    # @return [self]
+    def skip(skip)
+      options[:skip] = skip
+      self
+    end
+  end
+end