findable 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c5762db6fcb9200dd984f87ec167f1091ecfe26
-  data.tar.gz: 8c2386ee142b72c7bfd4814b45783f48a0a12367
+  metadata.gz: 022bdcf5a11ab55395af5ca7af256b23afd96376
+  data.tar.gz: 86900a51201b84491a1e361f0945ec4d36b4e064
 SHA512:
-  metadata.gz: 107b796739e028571c553dee7aa04fb31d6ef6b374c38a1dd44c2225d7fbd735d124488a5c76d6b136007b729cb4808668c56a6ca4ef1fff81869d1782a9b2a2
-  data.tar.gz: f42800de1d903c60cb478b8c5981ddfebd27ec3d1542586f61f286bfb7d6ffbf6bbcd3fd459ba8793e8f385c1be56bda08b8e7c55823726058554667d7081695
+  metadata.gz: 880d6023b382295648fd89c61c4e1bba1a73bc3a6e9266b7b84840d0eee4722ef388a8e94ba9b5c166e752f74b79a36b24577b1f6ba68998e5726306a1fd385d
+  data.tar.gz: 0670803e036bd49527ebc2d4208afb298ab5faed78eee5e2fc8052a00b340b4228efc7b6fbec58bc63d9e890aa7902b516b09afc9c52bd9208969de6437be339

data/lib/findable.rb

@@ -9,5 +9,6 @@ require "findable/version"
 require "findable/errors"
 require "findable/configuration"
 require "findable/query"
+require "findable/collection"
 require "findable/base"
 require "findable/railtie" if defined?(Rails)

data/lib/findable/associations/active_record_ext.rb

@@ -57,6 +57,15 @@ module Findable
             Utils.add_reflection(:belongs_to, name.to_sym, options, self)
           else
             super
+            define_method("#{name}_with_findable_polymorphic") do
+              begin
+                public_send("#{name}_without_findable_polymorphic")
+              rescue NotActiveRecord
+                id = public_send("#{name}_id")
+                public_send("#{name}_type").constantize.find(id)
+              end
+            end
+            alias_method_chain name.to_sym, :findable_polymorphic
           end
         end
       end

data/lib/findable/base.rb

@@ -1,4 +1,5 @@
 require "findable/associations"
+require "findable/schema"
 require "findable/inspection"
 
 module Findable
@@ -6,39 +7,32 @@ module Findable
     include ActiveModel::Model
     include ActiveModel::AttributeMethods
     include Associations
+    include Schema
     include Inspection
 
-    attribute_method_suffix "="
-    attribute_method_suffix "?"
-
     class << self
-      ## field definitions
-
-      def define_field(attr)
-        unless public_method_defined?(attr)
-          define_attribute_methods attr
-          define_method(attr) { attributes[attr] }
-          column_names << attr.to_sym
-        end
+      def arel_table
+        raise NotActiveRecord.new(self)
       end
 
       ## ActiveRecord like APIs
 
-      delegate :all, to: :query
+      delegate :first, :last, :order, :pluck, to: :all
+      alias_method :take, :first
 
       def primary_key
         "id"
       end
 
-      def column_names
-        @_column_names ||= [:id]
+      def all
+        collection!(query.all)
       end
 
       def find(ids)
         if records = find_by_ids(ids).presence
-          ids.is_a?(Array) ? records : records.first
+          ids.is_a?(Array) ? collection!(records) : records.first
         else
-          raise RecordNotFound.new(self, id: ids)
+          raise not_found(id: ids)
         end
       end
 
@@ -56,9 +50,7 @@ module Findable
               }
             end
           else
-            all.detect {|record|
-              conditions.all? {|k, v| record.public_send(k) == v }
-            }
+            all.find_by(conditions.dup)
           end
         else
           find_by_ids(conditions).first
@@ -66,7 +58,7 @@ module Findable
       end
 
       def find_by!(conditions)
-        find_by(conditions.dup) || (raise RecordNotFound.new(self, conditions))
+        find_by(conditions.dup) || (raise not_found(conditions))
       end
 
       def where(conditions)
