orange 0.5.5 → 0.5.7

data/lib/orange-core/magick.rb

@@ -1,270 +0,0 @@
-# Monkey Patch the extract_options! stolen from ActiveSupport
-# @private
-class ::Array #:nodoc:
-  def extract_options! 
-    last.is_a?(::Hash) ? pop : {}
-  end
-  def extract_with_defaults(defaults) 
-    extract_options!.with_defaults(defaults)
-  end
-end
-
-# Monkey Patch for merging defaults into a hash 
-# @private
-class ::Hash #:nodoc:
-  def with_defaults(defaults) 
-    self.merge(defaults){ |key, old, new| old.nil? ? new : old } 
-  end
-  def with_defaults!(defaults) 
-    self.merge!(defaults){ |key, old, new| old.nil? ? new : old } 
-  end
-end
-
-
-
-# Monkey patch for awesome array -> hash conversions
-# use:
-#
-#   [:x, :y, :z].inject_hash do |results, letter|
-#     results[letter] = rand(100)
-#   end
-#
-#   # => {:x => 32, :y => 63, :z => 91}
-# @private
-module Enumerable #:nodoc:
-  def inject_hash(hash = {}) 
-    inject(hash) {|(h,item)| yield(h,item); h}
-  end 
-end
-
-# Borrowed from Roman2k: 
-# http://github.com/Roman2K/class-inheritable-attributes/
-# @private
-module ClassInheritableAttributes
-  class << self
-    def eval_in_accessor_module(klass, code)
-      mod = klass.instance_eval { @_inheritable_attribute_accessors ||= Module.new }
-      klass.extend(mod)
-      mod.module_eval(code)
-    end
-    
-    def fetch_value(klass, attribute)
-      each_parent(klass) do |parent|
-        if values = registry[parent] and values.key?(attribute)
-          return values[attribute]
-        elsif parent.instance_variable_defined?("@#{attribute}")
-          return parent.instance_variable_get("@#{attribute}")
-        end
-      end
-      return nil
-    end
-    
-    def store_value(klass, attribute, value)
-      if Thread.current == Thread.main
-        if value.nil?
-          klass.instance_eval do
-            remove_instance_variable("@#{attribute}") if instance_variable_defined?("@#{attribute}")
-          end
-        else
-          klass.instance_variable_set("@#{attribute}", value)
-        end
-      else
-        registry[klass] ||= {}
-        if value.nil?
-          registry[klass].delete(attribute)
-          registry.delete(klass) if registry[klass].empty?
-        else
-          registry[klass][attribute] = value
-        end
-      end
-    end
-    
-  private
-    
-    def each_parent(klass)
-      while klass < Object
-        yield klass
-        klass = klass.superclass
-      end
-    end
-    
-    def registry
-      Thread.current[ClassInheritableAttributes.name] ||= {}
-    end
-  end
-  
-  def cattr_reader(*attributes)
-    attributes.each do |attribute|
-      ClassInheritableAttributes.eval_in_accessor_module(self, <<-EOS)
-        def #{attribute}
-          #{ClassInheritableAttributes}.fetch_value(self, :#{attribute})
-        end
-      EOS
-    end
-  end
-  
-  def cattr_writer(*attributes)
-    attributes.each do |attribute|
-      ClassInheritableAttributes.eval_in_accessor_module(self, <<-EOS)
-        def #{attribute}=(value)
-          #{ClassInheritableAttributes}.store_value(self, :#{attribute}, value)
-        end
-      EOS
-    end
-  end
-  
-  def cattr_accessor(*attributes)
-    cattr_reader(*attributes)
-    cattr_writer(*attributes)
-  end
-end
-
-module Orange
-  
-  # Class that extends hash so that [] can have an optional second attribute
-  class DefaultHash < ::Hash
-    def [](key, my_default = nil)
-      my_default = self.default if my_default.nil?
-      self.has_key?(key) ? super(key) : my_default
-    end
-  end
-  
-  # This class acts as a simple sink for ignoring messages, it will return itself
-  # for any message call. Orange::Core can optionally return this when trying 
-  # to access resources so that you can make method calls to a resource that 
-  # might not be really there. It will silently swallow any errors that might arrise,
-  # so this should be used with caution.
-  class Ignore
-    def blank?; true; end
-    def method_missing(name, *args, &block)
-      return self
-    end
-  end
-  
-  # Simple class for evaluating options and allowing us to access them.
-  class Options
-    
-    def initialize(*options, &block)
-      @options = options.extract_options!
-      @options ||= {}
-      instance_eval(&block) if block_given?
-    end
-    
-    def hash
-      @options
-    end
-
-    def method_missing(key, *args)
-      return (@options[key.to_s.gsub(/\?$/, '').to_sym].eql?(true)) if key.to_s.match(/\?$/)
-      if args.empty?
-        @options[key.to_sym]
-      elsif(key.to_s.match(/\=$/))
-        @options[key.to_s.gsub(/\=$/, '').to_sym] = (args.size == 1 ? args.first : args)
-      else
-        @options[key.to_sym] = (args.size == 1 ? args.first : args)
-      end
-    end
-  end
-  
-  # @private
-  module Inflector
-    extend self
-    # @private
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
-      end
-    end
-    
-    if Module.method(:const_get).arity == 1
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
- 
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
-      end
-    else
-      def constantize(camel_cased_word) #:nodoc:
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
- 
-        constant = Object
-        names.each do |name|
-          constant = constant.const_get(name, false) || constant.const_missing(name)
-        end
-        constant
-      end
-    end
-    
-  end
-  
-end
-
-# @private
-class Object #:nodoc:
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are blank.
-  #
-  # This simplifies
-  #
-  #   if !address.nil? && !address.empty?
-  #
-  # to
-  #
-  #   if !address.blank?
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-end
-
-# @private
-class NilClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-# @private
-class FalseClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-# @private
-class TrueClass #:nodoc:
-  def blank?
-    false
-  end
-end
-
-# @private
-class Array #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-# @private
-class Hash #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-# @private
-class String #:nodoc:
-  def blank?
-    self !~ /\S/
-  end
-end
-
-# @private
-class Numeric #:nodoc:
-  def blank?
-    false
-  end
-end
-

