findable 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed73de3540dfd5ad802f506f399aa52cfa748a7f
-  data.tar.gz: f35dc8a71965b62c822e6aa7a9070f733b043db5
+  metadata.gz: 79d36740a44c4a4a702069dab24e53b533e8db00
+  data.tar.gz: 2908163cf00a3546837f8a0fa5b3e20bad62b044
 SHA512:
-  metadata.gz: 8ffdcafaef3953de07e19f63d804bd25e0c69db535d964b96c4f0da81d3f4cddcdcb1bd1ddebaccc2dee5e48fb04a1a4d234526830050dfb423d5ef903b7b68e
-  data.tar.gz: 41d2b9c45cbd8b5902c66ca28779aa8d3bac5d453ce7912bb2578cd8180326598fb89ef77bf9f6a507233554cd74e4e8ece7a1ecd14e03527aab83720722a948
+  metadata.gz: 2761e6fbd194a70df6ecab268d507a4b689520b537c3210e83f9d1a59d1528a6df5085fcd23d9c5b129f60a3d8037135fa310e2a7c861f9a70be1a0a3fccd709
+  data.tar.gz: fdef311c4c618ee709ca488157753480ba2b2fc2bf61d6e1060d904d8aa9c9a1253c18d14d3e20fa3705a14581af019bd19e14950c2d024e73ec554b97d0c90b

data/lib/findable/associations/utils.rb

@@ -1,6 +1,6 @@
 module Findable
   module Associations
-    class Utils
+    module Utils
       def self.model_for(name, options = {})
         unless model_name = options[:class_name].presence
           name = options[:collection] ? name.to_s.singularize : name.to_s

data/lib/findable/base.rb

@@ -5,7 +5,6 @@ require "findable/inspection"
 module Findable
   class Base
     include ActiveModel::Model
-    include ActiveModel::AttributeMethods
     include Associations
     include Schema
     include Inspection
@@ -39,8 +38,14 @@ module Findable
       def find_by(conditions)
         if conditions.is_a?(Hash)
           conditions.symbolize_keys!
-          if id = conditions.delete(:id)
-            records = find_by_ids(id)
+          if index = conditions.keys.detect {|key| key.in?(indexes) }
+            value = conditions.delete(index)
+            if index == :id
+              records = find_by_ids(value)
+            else
+              records = find_by_index(index, value)
+            end
+
             case
             when records.empty? then nil
             when conditions.empty? then records.first
@@ -63,8 +68,14 @@ module Findable
 
       def where(conditions)
         conditions.symbolize_keys!
-        if id = conditions.delete(:id)
-          records = find_by_ids(id)
+        if index = conditions.keys.detect {|key| key.in?(indexes) }
+          value = conditions.delete(index)
+          if index == :id
+            records = find_by_ids(value)
+          else
+            records = find_by_index(index, value)
+          end
+
           if conditions.empty?
             collection!(records)
           else
@@ -84,10 +95,17 @@ module Findable
       end
       alias_method :create!, :create
 
+      ## Extension
+
+      def ordered_find(*_ids)
+        _ids.flatten!
+        find(_ids).ordered_find(_ids)
+      end
+
       ## Query APIs
 
-      delegate :find_by_ids, :insert, to: :query
-      delegate :count, :ids, :delete_all, to: :query
+      delegate :find_by_ids, :find_by_index, :insert, to: :query
+      delegate :count, :ids, :delete, :delete_all, to: :query
       alias_method :destroy_all, :delete_all
 
       def exists?(obj)
@@ -98,12 +116,6 @@ module Findable
         end
       end
 
-      def delete(obj)
-        if _id = id_from(obj)
-          query.delete(_id)
-        end
-      end
-
       def query
         @_query ||= Query.new(self)
       end

data/lib/findable/collection.rb

@@ -67,6 +67,11 @@ module Findable
       })
     end
 
+    def ordered_find(*_ids)
+      _ids.flatten!
+      records.index_by(&:id).values_at(*_ids)
+    end
+
     def pluck(*columns)
       columns.flatten!
       return records.map {|record| record.attributes.values } if columns.empty?

