riveter 0.0.1

data/lib/generators/rspec/worker/worker_generator.rb

@@ -0,0 +1,11 @@
+module Rspec
+  module Generators
+    class WorkerGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_worker_spec
+        template 'worker_spec.rb', File.join('spec/workers', class_path, "#{file_name}_worker_spec.rb")
+      end
+    end
+  end
+end

data/lib/generators/test_unit/TODO

@@ -0,0 +1 @@
+Create generators and templates for test unit implementation

data/lib/riveter/associated_type_registry.rb

@@ -0,0 +1,63 @@
+module Riveter
+  module AssociatedTypeRegistry
+    extend ActiveSupport::Concern
+
+    included do
+      container = self
+      type_registry = TypeRegistry.new()
+
+      define_singleton_method :container do
+        container
+      end
+
+      define_singleton_method :registry do
+        type_registry
+      end
+    end
+
+    module ClassMethods
+      def key_for(type)
+        type.is_a?(Symbol) ? type : type.name.underscore.to_sym
+      end
+
+      def register_type(type, associated_type, options={})
+        options = {
+          :key => key_for(associated_type)
+        }.merge(options)
+
+        # prevent duplicate registrations
+        type_list = container.registry[options[:key]]
+        type_list << type unless type_list.include?(type)
+      end
+
+      def resolve!(type)
+        registered = self.resolve(type)
+        raise UnregisteredType.new(type) unless registered
+        registered
+      end
+
+      def resolve(type)
+        self.resolve_all(type).first
+      end
+
+      def resolve_all(type)
+        key = key_for(type)
+        container.registry.key?(key) ? container.registry[key] : []
+      end
+    end
+  end
+
+  class TypeRegistry < Hash
+    def initialize
+      super {|h, k| h[k] = []}
+    end
+  end
+
+  class UnregisteredType < Exception
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+  end
+end

data/lib/riveter/attribute_default_values.rb

@@ -0,0 +1,67 @@
+module Riveter
+  module AttributeDefaultValues
+    extend ActiveSupport::Concern
+
+    included do
+      #
+      # NB:
+      #  defines the container within the scope of this class (or module)
+      #  so that the list of attributes with defaults aren't shared across models
+      #
+      class << self
+        def attribute_defaults
+          @attribute_defaults ||= {}
+        end
+      end
+
+      # setup after_initialize callback to set the defaults for listed attributes
+      after_initialize :set_defaults
+    end
+
+    module ClassMethods
+      #
+      # defines a default value for the given attribute
+      #
+      # E.g. default_value_for :active, true
+      #
+      #      default_value_for :active do
+      #        # ... some logic ...
+      #      end
+      #
+      def default_value_for(attribute, value=nil, &block)
+        self.attribute_defaults[attribute] = (block_given? ? block : value)
+      end
+
+      #
+      # defines default values for one or more attributes
+      # specify defaults using a hash, where the key is the attribute name
+      # and the value is the value or a proc
+      #
+      # E.g.  default_values :confirmed => true,
+      #                      :processed => false,
+      #                      :some_other => lambda { ... some logic ... }
+      #
+      def default_values(*args)
+        defaults = args.first.is_a?(Hash) ?
+                      args.first :
+                      { args.first => args.last }
+
+        defaults.each do |attribute, value_or_proc|
+          value_or_proc.respond_to?(:call) ?
+            default_value_for(attribute, &value_or_proc) :
+            default_value_for(attribute, value_or_proc)
+        end
+      end
+    end
+
+    def set_defaults
+      return if self.respond_to?(:persisted?) && self.persisted?
+      self.class.attribute_defaults.each do |attribute, value_or_proc|
+        value = value_or_proc.respond_to?(:call) ?
+          (value_or_proc.call(self) rescue value_or_proc.call) :
+          value_or_proc
+        send("#{attribute}=", value) if send(attribute).blank?
+      end
+    end
+  end
+end

data/lib/riveter/attributes.rb

