circuit 0.2.0

data/lib/circuit/storage/nodes.rb

@@ -0,0 +1,56 @@
+module Circuit
+  module Storage
+    module Nodes
+      autoload :Model,        'circuit/storage/nodes/model'
+      autoload :MemoryStore,  'circuit/storage/nodes/memory_store'
+      autoload :MongoidStore, 'circuit/storage/nodes/mongoid_store'
+
+      extend Circuit::Storage
+
+      # Raised when #get isn't overriden/implemented
+      class UnimplementedError < CircuitError; end
+
+      # Raised when a path is not found
+      class NotFoundError < CircuitError; end
+
+      # @abstract Subclass and override {#get}
+      class BaseStore
+        # @param [Sites::Model] site to find path under
+        # @param [String] path to find
+        # @return [Array<Model>] array of nodes for each path segment
+        def get(site, path)
+          raise UnimplementedError, "#{self.class.to_s}#get not implemented."
+        end
+
+        # @raise NotFoundError if the path cannot be found
+        # @param (see #get)
+        # @return [Model] Node Model
+        # @see #get
+        def get!(site, path)
+          get(site, path) or raise NotFoundError, "Path not found"
+        end
+
+        protected
+
+        # Iterates over the path segments to find the nodes
+        # @param [Model] root node
+        # @param [String] path to find
+        # @return [Array<Model>] array of node Models
+        # @see Rack::Request::ClassMethods#path_segments
+        def find_nodes_for_path(root, path)
+          raise(NotFoundError, "Root path not found") if root.nil?
+          [root].tap do |result|
+            ::Rack::Request.path_segments(path).each do |segment|
+              next if segment.blank?
+              if node = result.last.find_child_by_segment(segment)
+                result << node
+              else
+                break
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/nodes/memory_store.rb

@@ -0,0 +1,63 @@
+module Circuit
+  module Storage
+    module Nodes
+      # Concrete node store for memory
+      class MemoryStore < BaseStore
+        # @param [Sites::Model] site to find path under
+        # @param [String] path to find
+        # @return [Array<Model>] array of nodes for each path segment
+        def get(site, path)
+          find_nodes_for_path(site.route, path)
+        rescue NotFoundError
+          return nil
+        end
+
+        # Concrete memory Node class
+        class Node
+          include Circuit::Storage::MemoryModel
+          setup_attributes :slug, :behavior_klass, :site, :parent, :children
+
+          # @!attribute slug
+          #   @return [String] path segment slug
+
+          # @!attribute behavior_klass
+          #   @return [String] name of Behavior class or module
+
+          # @!attribute site
+          #   @return [Sites::Model] site
+
+          # @!attribute parent
+          #   @return [Sites::Node] parent node
+
+          # @!attribute children
+          #   @return [Array<Sites::Node>] array of child nodes
+
+          include Circuit::Storage::Nodes::Model
+          include Circuit::Storage::Nodes::Model::Validations
+
+          def initialize(opts={})
+            memory_model_setup
+            behavior = opts.delete(:behavior) || opts.delete("behavior")
+            self.attributes = opts
+            self.slug = opts[:slug]
+            self.behavior = behavior if behavior
+            self.children ||= Array.new
+          end
+
+          # Save the Node to memory
+          # @return [Boolean] `true` if the Node was saved
+          def save
+            return false if invalid?
+            unless persisted?
+              self.site.route = self if self.site
+              self.parent.children << self if self.parent
+              self.children.each {|c| c.parent = self}
+              self.class.all << self
+            end
+            persisted!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/nodes/model.rb

@@ -0,0 +1,67 @@
+require 'active_support/concern'
+require 'active_model/validations'
+require 'circuit/validators'
+
+module Circuit
+  module Storage
+    module Nodes
+      # @abstract include into a Class or Module to setup the necessary methods
+      # for a Node model
+      module Model
+        extend ActiveSupport::Concern
+
+        # Validations for Node models
+        # * validates the slug's format and presence when not the root
+        # * validates the presence of the behavior_klass
+        # * validates the presence of the parent if the slug is defined
+        # @see Circuit::Validators::SlugValidator
+        # @abstract include into a Node class or Module to add the Validations
+        module Validations
+          extend ActiveSupport::Concern
+          include ActiveModel::Validations
+
+          included do
+            validates :slug, :slug => {:allow_blank => true}, :presence => {:unless => :root?}
+            validates :behavior_klass, :presence => true
+            validates :parent, :presence => true, :if => :slug?
+          end
+        end
+
+        # @return [Boolean] `false` if the parent is `nil`
+        def root?
+          parent.nil?
+        end
+
+        # @return [Class,Module] Behavior class or module for the behavior_klass
+        # @see Behavior#get
+        def behavior
+          return nil if self.behavior_klass.blank?
+          Behavior.get(behavior_klass)
+        end
+
+        # @param [Class,Module] klass Module or Class to set the behavior_klass
+        def behavior=(klass)
+          self.behavior_klass = klass.to_s
+        end
+
+        # @param [String] segment path segment
+        # @return [Model] child for the segment or `nil` if not found
+        def find_child_by_segment(segment)
+          self.children.detect {|c| c.slug == segment}
+        end
+
+        # Walks the tree and forms the full path to the Node
+        # @return [String] full path down to this node
+        def path
+          result = []
+          node = self
+          while node.parent
+            result.unshift node.slug
+            node = node.parent
+          end
+          "/"+result.join("/")
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/nodes/mongoid_store.rb