data/lib/findable/query.rb

@@ -31,6 +31,12 @@ module Findable
       @serializer.deserialize(redis.hmget(data_key, *Array(ids)), model)
     end
 
+    def find_by_index(index, value)
+      if ids = ids_from_index([index, value].join(":"))
+        find_by_ids(ids)
+      end
+    end
+
     def exists?(id)
       redis.hexists(data_key, id)
     end
@@ -43,28 +49,51 @@ module Findable
           object.id,
           @serializer.serialize(object.attributes)
         )
+        update_index(object)
       end
       object
     end
 
     def import(hashes)
       lock do
-        auto_incremented = hashes.each_with_object([]) do |hash, obj|
+        indexes = Hash.new {|h, k| h[k] = [] }
+        values = hashes.each_with_object([]) do |hash, obj|
+          hash = hash.with_indifferent_access
           hash["id"] = auto_incremented_id(hash["id"])
           obj << hash["id"]
           obj << @serializer.serialize(hash)
+
+          if model.index_defined?
+            model.indexes.each_with_object([]) do |name, obj|
+              next if name == :id
+              indexes[[name, hash[name]].join(":")] << hash["id"]
+            end
+          end
+        end
+        redis.hmset(data_key, *values)
+        if indexes.present?
+          attrs = indexes.map {|k, v| [k, @serializer.serialize(v)] }.flatten
+          redis.hmset(index_key, *attrs)
         end
-        redis.hmset(data_key, *auto_incremented)
       end
     end
 
-    def delete(id)
-      redis.hdel(data_key, id)
+    def delete(object)
+      if model.index_defined?
+        model.indexes.each do |name|
+          next if name == :id
+          if value = object.public_send("#{name}_was") || object.public_send(name)
+            redis.hdel(index_key, value)
+          end
+        end
+      end
+
+      redis.hdel(data_key, object.id)
     end
 
     def delete_all
       redis.multi do
-        [data_key, info_key].each {|key| redis.del(key) }
+        [data_key, info_key, index_key].each {|key| redis.del(key) }
       end
     end
 
@@ -73,6 +102,32 @@ module Findable
       Lock.new(lock_key, thread_key).lock { yield }
     end
 
+    def update_index(object)
+      if model.index_defined?
+        indexes = model.indexes.each_with_object([]) {|name, obj|
+          next if name == :id || object.public_send("#{name}_changed?")
+
+          if old_value = object.public_send("#{name}_was")
+            old_index_key = [name, old_value].join(":")
+
+            if (old_ids = ids_from_index(old_index_key)).present?
+              new_ids = old_ids.reject {|id| id == object.id }
+              if new_ids.empty?
+                redis.hdel(index_key, old_index_key)
+              else
+                obj << old_index_key
+                obj << @serializer.serialize(new_ids)
+              end
+            end
+          end
+
+          obj << [name, object.public_send(name)].join(":")
+          obj << object.id
+        }
+        redis.hmset(index_key, *indexes)
+      end
+    end
+
     private
       def auto_incremented_id(id)
         if id.present?
@@ -86,5 +141,11 @@ module Findable
           redis.hincrby(info_key, AUTO_INCREMENT_KEY, 1)
         end
       end
+
+      def ids_from_index(index_name)
+        if ids = redis.hget(index_key, index_name)
+          @serializer.deserialize(ids)
+        end
+      end
   end
 end

data/lib/findable/schema.rb

@@ -5,6 +5,9 @@ module Findable
     extend ActiveSupport::Concern
 
     included do
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Dirty
+
       attribute_method_suffix "="
       attribute_method_suffix "?"
     end
@@ -14,19 +17,29 @@ module Findable
         @_column_names ||= [:id]
       end
 
+      def indexes
+        @_indexes ||= [:id]
+      end
+
+      def index_defined?
+        indexes.size > 1
+      end
+
       def define_field(*args)
         options = args.extract_options!
         name = args.first
         if !public_method_defined?(name) || options.present?
           define_attribute_methods name
-          conversion = Findable::Schema::Conversion.for(options[:type])
+          conversion = Findable::Schema::Conversion.to(options[:type])
           define_method(name) { conversion.call(attributes[name.to_sym]) }