@@ -0,0 +1,443 @@
+module Riveter
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+
+      include ActiveModel::Conversion
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+      include ActiveModel::ForbiddenAttributesProtection
+
+      # define attributes within the class scope
+      # so that they aren't shared between including classes
+
+      mattr_accessor :_attributes_container, :instance_writer => false
+      self._attributes_container = Hash.new {|hash, key| hash[key] = {}.with_indifferent_access }
+
+      def self._attributes
+        self._attributes_container[self]
+      end
+
+      def self.attributes
+        self._attributes.keys
+      end
+    end
+
+    module ClassMethods
+      def attr_string(name, options={})
+        converter = Converters.converter_for(:string)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        attr_writer name
+
+        add_attr(name, :string, converter, options)
+      end
+
+      alias_method :attr_text, :attr_string
+
+      def attr_integer(name, options={})
+        options = {
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:integer)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :numericality => { :only => :integer } if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :integer, converter, options)
+      end
+
+      def attr_decimal(name, options={})
+        options = {
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:decimal)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :numericality => true if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :decimal, converter, options)
+      end
+
+      def attr_date(name, options={})
+        options = {
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:date)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :timeliness => { :type => :date } if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :date, converter, options)
+      end
+
+      def attr_time(name, options={})
+        options = {
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:time)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :timeliness => { :type => :time } if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :time, converter, options)
+      end
+
+      alias :attr_datetime :attr_time
+
+      def attr_boolean(name, options={})
+        options = {
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:boolean)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        alias_method "#{name}?", name
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :booleaness => true if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :boolean, converter, options)
+      end
+
+      def attr_enum(name, enum, options={})
+        options = {
+          :enum => enum,
+          :validate => true
+        }.merge(options)
+
+        required = options[:required] == true
+        converter = Converters.converter_for(:enum, options)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        # helpers
+        # TODO: would be nicer to emulate an association
+
+        define_singleton_method "#{name}_enum" do
+          enum
+        end
+
+        define_singleton_method name.to_s.pluralize do
+          enum.collection
+        end
+
+        validates name,
+                  :allow_blank => !required,
+                  :allow_nil => !required,
+                  :inclusion => { :in => enum.all } if options[:validate]
+
+        attr_writer name
+
+        add_attr(name, :enum, converter, options)
+      end
+
+      def attr_array(name, options={}, &block)
+        options = {
+          :data_type => :integer,
+          :validate => true
+        }.merge(options)
+        data_type = options.delete(:data_type)
+
+        converter = block_given? ? block : Converters.converter_for(data_type)
+
+        define_method name do
+          (instance_variable_get("@#{name}") || []).map {|item| converter.call(item) }
+        end
+
+        attr_writer name
+
+        add_attr(name, :array, converter, options)
+      end
+
+      def attr_hash(name, options={})
+        converter = Converters.converter_for(:hash, options)
+
+        # FIXME:
+        #  * need converter for values?
+        #  * assumes the hash values are contiguous?
+        #
+
+        attr_accessor name
+
+        add_attr(name, :hash, converter, options)
+      end
+
+      def attr_model(name, model, options={})
+        options = {
+          :model => model
+        }.merge(options)
+        converter = Converters.converter_for(:model, options)
+
+        # FIXME:
+        #  * need converter for values?
+        #  * define methods to get the actual model instance?
+        #  * assign model instance directly?
+        #
+
+        # helpers
+        define_singleton_method "#{name}_model" do
+          model
+        end
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        attr_writer name
+
+        add_attr(name, :model, converter, options)
+      end
+
+      def attr_object(name, options={})
+        converter = Converters.converter_for(:object, options)
+
+        define_method name do
+          converter.call instance_variable_get("@#{name}")
+        end
+
+        attr_writer name
+
+        add_attr(name, :object, converter, options)
+      end
+
+    private
+
+      def add_attr(name, type, converter, options={})
+        self._attributes[name] = attribute_info = AttributeInfo.new(name, type, converter, options)
+        validates name, :presence => true if attribute_info.required?
+        attribute_info
+      end
+    end
+
+    class AttributeInfo < Struct.new(:name, :type, :converter, :options)
+
+      def required?
+        @required ||= (options[:required] == true)
+      end
+
+      def default
+        @default ||= options[:default]
+      end
+
+      def default?
+        !self.default.nil?
+      end
+
+    end
+
+    attr_reader :options
+
+    def initialize(params=nil, options={})
+      # assign default values
+      self.class._attributes.each do |name, attribute_info|
+        next unless attribute_info.default?
+        value = attribute_info.default
+        send("#{name}=", value.respond_to?(:call) ? value.call : value)
+      end
+
+      @options = options.freeze
+
+      # filter and clean params before applying
+      apply_params(
+        clean_params(
+          filter_params(
+            sanitize_for_mass_assignment(params)
+          )
+        )
+      ) unless params.nil?
+    end
+
+    def attributes(options={})
+      self.class._attributes.inject({}) do |list, (key, attribute_info)|
+        list[key] = self.send(attribute_info.name)
+        list
+      end
+    end
+
+    alias_method :to_params, :attributes
+
+    # forms use this to determine the HTTP verb
+    def persisted?
+      false
+    end
+
+    # forms use this for getting column meta data
+    def column_for_attribute(column)
+      attribute_info = self.class._attributes[column]
+      OpenStruct.new(
+        :name => attribute_info.name,
+        :type => attribute_info.type,
+        :null => !attribute_info.required?,
+        :default => attribute_info.default
+      )
+    end
+
+  protected
+
+    # only include defined attributes
+    def filter_params(params)
+      attributes = self.class._attributes
+      params.keep_if {|name, value|
+        attributes.key?(name)
+      }
+    end
+
+    # remove blank/nil attributes
+    def clean_params(params)
+      params.reject { |key, value|
+        reject_value?(value)
+      }
+    end
+
+    # given sanitized params, assign values to instance
+    def apply_params(params)
+      params.each do |attribute, value|
+        assign_attribute(attribute, value)
+      end
+    end
+
+  private
+
+    def reject_value?(value)
+      case value
+      when Array
+        value.reject! {|v| reject_value?(v) }
+        false
+      when Hash
+        value.reject! {|k, v| reject_value?(v) }
+        false
+      else
+        value.blank? unless value.is_a?(FalseClass)
+      end
+    end
+
+    def assign_attribute(attribute, value)
+      public_send("#{attribute}=", value)
+
+    rescue
+      if respond_to?("#{attribute}=")
+        raise
+      else
+        raise UnknownAttributeError.new(self, attribute)
+      end
+    end
+
+    module Converters
+
+      # supply a built-in converter for the given type
+      def self.converter_for(data_type, options={})
+        case data_type
+        when :string
+          lambda {|v| v.to_s }
+
+        when :boolean
+          lambda {|v| v.to_b }
+
+        when :integer
+          lambda {|v| Integer(v) rescue v }
+
+        when :decimal
+          lambda {|v| Float(v) rescue v }
+
+        when :hash
+          lambda {|v| v.to_hash rescue v }
+
+        when :date
+          lambda {|v| Date.parse(v) rescue v }
+
+        when :time
+          lambda {|v| Time.parse(v) rescue v }
+
+        when :enum
+          lambda {|enum, v|
+            if v.blank? || v.nil?
+              nil
+            else
+              # FIXME: assuming enum values are integers!
+              v = Integer(v) rescue v
+              (v.is_a?(String) || v.is_a?(Symbol)) ? enum.value_for(v) : v.to_i
+            end
+          }.curry[options[:enum]]
+
+        # FIXME:
+        # when :hash
+        #   lambda {|v| v }
+
+        when :model
+          # FIXME:
+          lambda {|model, v|
+            # assuming v is an ID
+            # model.find(v)
+            # FIXME
+            v
+          }.curry[options[:model]]
+
+        else
+          lambda {|v| v }
+        end
+      end
+
+    end
+
+    # helper class
+    class Base
+      include Attributes
+    end
+  end
+end

