circuit 0.2.0

data/lib/circuit/compatibility.rb

@@ -0,0 +1,73 @@
+require 'rack'
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/kernel/reporting'
+require 'dionysus/string/version_match'
+
+module Circuit
+  # Compatibility extensions for Rack 1.3 and Rails 3.1
+  module Compatibility
+    # Make Rack 1.3 and ActiveSupport 3.1 compatible with circuit.
+    # * Overrides Rack::Builder and Rack::URLMap with the classes from Rack 1.4
+    # * Adds #demodulize and #deconstantize inflections to ActiveSupport
+    def self.make_compatible
+      rack13 if ::Rack.release.version_match?("~> 1.3.0")
+      active_support31 if ActiveSupport::VERSION::STRING.version_match?("~> 3.1.0")
+    end
+
+    # Include in a model to modify it for compatibility.
+    module ActiveModel31
+      extend ActiveSupport::Concern
+
+      # @!method define_attribute_methods(*args)
+      #   Modified to call `attribute_method_suffix ''` first to create the 
+      #   accessors.
+      #   @see http://rubydoc.info/gems/activemodel/ActiveModel/AttributeMethods/ClassMethods#define_attribute_methods-instance_method
+      #   @see http://rubydoc.info/gems/activemodel/ActiveModel/AttributeMethods/ClassMethods#attribute_method_suffix-instance_method
+
+      included do
+        if ActiveModel::VERSION::STRING.version_match?("~> 3.1.0")
+          if has_active_model_module?("AttributeMethods")
+            class << self
+              alias_method_chain :define_attribute_methods, :default_accessor
+            end
+          end
+        end
+      end
+
+      private
+
+      module ClassMethods
+        def has_active_model_module?(mod_name)
+          included_modules.detect {|mod| mod.to_s == "ActiveModel::#{mod_name.to_s.camelize}"}
+        end
+
+        def define_attribute_methods_with_default_accessor(*args)
+          attribute_method_suffix ''
+          define_attribute_methods_without_default_accessor(*args)
+        end
+      end
+    end
+
+    private
+
+    def self.vendor_path
+      Circuit.vendor_path
+    end
+
+    def self.rack13
+      require "rack/urlmap"
+      require "rack/builder"
+
+      require vendor_path.join("rack-1.4", "builder").to_s
+      silence_warnings { require vendor_path.join("rack-1.4", "urlmap").to_s }
+    end
+
+    def self.active_support31
+      require "active_support/inflector"
+
+      require vendor_path.join("active_support-3.2", "inflector", "methods").to_s
+      require vendor_path.join("active_support-3.2", "core_ext", "string", "inflections").to_s
+    end
+  end
+end

data/lib/circuit/middleware.rb

@@ -0,0 +1,6 @@
+module Circuit
+  # Set of predefined middlewares to use with Circuit
+  module Middleware
+    autoload :Rewriter, "circuit/middleware/rewriter"
+  end
+end

data/lib/circuit/middleware/rewriter.rb

@@ -0,0 +1,43 @@
+module Circuit
+  module Middleware
+    # Raise if rewriting fails.
+    class RewriteError < CircuitError ; end
+
+    # Rewriter middleware
+    # @example Use the middleware (in rackup)
+    #   use Rewriter do |script_name, path_info|
+    #         ["/pages", script_name+path_info]
+    #       end
+    # @example Use the middleware with Rack::Request object (in rackup)
+    #   use Rewriter do |request|
+    #         ["/site/#{request.site.id}"+request.script_name, request.path_info]
+    #       end
+    # @see http://rubydoc.info/gems/rack/Rack/Request Rack::Request documentation
+    class Rewriter
+      # @param [#call] app Rack app
+      # @yield [script_name, path_info] `SCRIPT_NAME` and `PATH_INF`O values
+      # @yield [Request] `Rack::Request` object
+      # @yieldreturn [Array<String>] new `script_name` and `path_info`
+      def initialize(app, &block)
+        @app = app
+        @block = block
+      end
+
+      # Executes the rewrite
+      def call(env)
+        begin
+          request = ::Rack::Request.new(env)
+          script_name, path_info, path = request.script_name, request.path_info, request.path
+          env["SCRIPT_NAME"], env["PATH_INFO"] = @block.call(script_name, path_info)
+          if script_name != env["SCRIPT_NAME"] or path_info != env["PATH_INFO"]
+            ::Circuit.logger.info("[CIRCUIT] Rewriting: '#{path}'->'#{request.path}'")
+          end
+        rescue RewriteError => ex
+          headline = "[CIRCUIT] Rewrite Error"
+          ::Circuit.logger.error("%s: %s\n%s  %s"%[headline, ex.message, " "*headline.length, ex.backtrace.first])
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/circuit/rack.rb

@@ -0,0 +1,14 @@
+require 'rack/request'
+
+module Circuit
+  module Rack
+    require 'circuit/rack/request'
+    ::Rack::Request.send(:include, Request)
+
+    require 'circuit/rack/builder'
+    ::Rack::Builder.send(:include, BuilderExt)
+
+    autoload :Behavioral, 'circuit/rack/behavioral'
+    autoload :MultiSite,  'circuit/rack/multi_site'
+  end
+end

data/lib/circuit/rack/behavioral.rb

@@ -0,0 +1,45 @@
+module Circuit
+  module Rack
+    # Raised if the `rack.circuit.site` rack variable is not defined (or `nil`)
+    class MissingSiteError < CircuitError; end
+
+    # Finds the route (Array of Nodes) for the request, and executes the 
+    # route's behavior.
+    class Behavioral
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+
+        unless request.site
+          raise MissingSiteError, "Rack variable %s is missing"%[::Rack::Request::ENV_SITE]
+        end
+
+        remap! request
+        request.route.last.behavior.builder.tap do |builder|
+          builder.run(@app) unless builder.app?
+        end.call(env)
+      end
+
+    private
+
+      def remap(request)
+        route = ::Circuit.node_store.get(request.site, request.path)
+        return nil if route.blank?
+
+        request.route = route
+        return request
+      end
+
+      def remap!(request)
+        if result = remap(request)
+          result
+        else
+          raise ::Circuit::Storage::Nodes::NotFoundError, "Path not found"
+        end
+      end
+    end
+  end
+end

data/lib/circuit/rack/builder.rb

@@ -0,0 +1,50 @@
+require 'rack/server'
+require 'rack/builder'
+
+module Circuit
+  module Rack
+    # Extensions to Rack::Builder
+    module BuilderExt
+      # @return [Boolean] true if a default app is set
+      def app?
+        !!@run
+      end
+
+      # Duplicates the `@use` Array and `@map` Hash instance variables
+      def initialize_copy(other)
+        @use = other.instance_variable_get(:@use).dup
+        unless other.instance_variable_get(:@map).nil?
+          @map = other.instance_variable_get(:@map).dup
+        end
+      end
+    end
+
+    # A Rack::Builder variation that does not require a fully-compliant rackup
+    # file; specifically that a default app (`run` directive) is not required.
+    class Builder < ::Rack::Builder
+      include BuilderExt
+
+      # Parses the rackup (or circuit-rackup .cru) file.
+      # @return [Circuit::Rack::Builder] the builder
+      def self.parse_file(config, opts = ::Rack::Server::Options.new)
+        # allow for objects that are String-like but don't respond to =~ 
+        # (e.g. Pathname)
+        config = config.to_s
+
+        if config.to_s =~ /\.cru$/
+          options = {}
+          cfgfile = ::File.read(config)
+          cfgfile.sub!(/^__END__\n.*\Z/m, '')
+          builder = eval "%s.new {\n%s\n}"%[self, cfgfile], TOPLEVEL_BINDING, config
+          return builder, options
+        else
+          # this should be a fully-compliant rackup file (or a constant name),
+          # so use the real Rack::Builder, but return a Builder object instead 
+          # of the app
+          app, options = ::Rack::Builder.parse_file(config, opts)
+          return self.new(app), options
+        end
+      end
+    end
+  end
+end

data/lib/circuit/rack/multi_site.rb

@@ -0,0 +1,22 @@
+module Circuit
+  module Rack
+    # Finds the Circuit::Site for the request.  Returns a 404 if the site is not found.
+    class MultiSite
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+
+        request.site = Circuit.site_store.get(request.host)
+        unless request.site
+          # TODO custom 404 page for site not found
+          return [404, {}, ["Not Found"]]
+        end
+
+        @app.call(request.env)
+      end
+    end
+  end
+end

data/lib/circuit/rack/request.rb

