bucket_maker 0.0.1

data/lib/bucket_maker/engine.rb

@@ -0,0 +1,13 @@
+module BucketMaker
+  class Engine < Rails::Engine
+    initializer 'Require concerns path' do |app|
+      concerns_path = 'app/controllers/concerns'
+
+      unless app.paths.keys.include?(concerns_path)
+        app.paths.add(concerns_path)
+      end
+
+      require 'concerns/bucket_maker_concern'
+    end
+  end
+end

data/lib/bucket_maker/models/active_recordable.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+require 'bucket_maker/models/bucketable'
+
+module BucketMaker
+  module Models
+    module ActiveRecordable
+      extend ActiveSupport::Concern
+
+      included do
+        if BucketMaker.configured?
+          send(:include, InstanceMethods)
+
+          has_many :buckets, as: :bucketable
+
+          after_create :bucketize unless BucketMaker.configuration.lazy_load
+        end
+      end
+
+      module InstanceMethods
+        include BucketMaker::Models::Bucketable
+
+        def group_for_key(series_key)
+          if b = buckets.select('group_name').where(series_key: series_key).take
+            b.group_name
+          end
+        end
+
+        def set_group_for_key(series_key, group_name)
+          buckets.where(series_key: series_key, group_name: group_name).first_or_create
+          true
+        end
+      end
+    end
+  end
+end

data/lib/bucket_maker/models/bucketable.rb

@@ -0,0 +1,92 @@
+require 'bucket_maker/series_maker'
+
+module BucketMaker
+  module Models
+    module Bucketable
+      def in_bucket?(series_name, bucket_name, group_name, force=false)
+        # Get the singleton Series Maker
+        series_maker = BucketMaker::SeriesMaker.instance
+
+        # Check if the parameters are valid
+        if series_maker.bucketable?(self, series_name, bucket_name, group_name)
+          # The Key is generated by the Series Maker
+          series_key = series_maker.key_for_series(self, series_name, bucket_name)
+
+          # Get the Group if created before from Persisted Storage
+          saved_group = group_for_key(series_key)
+
+          # If its a forced operation then set the Group to the parameter given
+          if force
+            set_group_for_key(series_key, group_name) if saved_group != group_name.to_s
+            # Always return true for set
+            true
+          else
+            # Lazy Load ??
+            # If there is no Group then its lazy load/create time !
+            unless saved_group
+              # Get the random group for this instance
+              saved_group = series_maker.bucketize(series_name, bucket_name)
+              # Set the Group in Persisted Storage
+              set_group_for_key(series_key, saved_group)
+            end
+
+            # return if its the same bucket as requested
+            saved_group == group_name.to_s
+          end
+        else
+          # return false if invalid parameters
+          false
+        end
+      end
+
+      def not_in_bucket?(series_name, bucket_name, group_name)
+        !in_bucket?(series_name, bucket_name, group_name)
+      end
+
+      def force_to_bucket!(series_name, bucket_name, group_name)
+        # Forcefully place inside the bucket
+        in_bucket?(series_name, bucket_name, group_name, true)
+      end
+
+      def bucketize!
+        # Take each series and bucket
+        BucketMaker::SeriesMaker.instance.for_each_series_with_bucketable do |series_maker, series_name, bucket_name|
+          # Randomize
+          group_name = series_maker.bucketize(series_name, bucket_name)
+          # Get the series key
+          series_key = series_maker.key_for_series(self, series_name, bucket_name)
+          # Set the key
+          set_group_for_key(series_key, group_name)
+          true
+        end
+      end
+
+      def bucketize_for_series_and_bucket!(series_name, bucket_name)
+        # Get the singleton Series Maker
+        series_maker = BucketMaker::SeriesMaker.instance
+        if series_maker.has_bucket_in_series?(series_name, bucket_name)
+          # Randomize
+          group_name = series_maker.bucketize(series_name, bucket_name)
+          # Get the series key
+          series_key = series_maker.key_for_series(self, series_name, bucket_name)
+          # Set the key
+          set_group_for_key(series_key, group_name)
+          true
+        else
+          false
+        end
+      end
+
+      def group_for_key(series_key)
+        raise NotImplementedError, "Implement group_for_key"
+      end
+
+      def set_group_for_key(series_key, group_name)
+        raise NotImplementedError, "Implement set_group_for_key"
+      end
+
+      private :group_for_key, :set_group_for_key
+
+    end
+  end
+end

data/lib/bucket_maker/models/redisable.rb

@@ -0,0 +1,59 @@
+require 'active_support/concern'
+require 'bucket_maker/models/bucketable'
+
+module BucketMaker
+  module Models
+    module Redisable
+      extend ActiveSupport::Concern
+
+      included do
+        if BucketMaker.configured?
+          extend ClassMethods
+
+          send(:include, InstanceMethods)
+
+          after_create :bucketize unless BucketMaker.configuration.lazy_load
+          restart_for_disconnect_in_passenger
+        end
+      end
+
+      module InstanceMethods
+        include BucketMaker::Models::Bucketable
+
+        def group_for_key(series_key)
+          self.class.redis.get(series_key)
+        end
+
+        def set_group_for_key(series_key, group_name)
+          self.class.redis.setex(series_key, BucketMaker.configuration.redis_expiration_time, group_name)
+        end
+      end
+
+      module ClassMethods
+
+        def redis
+          @redis || connect_redis
+        end
+
+        def connect_redis
+          disconnect_redis
+          @redis ||= Redis.new(BucketMaker.configuration.redis_options)
+        end
+
+        def disconnect_redis
+          @redis.disconnect if @redis
+        ensure
+          @redis = nil
+        end
+
+        def restart_for_disconnect_in_passenger
+          PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            disconnect_redis if forked # We're in smart spawning mode
+          end if defined?(PhusionPassenger)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bucket_maker/series.rb

@@ -0,0 +1,48 @@
+module BucketMaker
+  class Series
+    attr_reader :name,
+                :description,
+                :created_after,
+                :buckets
+
+    SERIES_DESCRIPTION  = 'description'
+    SERIES_USER_AFTER   = 'created_after'
+    SERIES_BUCKETS      = 'buckets'
+
+    def initialize(name, options={})
+      @name = name.to_sym
+      @description = options[SERIES_DESCRIPTION] || ''
+      @created_after =  if options[SERIES_USER_AFTER]
+                                DateTime.parse(options[SERIES_USER_AFTER])
+                              else
+                                DateTime.parse("1st Jan 1900")
+                              end
+      @buckets =  options[SERIES_BUCKETS].inject({}) do |result, (bucket_name, bucket_options)|
+                    result[bucket_name.to_sym] = BucketMaker::Bucket.new(bucket_name, bucket_options)
+                    result
+                  end if options[SERIES_BUCKETS]
+    end
+
+    def each_bucket
+      @buckets.each do |bucket_name, bucket|
+        yield bucket_name, bucket
+      end if block_given?
+    end
+
+    def bucket_with_name(bucket_name)
+      @buckets[bucket_name.to_sym]
+    end
+
+    def is_bucketable?(bucketable)
+      bucketable.created_at >= @created_after
+    end
+
+    def has_bucket?(bucket_name)
+      @buckets[bucket_name.to_sym] != nil
+    end
+
+    def has_group_in_bucket?(bucket_name, group_name)
+      has_bucket?(bucket_name) && @buckets[bucket_name.to_sym].has_group?(group_name)
+    end
+  end
+end

data/lib/bucket_maker/series_maker.rb

@@ -0,0 +1,80 @@
+require 'singleton'
+require 'active_support/inflector'
+require 'bucket_maker/series'
+require 'bucket_maker/bucket'
+
+module BucketMaker
+  class SeriesMaker
+    include Singleton
+
+    attr_accessor :series
+
+    attr_reader :configuration
+
+    BUCKET_ROOT = 'series'
+
+    def make!(config)
+      @series = []
+
+      absolute_config_path = Rails.root + config
+
+      if File.exists?(absolute_config_path)
+        @configuration = YAML.load_file(absolute_config_path)
+
+        @series = @configuration[BUCKET_ROOT].inject({}) do |result, (series_name, series_options)|
+                    result[series_name.to_sym] = BucketMaker::Series.new(series_name, series_options)
+                    result
+                  end if @configuration && @configuration[BUCKET_ROOT]
+      end
+    end
+
+    def configured?
+      @configuration != nil
+    end
+
+    def for_each_series_with_bucketable
+      @series.collect do |series_name, series|
+        series.each_bucket do |bucket_name, bucket|
+          yield self, series_name, bucket_name
+        end
+      end.inject(true) {|result, value| result && value } if block_given?
+    end
+
+    def series_with_name(series_name)
+      @series[series_name.to_sym]
+    end
+
+    def has_series?(series_name)
+      @series[series_name.to_sym] != nil
+    end
+
+    def has_bucket_in_series?(series_name, bucket_name)
+      has_series?(series_name) && series_with_name(series_name).has_bucket?(bucket_name)
+    end
+
+    def has_group_in_bucket_in_series?(series_name, bucket_name, group_name)
+      has_bucket_in_series?(series_name, bucket_name) &&
+      series_with_name(series_name).bucket_with_name(bucket_name).has_group?(group_name)
+    end
+
+    def key_for_series(bucketable, series_name, bucket_name)
+      "bucket_maker:#{bucketable.class.to_s.underscore}_#{bucketable.id}:#{series_name.to_s}:#{bucket_name.to_s}" if bucketable && bucketable.id
+    end
+
+    def bucketize(series_name, bucket_name)
+      series_with_name(series_name).bucket_with_name(bucket_name).random_group
+    end
+
+    def bucketable?(bucketable, series_name, bucket_name, group_name)
+      if  bucketable.has_attribute?(:created_at) &&
+          has_group_in_bucket_in_series?(series_name, bucket_name, group_name)
+
+        series_with_name(series_name).bucket_with_name(bucket_name).is_bucketable?(bucketable) ||
+        series_with_name(series_name).is_bucketable?(bucketable)
+
+      else
+        false
+      end
+    end
+  end
+end

data/lib/bucket_maker/version.rb

@@ -0,0 +1,3 @@
+module BucketMaker
+  VERSION = "0.0.1"
+end

data/lib/generators/active_record/bucket_maker_generator.rb

@@ -0,0 +1,90 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class BucketMakerGenerator < ActiveRecord::Generators::Base
+
+      ACTIVE_RECORDABLE = 'bucket'
+
+      source_root File.expand_path("../../templates", __FILE__)
+      argument :store_in, type: :string, default: 'redis'
+
+      def generate_model
+        invoke "active_record:model", [name], :migration => false unless model_exists? && behavior == :invoke
+        if store_in == 'active_record'
+          invoke "active_record:model", [ACTIVE_RECORDABLE], :migration => false unless active_recordable_exists? && behavior == :invoke
+        end
+      end
+
+      def inject_bucket_maker_content
+        contents = <<-CONTENT.strip_heredoc
+          # Module Inclusion for BucketMaker
+          # The options are
+          # - BucketMaker::Models::Redisable
+          #
+          include #{module_name_for_include}
+
+        CONTENT
+
+        klass_path =  if namespaced?
+                        class_name.to_s.split("::")
+                      else
+                        [class_name]
+                      end
+
+        indent_depth = klass_path.size
+        contents = contents.split("\n").map { |line| " " * indent_depth + line } .join("\n") << "\n\n"
+
+        inject_into_class(model_path, klass_path.last, contents) if model_exists?
+
+        inject_for_active_recordable if store_in == 'active_record' && active_recordable_exists?
+      end
+
+      def inject_for_active_recordable
+        ar_contents = <<-CONTENT.strip_heredoc
+            # Association with the bucket
+            belongs_to :bucketable, polymorphic: true
+          CONTENT
+
+          ar_contents = ar_contents.split("\n").map { |line| " " + line } .join("\n") << "\n\n"
+
+          inject_into_class(active_recordable_path, ACTIVE_RECORDABLE.camelize, ar_contents)
+      end
+
+      def copy_bucket_maker_migration
+        if behavior == :invoke && store_in == 'active_record' && active_recordable_exists?
+          migration_template "active_recordable_migration.rb", "db/migrate/create_#{ACTIVE_RECORDABLE.pluralize}"
+        end
+      end
+
+      private
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      def active_recordable_exists?
+        File.exists?(File.join(destination_root, active_recordable_path))
+      end
+
+      def active_recordable_path
+        @ar_path ||= File.join("app", "models", "#{ACTIVE_RECORDABLE}.rb")
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+
+      def module_name_for_include
+        case store_in
+        when 'redis'
+          'BucketMaker::Models::Redisable'
+        when 'active_record'
+          'BucketMaker::Models::ActiveRecordable'
+        else
+          'BucketMaker::Models::Redisable'
+        end
+      end
+    end
+  end
+end

data/lib/generators/bucket_maker/bucket_maker_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators/named_base'
+
+module BucketMaker
+  module Generators
+    class BucketMakerGenerator < Rails::Generators::NamedBase
+
+      namespace 'bucket_maker'
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Generates the model with a given NAME (if it doesn't exist) and adds the hook for method calls"
+
+      hook_for :orm
+    end
+  end
+end