offline_lookup 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a980e6edb149fd22cc7c81f2986ddac4e6ca27dc
-  data.tar.gz: dedadea949a7706a88188eb2bd0a03b31530ac34
+  metadata.gz: 3f2b36619ce0489bb3be9209e0c6f375d6ad7b7f
+  data.tar.gz: 2a8b0b21903a8010032c6f99b9cfa5cfb7b5069d
 SHA512:
-  metadata.gz: 1bd3263c95eb71ea8a2a5f511ee075a8a893eaf56f9aedf5c40b84c5addd49ad1230e2506270f407010c719391602e713e0ec8ea641585f3af134df3ecb63a9d
-  data.tar.gz: cdefda2de296628c482b77bd156b08213a1205d696674682524ba6e99cc3ceb1be595d50e1d280ad6fae148146e76ed7f91b1e20c6b2a80511454aadace64ac4
+  metadata.gz: b1e8325950ade06e5daeeece7c496d717c26412c7be90119395442ef69f8cbd03f78b9dff2e9e1afb04dbd64710b5c7439215dce37da6683ce81a3f18eead93a
+  data.tar.gz: bf7fa6108c54b9dc3946d6ead0338e56f4a0996db3aabd14d83c75dc682694118c060a8bd66b5bce289bccc45e01c8e677b2a2891b31635395ba27d73ae10978

data/README.md