data/lib/orange-core/middleware/base.rb

@@ -1,96 +0,0 @@
-require 'orange-core/packet'
-
-# Orange Middleware is a bit more complex than Rack middleware. 
-# Initializing it requires both a link to the downstream app and 
-# the core, and calling the app often requires an Orange::Packet
-#
-# Orange::Middleware::Base takes care of these basic tasks.
-# Subclasses override the init method for extra initialization
-# and the packet_call for a call with a packet, rather than
-# a basic call
-module Orange::Middleware
-  class Base
-    # Initialize will set the core and downstream app, then call init
-    # subclasses should override init instead of initialize.
-    # If the subclass defines a stack_init, then it will be registered
-    # as a stack_loaded event.
-    # @param [Object] app a downstream app 
-    # @param [Orange::Core] core the orange core
-    # @param [optional, Array] args any arguments
-    def initialize(app, core, *args)
-      @app = app
-      @core = core
-      init(*args)
-      core.middleware(self)
-    end
-    
-    # A stub method that subclasses can override to handle initialization
-    # For initialization
-    # @return [void]
-    def init(*args)
-    end
-    
-    # The standard Rack "call". By default, Orange Middleware wraps the env into
-    # an Orange::Packet and passes it on to #packet_call. Subclasses will typically
-    # override packet_call rather than overriding call directly. 
-    # 
-    # Orange Middleware
-    # should expect to have this method ignored by upstream Orange-aware apps in
-    # favor of calling packet_call directly.
-    # @param [Hash] env the hash of environment variables given by the rack interface.
-    # @return [Array] the standard Rack striplet of status, headers and content
-    def call(env)
-      packet = Orange::Packet.new(@core, env)
-      packet_call(packet)
-    end
-    
-    # Like the standard call, but with the env hash already wrapped into a Packet
-    # This is called automatically as part of #call, so subclasses can have a packet
-    # without having to initialize it. It will be called directly by Orange-aware
-    # upstream middleware, skipping the step of initializing the packet during #call.
-    # 
-    # Passing the packet downstream should be done with #pass rather than the Rack
-    # standard @app.call, since #pass will take the packet and do a #packet_call
-    # if possible.
-    # @param [Orange::Packet] packet the packet corresponding to this env
-    # @return [Array] the standard Rack striplet of status, headers and content
-    def packet_call(packet)
-      pass packet
-    end
-    
-    # Pass will sent the packet to the downstream app by calling call or packet call.
-    # Calling pass on a packet is the preferred way to call downstream apps, as it
-    # will call packet_call directly if possible (to avoid reinitializing the packet)
-    # @param [Orange::Packet] packet the packet to pass to downstream apps
-    # @return [Array] the standard Rack striplet of status, headers and content
-    def pass(packet)
-      if @app.respond_to?(:packet_call)
-        @app.packet_call(packet)
-      else
-        recapture(@app.call(packet.env), packet)
-      end
-    end
-    
-    # After the pass has been completed, we should recapture the contents and make
-    # sure they are placed in the packet, in case the downstream app is not Orange aware.
-    # @param [Array] the standard Rack striplet of status, headers and content
-    # @param [Orange::Packet] packet the packet to pass to downstream apps
-    # @return [Array] the standard Rack striplet of status, headers and content
-    def recapture(response, packet)
-      packet[:status]  = response[0]
-      packet[:headers] = response[1]
-      packet[:content] = response[2].first
-      response
-    end
-    
-    # Accessor for @core, which is the stack's instance of Orange::Core
-    # @return [Orange::Core] the stack's instance of Orange::Core
-    def orange;     @core;    end
-    
-    # Help stack traces
-    # @return [String] string representing this middleware (#to_s)
-    def inspect
-      self.to_s
-    end
-  end
-end

