dock 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3eb11e2ae87a5336e40dd098eb5371c31ce95ab
+  data.tar.gz: f1fce866bc3e9b71c24de364bfcd61630fb822f2
+SHA512:
+  metadata.gz: 5bc60d26a3ad01791831fb2615a275bf5968aac8e14e9bb0d689ed99518afe29ab92338dc1cfd4c5c96e784b841a20fa9a04b9fa7a2cf372213b9c8bdc24c7d0
+  data.tar.gz: d84f663d14fbdc13046d3a7377c5a8da48ed8790f070c0053a04cb9b6e4e38e7a93cb675f5d156ed82fdd5e97dd723cae29c2dca4b06da6335727a9f269c483d

data/.gitignore

@@ -0,0 +1,15 @@
+.gem
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dock.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Austin Vecchio
+
+MIT License
+
+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,89 @@
+# dock
+
+TODO: Write a gem description
+dock is anything but simple. This gem outlines what the [ORM Adapter](https://github.com/ianwhite/orm_adapter) should have been in terms of both methods and database support.
+
+## Support
+
+
+#### NOTE:
+Support may be dropped for datamapper and sinatra activerecord since the last update for these gems has been a while.
+The fraction shows the number of methods supported out of the total number of methods for dock all together for that adapter.
+
+- 16/20 [ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html)
+- 16/20 [Sinatra ActiveRecord](https://github.com/janko-m/sinatra-activerecord)
+- 16/20 [CouchBase](https://github.com/couchbase/couchbase-ruby-model)
+- 0/20 [CouchDB](http://couchdb.apache.org/)
+- 16/20 [Cequel](https://github.com/cequel/cequel)
+- 16/20 [Datamapper](https://github.com/datamapper/dm-core)
+- 16/20 [MongoMapper](http://mongomapper.com/)
+- 16/20 [Mongoid](http://mongoid.org/en/mongoid/index.html)
+- 16/20 [NoBrainer](http://nobrainer.io/)
+- 16/20 [Sequel](https://github.com/jeremyevans/sequel)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+Note: until I can get the other dock removed, or change the name of this gem, this will be the only way to install this gem.
+```ruby
+gem 'dock', :git => 'git://github.com/avecchio/dock.git'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dock
+
+## Contributing
+
+WARNING: There are either methods missing in certain adapters, or other methdos that run on broken or untested code. So this gem is neither complete nor operational at the time being and will take some time to develop. Thus contributions are welcomed as well as additional adapters, methods and test code. But be warned, if you add a method to one adapter, you must create the same method for the rest of the adapters conforming to that adapters mechanics.
+
+1. Fork it ( https://github.com/[my-github-username]/dock/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+#### Goals
+
+1. Tests need to be written
+2. Methods to all adapters need to be checked and verified and possibly re-written.
+3. Documentation!!
+
+## Usage
+
+#### Getting Started
+
+```ruby
+require 'dock'
+```
+
+#### Methods
+
+```
+user_model.create             #
+user_model.find               #
+user_model.find!              #
+user_model.all                #
+user_model.first              #
+user_model.id                 #
+user_model.update             #
+user_model.destroy            #
+user_model.associations       #
+user_model.model_name         #
+user_model.column_names       #
+user_model.count              # Count the number of results returned from the 'all' method
+user_model.encoding           #
+user_model.belongs_to         #
+user_model.has_many           #
+user_model.scoped             #
+user_model.embedded           #
+user_model.cyclic?            #
+user_model.supports_joins?    #
+user_model.properties         #
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/dock.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dock"
+  spec.version       = Dock::VERSION
+  spec.authors       = ["Austin Vecchio"]
+  spec.email         = ["au.vecchio@gmail.com"]
+  spec.summary       = %q{What Orm Adapter should have been}
+  spec.description   = %q{Twenty methods for ten different adapters}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  # All supported models
+  spec.add_development_dependency "activerecord", "~> 4.1"
+  spec.add_development_dependency "cequel", "~> 1.4"
+  #spec.add_development_dependency "couchbase"#, "~>"
+  spec.add_development_dependency "couchrest", "~> 1.2"
+  spec.add_development_dependency "datamapper", "~> 1.2"
+  spec.add_development_dependency "mongoid", "~> 4.0"
+  spec.add_development_dependency "mongo_mapper", "~> 0.8"
+  spec.add_development_dependency "nobrainer", "~> 0.16"
+  spec.add_development_dependency "sequel", "~> 4.14"
+  spec.add_development_dependency "sinatra-activerecord", "~> 2.0"
+end

data/lib/dock.rb

@@ -0,0 +1,12 @@
+require_relative "dock/version"
+
+module Dock
+ # A collection of registered adapters
+  def self.adapters
+    @@adapters ||= []
+  end
+end
+
+require_relative "dock/base"
+require_relative "dock/env"
+require_relative "dock/aliases"

data/lib/dock/adapters/active_record.rb

@@ -0,0 +1,117 @@
+require 'active_record'
+
+module Dock
+  class ActiveRecord < Base
+    # Checked
+    def create(attributes = {})
+      model.create!(attributes)
+    end
+    # Checked
+    def find(id)
+      model.find(wrap_key(id))
+    end
+    # Checked
+    def find!(id)
+      model.where(model.primary_key => wrap_key(id)).first
+    end
+    # Checked
+    def all(options = {})
+      construct_relation(model, options)
+    end
+    # Checked
+    def first(options = {})
+      construct_relation(model, options).first
+    end
+    # Checked
+    def id
+      model.id
+    end
+    # Checked
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.find_by(search_key find_by)
+      entry.update(update_key by_value)
+    end
+    # Checked
+    def destroy(object)
+      object.destroy && true if valid_object?(object)
+    end
+    def associations()
+
+    end
+    # Checked
+    def model_name
+      model.model_name
+    end
+    # Checked
+    def column_names
+      model.column_names
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    # Checked
+    def encoding
+      model.client_encoding()
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    # Checked
+    def scoped?
+      model.all
+    end
+    # Checked
+    def embedded?
+      false
+    end
+    # Checked
+    def cyclic?
+      false
+    end
+    # Checked
+    def supports_joins?
+      true
+    end
+    def properties()
+
+    end
+    protected
+      def construct_relation(relation, options)
+        conditions, order, limit, offset = extract_conditions!(options)
+
+        relation = relation.where(conditions_to_fields(conditions))
+        relation = relation.order(order_clause(order)) if order.any?
+        relation = relation.limit(limit) if limit
+        relation = relation.offset(offset) if offset
+
+        relation
+      end
+
+    # Introspects the model to convert and objects in conditions into foreign key and type fields
+      def conditions_to_fields(conditions)
+        fields = {}
+        conditions.each do |key, value|
+        if value.is_a?(::ActiveRecord::Base) && (assoc = model.reflect_on_association(key.to_sym)) && assoc.belongs_to?
+          if ::ActiveRecord::VERSION::STRING < "3.1"
+            fields[assoc.primary_key_name] = value.send(value.class.primary_key)
+            fields[assoc.options[:foreign_type]] = value.class.base_class.name.to_s if assoc.options[:polymorphic]
+          else # >= 3.1
+            fields[assoc.foreign_key] = value.send(value.class.primary_key)
+            fields[assoc.foreign_type] = value.class.base_class.name.to_s if assoc.options[:polymorphic]
+          end
+        else
+          fields[key] = value
+        end
+        fields
+      end
+
+      def order_clause(order)
+        order.map {|pair| "#{pair[0]} #{pair[1]}"}.join(",")
+      end
+    end
+  end
+end

data/lib/dock/adapters/cequel.rb

@@ -0,0 +1,124 @@
+require 'cequel'
+
+module Dock
+  class Cequel < Base
+    def create(attributes = {})
+      model.create(attributes)
+    end
+    def find(key_values)
+      find!(key_values)
+    rescue Cequel::Record::RecordNotFound
+      nil
+    end
+    def find!(key_values)
+      model.find(*key_values)
+    end
+    def all(options = {})
+        construct_scope(options).to_a
+    end
+    def first(options = {})
+      construct_scope(options).first
+    end
+    def id
+      'id'
+    end
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.find(update_key).posts.find(find_by)
+      entry.update_attributes!(update_key by_value)
+    end
+    def destroy(record)
+      record.destroy
+    end
+    def associations()
+
+    end
+    def model_name
+      model.class.name
+    end
+    def column_names
+      model.columns.map { |column| column.name }
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped?
+      false
+    end
+    def embedded?
+      false
+    end
+    def cyclic?
+      false
+    end
+    def supports_joins?
+      false
+    end
+    def properties()
+
+    end
+    private
+      def construct_scope(options)
+        conditions, _, limit, _ =
+          extract_conditions!(options.deep_symbolize_keys)
+        scope = model.all
+        scope = apply_secondary_index_scope(scope, conditions) ||
+          apply_primary_key_scope(scope, conditions)
+        scope = scope.limit(limit) if limit
+        scope
+      end
+
+      def extract_conditions!(options)
+        super.tap do |_, order, _, offset|
+          if order.present?
+            fail ArgumentError,
+                 "Cassandra does not support ordering of results by " \
+                 "arbitrary columns"
+          end
+          if offset.present?
+            fail ArgumentError, 'Cassandra does not support row offsets'
+          end
+        end
+      end
+
+      def apply_primary_key_scope(scope, conditions)
+        conditions = conditions.dup
+        conditions.assert_valid_keys(*model.key_column_names)
+
+        model.key_column_names.each do |column_name|
+          column_value = conditions.delete(column_name)
+          break unless column_value
+          scope = scope[column_value]
+        end
+
+        assert_conditions_empty!(conditions)
+
+        scope
+      end
+
+      def apply_secondary_index_scope(scope, conditions)
+        return unless conditions.one?
+        condition_column = model.reflect_on_column(conditions.keys.first)
+        if condition_column.data_column? && condition_column.indexed?
+          scope.where(*conditions.first)
+        else
+        end
+      end
+
+      def assert_conditions_empty!(conditions)
+        unless conditions.empty?
+          fail ArgumentError,
+               "Invalid columns for conditions: #{conditions.keys.join(', ')}"
+      end
+    end
+  end
+end

data/lib/dock/adapters/couchbase.rb

@@ -0,0 +1,177 @@
+require 'couchbase'
+
+module Dock
+  class Couchbase < Base
+    def create(attributes = {})
+      model.create!(attributes)
+    end
+    def find(id)
+      model.find wrap_key(id)
+    end
+    def find!(id)
+      model.find_by_id(wrap_key(id))
+    end
+    def all(options = {})
+        view_name, view_options, options = view_for_options(options)
+        conditions, order, limit, offset = extract_conditions!(options)
+        stream = model.send(view_name, view_options)
+        # deal with everything which wasn't handled via the view
+        stream = apply_conditions(stream, conditions)
+        stream = apply_order(stream, order)
+        stream = stream.drop(offset) if offset
+        stream = stream.take(limit) if limit
+        stream.to_a # make sure to return an array
+    end
+    def first(options = {})
+      id = options.delete(:id)
+      conditions, _ = extract_conditions!(options.dup)
+      if id
+        apply_conditions([get(id)], conditions).first
+      else
+        find_all(options).first
+      end
+    end
+    def id
+      model.id
+    end
+    def update(search_key=:id, find_by, update_key, by_value)
+      entry = model.find(find_by)
+      entry.update(update_key => by_value)
+      entry.save
+    end
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    def model_name()
+      model.class.name
+    end
+    def column_names()
+      model.properties.map(&:name)
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped?
+      false
+    end
+    def embedded?
+      false
+    end
+    def cyclic?
+      false
+    end
+    def supports_joins?
+      false
+    end
+    def properties()
+
+    end
+    private
+      def apply_conditions(stream, conditions)
+        return stream if conditions.empty?
+        stream.select { |item| satisfies_conditions? item, conditions }
+      end
+
+      def satisfies_conditions?(item, conditions)
+        conditions.all? { |field, value| item.send(field) == value }
+      end
+
+      def apply_order(stream, order)
+        return stream if order.empty?
+
+        stream.to_a.sort_by do |item|
+          sort = []
+          order = order.to_enum
+          o = order.next
+          loop do
+            case o
+            when Array
+              value = item.send(o[0])
+              value = invert_value(value) if o[1] == :desc
+              sort.push(value)
+            else
+              value = item.send(o[0])
+              case order.peek
+              when :asc
+                begin
+                  order.next
+                rescue StopIteration
+                  break
+                end
+              when :desc
+                value = invert_value(value)
+                begin
+                  order.next
+                rescue StopIteration
+                  break
+                end
+              end
+              sort.push(value)
+            end
+            begin
+              o = order.next
+            rescue StopIteration
+              break
+            end
+          end
+          sort
+        end
+      end
+
+      def invert_value(value)
+        case value
+        when String
+          inverse = []
+          value.each_codepoint { |c| inverse.push(-c) }
+          inverse
+        else
+          -value
+        end
+      end
+
+      def view_for_options(options)
+        view_name = :all
+        view_options = { :stale => false }
+        conditions, order, limit, offset = extract_conditions!(options.dup)
+
+        # TODO would be nice to merge multiple conditions into one view name
+        # for example users have a rating, and the comprised key is [user,
+        # rating] if the view is named "by_user_and_rating" we could then merge
+        # this into one and even apply the ordering in one go
+        remaining_conditions = conditions.reject { |condition, value|
+          if klass.respond_to?("by_#{condition}")
+            view_name = "by_#{condition}".to_sym
+            view_options[:key] = value
+          end
+        }
+
+        options = { :conditions => remaining_conditions, :order => order }
+
+        if remaining_conditions.empty?
+          # merge limit, and offset conditions into view query
+          view_options[:limit] = limit if limit
+          view_options[:skip] = offset if offset
+        else
+          options[:limit] = limit if limit
+          options[:offset] = offset if offset
+        end
+
+        raise MissingViewException.new(view_name) unless klass.respond_to?(view_name)
+
+        [view_name, view_options, options]
+      end
+    end
+  end