nevermind 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 801d69d84b3ad05b15dba9d8d321c8618ab6b2ef
-  data.tar.gz: faf22b0eb6e66da9f35c797785fa30c9d0f90b15
+  metadata.gz: 7fcf26ca60bf55a6350a343e9ccc5baf4cb7ac72
+  data.tar.gz: 18869cda8433a822bab32a0feda6c3909c024d4c
 SHA512:
-  metadata.gz: 9cb18bf0a46718c59af0cb3d26e427b71fb1bcdd409ed3b58008f94680e96fa0d7fb22c70f391a8834ea109692ea8ccee46ca1f9d891c8f103b4988e645e4175
-  data.tar.gz: 5ec0cbe2a1cbf2c0e1650e7ad0cf27be4d301a0946779ca3cf1fcd16d049e226eb6c74215220ebc266caef2cc8b3716c4f70c5b93ffa73490ebe158159eb9457
+  metadata.gz: 66bef2ea482fafca3162490ad6691c8b4c47aaf4787ce9619021bc525bbba4ed908df00b4aa900b92132d5af5d9a7d147c80e8d921a9ebd8cfcc3aa2fb136d4c
+  data.tar.gz: a20a4b61d8845474d248eb40fbc905413a8718cb09f4b17efd6d73be16c418d9aa8d7cdf4d968a9ea52390b801c8cd61c1866b003bfd3107d251b2c40eb6db94

data/lib/nevermind.rb

@@ -1,5 +1,5 @@
 require 'nevermind/version'
-require 'nevermind/proto'
+require 'nevermind/proxy'
 
 module Nevermind
   # Your code goes here...

data/lib/nevermind/proxy.rb

@@ -0,0 +1,154 @@
+module Nevermind
+  class Proxy
+    # include Enumerable
+
+    def initialize(first, second)
+      @first, @second = first, second
+
+      @order_params = nil
+      @limit_params = nil
+      @offset_params = nil
+    end
+
+    def each(&block)
+      if @order_params || @limit_params || @offset_params
+        get_scoped &block
+      else
+        @first.each { |obj| yield obj }
+        @second.each { |obj| yield obj }
+      end
+    end
+
+    def [](index)
+      #todo: optimize!
+      count = 0
+      self.each do |obj|
+        return obj if count == index
+        count+= 1
+      end
+      return nil
+    end
+
+    def count
+      if @order_params || @limit_params || @offset_params
+        count = 0
+        get_scoped { |val| count+= 1 }
+        return count
+      else
+        @first.count + @second.count
+      end
+    end
+
+    def order(*args)
+      @order_params = *args
+      return self.clone
+    end
+
+    def limit(*args)
+      @limit_params = *args
+      return self.clone
+    end
+
+    def offset(*args)
+      @offset_params = *args
+      return self.clone
+    end
+
+    def method_missing(method, *args, &block)
+      if [:all, :where, :order].include? method
+        call_relation_method(method, *args, &block)
+      else
+        if '!' == method.to_s.last
+          call_forced_method(method, *args, &block)
+        else
+          call_regular_method(method, *args, &block)
+        end
+      end
+    end
+
+    private
+      # find_by, first, etc
+      def call_regular_method(method, *args, &block)
+        found = @first.send method, *args, &block
+        if found.nil?
+          found = @second.send method, *args, &block
+        end
+        return found
+      end
+
+      # find_by!, first!, etc
+      def call_forced_method(method, *args, &block)
+        begin
+          found = @first.send method, *args, &block
+        rescue
+          found = @second.send method, *args, &block
+        ensure
+          return found
+        end
+      end
+
+      def call_relation_method(method, *args, &block)
+        Proxy.new @first.send(method, *args, &block),
+                  @second.send(method, *args, &block)
+      end
+
+      # yields scoped result
+      def get_scoped(&block)
+        # can be used only with ActiveRecord
+        #todo: implement Mongoid
+        unless defined?(ActiveRecord::Relation) && @first.is_a?(ActiveRecord::Relation) && @second.is_a?(ActiveRecord::Relation)
+          raise "#{ self.class }.#{ __method__ } not implemented for #{ @first.class } && #{ @second.class } yet. Only ActiveRecord::Relation i supported"
+        end
+
+        get_scoped_active_record &block
+      end
+
+      def get_scoped_active_record(&block)
+        # get records ids in the desired scope
+        # prepare sql
+        #todo: protect from sql injection
+        tables = {@first.table_name => @first,
+                  @second.table_name => @second}
+
+        order_by = @order_params.map do |param|
+          if param.is_a? Hash
+            "#{ param.first[0] } #{ param.first[1].upcase }"
+          elsif param.is_a? String
+            param
+          elsif param.is_a? Symbol
+            param.to_s
+          end
+        end.join(', ')
+
+        columns = (['id'] +
+            @order_params.map do |param|
+              if param.is_a? Hash
+                param.first[0].to_s
+              elsif param.is_a? String
+                param
+              elsif param.is_a? Symbol
+                param.to_s
+              end
+            end
+        ).join(', ')
+
+        sql = "SELECT #{ columns }, '#{ tables.keys[0] }' as table_name FROM #{ tables.keys[0] } as `a`" +
+            ' UNION' +
+            " SELECT #{ columns }, '#{ tables.keys[1] }' as table_name FROM #{ tables.keys[1] } as `b`" +
+            (order_by == '' ? '' : " ORDER BY #{ order_by }") +
+            if @limit_params.nil?
+              ''
+            else
+              " LIMIT #{ @offset_params.nil? ? '' : "#{ @offset_params[0].to_s }, " }#{ @limit_params[0].to_s }"
+            end
+
+        # execute prepared sql
+        records_array = ActiveRecord::Base.connection.execute(sql)
+
+        # get records in the desired scope
+        records_array.each do |r|
+          yield tables[r['table_name']].find(r['id'])
+        end
+      end
+  end
+end

