opensteam 0.9.0 → 0.9.1

data/lib/opensteam/product_base.rb

@@ -1,3 +1,19 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
 module Opensteam
   
 =begin rdoc
@@ -49,7 +65,7 @@ Used to either be included into a model or injected with the
         products = (self._has_product || []).inject({}) { |r,v|
           r.merge!( { v => v.to_s.classify.constantize.find(:all) } ) }  || {}
 
-        products.delete(self.to_s.tableize) #unless <%= class_name %>.self.referential
+        products.delete(self.to_s.tableize) 
 
         products
       end
@@ -78,11 +94,23 @@ Used to either be included into a model or injected with the
 
 
         
+        
+        
         # inventory association
         has_many :inventories, :as => :product,
           :extend => Opensteam::Base::ExistByPropertiesExtension,
           :class_name => "Opensteam::InventoryBase::Inventory"
-                    
+
+        has_many :inventories_properties, :through => :inventories, :include => :property
+        
+        
+        
+        
+        
+        
+
+        
+        
   
         # holds the properties the product is allowed to have
         # used for view
@@ -136,7 +164,7 @@ Used to either be included into a model or injected with the
     # inventoy-objects which are currently associated with the product and do not
     # match the properties (p) are deleted.
     #
-    # used in the administration-views, to update the product-property associations.
+    # used in the admin-views, to update the product-property associations.
     #
     def set_properties=(p)
       save

data/lib/opensteam/property_base.rb

@@ -1,3 +1,19 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
 module Opensteam
   
   

data/lib/opensteam/shipment_base.rb

@@ -0,0 +1,60 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+module Opensteam
+
+
+  module ShipmentBase
+
+
+    # available States for an Shipment-Instance
+    module States
+
+    end
+
+
+
+    # Shipment Model
+    class Shipment < ActiveRecord::Base
+      
+      include Opensteam::StateMachine
+      
+      belongs_to :order, :class_name => 'Opensteam::OrderBase::Order'
+      belongs_to :customer, :class_name => 'Opensteam::UserBase::User'
+      belongs_to :address, :class_name => 'Opensteam::UserBase::Address'
+
+      has_many :order_items, :class_name => 'Opensteam::OrderBase::OrderItem'
+      
+      def initialize(*args)
+        super(*args)
+
+        if order
+          self.address = order.shipping_address
+          self.customer = order.customer
+        end
+
+      end
+  
+    end
+
+
+
+
+
+
+  end
+
+end

data/lib/opensteam/shopping_cart.rb

@@ -1,3 +1,18 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 require 'opensteam/finder'
 
@@ -8,20 +23,23 @@ module Opensteam
   module ShoppingCart
 		
 		
-		
-    # CartController
-    #
-    # - standard methods for ShoppingCart manipulation
-    # - automatically sets @cart to access shopping-cart
-    #
-    #
-    #
-    class CartController < ActionController::Base
-			
-			
-      #
-      #include @cart instance-variable in all actions
-      before_filter :set_instance_vars
+    def self.included(base)
+      base.extend ClassMethods
+      
+      base.class_eval do
+        include InstanceMethods
+        before_filter :set_instance_vars
+
+
+      end
+    end
+    
+    module ClassMethods
+    end
+    
+    
+    module InstanceMethods
+    
 			
       # delete item from cart
       #

data/lib/opensteam/state_logic.rb