+          indexes << name.to_sym if options[:index]
           column_names << name.to_sym
         end
       end
     end
 
     def attribute=(attr, value)
+      public_send("#{attr}_will_change!")
       attributes[attr] = value
     end
 

data/lib/findable/schema/conversion.rb

@@ -1,12 +1,12 @@
 module Findable
   module Schema
-    class Conversion
+    module Conversion
       class << self
         FALSE_VALUE = ["false", "0"]
 
-        def for(type)
+        def to(type)
           return types[:default] if type.nil?
-          types[type] || add_type!(type)
+          types[type.to_sym] || add_type!(type)
         end
 
         def types
@@ -16,8 +16,8 @@ module Findable
         end
 
         def add_type!(type)
-          return type if type.respond_to?(:call)
-          types[type.to_sym] = method(type)
+          return type if type.is_a?(Proc)
+          types[type.to_sym] = method(type).to_proc
         end
 
         def clear_types

data/lib/findable/seed.rb

@@ -1,14 +1,50 @@
+require "yaml"
+require "csv"
+
 module Findable
-  class Seed
+  class UnknownSeedDir < FindableError
+    def initialize(path)
+      if path
+        super("Couldn't find #{path}")
+      else
+        super("There is no configuration")
+      end
+    end
+  end
+
+  class Seed < Struct.new(:seed_files, :model_name)
     class << self
       def target_files(seed_dir: nil, seed_files: nil)
-        target_dir = pathname(seed_dir) || Findable.config.seed_dir
-        raise ArgumentError unless target_dir
-        Pathname.glob(target_dir.join("**", "*")).map {|full_path|
-          new(full_path, target_dir)
-        }.select {|seed|
-          seed_files.present? ? seed_files.include?(seed.basename) : true
-        }
+        target_dir = pathname(seed_dir || Findable.config.seed_dir)
+        raise UnknownSeedDir.new(target_dir) unless target_dir.try(:exist?)
+
+        seed_files = seed_files.map!(&:to_s) if seed_files
+        _model_name = method(:model_name).to_proc.curry.call(target_dir)
+        _selected = Proc.new do |seed|
+          seed_files.present? ? seed.table_name.in?(seed_files) : true
+        end
+
+        Pathname.glob(target_dir.join("**", "*"))
+          .select(&:file?)
+          .group_by(&_model_name)
+          .map {|name, files| new(files, name) }
+          .select(&_selected)
+      end
+
+      def model_name(seed_dir, seed_file)
+        if seed_dir != seed_file.dirname && seed_file.basename.to_s.match(/^data/)
+          from_seed_dir(seed_dir, seed_file.dirname).to_s.classify
+        else
+          from_seed_dir(seed_dir, without_ext(seed_file)).to_s.classify
+        end
+      end
+
+      def from_seed_dir(seed_dir, seed_file)
+        pathname(seed_file).relative_path_from(seed_dir)
+      end
+
+      def without_ext(seed_file)
+        pathname(seed_file).dirname.join(pathname(seed_file).basename(".*"))
       end
 
       def pathname(path)
@@ -20,37 +56,35 @@ module Findable
       end
     end
 
-    def initialize(full_path, seed_dir)
-      @_full_path = full_path
-      @_seed_dir = seed_dir
-    end
-
-    def basename
-      @_basename ||= @_full_path.basename(".*").to_s
+    def model
+      @_model_class ||= model_name.constantize
     end
 
-    def model
-      @_model ||= from_seed_dir(without_ext(@_full_path)).to_s.classify.constantize
+    def load_files
+      seed_files.sort_by(&:to_s).inject([]) do |data, file|
+        data | case file.extname
+          when ".yml" then load_yaml(file)
+          when ".csv" then load_csv(file)
+          else
+            raise UnknownFormat
+          end
+      end
     end
 
     def bootstrap!
       model.query.lock do
         model.delete_all
-        model.query.import YAML.load_file(@_full_path).values
+        model.query.import load_files
       end
     end
 
     private