@@ -0,0 +1,56 @@
+require 'mongoid/tree'
+
+module Circuit
+  module Storage
+    module Nodes
+      # Concrete nodes store for Mongoid
+      class MongoidStore < BaseStore
+        # @param [Sites::Model] site to find path under
+        # @param [String] path to find
+        # @return [Array<Model>] array of nodes for each path segment
+        def get(site, path)
+          find_nodes_for_path(site.route, path)
+        rescue NotFoundError
+          return nil
+        end
+
+        # Concrete Mongoid Node class
+        class Node
+          include Model
+          include Model::Validations
+          include Mongoid::Document
+          include Mongoid::Tree
+          include Mongoid::Tree::Ordering
+          include Mongoid::Tree::Traversal
+
+          store_in :collection => "circuit_nodes"
+
+          field :slug, :type => String
+          field :behavior_klass, :type => String
+
+          # @!attribute slug
+          #   @return [String] path segment slug
+
+          # @!attribute behavior_klass
+          #   @return [String] name of Behavior class or module
+
+          # @!attribute site
+          #   @return [Sites::Model] site
+
+          # @!attribute parent
+          #   @return [Sites::Node] parent node
+
+          # @!attribute children
+          #   @return [Array<Sites::Node>] array of child nodes
+
+          belongs_to :site, :class_name => "Circuit::Site",
+                            :inverse_of => :route
+
+          def find_child_by_segment(segment)
+            self.children.where(:slug => segment).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/sites.rb

@@ -0,0 +1,38 @@
+module Circuit
+  module Storage
+    module Sites
+      autoload :Model,        'circuit/storage/sites/model'
+      autoload :MemoryStore,  'circuit/storage/sites/memory_store'
+      autoload :MongoidStore, 'circuit/storage/sites/mongoid_store'
+
+      extend Circuit::Storage
+
+      # Raised when #get isn't overriden/implemented
+      class UnimplementedError < CircuitError; end
+
+      # Raised when a site is not found
+      class NotFoundError < CircuitError; end
+
+      # Raised when multiple sites are found for the same host
+      class MultipleFoundError < CircuitError; end
+
+      # @abstract Subclass and override {#get}
+      class BaseStore
+        # @raise MultipleFoundError if multiple sites are found for the given `host`
+        # @param [String] host to find
+        # @return [Model] site
+        def get(host)
+          raise UnimplementedError, "#{self.class.to_s}#get not implemented."
+        end
+
+        # @raise NotFoundError if the site is not found
+        # @param (see #get)
+        # @return [Model] site model
+        # @see #get
+        def get!(host)
+          get(host) or raise NotFoundError, "Host not found"
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/sites/memory_store.rb

@@ -0,0 +1,53 @@
+module Circuit
+  module Storage
+    module Sites
+      # Concrete site store for memory
+      class MemoryStore < BaseStore
+        # @raise MultipleFoundError if multiple sites are found for the given `host`
+        # @param [String] host to find
+        # @return [Model] site
+        def get(host)
+          sites = Site.all.select {|s| s.host == host or s.aliases.include?(host)}
+          if sites.length > 1
+            raise MultipleFoundError, "Multiple sites found"
+          end
+          sites.first
+        end
+
+        # Concrete memory Site class
+        class Site
+          include Circuit::Storage::MemoryModel
+          setup_attributes :host, :aliases, :route
+
+          # @!attribute host
+          #   @return [String] domain name
+
+          # @!attribute aliases
+          #   @return [Array<String>] array of domain name aliases
+
+          # @!attribute route
+          #   @return [Nodes::Model] root node
+
+          include Circuit::Storage::Sites::Model
+          include Circuit::Storage::Sites::Model::Validations
+
+          def initialize(opts={})
+            memory_model_setup
+            self.attributes = opts
+            self.aliases ||= Array.new
+          end
+
+          # Save the Site to memory
+          # @return [Boolean] `true` if the Site was saved
+          def save
+            return false if invalid?
+            unless persisted?
+              self.class.all << self
+            end
+            persisted!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/sites/model.rb

