findable 0.0.3 → 0.1.0

data/lib/findable/association.rb

@@ -1,71 +0,0 @@
-module Findable
-  module Association
-    def has_many(name, scope = nil, options = {})
-      super unless _define_association_methods(:has_many, name, options)
-    end
-
-    def has_one(name, scope = nil, options = {})
-      super unless _define_association_methods(:has_one, name, options)
-    end
-
-    def belongs_to(name, scope = nil, options = {})
-      super unless _define_association_methods(:belongs_to, name, options)
-    end
-
-    private
-      def _define_association_methods(association_type, name, options)
-        model = _model_for(name, options, true)
-        if _findable?(model) || _findable?(self)
-          self.send("_define_findable_#{association_type}", name, options, model)
-        else
-          false
-        end
-      end
-
-      def _model_for(name, options, _raise = false)
-        class_name = _class_name_for(name, options)
-        begin
-          class_name.constantize
-        rescue => e
-          _raise ? (raise Findable::ModelNotFound.new(class_name)) : nil
-        end
-      end
-
-      def _class_name_for(name, options)
-        options[:class].presence || name.to_s.classify
-      end
-
-      def _foreign_key_for(name, options)
-        options[:foreign_key].presence || name.to_s.foreign_key
-      end
-
-      def _findable?(model)
-        model.ancestors.include?(Findable::Base)
-      end
-
-      def _define_findable_has_many(name, options, model)
-        foreign_key = _foreign_key_for(self.model_name.name, options)
-
-        define_method name do
-          model.where(foreign_key.to_sym => id)
-        end
-      end
-
-      def _define_findable_has_one(name, options, model)
-        foreign_key = _foreign_key_for(self.model_name.name, options)
-
-        define_method name do
-          model.find_by(foreign_key.to_sym => id)
-        end
-      end
-
-      def _define_findable_belongs_to(name, options, model)
-        foreign_key = _foreign_key_for(name, options)
-
-        define_method name do
-          model.find(self.send(foreign_key))
-        end
-      end
-  end
-end
-

data/lib/findable/connection.rb

@@ -1,25 +0,0 @@
-module Findable
-  module Connection
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def redis
-        @_redis ||= generate_redis_connection!
-      end
-
-      private
-        def generate_redis_connection!
-          redis_options ? Redis.new(*redis_options) : Redis.current
-        end
-
-        def redis_options
-          Findable.config.redis_options.presence
-        end
-    end
-
-    def redis
-      self.class.redis
-    end
-  end
-end
-

data/lib/findable/namespace.rb

@@ -1,23 +0,0 @@
-module Findable
-  module Namespace
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def info_key
-        namespace[:info]
-      end
-
-      def data_key
-        namespace[:data]
-      end
-
-      private
-        def namespace
-          %i(info data).each_with_object({}) do |name, obj|
-            obj[name] = [self.model_name.plural, name].join(":")
-          end
-        end
-    end
-  end
-end
-

data/lib/findable/recordable.rb

@@ -1,93 +0,0 @@
-module Findable
-  module Recordable
-    extend ActiveSupport::Concern
-    include Serializer
-
-    included do
-      include ActiveModel::AttributeMethods
-
-      attribute_method_suffix "="
-      attribute_method_suffix "?"
-    end
-
-    module ClassMethods
-      def field(attr, options={})
-        options.symbolize_keys!
-        define_accessor(attr.to_sym, options)
-      end
-
-      def fields(*args)
-        options = args.extract_options!
-        args.each {|arg| field(arg, options) }
-      end
-
-      private
-        def define_accessor(attr, options)
-          unless public_method_defined?(attr)
-            define_attribute_methods attr
-            define_method attr do
-              attributes[attr]
-            end
-          end
-        end
-    end
-
-    def initialize(params={})
-      params = deserialize(params) if params.is_a?(String)
-      params.symbolize_keys!
-      params.keys.each {|attr| self.class.field(attr) }
-      @_attributes = params
-    end
-
-    def id
-      attributes[:id].presence || nil
-    end
-    # alias_method :quoted_id, :id
-
-    def id=(_id)
-      attributes[:id] = _id
-    end
-
-    def save
-      self.class.insert(self)
-    end
-    alias_method :save!, :save
-
-    def delete
-      self.class.delete(id)
-    end
-    alias_method :destroy, :delete
-
-    def new_record?
-      id ? !self.class.exists?(self) : true
-    end
-
-    def persisted?
-      !new_record?
-    end
-
-    def to_json(methods: nil)
-      _attrs = attributes.dup
-      _attrs.merge!(methods.to_sym => self.send(methods)) if methods
-      serialize(_attrs)
-    end
-
-    def hash
-      id.hash
-    end
-
-    def attributes
-      @_attributes ||= {}
-    end
-
-    private
-      def attribute=(attr, val)
-        attributes[attr.to_sym] = val
-      end
-
-      def attribute?(attr)
-        attributes[attr.to_sym].present?
-      end
-  end
-end
-

data/lib/findable/serializer.rb

@@ -1,12 +0,0 @@
-module Findable
-  module Serializer
-    def serialize(string)
-      Oj.dump(string)
-    end
-
-    def deserialize(string)
-      Oj.load(string)
-    end
-  end
-end
-