@@ -138,6 +138,21 @@ end
 Admin.id_for_name("John Doe")
 ```
 
+You can also define your own method of generaing the lookup name using the `:transform` options. The default is to ust the field, or delimiter-concatentaed fields. To specify a transofmation, provide a lambda whose arguments are the fields being used by OfflineLookup
+
+```
+class Admin < ActiveRecord::Base
+  use_offline_lookup :lastname, transform: ->(lastname){"lookup_#{lastname}"}
+end
+```
+
+Or for multiple fields
+```
+class Admin < ActiveRecord::Base
+  use_offline_lookup :firstname, :lastname, transform: ->(first, last){"#{first.first}_#{last}"}
+end
+```
+
 ## Known Issues
 
 If two entries in the table have the same value in the specified field, all but one will get overwritten.

data/lib/offline_lookup/active_record.rb

@@ -3,7 +3,7 @@ module OfflineLookup
     extend ActiveSupport::Concern
 
     included do
-      after_create :get_offline_lookup_values
+      after_create :get_offline_lookup_values, :add_offline_lookup
       after_destroy :get_offline_lookup_values
     end
 
@@ -11,6 +11,15 @@ module OfflineLookup
       self.class.get_offline_lookup_values
     end
 
+    def offline_lookup_value
+      self.class.offline_lookup_value(*offline_lookup_options[:fields].map{|f| self.attributes[f.to_s]})
+    end
+
+    def add_offline_lookup
+      builder = OfflineLookup::Builder.new(self.class, self.offline_lookup_options)
+      builder.add_lookup(self.attributes[builder.key], offline_lookup_value)
+    end
+
     module ClassMethods
       def use_offline_lookup(*fields, key: "id", identity_methods: false, lookup_methods: false, compact: false, delimiter: " ", name: fields.join(delimiter), transform: nil)
         class_attribute :offline_lookup_values, :offline_lookup_options
@@ -30,13 +39,22 @@ module OfflineLookup
         include OfflineLookup::Base
       end
 
+      def offline_lookup_value(*fields)
+        if offline_lookup_options[:transform].present?
+          offline_lookup_options[:transform].call(*fields.map(&:to_s))
+        else
+          fields.map(&:to_s).join(offline_lookup_options[:delimiter])
+        end
+      end
+
       def get_offline_lookup_values
         self.offline_lookup_values = self.all.pluck(offline_lookup_options[:key], *offline_lookup_options[:fields]).map do |key, *fields|
           fields.compact! if offline_lookup_options[:compact]
           value = offline_lookup_options[:transform].present? ? offline_lookup_options[:transform].call(*fields.map(&:to_s)) : fields.map(&:to_s).join(offline_lookup_options[:delimiter])
-          [key, value]
+          [key, value.to_s]
         end.to_h.freeze
       end
+
     end
   end
 end

data/lib/offline_lookup/base.rb

@@ -3,52 +3,7 @@ module OfflineLookup
     extend ActiveSupport::Concern
 
     included do
-      builder = OfflineLookup::Builder.new(self.offline_lookup_options)
-
-      ### define value-named methods such as :two_hour_id and :two_hour?
-
-      self.offline_lookup_values.each do |key, value|
-        # class method: get key value (e.g. FooType.bar_id)
-        define_singleton_method(builder.key_method_name(value)) do
-          key
-        end
-
-        # instance method: true if instance is of named type (e.g. FooType.first.bar?)
-        if self.offline_lookup_options[:identity_methods]
-          define_method(builder.indentiy_method_name(value)) do
-            self.attributes[self.offline_lookup_options[:key]] == key
-          end
-        end
-
-        # class method: get instance by named method (e.g. FooType.bar)
-        # not "Offline", but lookup by indexed key. Also, synactic sugar.
-        if self.offline_lookup_options[:lookup_methods]
-          define_singleton_method(builder.lookup_method_name(value)) do
-            key = self.offline_lookup_values.find{|k, v| v.to_s == value.to_s}.try(:first)
-            find(key)
-          end
-        end
-
-        # class method: get instance using more general `lookup` method
-        # Just as not "offline" as above, but less dangerous / more robust to any db value
-        define_singleton_method :lookup do |value|
-          key = self.offline_lookup_values.find{|k, v| v.to_s == value.to_s}.try(:first)
-          find_by(id: key)
-        end
-      end
-  
-
-      ### define statically-named methods where you pass in the named value, e.g., id_for_name(:two_hour)
-      # e.g. FooType.name_for_id(1)
-      define_singleton_method(builder.field_for_key_method_name) do |key_value|
-        self.offline_lookup_values[key_value]
-      end
-
-      # e.g. FooType.id_for_name("Bar")
-      define_singleton_method(builder.key_for_field_method_name) do |field_value|
-        self.offline_lookup_values.find{|k, v| v.to_s == field_value.to_s}.try(:first)
-      end
-
+      OfflineLookup::Builder.new(self, self.offline_lookup_options).build
     end
   end
 end

data/lib/offline_lookup/builder.rb

@@ -1,15 +1,46 @@
 module OfflineLookup
   class Builder
-    def initialize(options)
+    attr_reader :fields, :key, :name
+    def initialize(model, options)
+      @model = model
       @fields = options[:fields]
       @key = options[:key]
       @name = options[:name]
+      @build_identity_methods = options[:identity_methods]
+      @build_lookup_methods = options[:lookup_methods]
+      @modyule = get_module || create_module
+    end
+
+    def get_module
+      @model.const_defined?("OfflineLookupMethods") && @model::OfflineLookupMethods
+    end
+
+    def create_module
+      @modyule = Module.new
+      @modyule.extend ActiveSupport::Concern
+      @modyule.const_set("ClassMethods", Module.new)
+      @model.const_set("OfflineLookupMethods", @modyule)
+    end
+
+    def build
+      @model.offline_lookup_values.each do |key, value|
+        add_lookup(key, value)
+      end
+      add_name_for_key_method
+      add_key_for_name_method
+      add_static_lookup_method
+      @model.include @modyule
+    end
+
+    def add_lookup(key, value)
+      add_key_lookup_method(key, value)
+      add_identity_method(key, value) if @build_identity_methods
+      add_lookup_method(key, value) if @build_lookup_methods
     end
 
     def sanitize(string)
-      #:methodize went away. Where did it go?
       #1. Replace illegal chars and _ boundaries with " " boundary
-      string = string.gsub(/[^a-zA-Z\d]+/," ").strip
+      string = string.to_s.gsub(/[^a-zA-Z\d]+/," ").strip
       #2. Insert " " boundary at snake-case boundaries
       string.gsub!(/([a-z])([A-Z])/){|s| "#{$1} #{$2}"}
       #3. underscore
@@ -20,28 +51,58 @@ module OfflineLookup
       return string
     end
 
-    # e.g., :two_hour_id
-    def key_method_name(value)
-      sanitize "#{value}_#{@key}"
+    # Get key value (e.g. FooType.bar_id)
+    def add_key_lookup_method(key, value)
+      @modyule::ClassMethods.instance_exec(self, key, value) do |builder, key, value|
+        define_method builder.sanitize("#{value}_#{builder.key}") do
+          key
+        end
+      end
+    end
+
+    # Return true iff instance is of named type (e.g. FooType.first.bar?)
+    def add_identity_method(key, value)
+      @modyule.instance_exec(self, key, value) do |builder, key, value|
+        define_method builder.sanitize(value) + "?" do
+          self.attributes[builder.key] == key
+        end
+      end
     end
 
-    def lookup_method_name(value)
-      sanitize value.to_s
+    # Get instance by named method (e.g. FooType.bar) (Not offline, but syntactic sugar)
+    def add_lookup_method(key, value)
+      @modyule::ClassMethods.instance_exec(self, key, value) do |builder, key, value|
+        define_method builder.sanitize(value) do
+          find_by(builder.key => self.offline_lookup_values.key(value.to_s))
+        end
+      end
     end
 
-    # e.g., :two_hour?
-    def indentiy_method_name(value)
-      lookup_method_name(value) + "?"
+    # e.g. FooType.name_for_id(1)
+    def add_name_for_key_method
+      @modyule::ClassMethods.instance_exec(self) do |builder|
+        define_method builder.sanitize("#{builder.name}_for_#{builder.key}") do |key|
+          self.offline_lookup_values[key]
+        end
+      end
     end
 
-    # e.g. :name_for_id(id)
-    def field_for_key_method_name
-      sanitize "#{@name}_for_#{@key}"
+    # e.g. FooType.id_for_name("Bar")
+    def add_key_for_name_method
+      @modyule::ClassMethods.instance_exec(self) do |builder|
+        define_method builder.sanitize("#{builder.key}_for_#{builder.name}") do |value|
+          self.offline_lookup_values.key(value.to_s)
+        end
+      end
     end
 
-    # e.g. :id_for_name(name)
-    def key_for_field_method_name
-      sanitize "#{@key}_for_#{@name}"
+    # e.g. FooType.lookup("Bar")
+    def add_static_lookup_method
+      @modyule::ClassMethods.instance_exec(self) do |builder|
+        define_method "lookup" do |value|
+          find_by(builder.key => self.offline_lookup_values.key(value.to_s))
+        end
+      end
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: offline_lookup
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Schwartz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-19 00:00:00.000000000 Z
+date: 2016-09-20 00:00:00.000000000 Z
 dependencies: []
 description: Offline indexing of small tables syntactic sugar & less db touching
 email: ozydingo@gmail.com