@@ -0,0 +1,29 @@
+require 'active_support/concern'
+require 'active_model/validations'
+require 'circuit/validators'
+
+module Circuit
+  module Storage
+    module Sites
+      # @abstract include into a Class or Module to setup the necessary methods
+      # for a Site model
+      module Model
+        # Validations for Site models
+        # * validates the host's format and presence
+        # * validates the aliases' formats
+        # @see Circuit::Validators::DomainValidator
+        # @see Circuit::Validators::DomainArrayValidator
+        # @abstract include into a Site class or Module to add the Validations
+        module Validations
+          extend ActiveSupport::Concern
+          include ActiveModel::Validations
+
+          included do
+            validates :host, :presence => true, :domain => true
+            validates :aliases, :domain_array => true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/circuit/storage/sites/mongoid_store.rb

@@ -0,0 +1,43 @@
+module Circuit
+  module Storage
+    module Sites
+      # Concrete site store for Mongoid
+      class MongoidStore < BaseStore
+        # @raise MultipleFoundError if multiple sites are found for the given `host`
+        # @param [String] host to find
+        # @return [Model] site
+        def get(host)
+          sites = Circuit::Site.any_of({:host => host}, {:aliases => host}).all
+          if sites.length > 1
+            raise MultipleFoundError, "Multiple sites found"
+          end
+          sites.first
+        end
+
+        # Concrete Mongoid Site class
+        class Site
+          include Model
+          include Model::Validations
+          include Mongoid::Document
+
+          store_in :collection => "circuit_sites"
+
+          field :host, :type => String
+          field :aliases, :type => Array
+
+          # @!attribute host
+          #   @return [String] domain name
+
+          # @!attribute aliases
+          #   @return [Array<String>] array of domain name aliases
+
+          # @!attribute route
+          #   @return [Nodes::Model] root node
+
+          has_one :route, :class_name => "Circuit::Node",
+                          :inverse_of => :site
+        end
+      end
+    end
+  end
+end

data/lib/circuit/validators.rb

@@ -0,0 +1,74 @@
+require 'active_model/validator'
+
+module Circuit
+  module Validators
+    DOMAIN_REGEXP = /\A(([a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?)\.)*([a-z]{2,}|([a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?))\Z/
+    SLUG_REGEXP = /\A(?:[-_.!~*'()a-zA-Z\d:@&=+$,]|%[a-fA-F\d]{2})*(?:;(?:[-_.!~*'()a-zA-Z\d:@&=+$,]|%[a-fA-F\d]{2})*)*\Z/
+
+    # @!method validates_domain(*attr_names, options)
+    #   Validates that the attributes are domain names
+    #   @see ActiveModel::EachValidator
+    #   @param [Array<Symbol>] attr_names to validate
+    #   @param [Hash] options for validator
+    #   @option options [String] :message ("is not a valid domain.") invalid value message
+    #   @option options [String] :allow_nil (false) true to allow nil values
+    #   @option options [String] :allow_blank (false) true to allow blank values
+
+    class DomainValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:message] ||= "is not a valid domain."
+        super(options)
+      end
+
+      def validate_each(record, attribute, value)
+        record.errors.add attribute, options[:message] unless value =~ DOMAIN_REGEXP
+      end
+    end
+
+    # @!method validates_domain_array(*attr_names, options)
+    #   Validates that an Array is an Array of domain names
+    #   @see ActiveModel::EachValidator
+    #   @param [Array<Symbol>] attr_names to validate
+    #   @param [Hash] options for validator
+    #   @option options [String] :message ("has an valid domain.") invalid value message
+    #   @option options [String] :allow_nil (false) true to allow nil values
+    #   @option options [String] :allow_blank (false) true to allow blank values
+
+    class DomainArrayValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:message] ||= "has an invalid domain."
+        super(options)
+      end
+
+      def validate_each(record, attribute, value)
+        if Array.wrap(value).detect { |val| !(val =~ DOMAIN_REGEXP) }
+          record.errors.add attribute, options[:message]
+        end
+      end
+    end
+
+    # @!method validates_slug(*attr_names, options)
+    #   Validates that the attributes are slugs (i.e. URI path segments)
+    #   @see ActiveModel::EachValidator
+    #   @param [Array<Symbol>] attr_names to validate
+    #   @param [Hash] options for validator
+    #   @option options [String] :message ("is not a valid path segment.") invalid value message
+    #   @option options [String] :allow_nil (false) true to allow nil values
+    #   @option options [String] :allow_blank (false) true to allow blank values
+
+    class SlugValidator < ActiveModel::EachValidator
+      def initialize(options)
+        options[:message] ||= "is not a valid path segment."
+        super(options)
+      end
+
+      def validate_each(record, attribute, value)
+        record.errors.add attribute, options[:message] unless value =~ SLUG_REGEXP
+      end
+    end
+  end
+end
+
+DomainValidator = Circuit::Validators::DomainValidator
+DomainArrayValidator = Circuit::Validators::DomainArrayValidator
+SlugValidator = Circuit::Validators::SlugValidator