@@ -74,16 +66,14 @@ module Findable
         if id = conditions.delete(:id)
           records = find_by_ids(id)
           if conditions.empty?
-            records
+            collection!(records)
           else
-            records.select {|record|
+            collection!(records.select {|record|
               conditions.all? {|k, v| record.public_send(k) == v }
-            }
+            })
           end
         else
-          all.select {|record|
-            conditions.all? {|k, v| record.public_send(k) == v }
-          }
+          all.where(conditions.dup)
         end
       end
 
@@ -94,12 +84,6 @@ module Findable
       end
       alias_method :create!, :create
 
-      [:first, :last].each do |m|
-        define_method(m) do
-          self.all.public_send(m)
-        end
-      end
-
       ## Query APIs
 
       delegate :find_by_ids, :insert, to: :query
@@ -125,6 +109,14 @@ module Findable
       end
 
       private
+        def collection!(records)
+          records.is_a?(Array) ? Collection.new(self, records) : records
+        end
+
+        def not_found(params)
+          RecordNotFound.new(self, params)
+        end
+
         def id_from(obj)
           obj.is_a?(self) ? obj.id : obj.to_i
         end
@@ -169,13 +161,5 @@ module Findable
     def attributes
       @_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
     end
-
-    def attribute=(attr, value)
-      attributes[attr.to_sym] = value
-    end
-
-    def attribute?(attr)
-      attributes[attr.to_sym].present?
-    end
   end
 end

data/lib/findable/collection.rb

@@ -0,0 +1,94 @@
+module Findable
+  # Record collection class
+  class Collection
+    include Enumerable
+
+    attr_reader :model, :records
+
+    def initialize(model, records)
+      raise ArgumentError unless records.is_a?(Array)
+      @model = model
+      @records = records
+    end
+
+    delegate :size, :first, :last, to: :records
+    delegate :empty?, :blank?, :present?, to: :records
+    alias_method :length, :size
+    alias_method :count, :size
+    alias_method :take, :first
+    alias_method :to_a, :records
+
+    def presence
+      present? ? self : nil
+    end
+
+    def each
+      if block_given?
+        records.each {|record| yield(record) }
+      else
+        records.to_enum
+      end
+    end
+
+    def find(ids)
+      if ids.is_a?(Array)
+        if refined = records.select {|record| record.id.in?(ids) }
+          regenerate(refined)
+        else
+          raise not_found(id: ids)
+        end
+      else
+        records.detect {|record| record.id == ids } || (raise not_found(id: ids))
+      end
+    end
+
+    def find_by(conditions)
+      records.detect {|record|
+        conditions.all? {|k, v| record.public_send(k) == v }
+      }
+    end
+
+    def find_by!(conditions)
+      find_by(conditions.dup) || (raise not_found(conditions))
+    end
+
+    def where(conditions)
+      regenerate(records.select {|record|
+        conditions.all? {|k, v| record.public_send(k) == v }
+      })
+    end
+
+    def order(*columns)
+      columns.flatten!
+      raise ArgumentError, "Must contain arguments" if columns.empty?
+
+      regenerate(records.sort_by {|record|
+        columns.map {|column| record.public_send(column) }
+      })
+    end
+
+    def pluck(*columns)
+      columns.flatten!
+      return records.map {|record| record.attributes.values } if columns.empty?
+      single = (columns.size == 1)
+
+      records.map {|record|
+        values = columns.map {|column| record.public_send(column) }
+        single ? values.first : values
+      }
+    end
+
+    def inspect
+      "[#{records.map(&:inspect).join(",\n")}]"
+    end
+
+    private
+      def regenerate(records)
+        self.class.new(model, records)
+      end
+
+      def not_found(params)
+        RecordNotFound.new(model, params)
+      end
+  end
+end

data/lib/findable/errors.rb

@@ -8,5 +8,11 @@ module Findable
     end
   end
 
+  class NotActiveRecord < FindableError
+    def initialize(model)
+      super("#{model.model_name.name} class is not ActiveRecord")
+    end
+  end
+
   class LockTimeout < FindableError; end
 end

