engine-rea 0.2.1 → 0.2.2

data/lib/rea/aspect_type.rb

@@ -1,11 +1,33 @@
 module Rea
   module AspectType
+
     autoload :Base, 'rea/aspect_type/base'
-    autoload :IdentifierSetup, 'rea/aspect_type/identifier_setup'
-    autoload :Description, 'rea/aspect_type/description'
-    autoload :DueDateType, 'rea/aspect_type/due_date_type'
-    autoload :Classification, 'rea/aspect_type/classification_aspect'
-    autoload :ClassificationAspect, 'rea/aspect_type/classification_aspect'
-    autoload :MemberType, 'rea/aspect_type/classification_aspect'
+
+    TYPES = %W{identification classification due_date description}
+
+    TYPES.each do |type|
+      require "rea/aspect_type/#{type}"
+    end
+
+
+    module ClassMethods
+      TYPES.each do |pattern|
+        define_method pattern do |*names, &block|
+          $options = names.extract_options!
+          $options.merge! :base=>self
+          self.send :include, "Rea::AspectType::#{pattern.camelize}".constantize
+          self.send :cattr_accessor, "#{pattern}_aspect".to_sym
+          if names.size == 0
+            names << "%s_%s_aspect" % [self.name.underscore, pattern]
+          end
+          names.each do |name|
+            $aspect = "Rea::AspectType::#{pattern.camelize}::Aspect".constantize.new($options)
+            $aspect.instance_eval &block if block
+            self.send "#{pattern}_aspect=", $aspect
+            Rea.context.symbol_table[name] = $aspect
+          end
+        end
+      end
+    end
   end
 end

data/lib/rea/aspect_type/base.rb

@@ -1,8 +1,9 @@
 module Rea
   module AspectType
     class Base
-      def initialize options={}
-        options.keys.each { |key| self.instance_variable_set("@#{key}", options[key]) }
+      attr_reader :base
+      def initialize options = {}
+        @base = options.delete(:base)
       end
     end
   end

data/lib/rea/aspect_type/classification.rb

@@ -0,0 +1,142 @@
+module Rea
+  module AspectType
+    module Classification
+      def self.included base
+        base.scope :by_category, lambda { |*categories|
+          $options = categories.extract_options!
+          $aspect = base.classification_aspect
+          $condition = {}
+          categories.each do |category|
+            $category_type_name = category.category_type.name
+            $condition["#{$aspect.member_type_for($category_type_name)}_id"] = category.id
+          end
+          $condition.merge! $options
+          base.where($condition)
+        }
+
+        base.send :has_many, :category_members, :class_name=>::Rea::CategoryMember.name, :as=>:entity
+        base.send :has_many, :categories, :class_name=>::Rea::Category.name,
+          :through=>:category_members, :source=>:category
+
+        base.class_eval do
+
+          def self.categories_for member_type
+            self.classification_aspect.categories_for member_type
+          end
+
+          def is? category
+            $field_name = self.class.classification_aspect.member_type_for(category.category_type.name)
+            self.send($field_name) == category
+          end
+          def is_in? category
+            $field_name = self.class.classification_aspect.member_type_for(category.category_type.name)
+            $current = category.class.find(self.send($field_name))
+            while($current) do
+              return true if $current == category
+              $current = $current.parent_category
+            end
+            return false
+          end
+        end
+      end
+
+
+      module CategoryType
+
+        def self.included base
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def category_type *category_types, &block
+            $options = category_types.extract_options!
+            category_types.each do |type|
+              $category_type = self.find_or_create_by_name type, $options
+              $category_type.instance_eval &block if block
+            end
+          end
+        end
+
+        def category *category_names, &block
+          $options = category_names.extract_options!
+          category_names.flatten.each do |name|
+            category = self.categories.find_or_create_by_name name, $options
+            category.instance_eval &block if block_given?
+          end
+        end
+      end
+
+      module Category
+        def category *category_names, &block
+          $options = category_names.extract_options!
+          $options = {:category_type_id=>self.category_type_id, :category_id=>self.id}.merge($options)
+          category_names.flatten.each do |name|
+            $category = self.child_categories.find_or_create_by_name name, $options
+            $categroy.instance_eval &block if block_given?
+          end
+        end
+      end
+
+      class Aspect < Base
+
+        def members
+          @members ||= {}
+        end
+
+        def member *names, &block
+          $options = names.extract_options!
+          names.each do |name|
+            base.attr_accessible "#{name}_id"
+            base.belongs_to name, :class_name=>::Rea::Category.name
+            members[name] = MemberType.new($options)
+            members[name].instance_eval &block if block
+            #pp members[name]
+            if members[name].multiple_select
+              define_multiple_member name, members[name]
+            end
+          end
+        end
+
+        def member_type_for category_type
+          $types = {}
+          members.each_pair { |k,v| $types[v.category_type_name] = k }
+          $types[category_type.to_sym]
+        end
+
+        def categories_for member_type
+          $member_type = members[member_type]
+          raise "not found member_type #{member_type}" unless $member_type
+          $member_type.category_options
+        end
+
+        private
+        def define_multiple_member name, member
+          base.send :attr_accessible, "#{name.to_s.singularize}_ids"
+          base.send :has_many, name, :through=>:category_members, :source=>:category,
+            :class_name=>::Rea::Category.name, :include=> :category_type,
+            :conditions=>"rea_category_type.name = #{member.category_type_name}"
+        end
+
+      end
+      class MemberType < Base
+
+        attr_reader :category_type_name, :multiple_select
+
+        def initialize options={}
+          super
+          @multiple_select = options[:multiple_select] || false
+        end
+
+        def category name, options={}
+          @category_type_name = name
+        end
+
+        def category_options
+          Rea::CategoryType.find_by_name(category_type_name).categories
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rea/aspect_type/description.rb

