guacamole 0.0.1

data/Rakefile

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+require 'bundler/gem_tasks'
+
+require 'devtools'
+Devtools.init_rake_tasks
+
+import('./tasks/adjustments.rake')

data/config/devtools.yml

@@ -0,0 +1,4 @@
+---
+unit_test_timeout: 0.1
+fail_on_branch:
+- "master"

data/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 7
+total_score: 74

data/config/flog.yml

@@ -0,0 +1,2 @@
+---
+threshold: 0

data/config/mutant.yml

@@ -0,0 +1,3 @@
+---
+name: guacamole
+namespace: Guacamole

data/config/reek.yml

@@ -0,0 +1,104 @@
+---
+Attribute:
+  enabled: false
+  exclude: []
+BooleanParameter:
+  enabled: true
+  exclude: []
+ClassVariable:
+  enabled: true
+  exclude: []
+ControlParameter:
+  enabled: false
+  exclude: []
+DataClump:
+  enabled: true
+  exclude: []
+  max_copies: 2
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: true
+  exclude: []
+  max_calls: 1
+  allow_calls: []
+FeatureEnvy:
+  enabled: false
+  exclude: []
+IrresponsibleModule:
+  enabled: true
+  exclude: []
+LongParameterList:
+  enabled: true
+  exclude: []
+  max_params: 2
+  overrides:
+    initialize:
+      max_params: 3
+LongYieldList:
+  enabled: true
+  exclude: []
+  max_params: 2
+NestedIterators:
+  enabled: true
+  exclude: []
+  max_allowed_nesting: 2
+  ignore_iterators: []
+NilCheck:
+  enabled: true
+  exclude: []
+RepeatedConditional:
+  enabled: true
+  exclude: []
+  max_ifs: 2
+TooManyInstanceVariables:
+  enabled: true
+  exclude: []
+  max_instance_variables: 3
+TooManyMethods:
+  enabled: true
+  exclude: []
+  max_methods: 10
+TooManyStatements:
+  enabled: true
+  exclude:
+  - each
+  max_statements: 5
+UncommunicativeMethodName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeModuleName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  accept: []
+UncommunicativeParameterName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeVariableName:
+  enabled: true
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UnusedParameters:
+  enabled: true
+  exclude:
+  - Guacamole::Model#==
+UtilityFunction:
+  enabled: false
+  exclude: []
+  max_helper_calls: 0

data/config/rubocop.yml

@@ -0,0 +1,68 @@
+AllCops:
+  Includes:
+    - '**/*.rake'
+    - 'Guardfile'
+    - 'Rakefile'
+    - 'Gemfile'
+    - 'Gemfile.devtools'
+  Excludes:
+    - '**/spec/setup/**'
+    - '**/vendor/**'
+    - '**/benchmarks/**'
+
+# Avoid parameter lists longer than five parameters.
+ParameterLists:
+  Max: 3
+  CountKeywordArgs: true
+
+# Avoid more than `Max` levels of nesting.
+BlockNesting:
+  Max: 3
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    inject:   'reduce'
+    find:     'detect'
+    find_all: 'select'
+
+SignalException:
+  # Valid values are: semantic, only_raise and only_fail
+  EnforcedStyle: only_raise
+
+# Do not force public/protected/private keyword to be indented at the same
+# level as the def keyword. My personal preference is to outdent these keywords
+# because I think when scanning code it makes it easier to identify the
+# sections of code and visually separate them. When the keyword is at the same
+# level I think it sort of blends in with the def keywords and makes it harder
+# to scan the code and see where the sections are.
+AccessControl:
+  Enabled: false
+
+# Limit line length
+LineLength:
+  Max: 120
+
+# Disable documentation checking until a class needs to be documented once
+Documentation:
+  Enabled: false
+
+# Do not favor modifier if/unless usage when you have a single-line body
+IfUnlessModifier:
+  Enabled: false
+
+# Allow case equality operator (in limited use within the specs)
+CaseEquality:
+  Enabled: false
+
+# Constants do not always have to use SCREAMING_SNAKE_CASE
+ConstantName:
+  Enabled: false
+
+# Not all trivial readers/writers can be defined with attr_* methods
+TrivialAccessors:
+  Enabled: false
+
+RegexpLiteral:
+  Enabled: false

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/guacamole.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guacamole/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'guacamole'
+  spec.version       = Guacamole::VERSION
+  spec.authors       = ['Lucas Dohmen', 'Dirk Breuer']
+  spec.email         = ['moonglum@moonbeamlabs.com', 'dirk.breuer@gmail.com']
+  spec.description   = %q{ODM for ArangoDB}
+  spec.summary       = %q{An ODM for ArangoDB that uses the DataMapper pattern.}
+  spec.homepage      = 'https://github.com/triAGENS/guacamole'
+  spec.license       = 'Apache License 2.0'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ashikawa-core', '~> 0.9.0'
+  spec.add_dependency 'virtus', '~> 1.0.0.rc2'
+  spec.add_dependency 'activesupport', '>= 4.0.0'
+  spec.add_dependency 'activemodel', '>= 4.0.0'
+
+  spec.add_development_dependency 'fabrication', '~> 2.8.1'
+  spec.add_development_dependency 'logging', '~> 1.8.1'
+end