@@ -0,0 +1,218 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+
+module Opensteam
+  
+  module StateLogic
+
+
+    # StateLogic Module
+    # included in State Modules
+    module Mod
+
+      @@states = []
+      mattr_accessor :states
+
+      def self.included(base)
+        @@states << base
+        base.extend(ClassMethods) if base.is_a?(Module)
+        
+      end
+
+      module ClassMethods
+
+        def name ; self.to_s.demodulize.downcase.to_sym ; end
+
+        def respond_to?( method )
+          self.protected_instance_methods.include?( method )
+        end
+
+        def state_module? ; true ; end
+        
+        
+        
+        
+        # included method
+        # called when the state-module is included into the receiver-class (like Order, Shipment, Invoice)
+        #
+        # for each instance-method of the state-module, it creates an alias (in the receiver-klass) and delegates it
+        # to the corresponding state-module (based on receiver.state -> StatePattern) through the fire_event method.
+        #
+        
+        def included(receiver)
+          self.instance_methods(false).each do |m|
+            
+            receiver.class_eval do
+              define_method(m) { |*args| fire_event( m, *args ) }
+            end
+            
+          end
+          
+          state_name = self.to_s.demodulize.downcase
+          receiver.class_eval do
+            define_method("#{state_name}?") { self.state == state_name }
+            named_scope state_name, :conditions => ["#{self.table_name}.state = ?", state_name ]
+            
+            class << self ;
+              def available_states
+                self.included_modules.select { |s| 
+                  s.ancestors.include?( Opensteam::StateLogic::Mod ) }.reject { |s| 
+                  s == Opensteam::StateLogic::Mod }
+              end
+            end
+          end
+        
+        end
+
+      end
+
+    end
+
+
+
+    
+    require 'observer'
+    
+#    
+#    class Base < ActiveRecord::Base
+#      self.table_name = "states"
+#
+#
+#      def self.state_type ; :state_base ; end
+#      def state_type ; self.class.state_type ; end
+#      
+#      Object.const_set "State", self
+#      
+#      @@sub_states = []
+#      class_inheritable_accessor :sub_states
+#      
+#
+#      def self.inherited(base)
+#        ( self.sub_states ||= [] ) << base
+#
+#      end
+#
+#
+#
+#
+#      def self.mod ; "#{self.to_s}Module".classify.constantize ; end
+#      def mod ; self.class.mod ; end
+#
+#      def self.state_name
+#        self.to_s =~ /^(.+)State$/
+#        $1 ? $1.underscore.to_sym : self.to_s.to_sym
+#      end
+#      
+#      def state_name ; self.class.state_name ; end
+#      
+#      def to_s ; self.state_name ; end
+#      
+#      
+#      def self.events
+#        ( ( self.instance_methods(false) - self.generated_methods.to_a ).collect { |x|
+#            x =~ /!$/ ? x : nil }.compact.collect(&:to_sym) )
+#      end
+#      
+#      
+#      def events ; self.events ; end
+#      
+#      
+#      def self.instance_for_event( sym )
+#        "#{sym}State".classify.constantize.create
+#      end
+#      
+#      
+#      
+#      
+#      
+#      
+#      
+#     
+#      
+#      def self.state(name, &block)
+#        klass_name = "#{name}State".classify
+#        begin
+#          klass = klass_name.constantize
+#          raise NameError if klass.superclass != self
+#          puts "#{klass} is defined!!"
+#        rescue NameError
+#          klass = Class.new( self )
+#          Object.const_set klass_name, klass
+#        end
+#        klass.class_eval(&block) if block_given?
+#      end
+#      
+#      
+#      def self.event(name, *args, &block)
+#        self.class_eval { define_method(name) { block.call } if block_given? }
+#        Opensteam::StateMachine.inject_state_queries( self )
+#        Opensteam::StateMachine.inject_event_methods( self )
+#      end
+#      
+#      
+#      def self.transition_observer(*args, &block)
+#        if args.first.is_a?( Hash )
+#          from, to = args.first.keys.first, args.first.values.first
+#        else
+#          from, to = self.state_name, args.first
+#        end##
+#
+#        if block_given?
+#          #      Opensteam::StateMachine.transitions[from] ||= {}
+#          #      ( Opensteam::StateMachine.transitions[from][to] ||= [] ) << block
+#        end
+#        
+#      end
+#      
+#    end
+#    
+#    
+
+  
+  end
+  
+
+end
+
+
+
+#if defined? RAILS_ROOT
+#  
+#  Dir.glob("#{RAILS_ROOT}/app/states/**/*.rb").collect { |f|
+#    puts f
+#    require f
+#    klass_name = "#{File.basename(f,'.rb')}State".classify
+#    begin
+#      klass = klass_name.constantize
+#    rescue NameError
+#      klass = Class.new( Opensteam::StateLogic::Base )
+#      Object.const_set klass_name, klass
+#    end
+#  }
+#
+#end
+
+
+## if rails is runniny
+#if defined? RAILS_ROOT
+#  ## init all states and create event methods for the Order-Instance
+#  Dir.glob("#{RAILS_ROOT}/app/models/*_states.rb").collect { |f|
+#    require Opensteam::State::Machine.create_event_methods_for_order( File.basename(f, ".rb").classify.constantize )
+#  }
+#end
+
+

data/lib/opensteam/state_machine.rb