@@ -0,0 +1,81 @@
+require 'active_support/concern'
+
+module Circuit
+  module Rack
+    # Extensions made to the ::Rack::Request class
+    # @see http://rubydoc.info/gems/rack/Rack/Request ::Rack::Request API documentation
+    # @see ClassMethods
+    module Request
+      extend ActiveSupport::Concern
+
+      # Key for storing the Circuit::Site instance
+      ENV_SITE          = 'rack.circuit.site'
+
+      # Key for storing the array of Circuit::Node instances
+      ENV_ROUTE         = 'rack.circuit.route'
+
+      # Key for storing original parameters that Circuit modifies.
+      ENV_ORIGINALS     = 'rack.circuit.originals'
+
+      module ClassMethods
+        # Parses a URI path String into its segments
+        # @param [String] path to parse
+        # @return [Array<String>] segment parts; first segment will be `nil` if
+        #                         it is the root (i.e. the path is absolute)
+        # @see http://tools.ietf.org/html/rfc2396#section-3.3 RFC 2396: Uniform
+        #      Resource Identifiers (URI): Generic Syntax - Path Component
+        def path_segments(path)
+          path.gsub(/^\/+/,'').split(/\/+/).select { |seg| !seg.blank? }.tap do |result|
+            result.unshift nil if path =~ /^\//
+          end
+        end
+      end
+
+      # @return [Circuit::Site] site from the environment
+      def site() @env[ENV_SITE]; end
+
+      # @param [Circuit::Site] site to set into the environment
+      def site=(site)  @env[ENV_SITE] = site; end
+
+      # @return [Array<Circuit::Node>] the array of nodes that make up the
+      #                                route
+      def route() @env[ENV_ROUTE]; end
+
+      # Sets the route and modifies the `PATH_INFO` and `SCRIPT_NAME` variables
+      # to conform to the route. This means that that route's path will be set
+      # as the `SCRIPT_NAME` and the remainder of the path will be set as the
+      # `PATH_INFO`.  Also, the original `PATH_INFO` and `SCRIPT_NAME`
+      # values are copied into the originals key.
+      # @param [Array<Circuit::Node>] route the array of nodes that make up the route
+      def route=(route)
+        raise(Circuit::Error, "Route has already been set") if self.route
+        save_original_path_envs
+        @env["PATH_INFO"] = "/"+path_segments[route.length..-1].join("/")
+        @env["PATH_INFO"] = "" if @env["PATH_INFO"] == "/"
+        @env["SCRIPT_NAME"] = route.last.path
+        @env[ENV_ROUTE] = route;
+      end
+
+      # @return [String] the route's path (aka. the `SCRIPT_NAME`)
+      def route_path() @env["SCRIPT_NAME"]; end
+
+      # @return [Hash] the originals of any keys that Circuit modifies are
+      #                first copied into this Hash
+      def circuit_originals() @env[ENV_ORIGINALS] ||= {}; end
+
+      # @return [Array<String>] segment parts; first segment will be `nil` if
+      #                         it is the root (i.e. the path is absolute)
+      # @see ClassMethods#path_segments
+      def path_segments
+        self.class.path_segments self.path
+      end
+
+      # Saves the original path keys into #circuit_originals (i.e. `PATH_INFO`
+      # and `SCRIPT_NAME`)
+      def save_original_path_envs
+        circuit_originals["PATH_INFO"] = @env["PATH_INFO"]
+        circuit_originals["SCRIPT_NAME"] = @env["SCRIPT_NAME"]
+      end
+    end
+  end
+end

data/lib/circuit/railtie.rb