data/lib/findable/schema.rb

@@ -0,0 +1,37 @@
+require "findable/schema/conversion"
+
+module Findable
+  module Schema
+    extend ActiveSupport::Concern
+
+    included do
+      attribute_method_suffix "="
+      attribute_method_suffix "?"
+    end
+
+    module ClassMethods
+      def column_names
+        @_column_names ||= [:id]
+      end
+
+      def define_field(*args)
+        options = args.extract_options!
+        name = args.first
+        if !public_method_defined?(name) || options.present?
+          define_attribute_methods name
+          conversion = Conversion.for(options[:type])
+          define_method(name) { conversion.call(attributes[name.to_sym]) }
+          column_names << name.to_sym
+        end
+      end
+    end
+
+    def attribute=(attr, value)
+      attributes[attr] = value
+    end
+
+    def attribute?(attr)
+      attributes[attr].present?
+    end
+  end
+end

data/lib/findable/schema/conversion.rb

@@ -0,0 +1,74 @@
+module Findable
+  module Schema
+    class Conversion
+      class << self
+        FALSE_VALUE = ["false", "0"]
+
+        def for(type)
+          return types[:default] if type.nil?
+          types[type] || add_type!(type)
+        end
+
+        def types
+          @_types ||= {
+            default: Proc.new {|value| value }
+          }
+        end
+
+        def add_type!(type)
+          return type if type.respond_to?(:call)
+          raise ArgumentError unless private_method_defined?(type)
+          types[type.to_sym] = method(type)
+        end
+
+        private
+          # Conversion methods
+          def integer(value)
+            value.to_i
+          end
+
+          def float(value)
+            value.to_f
+          end
+
+          def decimal(value)
+            BigDecimal(value)
+          end
+
+          def string(value)
+            value.to_s
+          end
+
+          def boolean(value)
+            if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+              value
+            elsif value.in?(FALSE_VALUE)
+              false
+            else
+              !!value
+            end
+          end
+
+          def date(value)
+            return value if value.is_a?(Date)
+            Date.parse(value)
+          end
+
+          def datetime(value)
+            if value.is_a?(Time) || value.is_a?(ActiveSupport::TimeWithZone)
+              return value
+            end
+            Time.zone.parse(value)
+          end
+
+          def symbol(value)
+            value.to_sym
+          end
+
+          def inquiry(value)
+            value.to_s.inquiry
+          end
+      end
+    end
+  end
+end

data/lib/findable/version.rb

@@ -1,3 +1,3 @@
 module Findable
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/spec/findable/associations/active_record_ext_spec.rb

@@ -1,29 +1,32 @@
 require "spec_helper"
 
 describe Findable::Associations::ActiveRecordExt do
-  let(:company) { Company.first }
-  let(:store) { Store.first }
-  let(:email) { Email.first }
+  # ActiveRecord models
   let(:user) { User.first }
+  let(:user2) { User.second }
+  let(:status) { Status.take }
+
+  # Findable models
+  let(:image) { Image.take }
 
   describe "#has_many" do
-    it { expect(company.users).to be_kind_of(Array) }
-    it { expect(company.users.first).to be_kind_of(User) }
-    it { expect(company.stores).to be_kind_of(ActiveRecord::Relation) }
-    it { expect(company.stores.first).to be_kind_of(Store) }
+    it { expect(user.purchase_histories).to be_kind_of(Findable::Collection) }
+    it { expect(user.purchase_histories.first).to be_kind_of(PurchaseHistory) }
+    it { expect(user.comments).to be_kind_of(ActiveRecord::Relation) }
+    it { expect(user.comments.first).to be_kind_of(Comment) }
   end
 
   describe "#has_one" do
-    it { expect(company.image).to be_kind_of(Image) }
-    it { expect(store.email).to be_kind_of(Email) }
+    it { expect(user.image).to be_kind_of(Image) }
+    it { expect(user.status).to be_kind_of(Status) }
   end
 
   describe "#belongs_to" do