data/lib/nevermind/version.rb

@@ -1,3 +1,3 @@
 module Nevermind
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/nevermind.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Roman Exempliarov"]
   spec.email         = ["urvala@gmail.com"]
   spec.summary       = %q{Abstraction layer that allows to work with multiple models just like with one.}
-  spec.description   = %q{In development now. Next milestone: 1. Handling a pair of models with find_by. }
+  spec.description   = %q{In development now.}
   spec.homepage      = ""
   spec.license       = "MIT"
 

data/spec/nevermind_proxy_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Nevermind::Proxy do
+  before :all do
+    @posts = Nevermind::Proxy.new(Article.all, Video.all)
+  end
+
+  it 'handles .find_by & .find_by!' do
+    [
+        [Article, @posts.find_by!(content: 'article')],
+        [Video,   @posts.find_by!(content: 'video')],
+        [Article, @posts.find_by(content: 'article')],
+        [Video,   @posts.find_by(content: 'video')]
+    ].each do |klass, post|
+      expect(post.class).to eq klass
+    end
+  end
+
+  it 'handles .first' do
+    post = @posts.first
+    expect(post.class).to satisfy { |klass| [Article, Video].include? klass }
+  end
+
+  it 'handles .first!' do
+    post = @posts.first!
+    expect(post.class).to satisfy { |klass| [Article, Video].include? klass }
+  end
+
+  it 'handles .where' do
+    [
+        [ Article, @posts.where(content: 'article') ],
+        [ Video,   @posts.where(content: 'video')   ]
+    ].each do |klass, posts|
+      expect(posts.class).to eq Nevermind::Proxy
+      post = posts.first
+      expect(post.class).to eq klass
+    end
+  end
+
+  it 'handles .all' do
+    posts = @posts.all
+    expect(posts.class).to eq Nevermind::Proxy
+    post = posts.first
+    expect(post.class).to satisfy { |klass| [Article, Video].include? klass }
+  end
+
+  it 'handles .each' do
+    vid = 0
+    count = 0
+    vid_expectation = Article.all.map(&:vid).reduce(&:+) + Video.all.map(&:vid).reduce(&:+)
+    count_expectation = Article.count + Video.count
+    @posts.each { |post| vid+= post.vid; count+= 1 }
+    expect(count).to eq (count_expectation)
+    expect(vid).to eq (vid_expectation)
+  end
+
+  it 'handles .count' do
+    count = Article.all.count + Video.all.count
+    expect(@posts.count).to eq count
+  end
+
+  it 'handles .order with single param' do
+    posts = @posts.order :rand
+    previous_post = false
+    expect( posts.count ).to eq Article.count + Video.count
+    posts.each do |post|
+      unless false == previous_post
+        expect(post.rand).to be >= previous_post.rand
+      end
+      previous_post = post
+    end
+  end
+
+  it 'handles .order with single desc param' do
+    posts = @posts.order :rand => :desc
+    previous_post = false
+    expect(posts.count).to eq Article.count + Video.count
+    posts.each do |post|
+      unless false == previous_post
+        expect(post.rand).to be <= previous_post.rand
+      end
+      previous_post = post
+    end
+  end
+
+  it 'handles .order with double param' do
+    posts = @posts.order :id, :rand => :desc
+    previous_post = false
+    expect(posts.count).to eq Article.count + Video.count
+    posts.each do |post|
+      unless false == previous_post
+        expect(post.id).to be >= previous_post.id
+        if post.id == previous_post.id
+          expect(post.rand).to be <= previous_post.rand
+        end
+      end
+      previous_post = post
+    end
+  end
+
+  it 'handles .limit' do
+    posts = @posts.limit 5
+    expect(posts.count).to eq 5
+  end
+
+  it 'handles []' do
+    posts = @posts.order(:id)
+    expect(posts[0].id).to eq 1
+    expect(posts[1].id).to eq 1
+    expect(posts[2].id).to eq 2
+    expect(posts[3].id).to eq 2
+  end
+
+  it 'handles .offset' do
+    last_post = @posts.limit(5)[4]
+    posts = @posts.limit(5).offset(0)
+    expect(posts.count).to eq 5
+    expect(posts[4]).to eq last_post
+
+    posts = @posts.order(:id).limit(4).offset(2)
+    expect(posts[0].id).to eq 2
+    expect(posts[1].id).to eq 2
+    expect(posts[2].id).to eq 3
+    expect(posts[3].id).to eq 3
+    expect(posts[4]).to eq nil
+
+  end
+
+  it 'handles .order with .limit & .offset' do
+    posts_offset_0 = @posts.order(:rand).limit(5)
+    posts_offset_2 = @posts.order(:rand).limit(5).offset(2)
+
+    expect(posts_offset_0.count).to eq 5
+    expect(posts_offset_2.count).to eq 5
+
+    [posts_offset_0, posts_offset_2].each do |posts|
+      previous_post = false
+      posts.each do |post|
+        unless false == previous_post
+          expect(post.rand).to be >= previous_post.rand
+        end
+        previous_post = post
+      end
+    end
+
+    [0,1,2].each do |i|
+      expect(posts_offset_2[i]).to be == posts_offset_0[i+2]
+    end
+  end
+end

