lookup_by 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 170c2ef2408cf8495f0cfe3f30cd4811ee17cd6f
-  data.tar.gz: 14e0c54b5ec327fa87cd0044b67cd921df3a002b
+  metadata.gz: c32a15a02ac5c67549366075fac6d76db2122564
+  data.tar.gz: 07aa69751c19f10a96b573eb08d562e7290aee47
 SHA512:
-  metadata.gz: 258e5adbe68b2c181613e08e5cb59e6d8044e1b28cea20dffb282d3489826aa9061e884cd200844953e95a23cc4e9286595f0a3e849205faa4ba6a102bd27d71
-  data.tar.gz: 76c03e4a60019234ba204c47d65520076b5dad3705a765523be4706b9caa78ae5199d9f9f992dca7e7c3ef65a48f8dc0d1563bdaf666bcc970e5343e29f7b0fd
+  metadata.gz: 14f87c363d0c346dafb9f37a1b015a721786c0ba4223ddfa1bb656adfe0dbf1d9764ea3724ac3330b336719382c5f014ae393b97f0c6eeeff3a936844d825af5
+  data.tar.gz: c1cca0a1500aedf3a1f10ffaceca6dbe5d1fd870b86c9a0b23858f5c075aeaf6901c84f0fd73559a31c60a5cc64149c2f1925af69ab57935fa56d623f8550662

data/lib/lookup_by/association.rb

@@ -16,14 +16,31 @@ module LookupBy
       def lookup_for field, options = {}
         return unless table_exists?
 
+        options.symbolize_keys!
+        options.assert_valid_keys(:class_name, :foreign_key, :symbolize, :strict, :scope)
+
         field = field.to_sym
 