@@ -0,0 +1,24 @@
+module Circuit
+  # Initializer `circuit_railtie.configure_rails_initialization`
+  # ------------------------------------------------------------
+  # * adds Rack::MultiSite and Rack::Behavioral to the Rails middleware stack
+  # * Sets the Circuit logger to the Rails logger
+  class Railtie < Rails::Railtie
+    initializer "circuit_railtie.configure_rails_initialization" do |app|
+      app.middleware.insert 0, Rack::MultiSite
+      app.middleware.insert 1, Rack::Behavioral
+
+      unless Circuit.cru_path
+        Circuit.cru_path = app.root.join("app", "behaviors")
+      end
+
+      root = app.root.expand_path.to_s
+      rel = Circuit.cru_path.expand_path.to_s.gsub(/^#{Regexp.escape(root)}\//, "")
+      app.config.paths.add rel, :eager_load => true, :glob => "**/*.rb"
+
+      app.config.after_initialize do
+        Circuit.logger = Rails.logger
+      end
+    end
+  end
+end

data/lib/circuit/storage.rb

@@ -0,0 +1,74 @@
+require 'active_support/inflector'
+
+module Circuit
+  module Storage
+    autoload :MemoryModel,  'circuit/storage/memory_model'
+    autoload :Sites,        'circuit/storage/sites'
+    autoload :Nodes,        'circuit/storage/nodes'
+
+    # Raised if a storage instance is undefined.
+    class InstanceUndefinedError < CircuitError
+      def initialize(msg="Storage instance is undefined.")
+        super(msg)
+      end
+    end
+
+    # @raise InstanceUndefinedError if the instance isn't defined
+    # @return [Circuit::Storage::Nodes::BaseStore,Circuit::Storage::Sites::BaseStore]
+    #         the storage instance
+    def instance
+      @instance || raise(InstanceUndefinedError)
+    end
+
+    # Set the storage instance and alias the `Node` or `Site` model under
+    # `Circuit` as `Circuit::Node` or `Circuit::Site`.
+    #
+    # @raise ArgumentError if the storage instance or the `Site` or `Node` 
+    #                      model cannot be determined
+    # @overload set_instance(instance)
+    #   @param [Circuit::Storage::Nodes::BaseStore,Circuit::Storage::Sites::BaseStore]
+    #          instance storage instance
+    #   @return [Circuit::Storage::Nodes::BaseStore,Circuit::Storage::Sites::BaseStore]
+    #           storage instance
+    # @overload set_instance(klass_or_name, *args)
+    #   @param [Class,String,Symbol] klass_or_name class or name of class 
+    #                                (under Circuit::Storage::Nodes or 
+    #                                Circuit::Storage::Sites) for storage 
+    #                                instance
+    #   @param [Array] args any arguments to instantiate the storage instance
+    #   @return [Circuit::Storage::Nodes::BaseStore,Circuit::Storage::Sites::BaseStore]
+    #           storage instance
+    def set_instance(*args)
+      klass = nil
+
+      case args.first
+      when Nodes::BaseStore, Sites::BaseStore
+        @instance = args.first
+      when Class
+        klass = args.first
+      when String, Symbol
+        # TODO do we need to fall up the module hiearchy to find the constant?
+        #      (e.g. a store defined in the Kernel namespace?)
+        klass = const_get(args.first.to_s.camelize)
+      else
+        raise ArgumentError, "Unexpected type for storage instance: %s"%[args.first.class]
+      end
+
+      if klass
+        @instance = klass.new(*args[1..-1])
+      end
+
+      case @instance
+      when Nodes::BaseStore
+        ::Circuit.const_set(:Node, @instance.class.const_get(:Node))
+      when Sites::BaseStore
+        ::Circuit.const_set(:Site, @instance.class.const_get(:Site))
+      else
+        bad_instance = @instance; @instance = nil
+        raise ArgumentError, "Cannot determine a Site or Node class for storage type: %s"%[bad_instance.class]
+      end
+
+      @instance
+    end
+  end
+end

data/lib/circuit/storage/memory_model.rb

@@ -0,0 +1,70 @@
+require 'active_support/concern'
+require 'active_model/naming'
+require 'active_model/attribute_methods'
+
+module Circuit
+  module Storage
+    module MemoryModel
+      extend ActiveSupport::Concern
+
+      include ActiveModel::AttributeMethods
+      include Compatibility::ActiveModel31
+      attr_reader :attributes, :errors
+      attr_accessor :name
+
+      included do
+        extend ActiveModel::Naming
+        class_attribute :all
+        self.all = Array.new
+      end
+
+      module ClassMethods
+        def setup_attributes(*attrs)
+          attribute_method_suffix '?'
+          attribute_method_suffix '='
+          define_attribute_methods attrs.collect(&:to_sym)
+        end
+      end
+
+      def attributes=(hash)
+        @attributes = hash.with_indifferent_access
+      end
+
+      def save!
+        self.save ? true : raise("Invalid %s: %p"%[self.class, self.errors])
+      end
+
+      def persisted?
+        @persisted
+      end
+
+      def persisted!(val=true)
+        @persisted = val
+      end
+
+      def eql?(obj)
+        obj.instance_of?(self.class) && obj.attributes == self.attributes
+      end
+
+      protected
+
+      def attribute(key)
+        attributes[key]
+      end
+
+      def attribute=(key, val)
+        attributes[key] = val
+      end
+
+      def attribute?(attr)
+        !attributes[attr.to_sym].blank?
+      end
+
+      def memory_model_setup
+        @persisted = false
+        @attributes = HashWithIndifferentAccess.new
+        @errors = ActiveModel::Errors.new(self)
+      end
+    end
+  end
+end