montage_rails 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c5c2bc4fde46dd63c234dc588be50b964f28174
-  data.tar.gz: 4194ed623e630feddb105b251dbc175627d5eeb4
+  metadata.gz: 277cfc7ce7155045e893a43b55fb439cefcc1fb1
+  data.tar.gz: 0b8338daff90f24f126bf6d18daac01205b2a8e8
 SHA512:
-  metadata.gz: 6e78ab4b49d5a76751ce218d8639659f1519a853b554330b535ae338c8fb8e56813f1ed09dcae1e0db914af74c4626b0421f5d7faf2110616bc2077946ba275b
-  data.tar.gz: bfefffaa585a50703b62c89ea77ee293d973ea53d357becc5bb26d24e5e2ebb44bde279272e7c00ce3ffafdd2d840a277b0df1e5f3058cc61a58a00b36b6f431
+  metadata.gz: 87b3d4b9ac86ea2310c782091869252e94f23426f2cf226ef23e0fbfc7b27fd8d3f12941731b7226310ba624510a494203ed0d89695b2e4e28e9f7deb9c5166e
+  data.tar.gz: a5a907dceb7a233c2ac321c4984c24a193c91292dc5be1263f473278d0aa6e2f905dd3a9df19aca4b8fbcffd97f5394ce52cc745a3c449ae26223e7813d94a44

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 dphaener
+
+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/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MontageRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/montage_rails/base/column.rb

@@ -0,0 +1,57 @@
+module MontageRails
+  class Base
+    class Column
+      TYPE_MAP = {
+        "integer" => Integer,
+        "float" => Float,
+        "text" => String,
+        "date" => Date,
+        "time" => Time,
+        "datetime" => DateTime,
+        "numeric" => Numeric
+      }
+
+      attr_accessor :name, :type, :required
+
+      alias_method :required?, :required
+
+      def initialize(name, type, required = false)
+        @name = name
+        @type = type
+        @required = required
+      end
+
+      def value_valid?(value)
+        !(required? && value.nil?)
+      end
+
+      # Determines if the string value passed in is an integer
+      # Returns true or false
+      #
+      def is_i?(value)
+        /\A\d+\z/ =~ value
+      end
+
+      # Determines if the string value passed in is a float
+      # Returns true or false
+      #
+      def is_f?(value)
+        /\A\d+\.\d+\z/ =~ value
+      end
+
+      def coerce(value)
+        return value if value.is_a?(TYPE_MAP[type])
+
+        if is_i?(value)
+          coerce_to = Integer
+        elsif is_f?(value)
+          coerce_to = Float
+        else
+          coerce_to = TYPE_MAP[type]
+        end
+
+        Virtus::Attribute.build(coerce_to).coerce(value)
+      end
+    end
+  end
+end

data/lib/montage_rails/base.rb