-        %W(#{field} raw_#{field} #{field}= #{field}_before_type_cast).map(&:to_sym).each do |method|
+        %W(#{field} raw_#{field} #{field}= #{field}_before_type_cast #{field}?).map(&:to_sym).each do |method|
           raise Error, "method `#{method}` already exists on #{self.inspect}" if instance_methods.include? method
         end
 
-        options.symbolize_keys!
-        options.assert_valid_keys(:class_name, :foreign_key, :symbolize, :strict)
+        singleton_class.class_eval do
+          attr_reader :lookups
+        end
+
+        @lookups ||= []
+        @lookups << field
+
+        scope_name = "with_#{field}" unless options[:scope] == false
+
+        if scope_name
+          single_scope = scope_name
+          plural_scope = scope_name.pluralize
+
+          raise Error, "#{single_scope} already exists on #{self}. Use `lookup_for #{field}, scope: false` if you don't want scope :#{single_scope}" if respond_to?(single_scope)
+          raise Error, "#{plural_scope} already exists on #{self}. Use `lookup_for #{field}, scope: false` if you don't want scope :#{plural_scope}" if respond_to?(plural_scope)
+        end
 
         class_name = options[:class_name] || field
         class_name = class_name.to_s.camelize
@@ -31,22 +48,21 @@ module LookupBy
         foreign_key = options[:foreign_key] || "#{field}_id"
         foreign_key = foreign_key.to_sym
 
+        raise Error, "foreign key `#{foreign_key}` is required on #{self}" unless attribute_names.include?(foreign_key.to_s)
+
         strict = options[:strict]
         strict = true if strict.nil?
 
-        raise Error, "foreign key `#{foreign_key}` is required on #{self}" unless attribute_names.include?(foreign_key.to_s)
-
-        lookup_field = class_name.constantize.lookup.field
+        class_eval <<-SCOPES, __FILE__, __LINE__.next if scope_name
+          scope :#{scope_name},           ->(name)   { where(#{foreign_key}: #{class_name}[name]) }
+          scope :#{scope_name.pluralize}, ->(*names) { where(#{foreign_key}: #{class_name}[*names]) }
+        SCOPES
 
         cast = options[:symbolize] ? ".to_sym" : ""
 
+        lookup_field  = class_name.constantize.lookup.field
         lookup_object = "#{class_name}[#{foreign_key}]"
 
-        class << self; attr_reader :lookups; end
-
-        @lookups ||= []
-        @lookups << field
-
         class_eval <<-METHODS, __FILE__, __LINE__.next
           def raw_#{field}
             #{lookup_object}
@@ -57,16 +73,20 @@ module LookupBy
             value ? value.#{lookup_field}#{cast} : nil
           end
 
+          def #{field}?(name)
+            raise ArgumentError, "Invalid #{field} \#{name.inspect}" unless object = #{class_name}[name]
+            #{foreign_key} == object.id
+          end
+
           def #{field}_before_type_cast
-            value = #{lookup_object}
-            value.#{lookup_field}_before_type_cast
+            #{lookup_object}.#{lookup_field}_before_type_cast
           end
 
           def #{field}=(arg)
             value = case arg
             when "", nil
               nil
-            when String, Fixnum
+            when String, Integer
               #{class_name}[arg].try(:id)
             when Symbol
               #{%Q(raise ArgumentError, "#{foreign_key}=(Symbol): use `lookup_for :column, symbolize: true` to allow symbols") unless options[:symbolize]}
@@ -75,7 +95,7 @@ module LookupBy
               raise ArgumentError, "self.#{foreign_key}=(#{class_name}): must be saved" unless arg.id
               arg.id
             else
-              raise TypeError, "#{foreign_key}=(arg): arg must be a String, Symbol, Fixnum, nil, or #{class_name}"
+              raise TypeError, "#{foreign_key}=(arg): arg must be a String, Symbol, Integer, nil, or #{class_name}"
             end
 
             #{%Q(raise LookupBy::Error, "\#{arg.inspect} is not in the <#{class_name}> lookup cache" if arg.present? && value.nil?) if strict}

data/lib/lookup_by/cache.rb

@@ -23,7 +23,7 @@ module LookupBy
       when true
         @type    = :all
         @read  ||= false
-      when ::Fixnum
+      when ::Integer
         raise ArgumentError, "`#{@klass}.lookup_by :#{@field}` options[:find] must be true when caching N" if @read == false
 
         @type    = :lru
@@ -62,7 +62,7 @@ module LookupBy
     def fetch(value)
       increment :cache, :get
 
-      value = normalize(value)      if @normalize && !value.is_a?(Fixnum)
+      value = normalize(value)  if @normalize && !value.is_a?(Integer)
 
       found = cache_read(value) if cache?
       found ||= db_read(value)  if @read
@@ -108,7 +108,7 @@ module LookupBy
     end
 
     def cache_read(value)
-      if value.is_a? Fixnum
+      if value.is_a? Integer
         found = @cache[value]
       else
         found = @cache.values.detect { |o| o.send(@field) == value }
@@ -138,7 +138,7 @@ module LookupBy
     end
 
     def column_for(value)
-      value.is_a?(Fixnum) ? @primary_key : @field
+      value.is_a?(Integer) ? @primary_key : @field
     end
 
     def cache?

data/lib/lookup_by/lookup.rb

@@ -71,14 +71,19 @@ module LookupBy
         @lookup.cache.values.map { |o| o.send(column_name) }
       end
 
-      def [](arg)
-        case arg
-        when nil, "" then nil
-        when String  then @lookup.fetch(arg)
-        when Symbol  then @lookup.fetch(arg.to_s)
-        when Fixnum  then @lookup.fetch(arg)
-        when self    then arg
-        else raise TypeError, "#{name}[arg]: arg must be a String, Symbol, Fixnum, nil, or #{name}"
+      def [](*args)
+        case args.size
+        when 0 then raise ArgumentError, "#{name}[*args]: at least one argument is required"
+        when 1
+          case arg = args.first
+          when nil, "" then nil
+          when String  then @lookup.fetch(arg)
+          when Symbol  then @lookup.fetch(arg.to_s)
+          when Integer then @lookup.fetch(arg)
+          when self    then arg
+          else raise TypeError, "#{name}[arg]: arg must be at least one String, Symbol, Integer, nil, or #{name}"
+          end
+        else return args.map { |arg| self[arg] } 
         end
       end
     end
@@ -86,10 +91,10 @@ module LookupBy
     module InstanceMethods
       def ===(arg)
         case arg
-        when Symbol, String, Fixnum, nil
+        when Symbol, String, Integer, nil
           return self == self.class[arg]
         when Array
-          return !!arg.detect { |i| self === i }
+          return arg.any? { |i| self === i }
         end
 
         super

data/lib/lookup_by/version.rb

@@ -1,3 +1,3 @@
 module LookupBy
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/association_spec.rb

@@ -17,13 +17,25 @@ describe ::ActiveRecord::Base do
         public :define_method, :remove_method
       end
 
-      [:foo, :foo=, :raw_foo, :foo_before_type_cast].each do |method|
+      [:foo, :foo=, :raw_foo, :foo_before_type_cast, :foo?].each do |method|
         subject.define_method(method) { }
 
         expect { subject.lookup_for :foo }.to raise_error LookupBy::Error, /already exists/
 
         subject.remove_method(method)
       end
+
+      class << subject.singleton_class
+        public :define_method, :remove_method
+      end
+
+      [:with_foo, :with_foos].each do |method|
+        subject.singleton_class.define_method(method) { }
+
+        expect { subject.lookup_for :foo }.to raise_error LookupBy::Error, /already exists/
+
+        subject.singleton_class.remove_method(method)
+      end
     end
 
     it "requires a foreign key" do
@@ -33,6 +45,18 @@ describe ::ActiveRecord::Base do
     it "rejects unsaved lookup values" do
       expect { subject.new.city = City.new(name: "Toronto") }.to raise_error ArgumentError, /must be saved/
     end
+
+    context "scope: nil" do
+      it { should respond_to(:with_city).with(1).arguments }
+      it { should respond_to(:with_cities).with(2).arguments }
+    end
+
+    context "scope: false" do
+      it { should_not respond_to(:with_postal_code) }
+      it { should_not respond_to(:with_postal_codes) }
+    end
+
+    its(:lookups) { should include(:city) }
   end
 end
 
@@ -46,7 +70,7 @@ describe LookupBy::Association do
   context "Address.lookup_for :city, strict: false" do
     it_behaves_like "a lookup for", :city
 
-    it "accepts Fixnums" do
+    it "accepts Integers" do
       subject.city = City.where(city: "New York").first.id
       subject.city.should eq "New York"
     end
@@ -92,7 +116,7 @@ describe LookupBy::Association do
 
   context "Missing.lookup_for :city" do
     it "does not raise foreign key error when table hasn't been created" do
-      expect { require "missing"; }.to_not raise_error
+      expect { require "missing" }.to_not raise_error
     end
   end
 end

data/spec/dummy/app/models/address.rb

@@ -1,6 +1,6 @@
 class Address < ActiveRecord::Base
   lookup_for :city, strict: false
   lookup_for :state, symbolize: true
-  lookup_for :postal_code
+  lookup_for :postal_code, scope: false
   lookup_for :street
 end

data/spec/support/shared_examples_for_a_lookup.rb

@@ -3,24 +3,34 @@ shared_examples "a lookup" do
   it { should respond_to :lookup }
   it { should respond_to :lookup_by  }
   it { should respond_to :lookup_for }
+
   its(:is_a_lookup?) { should be_true }
 
+  it "raises with no args" do
+    expect { subject[] }.to raise_error ArgumentError
+  end
+
   it "returns nil for nil" do
     subject[nil].should be_nil
+    subject[nil, nil].should == [nil, nil]
   end
 
   it "returns nil for empty strings" do
     subject[""].should be_nil
+    subject["", ""].should == [nil, nil]
   end
 
   it "returns itself" do
-    first = subject.first
-    subject[first].should eq first if first
+    if first = subject.first
+      subject[first].should eq first
+      subject[first, first].should == [first, first]
+    end
   end
 
   it "rejects other argument types" do
-    [1.00, true, false, Address.new].each do |value|
-      expect { subject[value] }.to raise_error TypeError
+    [1.00, true, false, Rational(1), Address.new, Array.new, Hash.new].each do |value|
+      expect { subject[value] }.to        raise_error TypeError
+      expect { subject[value, value] }.to raise_error TypeError
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lookup_by
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Erik Peterson