data/lib/guacamole.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/core_ext'
+
+require 'guacamole/version'
+require 'guacamole/configuration'
+require 'guacamole/model'
+require 'guacamole/collection'
+require 'guacamole/document_model_mapper'
+
+if defined?(Rails)
+  require 'guacamole/railtie'
+end
+
+# An ODM for ArangoDB
+#
+# For more general information, see README or Homepage
+module Guacamole
+end

data/lib/guacamole/collection.rb

@@ -0,0 +1,246 @@
+# -*- encoding : utf-8 -*-
+
+require 'guacamole/query'
+
+require 'ashikawa-core'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+
+module Guacamole
+  # A collection persists and offers querying for models
+  #
+  # You use this as a mixin in your collection classes. Per convention,
+  # they are the plural form of your model with the suffix `Collection`.
+  # For example the collection of `Blogpost` models would be `BlogpostsCollection`.
+  # Including `Guacamole::Collection` will add a number of class methods to
+  # the collection. See the `ClassMethods` submodule for details
+  module Collection
+    extend ActiveSupport::Concern
+
+    # The class methods added to the class via the mixin
+    #
+    # @!method model_to_document(model)
+    #   Convert a model to a document to save it to the database
+    #
+    #   You can use this method for your hand made storage or update methods.
+    #   Most of the time it makes more sense to call save or replace though,
+    #   they do the conversion and handle the communication with the database
+    #
+    #   @param [Model] model The model to be converted
+    #   @return [Ashikawa::Core::Document] The converted document
+    module ClassMethods
+      extend Forwardable
+      def_delegators :mapper, :model_to_document
+      def_delegator :connection, :fetch, :fetch_document
+
+      attr_accessor :connection, :mapper, :database
+
+      # The raw `Database` object that was configured
+      #
+      # You can use this method for low level communication with the database.
+      # Details can be found in the Ashikawa::Core documentation.
+      #
+      # @see http://rubydoc.info/gems/ashikawa-core/Ashikawa/Core/Database
+      # @return [Ashikawa::Core::Database]
+      def database
+        @database ||= Guacamole.configuration.database
+      end
+
+      # The raw `Collection` object for this collection
+      #
+      # You can use this method for low level communication with the collection.
+      # Details can be found in the Ashikawa::Core documentation.
+      #
+      # @see http://rubydoc.info/gems/ashikawa-core/Ashikawa/Core/Collection
+      # @return [Ashikawa::Core::Collection]
+      def connection
+        @connection ||= database[collection_name]
+      end
+
+      # The DocumentModelMapper for this collection
+      #
+      # @api private
+      # @return [DocumentModelMapper]
+      def mapper
+        @mapper ||= Guacamole.configuration.default_mapper.new(model_class)
+      end
+
+      # The name of the collection in ArangoDB
+      #
+      # Use this method in your hand crafted AQL queries, for debugging etc.
+      #
+      # @return [String] The name
+      def collection_name
+        @collection_name ||= name.gsub(/Collection\z/, '').underscore
+      end
+
+      # The class of the resulting models
+      #
+      # @return [Class] The model class
+      def model_class
+        @model_class ||= collection_name.singularize.camelcase.constantize
+      end
+
+      # Find a model by its key
+      #
+      # The key is the unique identifier of a document within a collection,
+      # this concept is similar to the concept of IDs in most databases.
+      #
+      # @param [String] key
+      # @return [Model] The model with the given key
+      # @example Find a podcast by its key
+      #   podcast = PodcastsCollection.by_key('27214247')
+      def by_key(key)
+        raise Ashikawa::Core::DocumentNotFoundException unless key
+
+        mapper.document_to_model connection.fetch(key)
+      end
+
+      # Persist a model in the collection
+      #
+      # The model will be saved in the collection. Timestamps, revision
+      # and key will be set on the model.
+      #
+      # @param [Model] model The model to be saved
+      # @return [Model] The provided model
+      # @example Save a podcast to the database
+      #   podcast = Podcast.new(title: 'Best Show', guest: 'Dirk Breuer')
+      #   PodcastsCollection.save(podcast)
+      #   podcast.key #=> '27214247'
+      def save(model)
+        return false unless model.valid?
+
+        add_timestamps_to_model(model)
+        create_document_from(model)
+        model
+      end
+
+      # Delete a model from the database
+      #
+      # @param [String, Model] model_or_key The key of the model or a model
+      # @return [String] The key
+      # @example Delete a podcast by key
+      #   PodcastsCollection.delete(podcast.key)
+      # @example Delete a podcast by model
+      #   PodcastsCollection.delete(podcast)
+      def delete(model_or_key)
+        key = if model_or_key.respond_to? :key
+          model_or_key.key
+        else
+          model_or_key
+        end
+        fetch_document(key).delete
+        key
+      end
+
+      # Replace a model in the database with its new version
+      #
+      # Replaces the currently saved version of the model with
+      # its new version. It searches for the entry in the database
+      # by key. This will change the updated_at timestamp and revision
+      # of the provided model.
+      #
+      # @param [Model] model The model to be replaced
+      # @return [Model] The model
+      # @example Get a podcast, update its title, replace it
+      #   podcast = PodcastsCollection.by_key('27214247')
+      #   podcast.title = 'Even better'
+      #   PodcastsCollection.replace(podcast)
+      def replace(model)
+        return false unless model.valid?
+
+        model.updated_at = Time.now
+        replace_document_from(model)
+        model
+      end
+
+      # Find models by the provided attributes
+      #
+      # Search for models in the collection where the attributes are equal
+      # to those that you provided.
+      # This returns a Query object, where you can provide additional information
+      # like limiting the results. See the documentation of Query or the examples
+      # for more information.
+      # All methods of the Enumerable module and `.to_a` will lead to the execution
+      # of the query.
+      #
+      # @param [Hash] example The attributes and their values
+      # @return [Query]
+      # @example Get all podcasts with the title 'Best Podcast'
+      #   podcasts = PodcastsCollection.by_example(title: 'Best Podcast').to_a
+      # @example Get the second batch of podcasts for batches of 10 with the title 'Best Podcast'
+      #   podcasts = PodcastsCollection.by_example(title: 'Best Podcast').skip(10).limit(10).to_a
+      # @example Iterate over all podcasts with the title 'Best Podcasts'
+      #   PodcastsCollection.by_example(title: 'Best Podcast').each do |podcast|
+      #     p podcast
+      #   end
+      def by_example(example)
+        query = all
+        query.example = example
+        query
+      end
+
+      # Get all Models stored in the collection
+      #
+      # The result can be limited (and should be for most datasets)
+      # This can be done one the returned Query object.
+      # All methods of the Enumerable module and `.to_a` will lead to the execution
+      # of the query.
+      #
+      # @return [Query]
+      # @example Get all podcasts
+      #   podcasts = PodcastsCollection.all.to_a
+      # @example Get the first 50 podcasts
+      #   podcasts = PodcastsCollection.all.limit(50).to_a
+      def all
+        Query.new(connection.query, mapper)
+      end
+
+      # Specify details on the mapping
+      #
+      # The method is called with a block where you can specify
+      # details about the way that the data from the database
+      # is mapped to models.
+      #
+      # See `DocumentModelMapper` for details on how to configure
+      # the mapper.
+      def map(&block)
+        mapper.instance_eval(&block)
+      end
+
+      # Timestamp a fresh model
+      #
+      # @api private
+      def add_timestamps_to_model(model)
+        timestamp = Time.now
+        model.created_at = timestamp
+        model.updated_at = timestamp
+      end
+
+      # Create a document from a model
+      #
+      # @api private
+      def create_document_from(model)
+        document = connection.create_document(model_to_document(model))
+
+        model.key = document.key
+        model.rev = document.revision
+
+        document
+      end
+
+      # Replace a document in the database with this model
+      #
+      # @api private
+      def replace_document_from(model)
+        document = model_to_document(model)
+        response = connection.replace(model.key, document)
+
+        model.rev = response['_rev']
+
+        document
+      end
+
+    end
+  end
+end