datapathy 0.6.0

data/lib/datapathy/models/service.rb

@@ -0,0 +1,6 @@
+class Service
+  include Datapathy::Model
+
+
+end
+

data/lib/datapathy/query.rb

@@ -0,0 +1,141 @@
+require 'active_support/basic_object'
+require 'active_support/core_ext/module/delegation'
+
+class Datapathy::Query
+
+  attr_reader :model, :conditions,
+              :offset, :count, :instrumenter
+
+  def initialize(model, conditions = {}, &blk)
+    @model = model
+    @conditions = ConditionSet.new
+    @blocks = []
+    @instrumenter = ActiveSupport::Notifications.instrumenter
+    add(conditions, &blk)
+  end
+
+  def add(conditions = {}, &blk)
+    add_conditions_hash(conditions)
+    add_conditions(&blk) if block_given?
+  end
+
+  def add_conditions(&blk)
+    @blocks << blk
+    yield @conditions
+  end
+
+  def add_conditions_hash(conditions = {})
+    conditions.each do |k,v|
+      add_conditions { |q| q.send(k) == v }
+    end
+  end
+
+  def key_lookup?
+    @conditions.size == 1 &&
+      (@conditions.first.operation == :key || @conditions.first.operation == model.key) &&
+      @conditions.first.then.operation == :==
+  end
+
+  def key
+    @conditions.first.then.arguments.first
+  end
+
+  def initialize_and_filter(records)
+    filter(initialize_resources(records))
+  end
+
+  def initialize_resources(records)
+    return records if records.first.is_a?(Datapathy::Model)
+    records.map { |record|
+      resource = model.new(record)
+      resource.new_record = false
+      resource
+    }
+  end
+
+  def filter(resources)
+    resources = match_resources(resources)
+    resources = order_resources(resources)
+    resources = limit_resources(resources)
+
+    resources
+  end
+
+  def match_resources(resources)
+    resources.select do |record|
+      @blocks.all? do |block|
+        block.call(record)
+      end
+    end
+  end
+
+  def order_resources(resources)
+    resources
+  end
+
+  def limit_resources(resources)
+    return resources unless @offset || @count
+    resources.slice(@offset || 0, @count)
+  end
+
+  def limit(count, offset = 0)
+    @count, @offset = count, offset
+  end
+
+  def to_s
+    string = ""
+    string << @conditions.inspect
+    string << " limit #{@limit}" if @limit
+    string << " offset #{@offset}" if @offset && @offset > 0
+    string
+  end
+
+
+  class ConditionSet < ActiveSupport::BasicObject
+
+    delegate :size, :first, :to => :@conditions
+
+    def initialize
+      @conditions = []
+    end
+
+    def method_missing(method_name, *args, &blk)
+      condition = Condition.new(method_name, *args, &blk)
+      @conditions << condition
+      condition
+    end
+
+    def inspect
+      @conditions.inspect
+    end
+  end
+
+  class Condition < ActiveSupport::BasicObject
+
+    attr_reader :then
+    attr_accessor :operation, :arguments, :block
+
+    def initialize(operation, *arguments, &block)
+      @operation = operation
+      @arguments = arguments unless arguments.empty?
+      @block = block if block
+    end
+
+    def method_missing(method_name, *args, &blk)
+      @then = Condition.new(method_name, *args, &blk)
+    end
+
+    def respond_to?(arg)
+      false
+    end
+
+    def inspect
+      string = operation.to_s
+      string << "#{@arguments.inspect}" unless @arguments.nil?
+      string << " #{@then.inspect}" if @then
+      string
+    end
+
+  end
+
+end

data/lib/datapathy/railtie.rb

@@ -0,0 +1,48 @@
+require 'rails'
+require 'active_model/railtie'
+
+require 'action_controller/railtie'
+
+module Datapathy
+  class Railtie < Rails::Railtie
+
+    initializer "datapathy.log_runtime" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        include Datapathy::Railties::ControllerRuntime
+      end
+    end
+  end
+
+  require 'active_support/core_ext/module/attr_internal'
+  module Railties
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      attr_internal :query_runtime
+
+      def cleanup_view_runtime
+        runtime_before_render = Datapathy::LogSubscriber.reset_runtime
+        runtime = super
+        runtime_after_render = Datapathy::LogSubscriber.reset_runtime
+        self.query_runtime = runtime_before_render + runtime_after_render
+        runtime - runtime_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:query_runtime] = self.query_runtime
+      end
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages, query_runtime = super, payload[:query_runtime]
+          messages << ("Datapathy: %.1fms" % query_runtime.to_f) if query_runtime
+          messages
+        end
+      end
+
+    end
+  end
+
+end
+