-    it { expect(email.user).to be_kind_of(User) }
-    it { expect(store.company).to be_kind_of(Company) }
+    it { expect(image.user).to be_kind_of(User) }
+    it { expect(status.user).to be_kind_of(User) }
     it {
-      email.user = user
-      expect(email.user_id).to eq(user.id)
+      image.user = user2
+      expect(image).to have_attributes(user_id: user2.id)
     }
   end
 end

data/spec/findable/associations_spec.rb

@@ -1,33 +1,34 @@
 require "spec_helper"
 
 describe Findable::Associations do
-  let(:category) { Category.first }
-  let(:product) { Product.first }
-  let(:image) { Image.first }
-  let(:user) { User.find(UserData.first[:id]) }
-  let(:user2) { User.find(UserData.last[:id]) }
-  let(:other_company) { Company.last }
+  # Findable models
+  let(:category) { Category.find(CategoryData.first[:id]) }
+  let(:category2) { Category.find(CategoryData.second[:id]) }
+  let(:product) { Product.take }
+  let(:image) { Image.find(ImageData.first[:id]) }
+  let(:image2) { Image.find(ImageData.second[:id]) }
+  let(:cart) { Cart.take }
 
   describe "#has_many" do
-    it { expect(category.products).to be_kind_of(Array) }
+    it { expect(category.products).to be_kind_of(Findable::Collection) }
     it { expect(category.products.first).to be_kind_of(Product) }
-    it { expect(user.pictures).to be_kind_of(ActiveRecord::Relation) }
-    it { expect(user.pictures.first).to be_kind_of(Picture) }
+    it { expect(product.comments).to be_kind_of(ActiveRecord::Relation) }
+    it { expect(product.comments.first).to be_kind_of(Comment) }
   end
 
   describe "#has_one" do
     it { expect(product.image).to be_kind_of(Image) }
-    it { expect(user.email).to be_kind_of(Email) }
+    it { expect(cart.user).to be_kind_of(User) }
   end
 
   describe "#belongs_to" do
     it { expect(product.category).to be_kind_of(Category) }
-    it { expect(user.company).to be_kind_of(Company) }
-    it { expect(user.content).to be_kind_of(Image) }
-    it { expect(user2.content).to be_kind_of(Picture) }
+    it { expect(image.user).to be_kind_of(User) }
+    it { expect(image.content).to be_kind_of(image.content_type.constantize) }
+    it { expect(image2.content).to be_kind_of(image2.content_type.constantize) }
     it {
-      user.company = other_company
-      expect(user).to have_attributes(company_id: other_company.id)
+      product.category = category2
+      expect(product).to have_attributes(category_id: category2.id)
     }
   end
 end

data/spec/findable/base_spec.rb

@@ -13,13 +13,13 @@ describe Findable::Base do
   end
 
   describe ".all" do
-    it { expect(read_model.all).to be_kind_of(Array) }
-    it { expect(read_model.all.size).to eq(1) }
+    it { expect(read_model.all).to be_kind_of(Findable::Collection) }
+    it { expect(read_model.all.size).to eq(CategoryData.size) }
   end
 
   describe ".find" do
     it { expect(read_model.find(id)).to be_kind_of(read_model) }