data/spec/schema.rb

@@ -3,6 +3,7 @@ ActiveRecord::Schema.define do
 
   create_table :articles, :force => true do |t|
     t.integer :vid
+    t.integer :rand
     t.string :content
 
     t.timestamps
@@ -10,6 +11,7 @@ ActiveRecord::Schema.define do
 
   create_table :videos, :force => true do |t|
     t.integer :vid
+    t.integer :rand
     t.string :content
 
     t.timestamps

data/spec/seed.rb

@@ -1,4 +1,4 @@
-5.times do |i|
-  Article.create vid: i*2,   content: 'article'
-  Video.create   vid: i*2+1, content: 'video'
+20.times do |i|
+  Article.create vid: i*2,   content: 'article', rand: rand(1000)
+  Video.create   vid: i*2+1, content: 'video',   rand: rand(1000)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nevermind
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Roman Exempliarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-17 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,8 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'In development now. Next milestone: 1. Handling a pair of models with
-  find_by. '
+description: In development now.
 email:
 - urvala@gmail.com
 executables: []
@@ -94,12 +93,11 @@ files:
 - README.md
 - Rakefile
 - lib/nevermind.rb
-- lib/nevermind/proto.rb
-- lib/nevermind/relation.rb
+- lib/nevermind/proxy.rb
 - lib/nevermind/version.rb
 - nevermind.gemspec
 - spec/models.rb
-- spec/nevermind_proto_spec.rb
+- spec/nevermind_proxy_spec.rb
 - spec/schema.rb
 - spec/seed.rb
 - spec/spec_helper.rb
@@ -130,7 +128,7 @@ summary: Abstraction layer that allows to work with multiple models just like wi
   one.
 test_files:
 - spec/models.rb
-- spec/nevermind_proto_spec.rb
+- spec/nevermind_proxy_spec.rb
 - spec/schema.rb
 - spec/seed.rb
 - spec/spec_helper.rb

data/lib/nevermind/proto.rb

@@ -1,41 +0,0 @@
-module Nevermind
-  class Proto
-    def initialize(first, second)
-      @first, @second = first, second
-    end
-
-    def where(*args)
-      @first.where(*args)
-      @second.where(*args)
-    end
-
-    def method_missing(method, *args, &block)
-      if '!' == method.to_s.last
-        forced_method_missing(method, *args, &block)
-      else
-        regular_method_missing(method, *args, &block)
-      end
-    end
-
-    private
-      # find_by, first, etc
-      def regular_method_missing(method, *args, &block)
-        found = @first.send method, *args, &block
-        if found.nil?
-          found = @second.send method, *args, &block
-        end
-        return found
-      end
-
-      # find_by!, first!, etc
-      def forced_method_missing(method, *args, &block)
-        begin
-          found = @first.send method, *args, &block
-        rescue
-          found = @second.send method, *args, &block
-        ensure
-          return found
-        end
-      end
-  end
-end

data/lib/nevermind/relation.rb

@@ -1,5 +0,0 @@
-module Nevermind
-  class Relation
-
-  end
-end

data/spec/nevermind_proto_spec.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-describe Nevermind::Proto do
-  it 'passes find_by' do
-    posts = Nevermind::Proto.new(Article, Video)
-    post = posts.find_by(content: 'article')
-    expect(post.class).to eq Article
-    post = posts.find_by(content: 'video')
-    expect(post.class).to eq Video
-  end
-
-  it 'passes find_by!' do
-    posts = Nevermind::Proto.new(Article, Video)
-    post = posts.find_by!(content: 'article')
-    expect(post.class).to eq Article
-    post = posts.find_by!(content: 'video')
-    expect(post.class).to eq Video
-  end
-
-  it 'passes first' do
-    posts = Nevermind::Proto.new(Article, Video)
-    post = posts.first
-    expect(post.class).to satisfy { |klass| [Article, Video].include? klass }
-  end
-
-  it 'passes first!' do
-    posts = Nevermind::Proto.new(Article, Video)
-    post = posts.first
-    expect(post.class).to satisfy { |klass| [Article, Video].include? klass }
-  end
-end