kns_endpoint 0.1.8 → 0.1.9

data/lib/kns_endpoint.rb

@@ -5,99 +5,106 @@ require 'logger'
 module Kynetx
 
   class Endpoint
-    attr_accessor :session, :environment, :ruleset, :use_session, :headers, :logging, :log
 
-    @@events = {}
-    @@directives = {}
-    @@use_session = true;
-    @@environment = :production
-    @@ruleset = nil
     RestClient.log = Logger.new(STDOUT) if $KNS_ENDPOINT_DEBUG
 
+    # DSL 
+    class << self
+      attr_reader :events, :directives 
+      attr_reader :c_ruleset, :c_domain, :c_use_session, :c_environment
+
+      def event(e, params={}, &block)
+        @events ||= {}
+        @events[e] = { :params => params }
+        @events[e][:block] = block_given? ? block : lambda { |p| p }
+      end
+
+      def directive(d, &block)
+        @directives ||= {}
+        @directives[d] = block_given? ? block : lambda { |p| p }
+      end
+
+      def use_session(u); @c_use_session = u end
+      def environment(e); @c_environment = e end
+      def ruleset(r); @c_ruleset = r end
+      def domain(d); @c_domain = d end
+
+      def signal(e, params)
+        tmp_endpoint = self.new
+        tmp_endpoint.signal(e, params)
+      end
+
+      def method_missing(meth, *args)
+        if @events.include? meth.to_sym 
+          ruleset = @ruleset
+          if args.first.class == Symbol
+            ruleset = args.first 
+            params = args.length > 1 ? args.last : {}
+          else
+            params = args.first
+          end
+          e = self.new({:ruleset => ruleset})
+          e.signal(meth.to_sym, params)
+        else
+          super
+        end
+      end
+
+
+    end
+
+    attr_accessor :session, :environment, :ruleset, :use_session, :headers, :logging, :query_timeout
+    attr_reader :log
+
     def initialize(opts={})
       @environment = opts[:environment] if opts[:environment]
       @ruleset = opts[:ruleset] if opts[:ruleset]
       @use_session = opts[:use_session] if opts[:use_session]
       @query_timeout = opts[:query_timeout] if opts[:query_timeout]
       @logging = opts[:logging] if opts[:logging]
-
-      # set the defaults
-      @events = @@events
-      @directives = @@directives
-      @domain = @@domain
-      @environment ||= @@environment
-      @use_session ||= @@use_session
-      @ruleset ||= @@ruleset
+      @headers = opts[:headers] if opts[:headers]
+      
+      @events = self.class.events
+      @directives = self.class.directives
+      @ruleset ||= self.class.c_ruleset 
+      @domain = self.class.c_domain 
+      @environment ||= self.class.c_environment || :production
+      @use_session ||= self.class.c_use_session || true
+      
+      # instance level settings
       @query_timeout ||= 120
       @headers ||= {}
       @logging ||= false
       @log = []
+      @params = {}
+      raise "No events defined" unless @events 
+      raise "No directives defined" unless @directives
       raise "Undefined ruleset." unless @ruleset
-      raise "Undefined Domain" unless @domain
-    end
-
-    ## Endpoint DSL
-
-    def self.event(e, params={}, &block)
-      @@events[e] = { :params => params }
-      @@events[e][:block] = block_given? ? block : lambda { |p| p }
-    end
-
-    def self.directive(d, &block)
-      raise "Directive must supply a block." unless block_given?
-      @@directives[d] = block
+      raise "Undefined domain." unless @domain
     end
 
-    def self.ruleset(r); @@ruleset = r end
-    def self.domain(d); @@domain = d end
-    def self.environment(e); @@environment = e end
-    def self.use_session(s); @@use_session = s end
-
-    ##########
-
     def signal(e, params={})
       run_event(e, params)
     end
 
-    def self.signal(e, params)
-      tmp_endpoint = self.new({:ruleset => @@ruleset, :environment => @@environment})
-      tmp_endpoint.signal(e, params)
+    def params
+      @params ||= {}
     end
 
     # allow calling events directly
     def method_missing(meth, *args)
-      if @@events.keys.include? meth.to_sym
+      if @events.keys.include? meth.to_sym
         return run_event(meth.to_sym, args.first)
       else
         super
       end
     end
 
-    def self.method_missing(meth, *args)
-      if @@events.include? meth.to_sym 
-        ruleset = @@ruleset
-        if args.first.class == Symbol
-          ruleset = args.first 
-          params = args.length > 1 ? args.last : {}
-        else
-          params = args.first
-        end
-        e = self.new({:ruleset => ruleset})
-        e.signal(meth.to_sym, params)
-      else
-        super
-      end
-    end
-
     private
 
-    def run_event(e, params)
+    def run_event(e, p)
       # run the event
-
-      # set the default params as an empty hash
-
-      params ||= {}
-
+      @params = p
       kns_json = {"directives" => []}
       
       begin
@@ -105,6 +112,10 @@ module Kynetx
 
         if @events.keys.include? e
           @events[e][:block].call(params) 
+
+          if self.methods.include? "before_#{e}"
+            send "before_#{e}".to_sym
+          end
         else
           raise "Undefined event #{e.to_s}"
         end
@@ -169,8 +180,17 @@ module Kynetx
       # execute the returned directives
       directive_output = []
       kns_json["directives"].each do |d|
-        o = run_directive(d["name"].to_sym, d["options"]) if @directives.keys.include?(d["name"].to_sym)
-        directive_output.push o
+        directive = d["name"].to_sym
+        d_opts = d["options"]
+        if @directives.keys.include?(directive)
+          o = run_directive(directive, d_opts) 
+          directive_output.push o
+
+          if self.methods.include? "after_#{directive}"
+            send "after_#{directive}".to_sym, d_opts
+          end
+
+        end
       end
 
       return directive_output

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kns_endpoint
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Michael Farmer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-22 00:00:00 -07:00
+date: 2010-12-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency