findable 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed1492954c92884d4fcf68884ef79e9137607919
-  data.tar.gz: f7118ffa85352d988fc77af88128246edaf8ebd8
+  metadata.gz: 3d9b4cc9d5f9ac6949eaa3db65f5dc97359a8450
+  data.tar.gz: 3ca9a61d80ea9b8d74f5a4e2df78082f07083012
 SHA512:
-  metadata.gz: c85b0d1bcf815bfa2922e3f4504e8deae8b9b335e5fa0fd889883bf004d263d8a5836df74be55c81517b5d68be82cf55e8144b6535e71fd9e609febdbb460a40
-  data.tar.gz: 90b596946d2344d52c0ae952bdbc62ed252e1222888d359377c3fd9deb06becf16d31b5e605b560ef889ec29d404be415c6cb371478f93b23026ac043a979729
+  metadata.gz: 68ab5f2cb1c8b3fc443ff1b4d1c8199a07634d3fb7ad08a7587247c0ee9836d711f596e2286566f82e59c9dccb2d815098e84e95adc665b0c878d3a721461a1c
+  data.tar.gz: fdd8b84c3f07ded341d312cc6bd1117f2f64b61f5dc40865fa36877852c27b17562b6b2ff3bcb086344ec7e61317e01f058300c53d745b635e17658363793060

data/.travis.yml

@@ -1,14 +1,10 @@
 language: ruby
 rvm:
-  - 2.1.0
-  - 2.2.0
-branches:
-  only:
-    - master
+  - 2.1.5
+  - 2.2.1
 gemfile:
   - Gemfile
 script: bundle exec rake spec
-notifications:
-  mails:
-    - i2bskn@gmail.com
+services:
+  - redis-server
 

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in findable.gemspec
 gemspec
+

data/README.md

@@ -5,7 +5,7 @@
 [![Coverage Status](https://img.shields.io/coveralls/i2bskn/findable.svg)](https://coveralls.io/r/i2bskn/findable)
 [![Code Climate](https://codeclimate.com/github/i2bskn/findable/badges/gpa.svg)](https://codeclimate.com/github/i2bskn/findable)
 
-Redis wrapper with API like ActiveRecord. (While creating...)
+Redis wrapper with API like ActiveRecord.
 
 ## Installation
 
@@ -17,27 +17,79 @@ gem "findable"
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
+
+Setup config file and seed script:
+
+```
+$ rails generate findable:install
+```
+
+Added following files:
+
+- `config/initializers/findable.rb`
+    - Config file for Findable.
+- `db/findable_seeds.rb`
+    - Seed script for Findable.
+- `db/findable_seeds/.keep`
+    - Directory for storing seed files of Findable.
 
 ## Usage
 
+Create seed file if static data.
+
+Example `db/findable_seeds/tags.yml`:
+
+```yaml
+data1:
+  id: 1
+  name: Ruby
+```
+
+Create model.
+
+Example `app/models/tag.rb`:
+
 ```ruby
-class Company < ActiveRecord::Base
-  has_many :person
+class Tag < Findable::Base
 end
+```
 
-class Person < Findable::Base
-  fields :name, :email, :gender, :company_id
-  belongs_to :company
-end
+Execute seed script if you create seed files.
 
-person = Person.new(name: "Ken Iiboshi", gender: "male")
-person.email = "i2bskn@example.com"
-person.save
+```
+$ rake findable:seeds
+```
+
+Manipulate data with API like ActiveRecord.
+
+```
+$ rails console
+pry(main)> Tag.find(1)
+=> #<Tag:0x00000108068430 @_attributes={:id=>1, :name=>"Ruby"}>
+pry(main)> golang = Tag.create(name: "Go")
+=> #<Tag:0x00000107ff6420 @_attributes={:name=>"Go", :id=>2}>
+pry(main)> Tag.all.each {|tag| p tag.name }
+"Ruby"
+"Go"
+=> [#<Tag:0x00000107f49568 @_attributes={:id=>1, :name=>"Ruby"}>, #<Tag:0x00000107f492e8 @_attributes={:name=>"Go", :id=>2}>]
+```
+
+## Associations
+
+It is possible to use the `belongs_to` and `has_one` and `has_many`.
+Mutually can refer to objects of ActiveRecord and Findable.
+
+```ruby
+class Article < ActiveRecord::Base
+  include Findable::Associations::ActiveRecordExt
+  belongs_to :tag
+end
 
-people = Person.where(gender: "male")
-people.each do |person|
-  puts person.name
+class Tag < Findable::Base
+  has_many :articles
 end
 ```
 

data/Rakefile

@@ -1,10 +1,15 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
+task :default => :spec
+
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-task :default => :spec
+desc "Console with library"
+task :console do
+  sh "pry -I lib -r bundler/setup -r findable"
+end
 

data/findable.gemspec

@@ -1,3 +1,4 @@
+# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'findable/version'
@@ -19,13 +20,13 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activesupport"
   spec.add_dependency "activemodel"
-  spec.add_dependency "redis"
+  spec.add_dependency "redis-objects"
   spec.add_dependency "oj"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec-rails"
-  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "coveralls"
 end
 

data/lib/findable.rb

@@ -1,13 +1,12 @@
 require "active_support"
 require "active_model"
-require "redis"
+require "redis/objects"
 require "oj"
 
 require "findable/version"
 require "findable/errors"
 require "findable/configuration"
-require "findable/serializer"
-require "findable/association"
+require "findable/query"
 require "findable/base"
 require "findable/railtie" if defined?(Rails)
 

data/lib/findable/associations.rb

@@ -0,0 +1,52 @@
+require "findable/associations/utils"
+
+module Findable
+  module Associations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def has_many(*args)
+        name, options = Utils.parse_args(args)
+        model = Utils.model_for(name, collection: true, **options)
+        foreign_key = options[:foreign_key].presence || model_name.name.foreign_key
+
+        define_method(name) do
+          model.where(foreign_key => public_send(self.class.primary_key))
+        end
+      end
+
+      def has_one(*args)
+        name, options = Utils.parse_args(args)
+        model = Utils.model_for(name, **options)
+        foreign_key = options[:foreign_key].presence || model_name.name.foreign_key
+
+        define_method(name) do
+          model.find_by(foreign_key => public_send(self.class.primary_key))
+        end
+      end
+
+      def belongs_to(*args)
+        name, options = Utils.parse_args(args)
+        model = Utils.model_for(name, safe: true, **options)
+        foreign_key = options[:foreign_key].presence || name.to_s.foreign_key
+
+        if options[:polymorphic]
+          define_method(name) do
+            public_send("#{name}_type").constantize.find(public_send(foreign_key))
+          end
+        else
+          define_field(foreign_key)
+
+          define_method(name) do
+            model.find_by(model.primary_key => public_send(foreign_key))
+          end
+
+          define_method("#{name}=") do |value|
+            attributes[foreign_key.to_sym] = value ? value.public_send(model.primary_key) : nil
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/findable/associations/active_record_ext.rb

@@ -0,0 +1,87 @@
+module Findable
+  module Associations
+    module ActiveRecordExt
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_many(*args)
+          name, options = Utils.parse_args(args)
+          model = Utils.model_for(name, collection: true, safe: true, **options)
+
+          if model && model < Findable::Base
+            foreign_key = options[:foreign_key].presence || model_name.name.foreign_key
+
+            define_method(name) do
+              model.where(foreign_key => public_send(self.class.primary_key))
+            end
+
+            reflection = ActiveRecord::Reflection.create(
+              :has_many,
+              name.to_sym,
+              nil,
+              options,
+              self,
+            )
+            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+          else
+            super
+          end
+        end
+
+        def has_one(*args)
+          name, options = Utils.parse_args(args)
+          model = Utils.model_for(name, safe: true, **options)
+
+          if model && model < Findable::Base
+            foreign_key = options[:foreign_key].presence || model_name.name.foreign_key
+
+            define_method(name) do
+              model.find_by(foreign_key => public_send(self.class.primary_key))
+            end
+
+            reflection = ActiveRecord::Reflection.create(
+              :has_one,
+              name.to_sym,
+              nil,
+              options,
+              self,
+            )
+            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+          else
+            super
+          end
+        end
+
+        def belongs_to(*args)
+          name, options = Utils.parse_args(args)
+          model = Utils.model_for(name, safe: true, **options)
+
+          if model && model < Findable::Base
+            foreign_key = options[:foreign_key].presence || name.to_s.foreign_key
+
+            define_method(name) do
+              model.find_by(model.primary_key => public_send(foreign_key))
+            end
+
+            define_method("#{name}=") do |value|
+              value = value ? value.public_send(model.primary_key) : nil
+              public_send("#{foreign_key}=", value)
+            end
+
+            reflection = ActiveRecord::Reflection.create(
+              :belongs_to,
+              name.to_sym,
+              nil,
+              options,
+              self,
+            )
+            ActiveRecord::Reflection.add_reflection(self, name.to_sym, reflection)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/findable/associations/utils.rb

@@ -0,0 +1,25 @@
+module Findable
+  module Associations
+    class Utils
+      def self.model_for(name, options = {})
+        unless model_name = options[:class_name].presence
+          name = options[:collection] ? name.to_s.singularize : name.to_s
+          model_name = name.camelize
+        end
+
+        if options[:safe]
+          model_name.try(:safe_constantize)
+        else
+          model_name.constantize
+        end
+      end
+
+      def self.parse_args(args)
+        copied = args.dup
+        options = copied.extract_options!
+        [copied.first, options]
+      end
+    end
+  end
+end
+

data/lib/findable/base.rb

@@ -1,81 +1,95 @@
-require "findable/recordable"
-require "findable/connection"
-require "findable/namespace"
+require "findable/associations"
 
 module Findable
   class Base
     include ActiveModel::Model
-    include Recordable
-    include Connection
-    include Namespace
-    extend Association
+    include ActiveModel::AttributeMethods
+
+    include Associations
+
+    attribute_method_suffix "="
+    attribute_method_suffix "?"
 
     class << self
+      ## field definitions
+
+      def define_field(attr, options = {})
+        unless public_method_defined?(attr)
+          options.symbolize_keys!
+          define_attribute_methods attr
+          define_method(attr) { attributes[attr.to_sym] }
+          column_names << attr.to_sym
+        end
+      end
+
+      ## ActiveRecord like APIs
+
       def primary_key
         "id"
       end
 
       def column_names
-        raise NotImplementedError
+        @_column_names ||= [:id]
       end
 
       def all
-        all_data.map {|data| new(data) }
+        data.map {|val| new(val) }
       end
 
-      def find(*ids)
-        ids = ids.first if ids.size == 1
-        values = find_by_id(ids)
-
-        case
-        when values.empty? then nil
-        when ids.is_a?(Array) then values.map {|val| new(val)}
-        else new(values.first)
+      def find(ids)
+        if values = find_by_ids(ids).compact.presence
+          ids.is_a?(Array) ? values.map {|val| new(val) } : new(values.first)
+        else
+          raise RecordNotFound.new(self, id: ids)
         end
       end
 
-      def find_by(params)
-        params.symbolize_keys!
-        if id = params.delete(:id)
-          values = find_by_id(id)
-          return nil if values.empty?
-          return new(values.first) if params.empty?
-
-          values.each {|val|
-            record = new(val)
-            return record if params.all? {|k,v| record.send(k) == v }
-          }
+      def find_by(conditions)
+        if conditions.is_a?(Hash)
+          conditions.symbolize_keys!
+          if id = conditions.delete(:id)
+            values = find_by_ids(id).compact
+            case
+            when values.empty? then nil
+            when conditions.empty? then new(values.first)
+            else
+              value = values.detect {|val|
+                record = new(val)
+                conditions.all? {|k, v| record.public_send(k) == v }
+              }
+              value ? new(value) : nil
+            end
+          else
+            all.detect {|r|
+              conditions.all? {|k, v| r.public_send(k) == v }
+            }
+          end
         else
-          all_data.each {|val|
-            record = new(val)
-            return record if params.all? {|k,v| record.send(k) == v }
-          }
+          values = find_by_ids(conditions).compact
+          values.empty? ? nil : new(values.first)
         end
       end
 
-      def where(params)
-        all.select {|record| params.all? {|k,v| record.send(k) == v } }
+      def find_by!(conditions)
+        find_by(conditions.dup) || (raise RecordNotFound.new(self, conditions))
       end
 
-      def exists?(record)
-        if record.is_a?(self)
-          _id = record.id
-          return false unless _id
+      def where(conditions)
+        if id = conditions.delete(:id)
+          values = find_by_ids(id).compact
+          if conditions.empty?
+            values.map {|val| new(val) }
+          else
+            values.map {|val|
+              record = new(val)
+              conditions.all? {|k, v| record.public_send(k) == v } ? record : nil
+            }.compact
+          end
         else
-          _id = record.to_i
+          all.select {|r|
+            conditions.all? {|k, v| r.public_send(k) == v }
+          }
         end
-
-        redis.hexists data_key, _id
-      end
-
-      delegate :first, :last, to: :all
-
-      def count
-        redis.hlen(data_key)
-      end
-
-      def ids
-        redis.hkeys(data_key).map(&:to_i)
       end
 
       def create(attrs = {})
@@ -83,53 +97,99 @@ module Findable
         record.save
         record
       end
+      alias_method :create!, :create
 
-      def create!(attrs = {})
-        record = new(attrs)
-        record.save!
-        record
+      [:first, :last].each do |m|
+        define_method(m) do
+          value = self.data.public_send(m)
+          value ? new(value) : nil
+        end
       end
 
-      def delete_all
-        redis.del(data_key)
-      end
+      ## Query APIs
+
+      delegate :find_by_ids, :data, to: :query
+      delegate :count, :ids, :delete_all, to: :query
       alias_method :destroy_all, :delete_all
 
-      def transaction(&block)
-        redis.multi &block
+      def exists?(obj)
+        if _id = id_from(obj)
+          query.exists?(data_key, _id)
+        else
+          false
+        end
       end
 
-      def import(records)
-        data = records.each_with_object([]) {|record, obj|
-          record.id ||= auto_incremented_id
-          obj << record.id
-          obj << record.to_json
-        }
-        redis.hmset(data_key, *data)
+      def insert(obj)
+        query.insert(obj.attributes)
       end
 
-      def insert(record)
-        record.id ||= auto_incremented_id
-        redis.hset(data_key, record.id, record.to_json)
+      def delete(obj)
+        if _id = id_from(obj)
+          query.delete(_id)
+        end
       end
 
-      def delete(id)
-        redis.hdel(data_key, id)
+      def query
+        @_query ||= Query.new(self)
       end
 
       private
-        def auto_incremented_id
-          redis.hincrby(info_key, :auto_inclement, 1)
+        def id_from(obj)
+          obj.is_a?(self) ? obj.id : obj.to_i
         end
+    end
 
-        def all_data
-          redis.hvals(data_key)
-        end
+    def initialize(params = {})
+      params = Oj.load(params) if params.is_a?(String)
+      params.symbolize_keys!
+      params.keys.each {|attr| self.class.define_field(attr) }
+      @_attributes = params
+    end
 
-        def find_by_id(id)
-          redis.hmget(data_key, *Array(id)).compact
-        end
+    def id
+      attributes[:id].presence
+    end
+
+    def id=(value)
+      attributes[:id] = value
+    end
+
+    def hash
+      id.hash
+    end
+
+    def new_record?
+      id ? !self.class.exists?(self) : true
     end
+
+    def persisted?
+      !new_record?
+    end
+
+    def save
+      @_attributes = self.class.insert(self)
+      self
+    end
+    alias_method :save!, :save
+
+    def delete
+      self.class.delete(self)
+    end
+    alias_method :destroy, :delete
+
+    def attributes
+      @_attributes ||= {}
+    end
+
+    private
+      def attribute=(attr, value)
+        attributes[attr.to_sym] = value
+      end
+
+      def attribute?(attr)
+        attributes[attr.to_sym].present?
+      end
   end
 end