slugable 0.0.4 → 1.0.0

data/gemfiles/activerecord_3.2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 3.2.1"
+gem "ancestry", "~> 1.3.0"
+gem "test-unit", "~> 3.0"
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.0.1"
+gem "ancestry", "~> 2.1.0"
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1.1"
+gem "ancestry", "~> 2.1.0"
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.2.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.1"
+gem "ancestry", "~> 2.1.0"
+
+gemspec :path => "../"

data/lib/slugable.rb

@@ -1,6 +1,10 @@
-require "active_record"
-require "active_support"
-require "wnm_support"
-require "slugable/version"
-require "slugable/has_slug"
-require "slugable/railtie" if defined?(Rails)
+require 'active_record'
+require 'active_support'
+require 'slugable/version'
+require 'slugable/has_slug'
+require 'slugable/formatter/parameterize'
+require 'slugable/slug_builder/flat'
+require 'slugable/slug_builder/tree_ancestry'
+require 'slugable/slug_builder/caching_tree_ancestry'
+require 'slugable/cache_layer'
+require 'slugable/railtie' if defined?(Rails)

data/lib/slugable/cache_layer.rb

@@ -0,0 +1,24 @@
+module Slugable
+  class CacheLayer
+    attr_reader :storage, :model
+
+    def initialize(storage, model)
+      @storage = storage
+      @model = model
+    end
+
+    def read_slug(slug_column, id)
+      storage.fetch(cache_key(slug_column, id)) { model.find(id).public_send(slug_column) }
+    end
+
+    def update(slug_column, id, value)
+      storage.write(cache_key(slug_column, id), value)
+    end
+
+    private
+
+    def cache_key(slug_column, id)
+      "#{model.to_s.underscore}/#{slug_column}/#{id}"
+    end
+  end
+end

data/lib/slugable/formatter/parameterize.rb

@@ -0,0 +1,9 @@
+module Slugable
+  module Formatter
+    class Parameterize
+      def self.call(string)
+        string.parameterize
+      end
+    end
+  end
+end

data/lib/slugable/has_slug.rb

@@ -1,4 +1,21 @@
 module Slugable
+  Configuration = Struct.new(:formatter, :tree_cache_storage) do
+    def initialize(params)
+      params.each { |key, value| public_send(:"#{key}=", value) }
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new(
+        formatter:          Slugable::Formatter::Parameterize,
+        tree_cache_storage: nil
+    )
+  end
+
+  def self.configure
+    yield configuration
+  end
+
   module HasSlug
     #
     # USAGE
@@ -8,184 +25,98 @@ module Slugable
     # it also generate method to_slug (depanding od :to param), which generate slug url for link_path
     #
     # has_slug                                # generate to_slug
-    # has_slug :from => :title                # generate to_slug
-    # has_slug :to => :seo_url                # generate to_url
-    # has_slug :from => :name, :to => :slug   # generate to_slug
+    # has_slug from: :title                # generate to_slug
+    # has_slug to: :seo_url                # generate to_url
+    # has_slug from: :name, to: :slug   # generate to_slug
     #