@@ -1,7 +1,8 @@
 module Rea
   module AspectType
-    class Description < Base
-      attr_accessor :name, :media
+    module Description
+      class Aspect < Base
+      end
     end
   end
 end

data/lib/rea/aspect_type/due_date.rb

@@ -0,0 +1,34 @@
+module Rea
+  module AspectType
+    module DueDate
+
+      class Aspect < Base
+        def member *names
+          $options = names.extract_options!
+
+          base.send :scope, :expired_on, lambda { |*names|
+            $options = names.extract_options!
+            $clause = (names.collect {|name| " #{name} < :now " }).join(" AND ")
+            base.where($clause, :now=>DateTime.now )
+          }
+          base.send :scope, :active_on, lambda { |*names|
+            $options = names.extract_options!
+            $clause = (names.collect {|name| " #{name} > :now " }).join(" AND ")
+            base.where($clause, :now=>DateTime.now )
+          }
+
+          names.each do |name|
+            base.send :attr_accessible, name
+            base.send :define_method, "#{name}_state" do
+              (Time.now > self.send(name)) ? :expired : :active
+            end
+
+            base.send :define_method, "#{name}_expired?" do
+              self.send("#{name}_state") == :expired
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rea/aspect_type/identification.rb

@@ -0,0 +1,38 @@
+module Rea
+  module AspectType
+    module Identification
+
+      def self.included base
+        base.before_create do |object|
+          base.identification_aspect.identifiers.values.each do |val|
+            identifier = Rea::Identifier.find_by_name val.type
+            return unless identifier
+            object.send "#{val.name}=", identifier.generate
+          end
+        end
+      end
+
+      class Setup
+        attr_accessor :name, :type
+        def initialize options={}
+          options.keys.each do |key| instance_variable_set("@#{key}", options[key]) end
+        end
+      end
+
+      class Aspect < Base
+        def identifiers
+          @identifiers ||= {}
+        end
+
+        def identifier *names
+          $options = names.extract_options!
+          names.each do |name|
+            $default_id_type = "#{base.name.underscore}.#{name}"
+            $options = {:name=>name,:type=>$default_id_type}.merge($options)
+            identifiers[name] = Setup.new($options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rea/engine.rb

@@ -3,9 +3,7 @@ module Rea
     isolate_namespace Rea
 
     initializer :rea_rails_initializer do |app|
-      ActiveRecord::Base.class_eval do
-        include Rea::Dsl
-      end
+      app.config.i18n.load_path += Dir[::Rea::Engine.root.join('config','locales','*.{rb,yml}').to_s]
     end
   end
 end

data/lib/rea/meta_type.rb

@@ -1,7 +1,7 @@
 module Rea
   module MetaType
 
-    %w{entity resource event agent commitment contract group type schedule}.each do |name|
+    %w{entity resource event agent commitment contract group type schedule process exchange conversion}.each do |name|
       autoload name.camelize.to_sym, "rea/meta_type/#{name}"
     end
   end

data/lib/rea/meta_type/agent.rb

@@ -3,7 +3,7 @@ module Rea
     module Agent
       def self.included base
         base.fields = [:name]
-        Entity.included base
+        base.send :include, Entity
       end
     end
   end

data/lib/rea/meta_type/commitment.rb

@@ -6,20 +6,19 @@ module Rea
         Entity.included base
         base.extend ::Rea::MetaType::Event::ClassMethods
         base.extend ClassMethods
+        base.cattr_accessor :event_handler
         base.after_save :after_save_commitment
       end
 
       def after_save_commitment
-        if fulfilled_changed?
-          self.class.event_creator.create_event(self)
+        if self.respond_to?(:fulfilled_changed?) && fulfilled_changed?
+          self.instance_exec &self.class.event_handler if self.class.event_handler
         end
       end
 
       module ClassMethods
-
-        def event_creator klass, options={}
-          cattr_reader :event_creator
-          self.class_variable_set "@@event_creator", klass
+        def event_creator &block
+          self.event_handler = block
         end
       end
     end

data/lib/rea/meta_type/contract.rb

@@ -3,14 +3,27 @@ module Rea
     module Contract
       def self.included base
         base.fields = nil
-        Entity.included base
+        base.send :include, Entity
         base.extend ClassMethods
       end
 
       module ClassMethods
-        def clause klass, options={}
-          has_many klass.name.tableize.to_sym, {:class_name=>klass.name, :foreign_key=>:contract_id}.merge(options)
-          klass.belongs_to :contract, :class_name => self.name
+
+        def clauses
+          @@clauses ||= []
+        end
+
+        def clause klass_or_symbol, options={}
+          $klass = guess_entity_class klass_or_symbol
+          has_many $klass.name.tableize.to_sym, {:class_name=>$klass.name, :foreign_key=>:contract_id}.merge(options)
+          self.clauses << $klass
+          $klass.belongs_to :contract, :class_name => self.name
+        end
+
+        def party name, klass_or_sym, options={}
+          $klass = guess_entity_class(klass_or_sym)
+          attr_accessible :"#{name}_id"
+          belongs_to name, {:class_name=>$klass.name}.merge(options)
         end
       end
     end

data/lib/rea/meta_type/conversion.rb

@@ -0,0 +1,6 @@
+module Rea
+  module MetaType
+    class Conversion < Process
+    end
+  end
+end

data/lib/rea/meta_type/entity.rb

@@ -5,38 +5,64 @@ module Rea
         base.class_eval do
           unless self.ancestors.include? ActiveRecord::Base
             include ::Rea::Plugins::ActiveModel
-            attr_accessor *self.fields if base.fields
+          else
+            attr_accessible *self.fields if self.fields
+          end
+          if base.fields
+            validates_presence_of *self.fields
           end
-          validates_presence_of *self.fields if base.fields
         end
         base.extend ClassMethods
+        base.extend ::Rea::AspectType::ClassMethods
       end
 
       module ClassMethods
 
-        def item name, options={}, &block
-          if self.ancestors.include?(ActiveRecord::Base)
-            @context = self.find_or_create_by_name name, options
-          else
-            cattr_reader name
-            @context = self.new({:name=>name.to_s, :value=>1}.merge(options))
-            self.class_variable_set "@@#{name}", @context
+        def setup options=nil
+          options = {:entity_type=>:active_record}.merge(options)
+          class_option_set :entity_type, options
+
+          case
+          when self.entity_type == :simple
+            attr_accessor :id
+            self.class_eval do
+              def self.find id
+                self.items[id]
+              end
+            end
+          end
+        end
+
+        def groups; @@groups ||= [] ; end
+
+        def grouping *names
+          $options = names.extract_options!
+          names.each do |name|
+            attr_accessible "#{name}_id"
+            belongs_to name, $options
           end
-          block.call if block_given?
         end
 
-        def grouping options={}, &block
-          has_many :group_entities, :as=>:entity
-          has_many :groups, :through=>:group_entities
-          #group_class.entity_classes << self
-          block.call if block_given?
+        def groups_for name
+          klass = Rea.context.symbol_table[name]
+          klass.all
         end
 
-        def group_item *group_names, &block
-          options = group_names.extract_options!
-          group_names.flatten.each do |name|
-            @context = Rea::Group.groups(self).find_or_create_by_name(name, :entity_types=>self.name)
-            block.call if block_given?
+        def items
+          @@items ||= {}
+        end
+
+        def item name, options={}, &block
+          if self.entity_type == :simple
+            cattr_reader name
+            $item = self.new
+            options.keys.each do |key|
+              $item.instance_variable_set("@#{key}", options[key])
+            end if options
+            self.class_variable_set "@@#{name}", $item
+            items[$item.id] = $item
+          else
+            raise "not support #{self.entity_type} yet!" 
           end
         end
 
@@ -44,6 +70,21 @@ module Rea
         def specification name, options={}
           belongs_to name, options
         end
+
+        protected
+        def guess_entity_class klass_or_symbol 
+          $klass = klass_or_symbol.is_a?(Symbol) ? Rea.context.symbol_table[klass_or_symbol] : klass_or_symbol
+          raise "entity not found #{klass_or_symbol}" unless $klass
+          $klass
+        end
+
+        def class_option_set *names
+          $options = names.extract_options!
+          names.each do |name|
+            self.cattr_reader name
+            self.class_variable_set "@@#{name}", $options[name]
+          end
+        end
       end
     end
   end