data/lib/orange-core/middleware/database.rb

@@ -1,45 +0,0 @@
-require 'orange-core/middleware/base'
-module Orange::Middleware
-  
-  class Database < Base
-    def init(opts = {})
-      opts = opts.with_defaults(:migration_url => (orange.options[:development_mode] ? '/__ORANGE_DB__/migrate' : false), :no_auto_upgrade => false)
-      orange.mixin Orange::Mixins::DBLoader
-      @options = opts
-    end
-    
-    def stack_init
-      unless orange.options.has_key?('database') && orange.options['database'] == false
-        db = orange.options['database'] || 'sqlite3::memory:'
-        orange.load_db!(db) 
-        orange.upgrade_db! unless @options[:no_auto_upgrade] || orange.options['db_no_auto_upgrade']
-      end
-    end
-    
-    def packet_call(packet)
-      path = packet['route.path'] || packet.request.path_info
-      if @options[:migration_url] && @options[:migration_url] == path
-        orange.migrate_db!
-        after = packet.flash('redirect_to') || '/'
-        packet.reroute(after)
-      end
-      pass packet
-    end
-  end
-  
-end
-
-module Orange::Mixins::DBLoader
-  def load_db!(url)
-    DataMapper.setup(:default, url)
-  end
-  
-  def migrate_db!
-    DataMapper.auto_migrate!
-  end
-  
-  def upgrade_db!
-    DataMapper.auto_upgrade!
-  end
-  
-end

data/lib/orange-core/middleware/four_oh_four.rb

@@ -1,45 +0,0 @@
-require 'orange-core/middleware/base'
-
-module Orange::Middleware
-  # The FlexRouter middleware takes a resource that can route paths and
-  # then intercepts routes for that resource. By default,
-  # it uses the Orange::SitemapResource. 
-  # 
-  # The resource is automatically loaded into the core as 
-  # :sitemap. The resource must respond to "route?(path)" 
-  # and "route(packet)".  
-  # 
-  # Pass a different routing resource using the :resource arg
-  class FourOhFour < Base
-    def init(opts = {})
-      @resource = opts[:resource] || Orange::NotFound
-      orange.load @resource.new, :not_found
-      orange.add_pulp Orange::Pulp::NotFoundHelper
-    end
-    
-    # Sets the sitemap resource as the router if the resource can accept 
-    # the path.
-    def packet_call(packet)
-      packet['route.router'] = orange[:not_found] unless packet['route.router']
-      begin
-        pass packet
-      rescue Orange::NotFoundException
-        orange[:not_found].route(packet)
-        packet.finish
-      end
-    end
-    
-  end
-end
-
-module Orange
-  class NotFoundException < Exception
-    
-  end
-  
-  module Pulp::NotFoundHelper
-    def not_found
-      raise Orange::NotFoundException.new
-    end
-  end
-end