@@ -0,0 +1,406 @@
+require 'montage_rails/log_subscriber'
+require 'montage_rails/relation'
+require 'montage_rails/base/column'
+require 'active_model'
+require 'virtus'
+
+module MontageRails
+  class Base
+    extend ActiveModel::Callbacks
+    include ActiveModel::Model
+    include Virtus.model
+
+    define_model_callbacks :save, :create
+
+    class << self
+      # Delegates all of the relation methods to the class level object, so they can be called on the base class
+      #
+      delegate :limit, :offset, :order, :where, :first, to: :relation
+
+      # Delegate the connection to the base module for ease of reference
+      #
+      delegate :connection, :notify, to: MontageRails
+
+      cattr_accessor :table_name
+
+      # Define a new instance of the query cache
+      #
+      def cache
+        @cache ||= QueryCache.new
+      end
+
+      # Hook into the Rails logger
+      #
+      def logger
+        @logger ||= Rails.logger
+      end
+
+      # Setup a class level instance of the MontageRails::Relation object
+      #
+      def relation
+        @relation = Relation.new(self)
+      end
+
+      # Define a has_many relationship
+      #
+      def has_many(table)
+        class_eval do
+          define_method(table.to_s.tableize.to_sym) do
+            table.to_s.classify.constantize.where("#{self.class.table_name.demodulize.underscore.singularize.foreign_key} = #{id}")
+          end
+        end
+      end
+
+      # Define a belongs_to relationship
+      #
+      def belongs_to(table)
+        class_eval do
+          define_method(table.to_s.tableize.singularize.to_sym) do
+            table.to_s.classify.constantize.find_by_id(__send__(table.to_s.foreign_key))
+          end
+
+          define_method("#{table.to_s.tableize.singularize}=") do |record|
+            self.__send__("#{table.to_s.foreign_key}=", record.id)
+            self
+          end
+        end
+      end
+
+      # The pluralized table name used in API requests
+      #
+      def table_name
+        self.name.demodulize.underscore.pluralize
+      end
+
+      # Redefine the table name
+      #
+      def set_table_name(value)
+        instance_eval do
+          define_singleton_method(:table_name) do
+            value
+          end
+        end
+      end
+
+      alias_method :table_name=, :set_table_name
+
+      # Returns an array of MontageRails::Base::Column's for the schema
+      #
+      def columns
+        @columns ||= [].tap do |ary|
+          response = connection.schema(table_name)
+
+          return [] unless response.schema.respond_to?(:fields)
+
+          ary << Column.new("id", "text", false)
+          ary << Column.new("created_at", "datetime", false)
+          ary << Column.new("updated_at", "datetime", false)
+
+          response.schema.fields.each do |field|
+            ary << Column.new(field["name"], field["datatype"], field["required"])
+
+            instance_eval do
+              define_singleton_method("find_by_#{field["name"]}") do |value|
+                where("#{field["name"]} = '#{value}'").first
+              end
+            end
+          end
+        end
+      end
+
+      # Fetch all the documents
+      #
+      def all
+        relation.to_a
+      end
+
+      # Find a record by the id
+      #
+      def find_by_id(value)
+        response = cache.get_or_set_query(self, value) { connection.document(table_name, value) }
+
+        if response.success?
+          new(response.document.items.merge(persisted: true))
+        else
+          nil
+        end
+      end
+
+      alias_method :find, :find_by_id
+
+      # Find the record using the given params, or initialize a new one with those params
+      #
+      def find_or_initialize_by(params = {})
+        return nil if params.empty?
+
+        query = relation.where(params)
+
+        response = cache.get_or_set_query(self, query) { connection.documents(table_name, query) }
+
+        if response.success? && response.documents.any?
+          new(attributes_from_response(response).merge(persisted: true))
+        else
+          new(params)
+        end
+      end
+
+      # Returns an array of the column names for the table
+      #
+      def column_names
+        columns.map { |c| c.name }
+      end
+
+      # Initialize and save a new instance of the object
+      #
+      def create(params = {})
+        new(params).save
+      end
+
+      # Returns a string like 'Post id:integer, title:string, body:text'
+      #
+      def inspect
+        if self == Base
+          super
+        else
+          attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', '
+          "#{super}(#{attr_list})"
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        __send__(:columns)
+
+        if respond_to?(method_name.to_sym)
+          __send__(method_name.to_sym, *args)
+        else
+          super(method_name, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        __send__(:column_names).include?(method_name.to_s.split("_").first) || super(method_name, include_private)
+      end
+
+      def attributes_from_response(response)
+        case response.members
+        when Montage::Documents then response.documents.first.attributes.merge(persisted: true)
+        when Montage::Document then response.document.attributes.merge(persisted: true)
+        when Montage::Errors then raise MontageAPIError, "There was an error with the Montage API: #{response.errors.attributes}"
+        when Montage::Error then raise MontageAPIError, "There was an error with the Montage API: #{response.error.attributes}"
+        else raise MontageAPIError, "There was an error with the Montage API, please try again."
+        end
+      end
+    end
+
+    attr_accessor :persisted
+
+    alias_method :persisted?, :persisted
+
+    delegate :connection, :notify, to: MontageRails
+    delegate :attributes_from_response, to: "self.class"
+
+    def initialize(params = {})
+      initialize_columns
+      @persisted = params[:persisted] ? params[:persisted] : false
+      @current_method = "Load"
+      super(params)
+    end
+
+    # Save the record to the database
+    #
+    # Will return nil if the attributes are not valid
+    #
+    # Upon successful creation or update, will return an instance of self, otherwise returns nil
+    #
+    def save
+      run_callbacks :save do
+        return nil unless attributes_valid?
+
+        if persisted?
+          @current_method = "Update"
+
+          response = notify(self) do
+            connection.create_or_update_documents(self.class.table_name, [updateable_attributes(true)])
+          end
+        else
+          @current_method = "Create"
+
+          response = notify(self) do
+            connection.create_or_update_documents(self.class.table_name, [updateable_attributes(false)])
+          end
+        end
+
+        if response.success?
+          if persisted?
+            initialize(attributes_from_response(response))
+          else
+            run_callbacks :create do
+              initialize(attributes_from_response(response))
+            end
+          end
+
+          self
+        else
+          response
+        end
+      end
+    end
+
+    # The bang method for save, which will raise an exception if saving is not successful
+    #
+    def save!
+      unless save
+        raise MontageAPIError, response.errors.attributes
+      end
+    end
+
+    # Update the given attributes for the document
+    #
+    # Returns false if the given attributes aren't valid
+    #
+    # Returns a copy of self if updating is successful
+    #
+    def update_attributes(params)
+      old_attributes = attributes.clone
+
+      params.each do |key, value|
+        if respond_to?(key.to_sym)
+          coerced_value = column_for(key.to_s).coerce(value)
+          send("#{key}=", coerced_value)
+        end
+      end
+
+      return self if old_attributes == attributes
+
+      if attributes_valid?
+        @current_method = id.nil? ? "Create" : "Update"
+
+        response = notify(self) do
+          connection.create_or_update_documents(self.class.table_name, [updateable_attributes(!id.nil?)])
+        end
+
+        initialize(attributes_from_response(response))
+        @persisted = true
+        self
+      else
+        initialize(old_attributes)
+        false
+      end
+    end
+
+    # Destroy the copy of this record from the database
+    #
+    def destroy
+      @current_method = "Delete"
+      notify(self) { connection.delete_document(self.class.table_name, id) }
+
+      @persisted = false
+      self
+    end
+
+    # Reload the current document
+    #
+    def reload
+      @current_method = "Load"
+
+      response = notify(self) do
+        connection.document(self.class.table_name, id)
+      end
+
+      initialize(attributes_from_response(response))
+      @persisted = true
+      self
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    # Returns the Column class instance for the attribute passed in
+    #
+    def column_for(name)
+      self.class.columns.select { |column| column.name == name }.first
+    end
+
+    # Performs a check to ensure that required columns have a value
+    #
+    def attributes_valid?
+      attributes.each do |key, value|
+        next unless column_class = column_for(key.to_s)
+        return false unless column_class.value_valid?(value)
+      end
+    end
+
+    # The attributes used to update the document
+    #
+    def updateable_attributes(include_id = false)
+      include_id ? attributes.except(:created_at, :updated_at) : attributes.except(:created_at, :updated_at, :id)
+    end
+
+    # Required for notifications to work, returns a payload suitable
+    # for the log subscriber
+    #
+    def payload
+      {
+        reql: reql_payload[@current_method],
+        name: "#{self.class.name} #{@current_method}"
+      }
+    end
+
+    # Returns an <tt>#inspect</tt>-like string for the value of the
+    # attribute +attr_name+. String attributes are elided after 50
+    # characters, and Date and Time attributes are returned in the
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
+    #
+    #   person = Person.create!(:name => "David Heinemeier Hansson " * 3)
+    #
+    #   person.attribute_for_inspect(:name)
+    #   # => '"David Heinemeier Hansson David Heinemeier Hansson D..."'
+    #
+    #   person.attribute_for_inspect(:created_at)
+    #   # => '"2009-01-12 04:48:57"'
+    #
+    def attribute_for_inspect(attr_name)
+      value = attributes[attr_name]
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
+    # Returns the contents of the record as a nicely formatted string.
+    #
+    def inspect
+      attributes_as_nice_string = self.class.column_names.collect { |name|
+        if attributes[name.to_sym] || new_record?
+          "#{name}: #{attribute_for_inspect(name.to_sym)}"
+        end
+      }.compact.join(", ")
+      "#<#{self.class} #{attributes_as_nice_string}>"
+    end
+
+  private
+
+
+    def initialize_columns
+      self.class.columns.each do |column|
+        self.class.__send__(:attribute, column.name.to_sym, Column::TYPE_MAP[column.type])
+      end
+    end
+
+    def reql_payload
+      {
+        "Load" => id,
+        "Update" => "#{id}: #{updateable_attributes(true)}",
+        "Create" => updateable_attributes,
+        "Delete" => id,
+        "Save" => updateable_attributes
+      }
+    end
+  end
+end

data/lib/montage_rails/errors.rb

@@ -0,0 +1,7 @@
+module MontageRails
+  class AttributeMissingError < StandardError; end
+
+  class RelationError < StandardError; end
+
+  class MontageAPIError < StandardError; end
+end

data/lib/montage_rails/log_subscriber.rb

@@ -0,0 +1,48 @@
+module MontageRails
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["montage_rails_reql_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["montage_rails_reql_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def reql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      name = '%s (%.1fms)' % [event.payload[:name], event.duration]
+      reql  = event.payload[:reql]
+
+      if odd?
+        name = color(name, CYAN, true)
+        reql  = color(reql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name} #{reql}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+
+    def logger
+      MontageRails::Base.logger
+    end
+  end
+end
+
+MontageRails::LogSubscriber.attach_to :montage_rails

data/lib/montage_rails/query_cache.rb

@@ -0,0 +1,44 @@
+module MontageRails
+  class QueryCache
+    attr_reader :cache
+
+    def initialize
+      @cache = {}
+    end
+
+    def get_or_set_query(klass, query)
+      cached = cache.keys.include?("#{klass}/#{query}")
+      ActiveSupport::Notifications.instrument("reql.montage_rails", notification_payload(query, klass, cached)) do
+        if cached
+          cache["#{klass}/#{query}"]
+        else
+          response = yield
+          cache["#{klass}/#{query}"] = response
+          response
+        end
+      end
+    end
+
+    # Clear the entire query cache
+    #
+    def clear
+      @cache = {}
+    end
+
+    # Remove a certain key from the cache
+    # Returns the removed value, or nil if nothin was found
+    #
+    def remove(key)
+      cache.delete(key)
+    end
+
+  private
+
+    def notification_payload(query, klass, cached = false)
+      {
+        reql: query,
+        name: cached ? "#{klass} Load [CACHE]" : "#{klass} Load"
+      }
+    end
+  end
+end