orange-core 0.5.3

data/lib/orange-core/core.rb

@@ -0,0 +1,266 @@
+require 'dm-core'
+require 'rack'
+require 'rack/builder'
+
+module Orange
+  # Declare submodules for later use
+  module Pulp; end
+  module Mixins; end
+  module Plugins; end
+  
+  attr_accessor :plugins
+  
+  # Support for plugins
+  def self.plugins
+    @plugins ||= []
+  end
+  
+  # Allows adding plugins
+  def self.plugin(plugin)
+    self.plugins << plugin if plugin.kind_of?(Orange::Plugins::Base)
+  end
+  
+  # Allow mixins directly from Orange
+  def self.mixin(inc)
+    Core.mixin inc
+  end
+  
+  # Allow pulp directly from Orange
+  def self.add_pulp(inc)
+    Packet.mixin inc
+  end
+  
+  # Core is one of two main sources of interaction for Orange Applications
+  # 
+  # All portions of Orange based code have access to the Core upon
+  # initialization. Orange allows access to individual resources, 
+  # and also allows single point for event registration and firing.
+  # 
+  # Functionality of the core can be extended by loading resources,
+  # or by mixins that directly affect the Core. Generally, resources
+  # are the less convoluted (easier to debug) way to do it.
+  class Core
+    # Sets the default options for Orange Applications
+    DEFAULT_CORE_OPTIONS = 
+      {
+        :contexts => [:live, :admin, :orange],
+        :default_context => :live,
+        :default_resource => :not_found,
+        :default_database => 'sqlite3::memory:'
+      } unless defined?(DEFAULT_CORE_OPTIONS)
+    
+    # Args will be set to the @options array. 
+    # Block DSL style option setting also available:
+    #
+    #   orange = Orange::Core.new(:optional_option => 'foo') do
+    #     haml true
+    #     site_name "Banana"
+    #     custom_router MyRouterClass.new
+    #   end
+    #
+    #   orange.options[:site_name] #=> "Banana"
+    # 
+    # This method calls afterLoad when it is done. Subclasses can override
+    # the afterLoad method for initialization needs.
+    def initialize(*args, &block)
+      @options = Options.new(*args, &block).hash.with_defaults(DEFAULT_CORE_OPTIONS)
+      @resources = {}
+      @application = false
+      @stack = false
+      @middleware = []
+      @events = {}
+      @file = __FILE__
+      load(Orange::Parser.new, :parser)
+      load(Orange::Mapper.new, :mapper)
+      load(Orange::Scaffold.new, :scaffold)
+      load(Orange::PageParts.new, :page_parts)
+      Orange.plugins.each{|p| p.resources.each{|args| load(*args)} if p.has_resources?}
+      self.register(:stack_loaded) do |s| 
+        @middleware.each{|m| m.stack_init if m.respond_to?(:stack_init)}
+        @application.stack_init if @application
+      end
+      self.register(:stack_reloading){|s| @middleware = []} # Dump middleware on stack reload
+      # load(Orange::AdminResource.new, :admin)
+      afterLoad
+      self
+    end
+    
+    # Returns the orange library directory
+    # @return [String] the directory name indicating where the core file is
+    #   located
+    def core_dir(*args)
+      if args
+        File.join((options[:core_dir] ||= File.dirname(__FILE__)), *args)
+      else
+        options[:core_dir] ||= File.dirname(__FILE__)
+      end
+    end
+    
+    # Returns the directory of the currently executing file (using Dir.pwd),
+    # can be overriden using the option :app_dir in initialization
+    # 
+    # @return [String] the directory name of the currently running application
+    def app_dir(*args)
+      if args
+        File.join((options[:app_dir] ||= Dir.pwd), *args)
+      else
+        options[:app_dir] ||= Dir.pwd
+      end
+    end
+    
+    # Called by initialize after finished loading
+    def afterLoad
+      true
+    end
+    
+    # Returns status of a given resource by short name
+    # @param [Symbol] resource_name The short name of the resource
+    # @return [Boolean] result of has_key? in the resources list
+    def loaded?(resource_name)
+      @resources.has_key?(resource_name)
+    end
+    
+    # Takes an instance of a Orange::Resource subclass, sets orange
+    # then adds it to the orange resources
+    # 
+    # It can be assigned a short name to be used for accessing later
+    # on. If no short name is assigned, one will be generated by downcasing
+    # the class name and changing it to a symbol
+    #
+    # Resources must respond to set_orange, which is automatically used to 
+    # create a link back to the Core, and to notify the resource of its assigned
+    # short name.
+    # 
+    # @param [Orange::Resource] resource An instance of Orange::Resource subclass
+    # @param [optional, Symbol, String] name A short name to assign as key in Hash 
+    #   list of resources.
+    #   Doesn't necessarily need to be a symbol, but generally is.
+    #   Set to the class name lowercase as a symbol by default.
+    def load(resource, name = false)
+      name = resource.orange_name if(!name)
+      name = resource.class.to_s.gsub(/::/, '_').downcase.to_sym if(!name) 
+      @resources[name] = resource.set_orange(self, name)
+    end
+    
+    # Takes an instance of Orange::Middleware::Base subclass and
+    # keeps it for later. This way we can provide introspection into the 
+    # middleware instances (useful for calling stack_init on them)
+    def middleware(middle = false)
+      @middleware << middle if middle
+      @middleware
+    end
+    
+    # Takes an instance of Orange::Application and saves it. 
+    def application(app = false)
+      @application = app if app
+      @application
+    end
+    
+    # Takes an instance of Orange::Stack and saves it. 
+    def stack(new_stack = false)
+      @stack = new_stack if new_stack
+      @stack
+    end
+    
+    # Takes an instance of Orange::Stack and saves it.
+    def stack=(new_stack)
+      @stack = new_stack
+    end
+    
+    # Convenience self for consistent naming across middleware
+    # @return [Orange::Core] self
+    def orange;     self;     end
+    
+    # Registers interest in a callback for a named event.
+    #
+    # Event registration is stored as a hash list of events and arrays
+    # of procs to be executed on each event.
+    #
+    # @param [Symbol] event the name of the event registered for 
+    # @param [optional, Integer] position the position to place the event in,
+    #  by default goes to the front of the list. Doesn't necessarily need
+    #  to be exact count, empty spaces in array are taken out. Forcing the
+    #  event to be at 99 or some such position will typically make sure it 
+    #  happens last in the firing process.
+    # @param [Block] block The code to be executed upon event firing. 
+    #   Saved to an array of procs that are called when #fire is called.
+    #   Block must accept one param, which is the intended to be the packet 
+    #   causing the block to fire, unless the event happens in setup.
+    def register(event, position = 0, &block)
+      if block_given?
+        if @events[event] 
+          @events[event].insert(position, Proc.new)
+        else
+          @events[event] = Array.new.insert(position, Proc.new)
+        end
+      end
+    end
+    
+    # Fires a callback for a given packet (or other object)
+    # 
+    # @param [Symbol] event name of event something has registered for
+    # @param [Orange::Packet, object] packet Object, generally Orange::Packet, 
+    #   causing the fire. This is passed to each Proc registered.
+    # @return [Boolean] returns false if nothing has been registered for the
+    #   event, otherwise true.
+    def fire(event, packet, *args)
+      return false unless @events[event]
+      @events[event].compact!
+      for callback in @events[event]
+        callback.call(packet, *args)
+      end
+      true
+    end
+    
+    # Returns options of the orange core
+    # 
+    # @return [Hash] Hash of options
+    def options
+      @options
+    end
+    
+    
+    # Accesses resources array, stored as a hash {:short_name => Resource instance,...}
+    # 
+    # @param [Symbol] name the short name for the requested resource
+    # @param [optional, Boolean] ignore Whether to ignore any calls to resource if not found 
+    #   (false is default). This will allow method calls to non-existent resources. Should be
+    #   used with caution.
+    # @return [Orange::Resource] the resource for the given short name
+    def [](name, ignore = false)
+      if ignore && !loaded?(name)
+        Ignore.new
+      else
+        @resources[name]
+      end 
+    end
+    
+    # Includes module in the Packet class
+    # @param [Module] inc module to be included
+    def add_pulp(inc)
+      self.class.add_pulp inc
+    end
+    
+    # Includes module in this class
+    # @param [Module] inc module to be included
+    def mixin(inc)
+      self.class.mixin inc
+    end
+    
+    # Includes module in this class
+    # @param [Module] inc module to be included
+    def self.mixin(inc)
+      include inc
+    end
+    
+    # Includes module in the Packet class
+    # @param [Module] inc module to be included
+    def self.add_pulp(inc)
+      Packet.mixin inc
+    end
+    
+    def inspect
+      "#<Orange::Core:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+end

data/lib/orange-core/magick.rb

@@ -0,0 +1,270 @@
+# 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
+