mainej-activewarehouse 0.3.0

data/activewarehouse/lib/active_warehouse/builder/generator/generator.rb

@@ -0,0 +1,13 @@
+module ActiveWarehouse
+  module Builder
+    module Generator
+      # Base class for generators
+      class Generator
+        # Get the next value from the generator.
+        def next(options={})
+          raise "Abstract method"
+        end
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/builder/generator/name_generator.rb

@@ -0,0 +1,20 @@
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    module Generator #:nodoc:
+      # Generate a name consisting of one or more words from word groups
+      class NameGenerator < ActiveWarehouse::Builder::Generator::Generator
+        def next(options={})
+          options[:separator] ||= ' '
+          parts = []
+          word_groups = options[:word_groups]
+          0.upto(word_groups.first.length) do |i|
+            word_groups.each do |word_group|
+              parts << word_group[i]
+            end
+          end
+          parts.join(options[:separator])
+        end
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/builder/generator/paragraph_generator.rb

@@ -0,0 +1,11 @@
+module ActiveWarehouse
+  module Builder
+    module Generator
+      class ParagraphGenerator < ActiveWarehouse::Builder::Generator::Generator
+        def next(options={})
+          
+        end
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/builder/random_data_builder.rb

@@ -0,0 +1,239 @@
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    # Build random data usable for testing.
+    class RandomDataBuilder
+      # Hash of generators where the key is the class and the value is an
+      # implementation of AbstractGenerator
+      attr_reader :generators
+      
+      # Hash of names mapped to generators where the name is the column name
+      attr_reader :column_generators
+      
+      # Initialize the random data builder
+      def initialize
+        @generators = {
+          Fixnum => FixnumGenerator.new,
+          Float => FloatGenerator.new,
+          Date => DateGenerator.new,
+          Time => TimeGenerator.new,
+          String => StringGenerator.new,
+          Object => BooleanGenerator.new,
+        }
+        @column_generators = {}
+      end
+      
+      # Build the data for the specified class. Name may be a Class (which must
+      # descend from ActiveWarehouse::Dimension
+      # or ActiveWarehouse::Fact), a String or a Symbol. String or Symbol will
+      # be converted to a class name and then 
+      # passed back to this method.
+      def build(name, options={})
+        case name
+        when Class
+          if name.respond_to?(:base_class)
+            return build_dimension(name, options) if name.base_class == ActiveWarehouse::Dimension
+            return build_fact(name, options) if name.base_class == ActiveWarehouse::Fact
+          end
+          raise "#{name} is a class but does not appear to descend from Fact or Dimension"
+        when String
+          begin
+            build(name.classify.constantize, options)
+          rescue NameError
+            raise "Cannot find a class named #{name.classify}"
+          end
+        when Symbol
+          build(name.to_s, options)
+        else
+          raise "Unable to determine what to build"
+        end
+      end
+      
+      # Build test dimension data for the specified dimension name.
+      #
+      # Options:
+      #
+      # * <tt>:rows</tt>: The number of rows to create (defaults to 100)
+      # * <tt>:generators</tt>: A map of generators where each key is Fixnum,
+      #   Float, Date, Time, String, or Object and the
+      #   value is extends from AbstractGenerator. 
+      def build_dimension(name, options={})
+        options[:rows] ||= 100
+        options[:generators] ||= {}
+        rows = []
+
+        dimension_class = Dimension.to_dimension(name)
+        options[:rows].times do
+          row = {}
+          dimension_class.content_columns.each do |column|
+            generator = (options[:generators][column.klass] ||
+                         @column_generators[column.name] ||
+                         @generators[column.klass])
+            if generator.nil?
+              raise ArgumentError, "No generator found, unknown column type?: #{column.klass}"
+            end
+            row[column.name] = generator.generate(column, options)
+          end
+          rows << row
+        end
+        
+        rows
+      end
+      
+      # Build test fact data for the specified fact name
+      # 
+      # Options:
+      # * <tt>:rows</tt>: The number of rows to create (defaults to 100)
+      # * <tt>:generators</tt>: A Hash of generators where each key is Fixnum,
+      #   Float, Date, Time, String, or Object and the
+      #   value is extends from AbstractGenerator.
+      # * <tt>:fk_limit</tt>: A Hash of foreign key limits, where each key is
+      #   the name of column and the value is 
+      #   a number. For example options[:fk_limit][:date_id] = 1000 would limit
+      #   the foreign key values to something between
+      #   1 and 1000, inclusive.
+      # * <tt>:dimensions</tt>: The number of available dimension FKs
+      def build_fact(name, options={})
+        options[:rows] ||= 100
+        options[:generators] ||= {}
+        options[:fk_limit] ||= {}
+        rows = []
+
+        fact_class = Fact.to_fact(name)
+        options[:rows].times do
+          row = {}
+          fact_class.content_columns.each do |column|
+            generator = (options[:generators][column.klass] || @generators[column.klass])
+            row[column.name] = generator.generate(column, options)
+          end
+          fact_class.dimension_relationships.each do |name, reflection|
+            # it would be better to get a count of rows from the dimension tables
+            fk_limit = (options[:fk_limit][reflection.primary_key_name] ||
+                        options[:dimensions] || 100) - 1
+            row[reflection.primary_key_name] = rand(fk_limit) + 1
+          end
+          rows << row
+        end
+        
+        rows
+      end
+    end
+    
+    # Implement this class to provide an generator implementation for a specific class.
+    class AbstractGenerator
+      # Generate the next value. The column parameter must be an
+      # ActiveRecord::Adapter::Column instance. 
+      # The options hash is implementation dependent.
+      def generate(column, options={})
+        raise "generate method must be implemented by a subclass"
+      end
+    end
+    
+    # Basic Date generator
+    class DateGenerator < AbstractGenerator
+      # Generate a random date value
+      #
+      # Options:
+      # * <tt>:start_date</tt>: The start date as a Date or Time object
+      #   (default 1 year ago)
+      # * <tt>:end_date</tt>: The end date as a Date or Time object (default now)
+      def generate(column, options={})
+        end_date = (options[:end_date] || Time.now).to_date
+        start_date = (options[:start_date] || 1.year.ago).to_date
+        number_of_days = end_date - start_date
+        start_date + rand(number_of_days)
+      end
+    end
+    
+    # Basic Time generator
+    #
+    # Options:
+    # * <tt>:start_date</tt>: The start date as a Date or Time object
+    # (default 1 year ago)
+    # * <tt>:end_date</tt>: The end date as a Date or Time object (default now)
+    class TimeGenerator < DateGenerator #:nodoc:
+      # Generate a random Time value
+      def generate(column, options={})
+        super(column, options).to_time
+      end
+    end
+    
+    # Basic Fixnum generator
+    class FixnumGenerator
+      # Generate an integer from 0 to options[:max] inclusive
+      #
+      # Options:
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
+      # * <tt>:min</tt>: The minimum allowed value (default 0)
+      def generate(column, options={})
+        options[:max] ||= 1000
+        options[:min] ||= 0
+        rand(options[:max] + (-options[:min])) - options[:min]
+      end
+    end
+    
+    # Basic Float generator
+    class FloatGenerator
+      # Generate a float from 0 to options[:max] inclusive (default 1000)
+      #
+      # Options:
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
+      def generate(column, options={})
+        options[:max] ||= 1000
+        rand * options[:max].to_f
+      end
+    end
+    
+    # Basic BigDecimal generator
+    class BigDecimalGenerator
+      # Generate a big decimal from 0 to options[:max] inclusive (default 1000)
+      #
+      # Options:
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
+      def generate(column, options={})
+        options[:max] ||= 1000
+        BigDecimal.new((rand * options[:max].to_f).to_s) # TODO: need BigDecimal type?
+      end
+    end
+    
+    # A basic String generator
+    class StringGenerator
+      # Initialize the StringGenerator.
+      #
+      # Options:
+      # * <tt>:values</tt>: List of possible values
+      # * <tt>:chars</tt>: List of chars to use to generate random values
+      def initialize(options={})
+        @options = options
+      end
+      # Generate a random string
+      #
+      # Options:
+      # * <tt>:values</tt>: An array of values to use. If not specified then
+      #   random char values will be used.
+      # * <tt>:chars</tt>: An array of characters to use to generate random
+      #   values (default [a..zA..Z])
+      def generate(column, options={})
+        options[:values] ||= @options[:values]
+        options[:chars] ||= @options[:chars]
+        if options[:values]
+          options[:values][rand(options[:values].length)]
+        else
+          s = ''
+          chars = (options[:chars] || ('a'..'z').to_a + ('A'..'Z').to_a)
+          0.upto(column.limit - 1) do |n|
+            s << chars[rand(chars.length)]
+          end
+          s
+        end
+      end
+    end
+    
+    # A basic Boolean generator
+    class BooleanGenerator
+      # Generate a random boolean
+      def generate(column, options={})
+        rand(1) == 1
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/builder/test_data_builder.rb

@@ -0,0 +1,54 @@
+Dir[File.dirname(__FILE__) + "/generator/*.rb"].each { |file| require(file) }
+
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    # Unlike the RandomDataBuilder, which puts truly random data in the warehouse, this 
+    # generator uses collections of possible values to construct semi-understandable data
+    class TestDataBuilder
+      def initialize
+        
+      end
+      
+      # Usage: 
+      #
+      #   fields = [:id,:product_name,:product_description,:suggested_retail_price]
+      #   field_definitions = {
+      #     :id => :sequence,                                                  # symbol or string
+      #     :product_name => [['Foo','Bar']['Baz','Bing']],                    # array
+      #     :product_description => IpsumLorumGenerator                        # class
+      #     :suggested_retail_price => RandomNumberGenerator.new(0.00, 100.00) # generator instance
+      #   }
+      def build(fields, field_definitions, options={})
+        options[:number] ||= 100
+        rows = []
+        generators = {}
+        # set up all of the generators first
+        field_definitions.each do |name, fd|
+          case fd
+          when Class
+            generators[name] = fd.new
+          when String, Symbol
+            generators[name] = "#{fd}Generator".classify.constantize.new
+          when Array
+            generators[name] = NameGenerator.new(fd)
+          when Generator
+            generators[name] = fd
+          else
+            raise "Invalid generator specified: #{fd}"
+          end
+        end
+        
+        # generate all of the rows
+        0.upto(options[:number]) do
+          row = {}
+          fields.each do |field|
+            row[field] = generators[field].next(options)
+          end
+          rows << row
+        end
+        
+        rows
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/calculated_field.rb

@@ -0,0 +1,27 @@
+module ActiveWarehouse #:nodoc:
+  # A field that uses a Proc to calculate the value 
+  class CalculatedField < Field
+    attr_reader :block
+    # Initialize the calculated field
+    #
+    # +fact_class+ is the fact class that the field is calculated in
+    # +name+ is the name of the calculated field
+    # +type+ is the type of the calculated field (defaults to :integer)
+    # +field_options+ is a Hash of options for the field
+    # 
+    # This method accepts a block which should take a single argument that is the record
+    # itself.
+    def initialize(fact_class, name, type = :integer, field_options = {}, &block)
+      unless block_given?
+        raise ArgumentError, "A block is required for the calculated field #{name} in #{fact_class}"
+      end
+      super(fact_class, name.to_s, type, field_options)
+      @block = block
+    end
+    
+    # Calculate the field value using the Hash of type-casted values
+    def calculate(values)
+      @block.call(values)
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/compat/compat.rb

@@ -0,0 +1,49 @@
+# Provides 1.1.6 compatibility
+module ActiveRecord #:nodoc:
+  module Calculations #:nodoc:
+    module ClassMethods #:nodoc:
+      protected
+      def construct_count_options_from_legacy_args(*args)
+        options     = {}
+        column_name = :all
+
+        # We need to handle
+        #   count()
+        #   count(options={})
+        #   count(column_name=:all, options={})
+        #   count(conditions=nil, joins=nil)      # deprecated
+        if args.size > 2
+          raise ArgumentError, "Unexpected parameters passed to count(options={}): #{args.inspect}"
+        elsif args.size > 0
+          if args[0].is_a?(Hash)
+            options = args[0]
+          elsif args[1].is_a?(Hash)
+            column_name, options = args
+          else
+            # Deprecated count(conditions, joins=nil)
+            ActiveSupport::Deprecation.warn(
+              "You called count(#{args[0].inspect}, #{args[1].inspect}), which is a deprecated API call. " +
+              "Instead you should use count(column_name, options). Passing the conditions and joins as " +
+              "string parameters will be removed in Rails 2.0.", caller(2)
+            )
+            options.merge!(:conditions => args[0])
+            options.merge!(:joins      => args[1]) if args[1]
+          end
+        end
+
+        [column_name, options]
+      end
+    end
+  end
+end
+
+class Module #:nodoc:
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+  end
+end

data/activewarehouse/lib/active_warehouse/core_ext.rb

@@ -0,0 +1 @@
+require 'active_warehouse/core_ext/time'

data/activewarehouse/lib/active_warehouse/core_ext/time.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/time/calculations'
+
+class Time#:nodoc:
+  include ActiveWarehouse::CoreExtensions::Time::Calculations
+end

data/activewarehouse/lib/active_warehouse/core_ext/time/calculations.rb

@@ -0,0 +1,40 @@
+module ActiveWarehouse #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Time #:nodoc:
+      # Enables the use of time calculations within Time itself
+      module Calculations
+        def week
+          cyw = ((yday - 1) / 7) + 1
+          cyw = 52 if cyw == 53
+          cyw
+        end
+        def quarter
+          ((month - 1) / 3) + 1
+        end
+        def fiscal_year_week(offset_month=10)
+          fyw = ((fiscal_year_yday(offset_month) - 1) / 7) + 1
+          fyw = 52 if fyw == 53
+          fyw
+        end
+        def fiscal_year_month(offset_month=10)
+          shifted_month = month - (offset_month - 1)
+          shifted_month += 12 if shifted_month < 0
+          shifted_month
+        end
+        def fiscal_year_quarter(offset_month=10)
+          ((fiscal_year_month(offset_month) - 1) / 3) + 1
+        end
+        def fiscal_year(offset_month=10)
+          month >= offset_month ? year + 1 : year
+        end
+        def fiscal_year_yday(offset_month=10)
+          offset_days = 0
+          1.upto(offset_month - 1) { |m| offset_days += ::Time.days_in_month(m, year) }
+          shifted_year_day = yday - offset_days
+          shifted_year_day += 365 if shifted_year_day <= 0
+          shifted_year_day
+        end
+      end
+    end
+  end
+end