datapathy 0.6.0

data/lib/datapathy/collection.rb

@@ -0,0 +1,123 @@
+class Datapathy::Collection
+
+  attr_reader :query, :model, :adapter
+
+  # Collection.new(query)
+  # Collection.new(model, ...)
+  # Collection.new(Model, record, ...)
+  def initialize(*elements)
+    if elements.first.is_a?(Datapathy::Query)
+      query = elements.shift
+    elsif elements.first.is_a?(Datapathy::Model)
+      query = Datapathy::Query.new(elements.first.model)
+    elsif elements.first.ancestors.include?(Datapathy::Model)
+      query = Datapathy::Query.new(elements.shift)
+    else
+      raise "First element must be a query, model, or Model class"
+    end
+
+    @query, @model, @adapter = query, query.model, query.model.adapter
+    @elements = elements.first.is_a?(Hash) ? Array.wrap(query.model.new(*elements)) : elements
+  end
+
+  def new(*attributes)
+    self.model.new(*attributes)
+  end
+
+  def detect(*attrs, &blk)
+    slice(0, 1)
+    select(*attrs, &blk)
+    to_a.first
+  end
+  alias find detect
+  alias first detect
+
+  def select(*attrs, &blk)
+    query.add(*attrs, &blk)
+    self
+  end
+  alias find_all select
+
+  def slice(index_or_start_or_range, length = nil)
+    if index_or_start_or_range.is_a?(Range)
+      range = index_or_start_or_range
+      count, offset = (range.last - range.first), range.first
+    elsif length
+      start = index_or_start_or_range
+      count, offset = length, start
+    else
+      count, offset = 1, index_or_start_or_range
+    end
+
+    query.limit(count, offset)
+  end
+
+  def create(*attributes)
+    query.instrumenter.instrument('query.datapathy', :name => "Create #{model.to_s}", :query => attributes.inspect) do
+      if attributes.empty?
+        adapter.create(self)
+        each { |r| r.new_record = false }
+        size == 1 ? first : self
+      else
+        self.class.new(query, *attributes).create
+      end
+    end
+  end
+
+  def update(attributes = {}, &blk)
+    query.add(&blk)
+    query.instrumenter.instrument('query.datapathy', :name => "Update #{model.to_s}", :query => attributes.inspect) do
+      @elements = query.initialize_resources(adapter.update(attributes, self))
+    end
+  end
+
+  def delete(&blk)
+    query.add(&blk)
+    query.instrumenter.instrument('query.datapathy', :name => "Delete #{model.to_s}", :query => query.to_s) do
+      @elements = query.initialize_resources(adapter.delete(self))
+    end
+  end
+
+  def loaded?
+    !@elements.empty?
+  end
+
+  # Since @elements is an array, pretty much every array method should trigger
+  # a load. The exceptions are the ones defined above.
+  TRIGGER_METHODS = (Array.instance_methods - self.instance_methods).freeze
+  TRIGGER_METHODS.each do |meth|
+    class_eval <<-EVAL, __FILE__, __LINE__
+      def #{meth}(*a, &b)
+        self.load! unless loaded?
+        @elements.#{meth}(*a, &b)
+      end
+    EVAL
+  end
+
+  def to_a
+    self.load! unless loaded?
+    @elements
+  end
+
+  def load!
+    query.instrumenter.instrument('query.datapathy', :name => "Read #{model.to_s}", :query => query.to_s) do
+      @elements = query.initialize_and_filter(adapter.read(self))
+    end
+  end
+
+  def to_sql(formatter = nil)
+    if any?
+      "(" + collect { |e| e.to_sql(formatter) }.join(', ') + ")"
+    else
+      "(NULL)"
+    end
+  end
+
+  def equality_predicate_sql
+    "IN"
+  end
+
+  def inequality_predicate_sql
+    "NOT IN"
+  end
+end

data/lib/datapathy/log_subscriber.rb