-    it { expect(read_model.find([id])).to be_kind_of(Array) }
+    it { expect(read_model.find([id])).to be_kind_of(Findable::Collection) }
     it {
       expect {
         read_model.find(invalid_id)
@@ -52,13 +52,13 @@ describe Findable::Base do
   end
 
   describe ".where" do
-    it { expect(read_model.where(id: id)).to be_kind_of(Array) }
+    it { expect(read_model.where(id: id)).to be_kind_of(Findable::Collection) }
     it { expect(read_model.where(id: id).first).to be_kind_of(read_model) }
     it { expect(read_model.where(id: invalid_id)).to be_empty }
-    it { expect(read_model.where(id: id, name: name)).to be_kind_of(Array) }
+    it { expect(read_model.where(id: id, name: name)).to be_kind_of(Findable::Collection) }
     it { expect(read_model.where(id: id, name: name).first).to be_kind_of(read_model) }
     it { expect(read_model.where(id: invalid_id, name: name)).to be_empty }
-    it { expect(read_model.where(name: name)).to be_kind_of(Array) }
+    it { expect(read_model.where(name: name)).to be_kind_of(Findable::Collection) }
     it { expect(read_model.where(name: name).first).to be_kind_of(read_model) }
     it { expect(read_model.where(name: invalid_name)).to be_empty }
   end

data/spec/findable/query_spec.rb

@@ -8,16 +8,16 @@ describe Findable::Query do
 
   describe "#data" do
     it { expect(read_model.query.all).to be_kind_of(Array) }
-    it { expect(read_model.query.all.size).to eq(1) }
+    it { expect(read_model.query.all.size).to eq(CategoryData.size) }
   end
 
   describe "#ids" do
     it { expect(read_model.query.ids).to be_kind_of(Array) }
-    it { expect(read_model.query.ids).to eq([1]) }
+    it { expect(read_model.query.ids).to eq(CategoryData.map {|h| h[:id]}) }
   end
 
   describe "#count" do
-    it { expect(read_model.query.count).to eq(1) }
+    it { expect(read_model.query.count).to eq(CategoryData.size) }
   end
 
   describe "#find_by_ids" do
@@ -30,7 +30,7 @@ describe Findable::Query do
 
   describe "#exists?" do
     it { expect(read_model.exists?(1)).to be_truthy }
-    it { expect(read_model.exists?(2)).to be_falsey }
+    it { expect(read_model.exists?(100)).to be_falsey }
   end
 
   describe "#insert" do

data/spec/spec_helper.rb

@@ -20,6 +20,10 @@ require "pry"
 require "findable"
 require "findable/associations/active_record_ext"
 
+Findable.configure do |config|
+  config.redis_options = { host: "localhost", port: 6379, db: 10 }
+end
+
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|

data/spec/support/initialize_database.rb

@@ -3,7 +3,7 @@
 # =========================
 
 # Initialize Redis
-Redis.current.flushdb
+Findable::Base.query.redis.flushdb
 
 # Initialize SQLite
 ActiveRecord::Base.establish_connection({
@@ -11,24 +11,26 @@ ActiveRecord::Base.establish_connection({
   database: ":memory:",
 })
 
-ActiveRecord::Migration.create_table :companies do |t|
+ActiveRecord::Migration.create_table :users do |t|
   t.string :name
+  t.integer :cart_id
+  t.string :content_type
+  t.integer :content_id
 end
 
-ActiveRecord::Migration.create_table :stores do |t|
-  t.string :name
-  t.integer :company_id
+ActiveRecord::Migration.create_table :statuses do |t|
+  t.integer :total_payments
+  t.integer :user_id
 end
 
-ActiveRecord::Migration.create_table :emails do |t|
-  t.string :address
-  t.integer :store_id
+ActiveRecord::Migration.create_table :comments do |t|
+  t.text :body
   t.integer :user_id
+  t.integer :product_id
 end
 
 ActiveRecord::Migration.create_table :pictures do |t|
   t.string :name
-  t.integer :user_id
 end
 
 # =========================
@@ -36,12 +38,12 @@ end
 # =========================
 
 # Model < Findable
-%w(Category Product Image User).each do |class_name|
+%w(Category Product Image PurchaseHistory Cart).each do |class_name|
   Object.const_set(class_name, Class.new(Findable::Base))
 end
 
 # Model < ActiveRecord
-%w(Company Store Email Picture).each do |class_name|
+%w(User Comment Status Picture).each do |class_name|
   Object.const_set(class_name, Class.new(ActiveRecord::Base))
 end
 
@@ -49,58 +51,67 @@ ActiveRecord::Base.subclasses.each do |ar|
   ar.include Findable::Associations::ActiveRecordExt
 end
 
-# Associations
+# Associations (Findable <=> Findable)
 Category.has_many :products
 Product.belongs_to :category
 Product.has_one :image
 Image.belongs_to :product
 
-Company.has_many :stores
-Store.belongs_to :company
-Store.has_one :email
-Email.belongs_to :store
+# Associations (ActiveRecord <=> ActiveRecord)
+User.has_many :comments
+User.has_one :status
+Comment.belongs_to :user
+Status.belongs_to :user
 
-User.belongs_to :content, polymorphic: true
+# Associations (Findable <=> ActiveRecord)
+Product.has_many :comments
+Comment.belongs_to :product
 
-User.has_many :pictures
-Picture.belongs_to :user
+Cart.has_one :user
+User.belongs_to :cart
 
-User.has_one :email
-Email.belongs_to :user
+User.has_many :purchase_histories
+PurchaseHistory.belongs_to :user
 
-Company.has_many :users
-User.belongs_to :company
+User.has_one :image
+Image.belongs_to :user
 
-Company.has_one :image
-Image.belongs_to :company
+# Polymorphic association
+User.belongs_to :content, polymorphic: true
+Image.belongs_to :content, polymorphic: true
 
 # =========================
 # Data import
 # =========================
-CategoryData = [{id: 1, name: "Book"}]
+CategoryData = [
+  {id: 1, name: "Book"},
+  {id: 2, name: "Computer"},
+]
 Category.query.import(CategoryData)
 
 ProductData = [
-  {id: 1, name: "book 1", category_id: 1},
-  {id: 2, name: "book 2", category_id: 1},
+  {id: 1, name: "book1", category_id: 1},
+  {id: 2, name: "book2", category_id: 1},
 ]
 Product.query.import(ProductData)
 
 ImageData = [
-  {id: 1, product_id: 1, company_id: 1},
-  {id: 2, product_id: 2, company_id: 1},
+  {id: 1, product_id: 1, user_id: 1, content_type: "User", content_id: 1},
+  {id: 2, product_id: 2, user_id: 2, content_type: "Category", content_id: 1},
 ]
 Image.query.import(ImageData)
 
-UserData = [
-  {id: 1, name: "user 1", content_type: "Image", content_id: 1, company_id: 1},
-  {id: 2, name: "user 2", content_type: "Picture", content_id: 1, company_id: 1}
-]
-User.query.import(UserData)
-
-Company.create!(id: 1, name: "company 1")
-Company.create!(id: 2, name: "company 2")
-Store.create(id: 1, name: "store 1", company_id: 1)
-Email.create!(id: 1, address: "findable@example.com", store_id: 1, user_id: 1)
-Picture.create!(id: 1, name: "picture 1", user_id: 1)
-Picture.create!(id: 2, name: "picture 2", user_id: 1)
+CartData = [{id: 1}, {id: 2}]
+Cart.query.import(CartData)
+
+Picture.create(name: "example.jpg")
+User.create(name: "user1", content_type: "Picture", content_id: Picture.first.id, cart_id: CartData.first[:id])
+User.create(name: "user2", content_type: "Image", content_id: Image.first.id, cart_id: CartData.second[:id])
+User.all.each do |user|
+  user.create_status!(total_payments: rand(100_000))
+  user.comments.create!(body: "some comment", product_id: Product.take.id)
+end
+
+User.all.each do |user|
+  PurchaseHistory.create(user_id: user.id)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: findable
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - i2bskn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-05 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -185,6 +185,7 @@ files:
 - lib/findable/associations/active_record_ext.rb
 - lib/findable/associations/utils.rb
 - lib/findable/base.rb
+- lib/findable/collection.rb
 - lib/findable/configuration.rb
 - lib/findable/errors.rb
 - lib/findable/inspection.rb
@@ -194,6 +195,8 @@ files:
 - lib/findable/query/namespace.rb
 - lib/findable/query/serializer.rb
 - lib/findable/railtie.rb
+- lib/findable/schema.rb
+- lib/findable/schema/conversion.rb
 - lib/findable/seed.rb
 - lib/findable/version.rb
 - lib/generators/findable/install_generator.rb