data/profile/initialize.calltree

@@ -0,0 +1,62 @@
+events: process_time
+
+fl=/home/rando/development/api/datapathy/(eval)
+fn=DatapathyModel::text=
+5 110000
+
+fl=/home/rando/development/api/datapathy/(eval)
+fn=DatapathyModel::title=
+5 60000
+
+fl=/home/rando/development/api/datapathy/(eval)
+fn=DatapathyModel::id=
+5 80000
+
+fl=/home/rando/development/api/datapathy/lib/datapathy/model.rb
+fn=Datapathy::Model::initialize
+8 390000
+cfl=/home/rando/development/api/datapathy/(eval)
+cfn=DatapathyModel::id=
+calls=100000 12
+12 80000
+cfl=/home/rando/development/api/datapathy/(eval)
+cfn=DatapathyModel::title=
+calls=100000 13
+13 60000
+cfl=/home/rando/development/api/datapathy/(eval)
+cfn=DatapathyModel::text=
+calls=100000 14
+14 110000
+
+fl=/home/rando/development/api/datapathy/ruby_runtime
+fn=<Class::BasicObject>::allocate
+0 50000
+
+fl=/home/rando/development/api/datapathy/ruby_runtime
+fn=Class::new
+0 120000
+cfl=/home/rando/development/api/datapathy/ruby_runtime
+cfn=<Class::BasicObject>::allocate
+calls=100000 19
+19 50000
+cfl=/home/rando/development/api/datapathy/lib/datapathy/model.rb
+cfn=Datapathy::Model::initialize
+calls=100000 19
+19 640000
+
+fl=/home/rando/development/api/datapathy/ruby_runtime
+fn=Integer::times
+0 80000
+cfl=/home/rando/development/api/datapathy/ruby_runtime
+cfn=Class::new
+calls=100000 19
+19 810000
+
+fl=/home/rando/development/api/datapathy/profile/initialize.rb
+fn=Global::[No method]
+18 0
+cfl=/home/rando/development/api/datapathy/ruby_runtime
+cfn=Integer::times
+calls=1 18
+18 890000
+

data/profile/initialize.rb