@@ -0,0 +1,28 @@
+require 'active_support/log_subscriber'
+require 'active_support/notifications'
+
+module Datapathy
+  class LogSubscriber < ActiveSupport::LogSubscriber
+
+    def self.runtime=(value)
+      Thread.current["datapathy_query_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["datapathy_query_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def query(event)
+      self.class.runtime += event.duration
+      debug("Datapathy: %s (%.1fms) %s" % [event.payload[:name], event.duration, event.payload[:query]])
+    end
+
+  end
+end
+
+Datapathy::LogSubscriber.attach_to :datapathy

data/lib/datapathy/model.rb

@@ -0,0 +1,142 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/slice'
+
+require 'active_model'
+
+require 'datapathy/query'
+
+require 'datapathy/model/crud'
+require 'datapathy/model/dynamic_finders'
+
+module Datapathy::Model
+  extend ActiveSupport::Concern
+  extend ActiveModel::Naming
+
+  include ActiveModel::Conversion
+
+  include ActiveModel::Validations
+
+  include Datapathy::Model::Crud
+  include Datapathy::Model::DynamicFinders
+
+  attr_accessor :new_record
+
+  def initialize(attributes = {})
+    @attributes = {}
+    merge(attributes)
+    @new_record = true
+  end
+
+  def persisted_attributes
+    @attributes
+  end
+
+  def merge(attributes = {})
+    attributes.each do |name, value|
+      method = :"#{name}="
+      send(method, value) if respond_to?(method)
+    end
+  end
+
+  def merge!(attributes = {})
+    @attributes = @attributes || {}
+    @attributes.merge!(attributes)
+  end
+
+  def key
+    send(self.class.key)
+  end
+
+  def key=(value)
+    send(:"#{self.class.key}=", value)
+  end
+
+  def model
+    self.class
+  end
+
+  def ==(other)
+    self.key == (other && other.key)
+  end
+
+  def new_record?
+    @new_record
+  end
+
+  def adapter
+    self.class.adapter
+  end
+
+  #override the ActiveModel::Validations one, because its dumb
+  def valid?
+    _run_validate_callbacks if errors.empty?
+    errors.empty?
+  end
+
+  module ClassMethods
+
+    def new(*attributes)
+      attributes = [{}] if attributes.empty?
+      resources = attributes.map do |attrs|
+        super(attrs)
+      end
+
+      collection = Datapathy::Collection.new(*resources)
+      collection.size == 1 ? collection.first : collection
+    end
+
+    def persists(*args)
+      persisted_attributes.push(*args)
+      args.each do |name|
+        name = name.to_s.gsub(/\?\Z/, '')
+        define_getter_method(name)
+        define_setter_method(name)
+      end
+    end
+
+    def define_getter_method(name)
+      class_eval <<-CODE
+        def #{name}
+          @attributes[:#{name}]
+        end
+        alias #{name}? #{name}
+      CODE
+    end
+
+    def define_setter_method(name)
+      class_eval <<-CODE
+        def #{name}=(val)
+          @attributes[:#{name}] = val
+        end
+      CODE
+    end
+
+    def persisted_attributes
+      @persisted_attributes ||= []
+    end
+
+    def new_from_attributes(attributes = {})
+      m = allocate
+      m.merge!(attributes = {})
+      m.new_record = false
+      m
+    end
+
+    def key
+      :href
+    end
+
+    def adapter
+      Datapathy.adapter
+    end
+
+    def model
+      self
+    end
+
+  end
+
+end
+

data/lib/datapathy/model/crud.rb

@@ -0,0 +1,61 @@
+
+module Datapathy::Model
+  module Crud
+
+    extend ActiveSupport::Concern
+
+    def save
+      if new_record?
+        create()
+      else
+        update()
+      end
+    end
+
+    def create
+      Datapathy::Collection.new(self).create
+    end
+
+    def update
+      Datapathy::Collection.new(self).update(persisted_attributes).first
+    end
+
+    def delete
+      Datapathy::Collection.new(self).delete.first
+    end
+
+    module ClassMethods
+      def create(*attributes)
+        collection = Datapathy::Collection.new(self, *attributes).create
+      end
+
+      def [](value)
+        detect{ |m| m.key == value} || raise(Datapathy::RecordNotFound, "No #{model} found with #{key} `#{value}`")
+      end
+
+      def select(*attrs, &blk)
+        query = Datapathy::Query.new(model)
+        Datapathy::Collection.new(query).select(*attrs, &blk)
+      end
+      alias all select
+      alias find_all select
+
+      def detect(*attrs, &blk)
+        select(*attrs, &blk).first
+      end
+      alias first detect
+      alias find detect
+
+      def update(attributes, &blk)
+        select(&blk).update(attributes)
+      end
+
+      def delete(&blk)
+        select(&blk).delete
+      end
+
+    end
+
+  end
+
+end

data/lib/datapathy/model/dynamic_finders.rb

@@ -0,0 +1,89 @@
+
+module Datapathy::Model
+  module DynamicFinders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def method_missing(method_id, *arguments, &block)
+        if match = DynamicFinderMatch.match(method_id)
+          if match.finder?
+            define_find_by(method_id, match)
+          elsif match.instantiator?
+            define_find_or_create_by(method_id, match)
+          end
+          send(method_id, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      def define_find_by(method_id, match)
+        self.class_eval %{
+          def self.#{method_id}(*args)
+            find_attributes = Hash[[:#{match.attribute_names.join(',:')}].zip(args)]
+
+            #{match.finder == :first ? "detect(find_attributes)" : "select(find_attributes)"}
+          end
+        }, __FILE__, __LINE__
+      end
+
+      def define_find_or_create_by(method_id, match)
+        self.class_eval %{
+          def self.#{method_id}(*args)
+            if args[0].is_a?(Hash)
+              attributes = args[0]
+              find_attributes = attributes.slice(*[:#{match.attribute_names.join(',:')}])
+            end
+
+            record = detect(find_attributes)
+
+            if record.nil?
+              record = self.new(attributes)
+              #{'record.save' if match.instantiator == :create}
+            end
+
+            record
+          end
+        }, __FILE__, __LINE__
+      end
+
+      class DynamicFinderMatch
+
+        attr_reader :finder, :attribute_names, :instantiator
+
+        def self.match(method)
+          df_match = self.new(method)
+          df_match.finder ? df_match : nil
+        end
+
+        def initialize(method)
+          @finder = :first
+          case method.to_s
+          when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
+            @finder = :last if $1 == 'last_by'
+            @finder = :all if $1 == 'all_by'
+            names = $2
+          when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+            @instantiator = $1 == 'initialize' ? :new : :create
+            names = $2
+          else
+            @finder = nil
+          end
+          @attribute_names = names && names.split('_and_')
+        end
+
+        def finder?
+          !@finder.nil? && @instantiator.nil?
+        end
+
+        def instantiator?
+          @finder == :first && !@instantiator.nil?
+        end
+
+      end
+
+    end
+
+  end
+end