offline_lookup 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f2b36619ce0489bb3be9209e0c6f375d6ad7b7f
-  data.tar.gz: 2a8b0b21903a8010032c6f99b9cfa5cfb7b5069d
+  metadata.gz: 9df8ec8a2ac9076d35a4965141e8f7ddd64ef41e
+  data.tar.gz: cf5881b25c71c21378b012024dd6f9615264f5bb
 SHA512:
-  metadata.gz: b1e8325950ade06e5daeeece7c496d717c26412c7be90119395442ef69f8cbd03f78b9dff2e9e1afb04dbd64710b5c7439215dce37da6683ce81a3f18eead93a
-  data.tar.gz: bf7fa6108c54b9dc3946d6ead0338e56f4a0996db3aabd14d83c75dc682694118c060a8bd66b5bce289bccc45e01c8e677b2a2891b31635395ba27d73ae10978
+  metadata.gz: 0183aafc5868444dfe5d8452f43c65e02cd0ceee4abc50b93ac87ad9526d6ac376046576d83a4270e1fbcb9c68c9f6bc7aa34f783c30ad940db6f3e1cb9baa3b
+  data.tar.gz: a3ba577eb3860d3b906fe87984d003f4004b1c8495978695fba245f4637e8831b120e75df38a510154f40375d20282d6e881c95315781bf83660e9ed4c9fb68e

data/README.md

@@ -31,6 +31,11 @@ Add `lookup` method to allow lookup by key'd name without risking bad / reserved
 
 You can now specify multiple columns for lookup! The values are by default joined with a " " (note this translates to "_" for method names). You can configure this delimiter and what to do with `nil` values.
 
+v1.1.0
+I forget. Probably a big bugfix.
+
+v1.2.0
+Definitely a big bugfix. The core OfflineLookup module was getting included in all of ActiveRecord, which mistakenly included callback methods that depended on the existence of `self.offline_lookup_options`. This has been fixed and this behavior is now only exhibited on models that explicitly call `use_offline_lookup`
 
 
 ## How To Use It

data/lib/offline_lookup.rb

@@ -2,7 +2,7 @@
 # TODO: support scope arg in use_offline_lookup (partial index)
 
 require 'offline_lookup/active_record.rb'
-require 'offline_lookup/base.rb'
-require 'offline_lookup/builder.rb'
+require 'offline_lookup/core.rb'
+require 'offline_lookup/dynamic_module_builder.rb'
 
 ActiveRecord::Base.include OfflineLookup::ActiveRecord

data/lib/offline_lookup/active_record.rb

@@ -2,27 +2,9 @@ module OfflineLookup
   module ActiveRecord
     extend ActiveSupport::Concern
 
-    included do
-      after_create :get_offline_lookup_values, :add_offline_lookup
-      after_destroy :get_offline_lookup_values
-    end
-
-    def get_offline_lookup_values
-      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
+        class_attribute :offline_lookup_options
         self.offline_lookup_options = {
           fields: fields.map(&:to_s),
           key: key.to_s,
@@ -32,29 +14,10 @@ module OfflineLookup
           delimiter: delimiter.to_s,
           name: name,
           transform: transform
-        }.freeze
-
-        get_offline_lookup_values
-
-        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
+        }
+        include OfflineLookup::Core
+        include OfflineLookup::DynamicModuleBuilder.new(self, self.offline_lookup_options).build_module
       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.to_s]
-        end.to_h.freeze
-      end
-
     end
   end
 end

data/lib/offline_lookup/core.rb

@@ -0,0 +1,44 @@
+module OfflineLookup
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :offline_lookup_values
+      self.offline_lookup_values = get_offline_lookup_values
+
+      after_create :set_class_offline_lookup_values, :add_to_offline_lookup
+      after_destroy :set_class_offline_lookup_values
+    end
+
+    module ClassMethods
+      def offline_lookup_value(*field_values)
+        field_values.compact! if offline_lookup_options[:compact]
+        if offline_lookup_options[:transform].present?
+          offline_lookup_options[:transform].call(*field_values.map(&:to_s))
+        else
+          field_values.map(&:to_s).join(offline_lookup_options[:delimiter])
+        end
+      end
+
+      def get_offline_lookup_values
+        self.all.pluck(offline_lookup_options[:key], *offline_lookup_options[:fields]).map do |key_value, *field_values|
+          [key_value, offline_lookup_value(*field_values)]
+        end.to_h.freeze
+      end
+    end
+
+    def set_class_offline_lookup_values
+      self.class.offline_lookup_values = 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_to_offline_lookup
+      builder = OfflineLookup::DynamicModuleBuilder.new(self.class, self.offline_lookup_options)
+      builder.add_dynamic_lookup_methods(self.attributes[self.offline_lookup_options[:key]], offline_lookup_value)
+    end
+
+  end
+end