data/lib/riveter/booleaness_validator.rb

@@ -0,0 +1,20 @@
+module Riveter
+  class BooleanessValidator < ActiveModel::EachValidator
+    def initialize(options)
+      @allow_nil, @allow_blank = options.delete(:allow_nil), options.delete(:allow_blank)
+      super
+    end
+
+    def validate_each(record, attribute, value)
+      return if (@allow_nil && value.nil?) || (@allow_blank && value.blank?)
+
+      unless [true, false].include?(value)
+        record.errors.add(attribute, :booleaness, :value => value)
+      end
+    end
+  end
+end
+
+# add compatibility with ActiveModel validates method which
+# matches option keys to their validator class
+ActiveModel::Validations::BooleanessValidator = Riveter::BooleanessValidator

data/lib/riveter/command.rb

@@ -0,0 +1,59 @@
+module Riveter
+  module Command
+    extend ActiveSupport::Concern
+
+    included do
+      include Riveter::Attributes
+
+      class << self
+        alias_method :command_name, :model_name
+
+        def i18n_scope
+          :commands
+        end
+
+        def success_notice
+          I18n.translate(
+            :success,
+            :scope => [i18n_scope, :notices, command_name.i18n_key],
+            :default => "Successfully executed #{command_name.human}."
+          )
+        end
+      end
+
+      alias_method :can_perform?, :valid?
+    end
+
+    def submit(*args)
+      params = args.extract_options!
+
+      # filter and clean params before applying
+      apply_params(
+        clean_params(
+          filter_params(params)
+        )
+      )
+
+      # perform validations, and proceed if valid
+      return false unless self.can_perform?
+
+      # all good, perform the action
+      self.perform *args
+    end
+
+  protected
+
+    def perform(*args)
+      # resolve for the registered service for this command
+      service_class = Service::Base.resolve!(self.class)
+      # create an instance and invoke perform
+      service = service_class.new()
+      service.perform(self, *args)
+    end
+
+    # helper class
+    class Base
+      include Command
+    end
+  end
+end