@@ -0,0 +1,216 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+module Opensteam
+
+
+  # StateMachine Module
+  #
+  # 
+  module StateMachine
+      
+
+    class EventNotDefined < Opensteam::Config::Errors::OpensteamError
+    end
+
+    # raised when the event is not defined for current state
+    class EventNotDefinedForCurrentState < Opensteam::Config::Errors::OpensteamError
+    end
+      
+    class EventExecutionError < Opensteam::Config::Errors::OpensteamError
+    end
+    
+    module ClassMethods
+
+     def get_observer ; @@observer ||= [] ; end
+        
+      def initial_state( state )
+        after_create { |record| record.state = state }
+      end
+
+      # observe state-changes -> calls given block after change_state
+      def observe( &block )
+        observers << Opensteam::StateMachine::Observer.new( self, &block )
+      end
+      
+      # notify association on state-change
+      # calls the observers of the association
+      def notify(assoc)
+        observers << Opensteam::StateMachine::Observer.new( self ) do |record|
+          record.send( assoc ).class.observers.each { |o| o.exc( record.send( assoc ) ) }
+        end
+      end
+      
+    end
+    
+    
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+       include InstanceMethods
+        
+        # include the history module
+        include Opensteam::History
+        
+        @observers = []
+        class << self ; attr_accessor :observers ; end
+       
+      end
+
+    end
+    
+    
+    class Observer
+      attr_accessor :receiver, :code
+      
+      def initialize( receiver, &block )
+        @receiver = receiver
+        @code = block
+      end
+      
+      def exc( instance )
+        @code.call( instance )
+        #        @code.bind( instance ).call
+      end
+      
+      
+    end
+
+    
+    module ClassMethods
+    end
+    
+    
+    module InstanceMethods
+      
+      
+      # returns an array of event-methods for the current state
+      # -> the instance_methods of the current +state_module+
+      def events ; (s = self.state_module ) ? s.instance_methods : [] ; end
+
+      
+      # returns the corresponding module for the current state
+      #
+      # ex:
+      #   o = Order.create
+      #   o.state = :pending
+      #   o.state_module # => OrderStates::Pending
+      #
+      def state_module
+        return nil unless state
+        "#{self.class.to_s.demodulize}States::#{self.state.to_s.classify}".constantize rescue nil
+      end
+      
+
+      # overrides state-attribute setter
+      # calls +change_state+
+      def state=(new_state)
+        change_state(new_state)
+      end
+
+      
+      
+      
+      # fire an event for current state
+      # 
+      # if self.state is nil, returns false
+      # if +event+ is not defined for current state (not an instance method of +state_module+), an error is raised
+      # if an error occured during the event, an error-entry is saved into the history
+      # calls +change_state+ (return value of the event is used as next-state, if return value is a Symbol or a Module)
+      #
+      def fire_event(event, *args, &block )
+        
+        return false unless self.state
+        
+        add_history( "trying to fire event '#{event}' for state '#{self.state}'" )
+        
+        return false unless event_scope = self.state_module
+        
+        unless events.include?( event.to_s )
+          add_history( msg = "Error: event '#{event}' not defined for state '#{self.state}'")
+          raise EventNotDefined, msg
+          return false
+        end
+        
+        begin 
+          event_return = event_scope.instance_method( event ).bind( self ).call( *args, &block )
+          add_history( "Successfully executed event '#{event}' for state '#{self.state}'" )
+        rescue
+          add_history("Error: An error occured during event '#{event}' in state '#{self.state}' : '#{$!}'")
+        end
+        
+        unless event_return == false
+          self.state = event_return if( event_return.is_a?(Symbol) || event_return.is_a?(Module) )
+          return event_return
+        end
+
+      end
+      
+      
+      # changes state to +new_state+
+      #
+      # if current_state is equal +new_state+, return false
+      #
+      def change_state( new_state )
+        if new_state.is_a?( Module )
+          new_state = new_state.name
+        end
+        
+        current_state = state
+        
+        add_history "starting transition from state '#{current_state}' to state '#{new_state}'"
+        
+        if current_state == new_state
+          add_history "transition failed: current_state '#{current_state}' and new_state '#{new_state}' are the same!"
+          return false
+        end
+        
+        write_attribute(:state, new_state.to_s)
+        ret = save
+        
+        if ret
+          add_history( "Successfull: transition from state '#{current_state}' to state '#{new_state.to_s}'" )
+        else
+          add_history("Failed: transition from state '#{current_state}' to state '#{new_state.to_s}'")
+        end
+
+        
+        self.execute_observers
+#        self.class.observers.each do |o|
+#          o.exc( self )
+#        end
+        
+        ret
+  
+      end
+      
+      
+      def execute_observers
+        self.class.observers.each do |o|
+          o.exc( self )
+        end
+      end
+
+      
+
+      
+    end
+    
+  end
+  
+end
+