@@ -0,0 +1,28 @@
+
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'datapathy'
+class DatapathyModel
+  include Datapathy::Model
+
+  persists :id, :title, :text
+end
+
+ATTRS = {:id => 1, :title => "Foo", :text => "Bar"}
+
+require 'ruby-prof'
+
+# Profile the code
+result = RubyProf.profile do
+  100_000.times do
+    DatapathyModel.new(ATTRS)
+  end
+end
+
+# Print a graph profile to text
+printer = RubyProf::CallTreePrinter.new(result)
+File.open(File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") + ".calltree", "w") do |file|
+  printer.print(file, 0)
+end
+

data/spec/adapter_api_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Adapter API' do
+
+  share_as :ArrayOfHashes do
+    it 'should return an Array(Hash) of records' do
+      @results.should be_an(Array)
+      @results.should have(1).item
+
+      result = @results.first
+      result.should be_a(Hash)
+    end
+  end
+
+
+  before do
+    @adapter = Datapathy::Adapters::MemoryAdapter.new
+  end
+
+  describe "#create(collection)" do
+    before do
+      @article = Article.new(:id => new_uuid,
+                             :title => "Whee!",
+                             :text  => "This is fun!")
+      @collection = Datapathy::Collection.new(@article)
+
+      @results = @adapter.create(@collection)
+      @result = @results.first
+    end
+
+    it_should_behave_like ArrayOfHashes
+
+    it 'should return the populated attributes' do
+      @result.should == @article.persisted_attributes
+    end
+  end
+
+  describe "#read(query)" do
+    before do
+      @article = Article.new(:id => new_uuid,
+                             :title => "Whee!",
+                             :text  => "This is fun!")
+
+      @adapter.datastore[Article][@article.id] = @article.persisted_attributes
+
+      @query = Datapathy::Query.new(Article) { |q| q.title == @article.title }
+      @collection = Datapathy::Collection.new(@query)
+
+      @results = @adapter.read(@collection)
+      @result = @results.first
+    end
+
+    it_should_behave_like ArrayOfHashes
+
+    it 'should have the attributes' do
+      @result.should == @article.persisted_attributes
+    end
+  end
+
+  describe "#update(attributes, collection)" do
+    before do
+      @article = Article.new(:id => new_uuid,
+                             :title => "Whee!",
+                             :text  => "This is fun!")
+
+      @adapter.datastore[Article][@article.id] = @article.persisted_attributes
+    end
+
+    describe "with loaded collection (update already retrived records)" do
+      before do
+        @collection = Datapathy::Collection.new(@article)
+        @collection.should be_loaded
+        @results = @adapter.update({:title => "Boo"}, @collection)
+        @result = @results.first
+      end
+
+      it_should_behave_like ArrayOfHashes
+
+      it 'should return the update attribute values' do
+        @result[:title].should == "Boo"
+      end
+    end
+
+    describe "with empty collection (update in bulk, without retrieval)" do
+      before do
+        @query = Datapathy::Query.new(Article) { |q| q.title == @article.title }
+        @collection = Datapathy::Collection.new(@query)
+        @collection.should_not be_loaded
+
+        @results = @adapter.update({:title => "Boo"}, @collection)
+        @result = @results.first
+      end
+
+      it_should_behave_like ArrayOfHashes
+
+      it 'should return an updated attribute values' do
+        @result[:title].should == "Boo"
+      end
+    end
+
+  end
+
+  describe "#delete(attributes)" do
+    before do
+      @article = Article.new(:id => new_uuid,
+                             :title => "Whee!",
+                             :text  => "This is fun!")
+
+      @adapter.datastore[Article][@article.id] = @article.persisted_attributes
+    end
+
+    describe "with loaded collection (delete already retrived records)" do
+      before do
+        @collection = Datapathy::Collection.new(@article)
+        @collection.should be_loaded
+        @results = @adapter.delete(@collection)
+        @result = @results.first
+      end
+
+      it_should_behave_like ArrayOfHashes
+
+      it 'should return the remove attributes' do
+        @result.should == @article.persisted_attributes
+      end
+    end
+
+    describe "with empty collection (delete in bulk, without retrieval)" do
+      before do
+        @query = Datapathy::Query.new(Article) { |q| q.title == @article.title }
+        @collection = Datapathy::Collection.new(@query)
+        @collection.should_not be_loaded
+
+        @results = @adapter.delete(@collection)
+        @result = @results.first
+      end
+
+      it_should_behave_like ArrayOfHashes
+
+      it 'should return the removed attribute values' do
+        @result.should == @article.persisted_attributes
+      end
+    end
+
+  end
+
+end

data/spec/create_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Creating models" do
+
+  share_as :CreatingARecord do
+    it 'should create a record' do
+      test_adapter.datastore[Article].should have(1).key
+    end
+
+    it 'should store persistable attributes' do
+      record = test_adapter.datastore[Article][@article.id]
+
+      record[:id].should    eql(@article.id)
+      record[:title].should eql(@article.title)
+      record[:text].should  eql(@article.text)
+    end
+
+    it 'should not store other attributes' do
+      record = test_adapter.datastore[Article][@article.id]
+
+      @article.should respond_to(:summary)
+      record.should_not have_key("summary")
+    end
+  end
+
+  describe 'Model.create' do
+    before do
+      pending
+      @article = Article.create(:id => new_uuid,
+                                :title => "Datapathy is awesome!",
+                                :text => "It just is!")
+    end
+
+    it_should_behave_like CreatingARecord
+
+  end
+
+  describe 'Model.new; #save' do
+    before do
+      pending
+      @article = Article.new(:id => new_uuid,
+                             :title => "Datapathy is awesome!",
+                             :text => "It just is!")
+      @article.save
+    end
+
+    it_should_behave_like CreatingARecord
+
+  end
+
+  describe 'Bulk Model.create' do
+    before do
+      pending
+      @articles = Article.create([
+        { :id => new_uuid, :title => "Article A", :text => "Foo"},
+        { :id => new_uuid, :title => "Article B", :text => "Bar"},
+        { :id => new_uuid, :title => "Article C", :text => "Baz"}
+      ])
+    end
+
+    it 'should create the records' do
+      test_adapter.datastore[Article].should have(@articles.size).keys
+    end
+
+  end
+
+  after do
+    test_adapter.clear!
+  end
+
+end