-      def pathname(path)
-        self.class.pathname(path)
-      end
-
-      def without_ext(path)
-        pathname(path).dirname.join(pathname(path).basename(".*"))
+      def load_yaml(seed_file)
+        YAML.load_file(seed_file).values
       end
 
-      def from_seed_dir(path)
-        pathname(path).relative_path_from(@_seed_dir)
+      def load_csv(seed_file)
+        CSV.table(seed_file).map(&:to_h)
       end
   end
 end

data/lib/findable/version.rb

@@ -1,3 +1,3 @@
 module Findable
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/generators/findable/templates/seeds.rb

@@ -10,4 +10,4 @@ require "findable/seed"
 seed_files = nil
 
 # Execute
-Findable::Seed.target_files(seed_files: seed_files).each {|seed| seed.bootstrap! }
+Findable::Seed.target_files(seed_files: seed_files).each(&:bootstrap!)

data/spec/findable/base_spec.rb

@@ -125,12 +125,12 @@ describe Findable::Base do
 
   # Private instance methods
   describe "#attribute=" do
-    before { instance.send(:attribute=, :example, "value") }
-    it { expect(instance.attributes[:example]).to eq("value") }
+    before { instance.send(:attribute=, :name, "value") }
+    it { expect(instance.attributes[:name]).to eq("value") }
   end
 
   describe "#attribute?" do
-    before { instance.send(:attribute=, :example, "value") }
-    it { expect(instance.send(:attribute?, :example)).to be_truthy }
+    before { instance.send(:attribute=, :name, "value") }
+    it { expect(instance.send(:attribute?, :name)).to be_truthy }
   end
 end

data/spec/findable/query_spec.rb

@@ -52,7 +52,7 @@ describe Findable::Query do
 
     it {
       expect {
-        model.query.delete(persisted_object.id)
+        model.query.delete(persisted_object)
       }.to change { model.query.count }.by(-1)
     }
   end

data/spec/findable/schema/conversion_spec.rb

@@ -4,17 +4,17 @@ describe Findable::Schema::Conversion do
   after(:each) { conversion.clear_types }
   let(:conversion) { Findable::Schema::Conversion }
 
-  describe ".for" do
-    it { expect(conversion.for(nil)).to eq(conversion.types[:default]) }
-    it { expect(conversion.for(:integer)).to eq(conversion.types[:integer]) }
-    it { expect(conversion.for(:float)).to eq(conversion.types[:float]) }
-    it { expect(conversion.for(:decimal)).to eq(conversion.types[:decimal]) }
-    it { expect(conversion.for(:string)).to eq(conversion.types[:string]) }
-    it { expect(conversion.for(:boolean)).to eq(conversion.types[:boolean]) }
-    it { expect(conversion.for(:date)).to eq(conversion.types[:date]) }
-    it { expect(conversion.for(:datetime)).to eq(conversion.types[:datetime]) }
-    it { expect(conversion.for(:symbol)).to eq(conversion.types[:symbol]) }
-    it { expect(conversion.for(:inquiry)).to eq(conversion.types[:inquiry]) }
+  describe ".to" do
+    it { expect(conversion.to(nil)).to eq(conversion.types[:default]) }
+    it { expect(conversion.to(:integer)).to eq(conversion.types[:integer]) }
+    it { expect(conversion.to(:float)).to eq(conversion.types[:float]) }
+    it { expect(conversion.to(:decimal)).to eq(conversion.types[:decimal]) }
+    it { expect(conversion.to(:string)).to eq(conversion.types[:string]) }
+    it { expect(conversion.to(:boolean)).to eq(conversion.types[:boolean]) }
+    it { expect(conversion.to(:date)).to eq(conversion.types[:date]) }
+    it { expect(conversion.to(:datetime)).to eq(conversion.types[:datetime]) }
+    it { expect(conversion.to(:symbol)).to eq(conversion.types[:symbol]) }
+    it { expect(conversion.to(:inquiry)).to eq(conversion.types[:inquiry]) }
   end
 
   describe ".types" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: findable
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - i2bskn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-15 00:00:00.000000000 Z
+date: 2015-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport