rose 0.0.5

data/lib/rose/active_record.rb

@@ -0,0 +1,56 @@
+require 'rose'
+require 'active_record'
+
+module Rose
+  # This class is provides ActiveRecord models the ability to run reports
+  class ActiveRecordAdapter < ObjectAdapter
+    # @see Rose::ObjectAdapter#sprout
+    def self.sprout(seedling, options={})
+      table = nil
+      options[:class].transaction do
+        table = super(seedling, options)
+        raise ActiveRecord::Rollback
+      end
+      table
+    end
+  end
+
+  module ActiveRecordExtensions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def rose(name, options={}, &blk)
+        instance = Rose::Seedling.new(Rose::ActiveRecordAdapter, options.merge(:class => self))
+        instance.instance_eval(&blk)
+        register_seedling(name, instance)
+      end
+
+      def rose_for(name, *args)
+        seedlings(name).bloom(self.find(:all, *args))
+      end
+
+      def root_for(name, options={}, *args)
+        seedlings(name).photosynthesize(self.find(:all, *args), options)
+      end
+
+      def seedlings(name)
+        @seedlings ||= {}
+        @seedlings[name]
+      end
+
+      private
+
+      def register_seedling(name, instance)
+        @seedlings ||= {}
+        @seedlings[name] = Shell.new(instance)
+      end
+    end
+  end
+end
+
+# This extends ActiveRecord::Base to include Rose reporting
+class ActiveRecord::Base
+  include Rose::ActiveRecordExtensions
+end

data/lib/rose/attribute.rb

@@ -0,0 +1,93 @@
+module Rose
+  # An Attribute is value object used to operate on a table
+  class Attribute
+    attr_reader :method_name
+    attr_reader :column_name
+
+    def initialize(method_name, column_name)
+      @method_name = method_name
+      @column_name = column_name
+    end
+
+    def column_name
+      @column_name || @method_name
+    end
+
+    # This class defines an Attribute whose value is defined via a block
+    class Indirect < Attribute
+      attr_reader :value_block
+
+      def initialize(method_name, column_name, value_block)
+        super(method_name, column_name)
+        @value_block = value_block
+      end
+
+      def evaluate(item)
+        item.instance_eval(&@value_block)
+      end
+    end
+
+    # This class defines an Attribute whose value is defined via a method
+    class Direct < Attribute
+      def evaluate(item)
+        if item.respond_to?(@method_name.to_sym)
+          item.__send__(@method_name)
+        end
+      end
+    end
+
+    # This is a value object for pivot parameters
+    class Pivot < Indirect
+      alias_method :group_column, :method_name
+      alias_method :pivot_column, :column_name
+
+      def on(table)
+        table.pivot(pivot_column, :group_by => group_column, :values => value_block)
+      end
+    end
+
+    # Defines a collection of attributes
+    class Collection < Array
+      def row
+        inject({}) do |row, attribute|
+          row[attribute.column_name] = yield(attribute) if block_given?
+          row
+        end
+      end
+
+      def column_names
+        map(&:column_name)
+      end
+    end
+
+    # This is a value object for sort parameters
+    class Sort
+      attr_reader :column_name, :order, :sort_block
+
+      def initialize(column_name, order, &sort_block)
+        @column_name = column_name
+        @order       = order
+        @sort_block  = sort_block
+      end
+
+      def on(table)
+        if @sort_block
+          table.sort_rows_by!(nil, :order => @order) do |row|
+            @sort_block.call(row[@column_name])
+          end
+        else
+          table.sort_rows_by!(@column_name, :order => @order)
+        end
+        table
+      end
+    end
+
+    # This class defines an Indirect Attribute for rejecting table rows
+    class Filter < Indirect
+      def on(table)
+        table.data.reject! { |record| !@value_block.call(record) }
+        table
+      end
+    end
+  end
+end

data/lib/rose/core_extensions.rb

@@ -0,0 +1,27 @@
+module Rose
+  module CoreExtensions
+    # Validates that the given hash includes the required keys.
+    # If any keys are missing, ArgumentError will be raised.
+    #
+    # @param [Hash] hash the hash to validate
+    # @param [Array<Symbol>] required_keys the list of keys
+    # @raise [ArgumentError]
+    def require_keys(hash, *required_keys)
+      missing_keys = required_keys - hash.keys
+      raise ArgumentError, "Missing required key(s): #{missing_keys.join(', ')}" unless missing_keys.empty?
+    end
+
+    # Returns the values of required keys in the given hash
+    #
+    # @param [Hash] hash the hash to validate
+    # @param [Array<Symbol>] required_keys the list of keys
+    # @raise [ArgumentError] (see Rose::CoreExtensions#require_keys)
+    def required_values(hash, *required_keys)
+      require_keys(hash, *required_keys)
+      values = required_keys.inject([]) do |values, key|
+        values << hash[key]
+      end
+      required_keys.length == 1 ? values.first : values
+    end
+  end
+end

data/lib/rose/object.rb

@@ -0,0 +1,130 @@
+require 'rose'
+require 'rose/ruport'
+
+module Rose
+  # This class is provides Objects the ability to run reports
+  class ObjectAdapter
+    class << self
+      include CoreExtensions
+    end
+
+    # @param [Rose::Seedling] seedling the seedling to sprout
+    # @param [Hash] options the options to run with
+    # @option options [Array] :items (required) the items to report on
+    # @option options [Rose::Attribute::Collection] :attributes (nil) a row of attributes
+    # @option options [String] :group_column (nil) @deprecated
+    # @option options [String] :pivot_column (nil) @deprecated
+    # @option options [String] :value_block (nil) @deprecated
+    # @option options [String] :summary (nil) @deprecated
+    # @option options [String] :summary_on (nil) @deprecated
+    # @option options [String] :sort_by (nil) @deprecated
+    # @option options [String] :sort_order (nil) @deprecated
+    # @return [Ruport::Data::Table] the resulting table
+    def self.sprout(seedling, options={})
+      items, attributes = required_values(options, :items, :attributes)
+      table = Ruport::Data::RoseTable.new(:column_names => attributes.column_names)
+
+      self.rows(table, options)
+
+      if (alterations = options[:alterations])
+        alterations.each do |alteration|
+          table = alteration.on(table)
+        end
+      end
+
+      table
+    end
+
+    # @param [Rose::Seedling] seedling the seedling to update
+    # @param [Hash] options the options to run with
+    # @option options [Array] :items (required) an Array of items
+    # @option options [Hash,String] :with (required) (see Rose::Shell#photosynthesize)
+    def self.osmosis(seedling, options={})
+      hash_or_csv, items = required_values(options, :with, :items)
+
+      root, row = seedling.root, seedling.row
+      idy_attr = row.identity_attribute
+
+      items = case hash_or_csv
+      when String # CSV File
+        self.osmosis_from_csv(root, options.merge(
+          :idy_attr => idy_attr,
+          :csv_file => hash_or_csv,
+          :items    => items
+        ))
+      when Hash
+        self.osmosis_from_hash(root, options.merge(
+          :idy_attr => idy_attr,
+          :updates  => hash_or_csv,
+          :items    => items
+        ))
+      end
+
+      self.sprout(seedling, options.merge(
+        :attributes => row.attributes,
+        :items      => items
+      ))
+    end
+
+    protected
+
+    def self.rows(table, options={})
+      items, attributes = required_values(options, :items, :attributes)
+      items.each do |item|
+        options[:class].tap { |enforce_class| enforce_item_type(item, enforce_class) if enforce_class }
+        table << attributes.row { |attr| attr.evaluate(item).to_s }
+      end
+    end
+
+    def self.enforce_item_type(item, klass)
+      raise TypeError.new("Expected #{klass}, got #{item.class}") unless item.kind_of?(klass)
+    end
+
+    # @return [Array] items (see Rose::ObjectAdapter#osmosis_from_hash)
+    def self.osmosis_from_csv(root, options={})
+      idy_attr, csv_file, items = required_values(options, :idy_attr, :csv_file, :items)
+      updates = data_from_csv(csv_file).inject({}) do |updates, data|
+        updates[data.delete(idy_attr.column_name)] = data
+        updates
+      end
+      self.osmosis_from_hash(root, options.merge(:updates => updates))
+    end
+
+    # @return [Array] items the updated items
+    def self.osmosis_from_hash(root, options={})
+      idy_attr, updates, items = required_values(options, :idy_attr, :updates, :items)
+      finder = root.finder || auto_finder(idy_attr)
+      new_items = []
+      updates.each do |idy, update|
+        record = use_finder(finder, items, idy)
+        if record
+          root.updater(options[:preview]).call(record, update)
+        elsif creator = root.creator(options[:preview])
+          new_items << creator.call(idy, update)
+        else
+          next
+        end
+      end
+      items | new_items
+    end
+
+    def self.data_from_csv(csv_file)
+      Ruport::Data::RoseTable.load(csv_file).data.map(&:to_hash)
+    end
+
+    # @param [Rose::Attribute] idy_attr the attribute to find items with
+    # @return [Proc] a Proc that will find items with attribute evaluating to given id
+    def self.auto_finder(idy_attr)
+      lambda { |items, idy|
+        items.find do |item|
+          idy_attr.evaluate(item).to_s == idy
+        end
+      }
+    end
+
+    # In case subclasses want to call finders differently
+    def self.use_finder(finder, items, idy)
+      finder.call(items, idy)
+    end
+  end
+end

data/lib/rose/proxy.rb

@@ -0,0 +1,114 @@
+require 'rose/attribute'
+
+module Rose
+  module Proxy
+    # This class is used by the DSL to collect a row of attributes
+    class Row
+      # Each attribute defines how values are generated for that column
+      # as well how that column is named
+      # @return [Rose::Attribute::Collection] A collection of attributes
+      attr_reader :attributes
+
+      # @return [Rose::Attribute] attribute used to determine which column
+      #   is the id column
+      attr_reader :identity_attribute
+
+      def initialize
+        @attributes = Attribute::Collection.new
+      end
+
+      def column(name, &blk)
+        @attributes << attribute(name, &blk)
+      end
+
+      def identity(name, &blk)
+        column(name, &blk)
+        @identity_attribute = @attributes.last
+      end
+
+      def self.name_and_title(name)
+        case name
+        when Hash
+          name.to_a.first
+        else
+          [name, nil]
+        end
+      end
+
+      private
+
+      def attribute(name, &blk)
+        name, title = self.class.name_and_title(name)
+
+        if block_given?
+          attribute = Attribute::Indirect.new(name, title, blk)
+        else
+          attribute = Attribute::Direct.new(name, title)
+        end
+      end
+    end
+
+    # This class is used by the DSL to collect summary attributes
+    class Summary < Row
+      attr_reader :column_name
+
+      def initialize(column_name)
+        super()
+        @column_name = column_name
+      end
+
+      def on(table)
+        rows = table.column(@column_name).uniq.inject([]) do |rows, group|
+          rows << @attributes.row { |attr|
+            gr = table.grouped_rows({@column_name => group}, attr.column_name)
+            attr.evaluate(gr)
+          }.merge(@column_name => group)
+        end
+        Ruport::Data::RoseTable.new(:column_names => [@column_name] | @attributes.column_names).tap do |table|
+          rows.each { |row| table << row }
+        end
+      end
+    end
+
+    # This class is used by the DSL to collect update attributes.
+    # Just like a root is the foundation of transporting water into
+    # a tree, a Root provides what's required to import data into a Rose
+    class Root
+      attr_reader :finder
+      attr_reader :updater
+      attr_reader :update_previewer
+      attr_reader :creator
+      attr_reader :create_previewer
+
+      def find(&blk)
+        @finder = blk
+      end
+
+      def update(&blk)
+        @updater = blk
+      end
+
+      def preview_update(&blk)
+        @update_previewer = blk
+      end
+
+      def create(&blk)
+        @creator = blk
+      end
+
+      def preview_create(&blk)
+        @create_previewer = blk
+      end
+
+      # @param [true, false] preview whether to use the update_previewer or not
+      def updater(preview = false)
+        preview ? @update_previewer : @updater
+      end
+
+      # @param [true, false] preview whether to use the create_previewer or not
+      def creator(preview = false)
+        preview ? @create_previewer : @creator
+      end
+    end
+  end
+end

data/lib/rose/ruport.rb

@@ -0,0 +1,45 @@
+# Enables pivoting with value columns
+class Ruport::Data::RoseTable < Ruport::Data::Table
+  def pivot(pivot_column, options = {})
+    group_column = options[:group_by] ||
+      raise(ArgumentError, ":group_by option required")
+    value_column = options[:values]   ||
+      raise(ArgumentError, ":values option required")
+    RosePivot.new(
+      self, group_column, pivot_column, nil, options
+    ).to_table(&value_column)
+  end
+
+  def grouped_rows(with, column_name)
+    rows_with(with).map { |row|
+      begin
+        row.send(column_name.to_sym)
+      rescue NoMethodError => no_method_error
+        nil
+      end
+    }
+  end
+end
+
+# Enables using value blocks for the value column
+class Ruport::Data::Table::RosePivot < Ruport::Data::Table::Pivot
+  def to_table
+    result = Ruport::Data::RoseTable.new()
+    result.add_column(@group_column)
+    pivoted_columns = columns_from_pivot
+    pivoted_columns.each { |name| result.add_column(name) }
+    outer_grouping = Grouping(@table, :by => @group_column)
+    group_column_entries.each {|outer_group_name|
+      outer_group = outer_grouping[outer_group_name]
+      pivot_values = pivoted_columns.inject({}) do |hsh, pc|
+        matching_rows = outer_group.rows_with(@pivot_column => pc)
+        hsh[pc] = yield(matching_rows)
+        hsh
+      end
+      result << [outer_group_name] + pivoted_columns.map {|pc|
+        pivot_values[pc]
+      }
+    }
+    result
+  end
+end