data/lib/offline_lookup/dynamic_module_builder.rb

@@ -0,0 +1,115 @@
+module OfflineLookup
+  class DynamicModuleBuilder
+    def initialize(model, options)
+      @model = model
+      @fields = options[:fields].map(&:to_s)
+      @key_name = 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)
+      return modyule
+    end
+
+    def build_module
+      add_all_dynamic_lookups
+      add_name_for_key_method
+      add_key_for_name_method
+      add_static_lookup_method
+      return @modyule
+    end
+
+    def add_all_dynamic_lookups
+      @model.offline_lookup_values.each{|key_value, value| add_dynamic_lookup_methods(key_value, value)}
+    end
+
+    def add_dynamic_lookup_methods(key_value, value)
+      add_key_lookup_method(key_value, value)
+      add_identity_method(key_value, value) if @build_identity_methods
+      add_lookup_method(key_value, value) if @build_lookup_methods
+    end
+
+    # Get key value (e.g. FooType.bar_id)
+    def add_key_lookup_method(key_value, value)
+      key_lookup_method_name = sanitize("#{value}_#{@key_name}")
+      @modyule::ClassMethods.instance_exec(key_lookup_method_name, key_value, value) do |method_name, key_value|
+        define_method method_name do
+          key_value
+        end
+      end
+    end
+
+    # Return true iff instance is of named type (e.g. FooType.first.bar?)
+    def add_identity_method(key_value, value)
+      identify_method_name = sanitize(value) + "?"
+      @modyule.instance_exec(identify_method_name, @key_name, key_value) do |method_name, key_name, key_value|
+        define_method method_name do
+          self.attributes[key_name] == key_value
+        end
+      end
+    end
+
+    # Get instance by named method (e.g. FooType.bar) (Not offline, but syntactic sugar)
+    def add_lookup_method(key_value, value)
+      lookup_method_name = sanitize(value)
+      @modyule::ClassMethods.instance_exec(lookup_method_name, @key_name, key_value, value) do |method_name, key_name, key_value|
+        define_method method_name do
+          find_by(key_name => key_value)
+        end
+      end
+    end
+
+    # e.g. FooType.name_for_id(1)
+    def add_name_for_key_method
+      method_name = sanitize("#{@name}_for_#{@key_name}")
+      @modyule::ClassMethods.instance_exec(method_name) do |method_name|
+        define_method method_name do |key|
+          self.offline_lookup_values[key]
+        end
+      end
+    end
+
+    # e.g. FooType.id_for_name("Bar")
+    def add_key_for_name_method
+      method_name = sanitize("#{@key_name}_for_#{@name}")
+      @modyule::ClassMethods.instance_exec(method_name) do |method_name|
+        define_method method_name do |value|
+          self.offline_lookup_values.key(value.to_s)
+        end
+      end
+    end
+
+    # e.g. FooType.lookup("Bar")
+    def add_static_lookup_method
+      @modyule::ClassMethods.instance_exec(@key_name) do |key_name|
+        define_method "lookup" do |value|
+          find_by(key_name => self.offline_lookup_values.key(value.to_s))
+        end
+      end
+    end
+
+    def sanitize(string)
+      #1. Replace illegal chars and _ boundaries with " " boundary
+      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
+      string.gsub!(/\s+/, "_")
+      string.downcase!
+      #4. Append underscore if name begins with digit
+      string = "_#{string}" if string.length == 0 || string[0] =~ /\d/
+      return string
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: offline_lookup
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrew Schwartz
@@ -19,9 +19,9 @@ files:
 - README.md
 - lib/offline_lookup.rb
 - lib/offline_lookup/active_record.rb
-- lib/offline_lookup/base.rb
-- lib/offline_lookup/builder.rb
-homepage: 
+- lib/offline_lookup/core.rb
+- lib/offline_lookup/dynamic_module_builder.rb
+homepage: http://github.com/ozydingo/offline_lookup
 licenses:
 - MIT
 metadata: {}

data/lib/offline_lookup/base.rb

@@ -1,9 +0,0 @@
-module OfflineLookup
-  module Base
-    extend ActiveSupport::Concern
-
-    included do
-      OfflineLookup::Builder.new(self, self.offline_lookup_options).build
-    end
-  end
-end

data/lib/offline_lookup/builder.rb

@@ -1,109 +0,0 @@
-module OfflineLookup
-  class Builder
-    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)
-      #1. Replace illegal chars and _ boundaries with " " boundary
-      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
-      string.gsub!(/\s+/, "_")
-      string.downcase!
-      #4. Append underscore if name begins with digit
-      string = "_#{string}" if string.length == 0 || string[0] =~ /\d/
-      return string
-    end
-
-    # 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
-
-    # 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. 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. 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. 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
-end