-    def has_slug(options={})
-      defaults = {:from => :name, :to => :slug, :formatter => :parameterize, :cache_tree => true}
-      options.reverse_merge!(defaults)
-      from = options.delete(:from)
-      to = options.delete(:to)
-      formatter = options.delete(:formatter)
-      cache_tree = options.delete(:cache_tree)
-      before_save :"fill_slug_from_#{from}_to_#{to}", :"format_slug_from_#{from}_to_#{to}"
-      after_save :"update_my_#{to}_cache"
-
-      # generate this
-      #
-      # def fill_slug
-      #   self.slug = name if slug.blank? || slug.parameterize.blank?
-      # end
-      code =<<-method
-        def fill_slug_from_#{from}_to_#{to}
-          self.#{to} = #{from} if #{to}.blank? || #{to}.parameterize.blank?
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def format_slug
-      #   self.slug = slug.parameterize
-      # end
-      code =<<-method
-        def format_slug_from_#{from}_to_#{to}
-          self.#{to} = #{to}.send(:#{formatter})
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      # def update_my_slug_cache
-      #  @@all ||= {}
-      #  @@all[id] = send(:slug)
-      # end
-      code =<<-method
-        def update_my_#{to}_cache
-          @@all ||= {}
-          @@all[id] = send(:#{to})
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def self.all_slugs
-      #  slug_column = :slug
-      #  @@all ||= self.all.map_to_hash{|slug_element| {slug_element.id => slug_element.send(slug_column)}}
-      # end
-      code =<<-method
-        def self.all_#{to}s
-          @@all ||= self.all.map_to_hash{|slug_element| {slug_element.id => slug_element.send(:#{to})}}
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def self.clear_cached_slugs
-      #  @@all = nil
-      # end
-      code =<<-method
-        def self.clear_cached_#{to}s
-          @@all = nil
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def self.cached_slug(id)
-      #  all_slugs[id]
-      # end
-      code =<<-method
-        def self.cached_#{to}(id)
-          all_#{to}s[id].to_s
+    def has_slug(options = {})
+      MethodBuilder.build(self, options)
+    end
+
+    class MethodBuilder
+      def self.default_options
+        {
+            from:               :name,
+            to:                 :slug,
+            formatter:          Slugable.configuration.formatter,
+            tree_cache_storage: Slugable.configuration.tree_cache_storage,
+            to_slug_builder:    nil,
+        }
+      end
+
+      def self.build(model, options)
+        options             = options.reverse_merge(default_options)
+
+        from                = options.delete(:from)
+        to                  = options.delete(:to)
+        formatter           = options.delete(:formatter)
+        tree_cache_storage  = options.delete(:tree_cache_storage)
+        to_slug_builder     = options.delete(:to_slug_builder)
+
+        cache_layer         = nil
+        if tree_cache_storage
+          cache_layer = Slugable::CacheLayer.new(tree_cache_storage, model)
+          builder_options = {
+              slug_column: to,
+              formatter:   formatter,
+              cache:       cache_layer
+          }
+        else
+          builder_options = {
+              slug_column: to,
+              formatter:   formatter,
+          }
         end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def to_slug
-      #  if respond_to?(:path_ids)
-      #    slugs = if true
-      #      path_ids.map{|id| self.class.cached_slug(id)}.compact.select{|i| i.size > 0 }
-      #    else
-      #      path.map{|record| record.send(:"slug")}.compact.select{|i| i.size > 0 }
-      #    end
-      #    slugs.empty? ? "" : slugs
-      #  else
-      #    send(:slug)
-      #  end
-      # end
-      code =<<-method
-        def to_#{to}
-          if respond_to?(:path_ids)
-            slugs = if #{cache_tree}
-              path_ids.map{|id| self.class.cached_#{to}(id)}.compact.select{|i| i.size > 0 }
+
+        if to_slug_builder.nil?
+          builder = Slugable::SlugBuilder::Flat
+
+          if model.respond_to?(:ancestry_column)
+            if cache_layer
+              builder = Slugable::SlugBuilder::CachingTreeAncestry
             else
-              path.map{|record| record.send(:"#{to}")}.compact.select{|i| i.size > 0 }
+              builder = Slugable::SlugBuilder::TreeAncestry
             end
-            slugs.empty? ? "" : slugs
-          else
-            send(:#{to})
           end
+          to_slug_builder = builder.new(builder_options)
         end
-      method
-      class_eval(code)
-
-
-      # generate this
-      #
-      # def to_slug_was
-      #  if respond_to?(:ancestry_was)
-      #    old_slugs = if true
-      #      ancestry_was.to_s.split("/").map { |ancestor_id| self.class.cached_slug(ancestor_id.to_i) }
-      #    else
-      #      ancestry_was.to_s.split("/").map { |ancestor_id| self.class.find(ancestor_id).send(:slug) }
-      #    end
-      #    old_slugs << send(:slug_was)
-      #  else
-      #    send(:slug_was)
-      #  end
-      # end
-      code =<<-method
-        def to_#{to}_was
-          if respond_to?(:ancestry_was)
-            old_slugs = if #{cache_tree}
-              ancestry_was.to_s.split("/").map { |ancestor_id| self.class.cached_#{to}(ancestor_id.to_i) }
-            else
-              ancestry_was.to_s.split("/").map { |ancestor_id| self.class.find(ancestor_id).send(:#{to}) }
+
+        model.class_eval do
+          before_save :"prepare_slug_in_#{to}"
+          if cache_layer
+            after_save :"update_my_#{to}_cache"
+          end
+
+          define_method :"slug_builder_for_#{to}" do
+            to_slug_builder
+          end
+
+          define_method :"prepare_slug_in_#{to}" do
+            if public_send(to).blank? || formatter.call(public_send(to)).blank?
+              public_send(:"#{to}=", public_send(from))
             end
-            old_slugs << send(:#{to}_was)
-          else
-            send(:#{to}_was)
+            public_send(:"#{to}=", formatter.call(public_send(to)))
           end
-        end
-      method
-      class_eval(code)
-
-      # generate this
-      #
-      # def to_slug_will
-      #  if respond_to?(:ancestry)
-      #    old_slugs = if true
-      #      ancestry.to_s.split("/").map { |ancestor_id| self.class.cached_slug(ancestor_id.to_i) }
-      #    else
-      #      ancestry.to_s.split("/").map { |ancestor_id| self.class.find(ancestor_id).send(:slug) }
-      #    end
-      #    old_slugs << send(:slug)
-      #  else
-      #    send(:slug_was)
-      #  end
-      # end
-      code =<<-method
-          def to_#{to}_will
-            if respond_to?(:ancestry)
-              new_slugs = if #{cache_tree}
-                ancestry.to_s.split("/").map { |ancestor_id| self.class.cached_#{to}(ancestor_id.to_i) }
-              else
-                ancestry.to_s.split("/").map { |ancestor_id| self.class.find(ancestor_id).send(:#{to}) }
-              end
-              new_slugs << send(:#{to}).send(:#{formatter})
-            else
-              send(:#{to}).send(:#{formatter})
+
+          define_method :"to_#{to}" do
+            public_send(:"slug_builder_for_#{to}").to_slug(self)
+          end
+
+          define_method :"to_#{to}_was" do
+            public_send(:"slug_builder_for_#{to}").to_slug_was(self)
+          end
+
+          define_method :"to_#{to}_will" do
+            public_send(:"slug_builder_for_#{to}").to_slug_will(self)
+          end
+
+          if cache_layer
+            define_method :"update_my_#{to}_cache" do
+              cache_layer.update(to, id, public_send(to))
             end
           end
-      method
-      class_eval(code)
+        end
+      end
     end
   end
 end

data/lib/slugable/railtie.rb

@@ -1,6 +1,6 @@
 module Slugable
   class Railtie < Rails::Railtie
-    initializer "slugable.active_record_ext" do
+    initializer 'slugable.active_record_ext' do
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.send :extend, Slugable::HasSlug
       end

data/lib/slugable/slug_builder/caching_tree_ancestry.rb

@@ -0,0 +1,16 @@
+module Slugable
+  module SlugBuilder
+    class CachingTreeAncestry < TreeAncestry
+      attr_reader :cache
+
+      def initialize(options)
+        super
+        @cache = options.fetch(:cache)
+      end
+
+      def to_slug(record)
+        record.path_ids.map{ |id| cache.read_slug(slug_column, id) }.select(&:present?)
+      end
+    end
+  end
+end

data/lib/slugable/slug_builder/flat.rb

@@ -0,0 +1,24 @@
+module Slugable
+  module SlugBuilder
+    class Flat
+      attr_reader :slug_column, :formatter
+
+      def initialize(options)
+        @slug_column = options.fetch(:slug_column)
+        @formatter = options.fetch(:formatter)
+      end
+
+      def to_slug(record)
+        record.public_send(slug_column)
+      end
+
+      def to_slug_was(record)
+        record.public_send(:"#{slug_column}_was")
+      end
+
+      def to_slug_will(record)
+        formatter.call(record.public_send(slug_column))
+      end
+    end
+  end
+end

data/lib/slugable/slug_builder/tree_ancestry.rb

@@ -0,0 +1,28 @@
+module Slugable
+  module SlugBuilder
+    class TreeAncestry
+      attr_reader :slug_column, :formatter
+
+      def initialize(options)
+        @slug_column = options.fetch(:slug_column)
+        @formatter = options.fetch(:formatter)
+      end
+
+      def to_slug(record)
+        record.path.map{ |path_record| path_record.public_send(slug_column) }.select(&:present?)
+      end
+
+      def to_slug_was(record)
+        old_slugs = record.ancestry_was.to_s.split('/').map { |ancestor_id| record.class.find(ancestor_id).public_send(slug_column) }
+        old_slugs << record.public_send(:"#{slug_column}_was")
+        old_slugs
+      end
+
+      def to_slug_will(record)
+        new_slugs = record.ancestry.to_s.split('/').map { |ancestor_id| record.class.find(ancestor_id).public_send(slug_column) }
+        new_slugs << formatter.call(record.public_send(slug_column))
+        new_slugs
+      end
+    end
+  end
+end