orange 0.0.2 → 0.0.3

data/README.markdown

@@ -93,7 +93,7 @@ is a bit overkill. We designed this to replace ModX in our web builds for client
 Required Gems
 -------------
 
-Make sure githubs gems can be downloaded:
+Make sure github gems can be downloaded:
 
     $ gem sources -a http://gems.github.com
 
@@ -151,4 +151,17 @@ Pulp and Mixins
 The ability to add pulp and mixins is incredibly handy because the packet and the core are 
 available from just about anywhere in the Orange framework. For instance, the haml parser
 evaluates all local calls as if made to the packet, so adding pulp is essentially adding 
-functionality that is directly available to haml.
+functionality that is directly available to haml.
+
+
+LICENSE:
+=========
+(The MIT License)
+
+Copyright © 2009 Orange Sparkle Ball, inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/orange.rb

@@ -3,5 +3,5 @@ $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
 Dir.glob(File.join(libdir, 'orange', '*.rb')).each {|f| require f }
 Dir.glob(File.join(libdir, 'orange', 'cartons', '*.rb')).each {|f| require f }
-Dir.glob(File.join(libdir, 'orange', 'middleware', '*.rb')).each {|f| require f }
-Dir.glob(File.join(libdir, 'orange', 'resources', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'orange', 'resources', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'orange', 'middleware', '*.rb')).each {|f| require f }

data/lib/orange/carton.rb

@@ -1,8 +1,22 @@
 require 'dm-core'
 
 module Orange
+  # Orange::Carton is the main model class for Orange. It's based on Datamapper.
+  # In addition to handling the database interactions, the carton keeps
+  # track of declared properties, which is used to create scaffolds.
+  #
+  # All subclasses should start by declaring the "id" attribute. All models
+  # are assumed to have an id attribute by most everything else, so it's 
+  # a good idea to have one. 
+  # 
+  # Orange::Carton adds many shortcut methods for adding various datatypes
+  # to the model in a more declarative style (`id` vs `property :id, Serial`)
+  # 
+  # For classes that don't need anything but scaffolding, there's the 
+  # as_resource method, which automatically creates a scaffolding resource
+  # for the model.
   class Carton
-    
+    # 
     def self.as_resource
       name = self.to_s
       eval <<-HEREDOC

data/lib/orange/magick.rb

@@ -23,11 +23,11 @@ end
 # Monkey patch for awesome array -> hash conversions
 # use:
 #
-# [:x, :y, :z].inject_hash do |results, letter|
-#   results[letter] = rand(100)
-# end
+#   [:x, :y, :z].inject_hash do |results, letter|
+#     results[letter] = rand(100)
+#   end
 #
-# => {:x => 32, :y => 63, :z => 91}
+#   # => {:x => 32, :y => 63, :z => 91}
 module Enumerable
   def inject_hash(hash = {}) 
     inject(hash) {|(h,item)| yield(h,item); h}

data/lib/orange/packet.rb

@@ -1,15 +1,58 @@
 module Orange
+  # Orange::Packet is a wrapper for Rack's basic env variable. 
+  # It acts somewhat like Rack::Request, except with more functionality.
+  # For each request a unique Packet is generated, and this packet is 
+  # used to by middleware to create the response. 
+  # 
+  # All orange enhanced middleware has a packet_call method that
+  # automatically turns the generic rack call(env) into a call
+  # that has a packet instead, so all functions for the packet should
+  # be available for the request.
+  #
+  # Pulps are modules that are mixed into the Packet, allowing
+  # additional functionality to be used by the packet.
+  #
   # By default, haml files are parsed in the context of their
   # packet. This means all of instance variables and functions should
   # be available to the haml parser.
   class Packet
+    # By default, header will be content-type
     DEFAULT_HEADERS = {"Content-Type" => 'text/html'} unless defined?(DEFAULT_HEADERS)
     
+    # We override the instantiation to only create one packet per env
+    # @param [Orange::Core] orange a pointer to the orange core
+    # @param [Hash] env a standard Rack hash
     def self.new(orange, env)
       return env['orange.packet'] if env['orange.packet']
       super(orange, env)
     end
     
+    # Allows tying in to the method_missing method without redefining it 
+    # elsewhere. This lets dynamic methods be defined on the packet.
+    # Regexes are defined to match method names. #method_missing will
+    # loop through and try to find a match, executing the proc defined in
+    # the block.
+    # @param [Regexp] regex the regex to match
+    # @yield [Orange::Packet, MatchData, args] the block to execute if matched 
+    #   (passed instance, match data and args)
+    def self.meta_methods(regex, &block)
+      return unless block_given?
+      proc = block
+      @@matchers ||= {}
+      @@matchers[regex] = proc
+    end
+    
+    # Allows access to the matchers added via the #meta_methods method
+    # @return [Hash] the matchers hash
+    def matchers
+      @@matchers || {}
+    end
+    
+    # Initialize is only called if a packet hasn't already been called for 
+    # this env. Sets up the basic env, creating a pointer back to self
+    # and a Rack::Request object.
+    # @param [Orange::Core] orange a pointer to the orange core
+    # @param [Hash] env a standard Rack hash
     def initialize(orange, env)
       @orange = orange
       @env = env
@@ -19,46 +62,77 @@ module Orange
       @env['orange.env'][:headers] = {}
     end
     
+    # Gives access to the orange.env key in the env, optionally 
+    # including a default if key isn't involved.
+    # @param [Symbol, String] key the key to be found
+    # @param [optional, Object] default the return value if key doesn't exist (default is false)
+    # @return [Object] any value stored in the env
     def [](key, default = false)
       @env['orange.env'].has_key?(key) ? @env['orange.env'][key] : default
     end
     
+    # Lets user set a value in the orange.env
+    # @param [Symbol, String] key the key to be set
+    # @param [Object] val the value to be set
     def []=(key, val)
       @env['orange.env'][key] = val
     end
     
+    # Access to the main env (orange env is stored within the main env)
+    # @return [Hash] the request's env hash
     def env
       @env
     end
     
+    # Access to the rack session
+    # @return [Hash] the session information made available by Rack
     def session
       env['rack.session']
     end
     
+    # Generate headers for finalization
+    # @return [Hash] the header information stored in the orange.env, combined with the defaults
+    #   set as DEFAULT_HEADERS
     def headers
       packet[:headers, {}].with_defaults(DEFAULT_HEADERS)
     end
+    
+    # Set a header
+    # @param [String] key the key to be set
+    # @param [Object] val the value to be set
     def header(key, val)
       @env['orange.env'][:headers][key] = val
     end
     
+    # Set a header (same as #header)
+    # @param [String] key the key to be set
+    # @param [Object] val the value to be set
     def add_header(key, val)
       header key, val
     end
     
+    # Returns the content ready to be used by Rack (wrapped in an array)
+    # @return [Array] array of strings to be rendered
     def content
       return [packet[:content]] if packet[:content]
-      return []
+      return ['']
     end
     
+    # Returns the request object generated by Rack::Request(packet.env)
+    # @return [Rack::Request] the request object
     def request
       packet[:request]
     end
     
+    # A pointer to the Orange::Core instance
+    # @return [Orange::Core] the orange core run by the application
     def orange
       @orange
     end
     
+    # Returns the array of [status, headers, content] Rack expects
+    # @return [Array] the triple array expected by Rack at the end 
+    #   of a call
     def finish
       headers = packet.headers
       status = packet[:status, 200]
@@ -70,19 +144,39 @@ module Orange
       [status, headers, content]
     end
     
+    # Returns self
+    # @return [Orange::Packet] self
     def packet
       self
     end
     
+    # Includes the module passed
+    # @param [Module] inc the module to be mixed into the class
     def self.mixin(inc)
       include inc
     end
     
+    # Route calls the router object set in the packet
+    # @return [void] route doesn't return anything directly, the
+    #   main application calls packet.route then returns packet.finish.
+    #   Routers set content, headers and status if necessary.
+    #   They can also raise redirect errors to circumvent the process.
     def route
       router = packet['route.router']
       raise 'Router not found' unless router
       router.route(self)
     end
+    
+    # Method Missing allows defining custom methods
+    def method_missing(id, *args)
+      matched = false
+      id = id.to_s
+      @@matchers.each_key do |k|
+        matched = k if id =~ k
+        break if matched
+      end
+      return @@matchers[matched].call(packet, matched.match(id), args) if matched
+      raise NoMethodError
+    end
   end
-  
 end

data/lib/orange/resource.rb

@@ -4,7 +4,7 @@ module Orange
   # Orange Resource for being subclassed
   class Resource
     def initialize(*args, &block)
-      @options = Options.new(args, &block).hash
+      @options = Options.new(*args, &block).hash
     end
     
     def set_orange(orange, name)
@@ -15,7 +15,7 @@ module Orange
     end
     
     def self.set_orange(*args)
-      raise 'trying to call set orange on a class (you probably need to instantiate a resource)'
+      raise 'instantiate the resource before calling set orange'
     end
     
     def afterLoad
@@ -30,8 +30,16 @@ module Orange
       false
     end
     
-    def view(packet = false)
+    def view(packet = false, *args)
       ''
     end
+    
+    def orange_name
+      @my_orange_name
+    end
+    
+    def options
+      @options
+    end
   end
 end

data/lib/orange/resources/model_resource.rb

@@ -0,0 +1,248 @@
+require 'orange/resources/routable_resource'
+
+module Orange
+  class ModelResource < RoutableResource
+    extend ClassInheritableAttributes
+    # Defines a model class as an inheritable class attribute and also an instance
+    # attribute
+    cattr_inheritable :model_class
+    attr_accessor :model_class
+    
+    # Tells the Model resource which Carton class to scaffold
+    # @param [Orange::Carton] my_model_class class name of the carton class to scaffold
+    def self.use(my_model_class)
+      self.model_class = my_model_class
+    end
+    
+    # Overrides the instantiation of new Resource object to set instance model
+    # class to the class-level model class defined by #use
+    def self.new(*args, &block)
+      me = super(*args, &block)
+      me.model_class = self.model_class 
+      me
+    end
+    
+    # Views a packet by calling method defined as opts[:mode].
+    # Defaults mode to show or list, if it can't find opts[:mode].
+    # Decision between show or list is determined by whether an id has been chosen.
+    # An id is set in opts[:id], or extracted from the packet['route.resource_id']. 
+    # Calling view is equivalent to calling a viewable method directly, view just
+    # sets up safe defaults so method missing errors are less likely.
+    # @param [Orange::Packet] packet the packet calling view on this resource
+    def view(packet, *args)
+      opts = args.last || {}
+      resource_id = opts[:id] || packet['route.resource_id', false]
+      mode = opts[:mode] || packet['route.resource_action'] || 
+        (resource_id ? :show : :index)
+      self.__send__(mode, packet, *args)
+    end
+    
+    # Renders a view, with all options set for haml to access.
+    # Calls #view_opts to generate the haml options. 
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [optional, Array] args the args array
+    # @return [String] haml parsed string to be placed in packet[:content] by #route
+    def do_view(packet, mode, *args)
+      haml_opts = view_opts(packet, mode, false, *args)
+      orange[:parser].haml("#{mode.to_s}.haml", packet, haml_opts)
+    end
+    
+    # Renders a view, with all options set for haml to access. Same as do_view, but
+    # calls #view_opts with is_list set to true to generate the haml options.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [optional, Array] args the args array
+    # @return [String] haml parsed string to be placed in packet[:content] by #route
+    def do_list_view(packet, mode, *args)
+      haml_opts = view_opts(packet, mode, true, *args)
+      orange[:parser].haml("#{mode.to_s}.haml", packet, haml_opts)
+    end
+    
+    # Returns the options for including in template rendering. All keys passed in the args array
+    # will automatically be local variables in the haml template.
+    # In addition, the props, resource, and model_name variables will be available.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [boolean] is_list whether we want a list or not (view_opts will automatically look up
+    #   a single object or a list of objects, so we need to know which)
+    # @param [optional, Array] args the args array
+    # @return [Hash] hash of options to be used
+    def view_opts(packet, mode, is_list, *args)
+      opts = args.extract_options!.with_defaults({:path => ''})
+      props = model_class.form_props(packet['route.context'])
+      resource_id = opts[:id] || packet['route.resource_id'] || false
+      all_opts = {:props => props, :resource => self.class.to_s, :model_name => @my_orange_name}.merge!(opts)
+      all_opts.with_defaults! :model => find_one(packet, mode, resource_id) unless is_list
+      all_opts.with_defaults! :list => find_list(packet, mode) if is_list
+      all_opts.with_defaults! find_extras(packet, mode)
+      all_opts
+    end
+    
+    # Returns a single object found by the model class, given an id. 
+    # If id isn't given, we return false.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [Numeric] id the id to lookup on the model class
+    # @return [Object] returns an object of type set by #use, if one found with same id
+    def find_one(packet, mode, id = false)
+      return false unless id
+      model_class.get(id) 
+    end
+    
+    # Returns a list of all objects found by the model class
+    # If none, returns an empty array
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [Numeric] id the id to lookup on the model class
+    # @return [Enumerable] returns a collection of objects of type set by #use
+    def find_list(packet, mode)
+      model_class.all || []
+    end
+    
+    # Returns a hash of extra options to be set and made available by the haml parser.
+    # Overriding this method is useful for passing extra bits of info to rendering
+    # for certain view modes without rewriting all of the other scaffolding
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @return [Hash] a hash of extras to be included in the rendering
+    def find_extras(packet, mode)
+      {}
+    end
+    
+    # Creates a new model object and saves it (if a post), then reroutes to the main page
+    # @param [Orange::Packet] packet the packet being routed
+    def new(packet, *opts)
+      if packet.request.post?
+        model_class.new(packet.request.params[@my_orange_name.to_s]).save
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    # Deletes an object specified by packet['route.resource_id'], then reroutes to main
+    # @param [Orange::Packet] packet the packet being routed
+    def delete(packet, *opts)
+      if packet.request.delete?
+        m = model_class.get(packet['route.resource_id'])
+        m.destroy! if m
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    # Saves updates to an object specified by packet['route.resource_id'], then reroutes to main
+    # @param [Orange::Packet] packet the packet being routed
+    def save(packet, *opts)
+      if packet.request.post?
+        m = model_class.get(packet['route.resource_id'])
+        if m
+          m.update(packet.request.params[@my_orange_name.to_s])
+        else 
+        end
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    # Calls #do_view with :show mode
+    # @param [Orange::Packet] packet the packet being routed
+    def show(packet, *opts)
+      do_view(packet, :show, *opts)
+    end
+    
+    # Calls #do_view with :edit mode
+    # @param [Orange::Packet] packet the packet being routed
+    def edit(packet, *opts)
+      do_view(packet, :edit, *opts)
+    end
+    
+    # Calls #do_view with :create mode
+    # @param [Orange::Packet] packet the packet being routed
+    def create(packet, *opts)
+      do_view(packet, :create, *opts)
+    end
+    
+    # Calls #do_view with :table_row mode
+    # @param [Orange::Packet] packet the packet being routed
+    def table_row(packet, *opts)
+      do_view(packet, :table_row, *opts)
+    end
+    
+    # Calls #do_list_view with :list mode
+    # @param [Orange::Packet] packet the packet being routed
+    def list(packet, *opts)
+      do_list_view(packet, :list, *opts)
+    end
+    
+    # Calls #do_list_view with :list mode. 
+    # @param [Orange::Packet] packet the packet being routed
+    def index(packet, *opts)
+      do_list_view(packet, :list, *opts)
+    end
+  
+  end
+  
+  class Packet
+    # Adds view_[mode_name] magic methods to the packet
+    meta_methods(/view_([a-zA-Z_]+)/) do |packet, match, args|
+      model = args.shift
+      args = args.extract_with_defaults(:mode => match[1].to_sym)
+      packet.view(model, args)
+    end
+    
+    # Creates a button that appears to be a link but 
+    # does form submission with custom method (_method param in POST)
+    # This is to avoid issues of a destructive get.
+    # @param [String] text link text to show
+    # @param [String] link the actual href value of the link
+    # @param [String, false] confirm text of the javascript confirm (false for none [default])
+    # @param [optional, Array] args array of optional arguments, only opts[:method] defined
+    # @option opts [String] method method name (Should be 'DELETE', 'PUT' or 'POST')
+    def form_link(text, link, confirm = false, *args)
+      opts = args.extract_options!
+      meth = (opts[:method]? "<input type='hidden' name='_method' value='#{opts[:method]}' />" : '')
+      if confirm
+        "<form action='#{link}' method='post' class='mini' onsubmit='return confirm(\"#{confirm}\")'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
+      else
+        "<form action='#{link}' method='post' class='mini'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
+      end
+    end
+    
+    # Calls view for an orange resource. 
+    def view(model_name, *args)
+      orange[model_name].view(self, *args)
+    end
+    
+    # Returns a scaffolded attribute
+    def view_attribute(prop, model_name, *args)
+      args = args.extract_options!
+      val = args[:value] || ''
+      label = args[:label] || false
+      show = args[:show] || false
+      name = prop[:name]
+      unless show
+        case prop[:type]
+        when :title
+          ret = "<input class='title' type='text' value='#{val}' name='#{model_name}[#{name}]' />"
+        when :text
+          ret = "<input type='text' value='#{val}' name='#{model_name}[#{name}]' />"
+        when :fulltext
+          ret = "<textarea name='#{model_name}[#{name}]'>#{val}</textarea>"
+        else
+          ret = "<input type='text' value='#{val}' name='#{model_name}[#{name}]' />"
+        end
+        ret = "<label for=''>#{name}</label><br />" + ret if label
+      else
+        case prop[:type]
+        when :title
+          ret = "<h3 class='#{model_name}-#{name}'>#{val}</h3>"
+        when :text
+          ret = "<p class='#{model_name}-#{name}'>#{val}</p>"
+        when :fulltext
+          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
+        else
+          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
+        end
+      end
+      ret
+    end
+  end
+end

data/lib/orange/resources/parser.rb

@@ -26,19 +26,19 @@ module Orange
       default_dir = File.join(views_dir, 'default_resource')
       
       string = false
-      string ||= read_if('templates', file) if temp
-      string ||= read_if(templates_dir, file) if temp
-      string ||= read_if('views', resource, file) if resource
-      string ||= read_if('views', file)
-      string ||= read_if(views_dir, file)
-      string ||= read_if(views_dir, 'default_resource', file)
+      string ||= read_if_exists('templates', file) if temp
+      string ||= read_if_exists(templates_dir, file) if temp
+      string ||= read_if_exists('views', resource, file) if resource
+      string ||= read_if_exists('views', file)
+      string ||= read_if_exists(views_dir, file)
+      string ||= read_if_exists(views_dir, 'default_resource', file)
       raise LoadError, "Couldn't find haml file '#{file}" unless string
       
       haml_engine = Haml::Engine.new(string)
       out = haml_engine.render(packet, opts, &block)
     end
     
-    def read_if(*args)
+    def read_if_exists(*args)
       return File.read(File.join(*args)) if File.exists?(File.join(*args))
       false
     end

data/spec/magick_spec.rb

@@ -1,9 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Black::Magick" do
-  it "should be spec'ed"
-end
-
 describe Orange::DefaultHash do
   it "should be a kind of Hash" do
     Orange::DefaultHash.new.should be_a_kind_of Hash

data/spec/mock/mock_app.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'orange'
 require 'rack/abstract_format'
 
 class MockApplication < Orange::Application

data/spec/mock/mock_carton.rb

@@ -0,0 +1,15 @@
+class MockCarton < Orange::Carton
+  id
+  admin do
+    text :banana
+  end
+end
+
+class MockCartonTwo < Orange::Carton
+  def self.get(id)
+    'mock_get'
+  end
+  def self.all
+    'mock_all'
+  end
+end

data/spec/mock/mock_model_resource.rb

@@ -0,0 +1,43 @@
+class MockModelResource < Orange::ModelResource
+  use MockCarton
+end
+
+class MockModelResourceOne < Orange::ModelResource
+  use MockCarton
+  def index(packet, *args)
+    raise 'I see you\'re using index'
+  end
+  def show(packet, *args)
+    raise 'I see you\'re using show'
+  end
+  def other(packet, *args)
+    raise 'I see you\'re using other'
+  end
+  def find_one(packet, mode, resource_id =false)
+    raise 'calling find_one'
+  end
+  def find_list(packet, mode)
+    raise 'calling find_list'
+  end
+end
+
+class MockModelResourceTwo < Orange::ModelResource
+  use MockCartonTwo
+end
+
+class MockModelResourceThree < Orange::ModelResource
+  use MockCarton
+  def find_extras(packet, mode)
+    raise 'calling find_extras'
+  end
+end
+
+class MockModelResourceFour < Orange::ModelResource
+  use MockCarton
+  def find_one(packet, mode, resource_id =false)
+    'mock_one'
+  end
+  def find_list(packet, mode)
+    'mock_list'
+  end
+end

data/spec/mock/mock_resource.rb

@@ -2,4 +2,13 @@ class MockResource < Orange::Resource
   def mock_method
     'MockResource#mock_method'
   end
+  def afterLoad
+    @options[:mocked] = true
+  end
+end
+
+class MockHamlParser < Orange::Resource
+  def haml(template, packet, opts)
+    [template, packet, opts]
+  end
 end

data/spec/packet_spec.rb

@@ -131,4 +131,49 @@ describe Orange::Packet do
     p= Orange::Packet.new(Orange::Core.new, {})
     p.request.should be_an_instance_of Rack::Request
   end
+  
+  it "should store method matchers for extending method_missing handlers" do
+    class Orange::Packet 
+      meta_methods(/pretend_method_we_dont_want/) do |match, args|
+        "my mock meta method"
+      end
+      
+      meta_methods(/pretend_method_we_dont_want(\w+)/) do |match, args|
+        "my mock meta method"
+      end
+    end
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.matchers.size.should >= 2
+  end
+  
+  it "should have method_missing capabilities" do
+    p= Orange::Packet.new(Orange::Core.new, {})
+    p.should respond_to(:method_missing)
+    lambda {
+      p.my_mock_meta_method
+      p.mock_meta_test
+      p.mock_meta_test_with_args
+    }.should raise_error(NoMethodError)
+    class Orange::Packet 
+      meta_methods(/my_mock_meta_method/) do 
+        "my mock meta method"
+      end
+      
+      meta_methods(/mock_meta_(\w+)/) do |packet, match|
+        "my mock #{match[1]} method"
+      end
+      
+      meta_methods(/mock_meta_(\w+)_with_args/) do |packet, match, args|
+        "my mock #{match[1]} method args0 = #{args[0]}"
+      end
+    end
+    lambda {
+      p.my_mock_meta_method
+      p.mock_meta_test
+      p.mock_meta_test_with_args 'test'
+    }.should_not raise_error(NoMethodError)
+    p.my_mock_meta_method.should == "my mock meta method"
+    p.mock_meta_test.should == "my mock test method"
+    p.mock_meta_test_with_args('test').should == "my mock test method args0 = test"
+  end
 end

data/spec/resource_spec.rb

@@ -1,5 +1,89 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Orange::Resource do
-  it "should be spec'ed"
+  it "should allow options" do
+    r= Orange::Resource.new(:opt_1 => true){ opt_2 true }
+    r.options[:opt_1].should == true
+    r.options[:opt_2].should == true
+    r.options.should have_key(:opt_1)
+    r.options.should_not have_key(:opt_3)
+  end
+  
+  it "should accept an orange core on set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange.should equal(c)
+    r.orange.should be_a_kind_of(Orange::Core)
+  end
+  
+  it "should call afterLoad after calling set_orange" do
+    c= Orange::Core.new 
+    r= MockResource.new
+    r.options.should_not have_key(:mocked)
+    r.set_orange(c, :name)
+    r.options.should have_key(:mocked)
+    r.options[:mocked].should == true
+  end
+  
+  it "should set the orange_name after calling set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r2= Orange::Resource.new
+    r.set_orange(c, :name)
+    r2.set_orange(c, 'name')
+    r.orange_name.should == :name
+    r2.orange_name.should_not == :name
+    r2.orange_name.should == 'name'
+  end
+  
+  it "should return self after set_orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    me = r.set_orange(c, :name)
+    me.should equal r
+  end
+  
+  it "should return an error if setting orange on a class" do
+    lambda {
+      Orange::Resource.set_orange(Orange::Core.new, :mock)
+    }.should raise_error(RuntimeError, "instantiate the resource before calling set orange")
+  end
+  
+  it "should give access to the core through orange" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange.should equal(c)
+    r.orange.should be_a_kind_of(Orange::Core)
+  end
+  
+  it "should respond to routable" do
+    r = Orange::Resource.new
+    r.should respond_to(:routable)
+    r.routable.should be_false
+  end
+  
+  it "should return an empty string on calling view" do
+    r = Orange::Resource.new
+    r.view.should == ''
+    r.view(Orange::Packet.new(Orange::Core.new, {})).should == ''
+  end
+  
+  it "should accept an options hash to view" do
+    p = Orange::Packet.new(Orange::Core.new, {})
+    r = Orange::Resource.new
+    lambda{
+      r.view(p, :opts => 'foo', :test => 'bar')
+    }.should_not raise_error
+  end
+  
+  it "should give access to the orange name attribute" do
+    c= Orange::Core.new 
+    r= Orange::Resource.new
+    r.set_orange(c, :name)
+    r.orange_name.should == :name
+  end
+  
+  
 end

data/spec/resources/model_resource_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Orange::ModelResource do
+
+  it "should extend class inheritable attributes" do
+    Orange::ModelResource.should be_a_kind_of(ClassInheritableAttributes)
+  end
+  
+  it "should have a model class when calling use" do
+    a = MockModelResourceOne.new
+    b = MockModelResourceTwo.new
+    MockModelResourceOne.model_class.should equal MockCarton
+    a.model_class.should equal MockCarton
+    MockModelResourceTwo.model_class.should equal MockCartonTwo
+    b.model_class.should equal MockCartonTwo
+  end
+  
+  it "have a usable view method" do
+     a = MockModelResource.new
+     a.should respond_to(:view)
+  end
+  
+  it "should call index or show by default for an orange packet" do
+    c = Orange::Core.new
+    c.load(MockModelResourceOne.new, :mocked)
+    p = Orange::Packet.new(c, {})
+    p2 = Orange::Packet.new(c, {})
+    p2['route.resource_id'] = 1
+    lambda {
+      c[:mocked].view(p)
+    }.should raise_error(RuntimeError, "I see you're using index")
+    lambda {
+      c[:mocked].view(p2)
+    }.should raise_error(RuntimeError, "I see you're using show")
+  end
+  
+  it "should send the mode to the appropriate method" do
+    c = Orange::Core.new
+    c.load(MockModelResourceOne.new, :mocked)
+    p = Orange::Packet.new(c, {})
+    lambda {
+      c[:mocked].view(p, :mode => :other)
+    }.should raise_error(RuntimeError, "I see you're using other")
+  end
+  
+  it "shouldn't give a shit" do
+    lambda{
+      MockModelResource.shit
+    }.should raise_error(NoMethodError)
+  end
+  
+  it "should call find_one if calling view_opts with is_list false" do
+    a= MockModelResourceOne.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, false)
+    }.should raise_error(RuntimeError, "calling find_one")
+  end
+  
+  it "should call find_list if calling view_opts with is_list true" do
+    a= MockModelResourceOne.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, true)
+    }.should raise_error(RuntimeError, "calling find_list")
+  end
+  
+  it "should return a hash of options on calling view_opts" do
+    a= MockModelResourceFour.new
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    lambda{
+      a.view_opts(p, :list, true)
+    }.should_not raise_error(RuntimeError)
+    opts = a.view_opts(p, :list, true, :extra => 'foo')
+    opts3 = a.view_opts(p, :list, false, :extra => 'foo')
+    opts2 = a.view_opts(p, :list, true, :list => 'banana')
+    opts[:props].should == MockCarton.form_props(p['route.context'])
+    opts.should have_key(:list)
+    opts3.should_not have_key(:list)
+    opts.should have_key(:resource)
+    opts.should have_key(:model_name)
+    opts.should_not have_key(:model)
+    opts3.should have_key(:model)
+    opts.should have_key(:extra)
+    opts3.should have_key(:extra)
+    opts[:extra].should == 'foo'
+    opts3[:extra].should == 'foo'
+    opts[:list].should_not == opts2[:list]
+    opts2[:list].should == 'banana'
+    opts[:list].should == 'mock_list'
+  end
+  
+  it "should call view_extras after during view_opts" do
+    a= MockModelResourceThree.new
+    lambda{
+      a.view_opts(Orange::Packet.new(Orange::Core.new, {}), :list, true)
+    }.should raise_error(RuntimeError, "calling find_extras")
+  end
+  
+  it "should call haml parser with opts on do_view" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    c.load(MockHamlParser.new, :parser)
+    c.load(MockModelResourceFour.new, :mocked)
+    parsed = c[:mocked].do_view(p, :test, :extra => 'foo')
+    parsed.first.should == 'test.haml'
+    parsed.last.should == c[:mocked].view_opts(p, :test, false, :extra => 'foo')
+    parsed.last.should_not == c[:mocked].view_opts(p, :test, true, :extra => 'foo')
+    parsed.last.should have_key(:extra)
+    parsed[1].should equal(p)
+  end
+  
+  it "should call haml parser with opts on do_list_view" do
+    c= Orange::Core.new
+    p= Orange::Packet.new(c, {})
+    c.load(MockHamlParser.new, :parser)
+    c.load(MockModelResourceFour.new, :mocked)
+    parsed = c[:mocked].do_list_view(p, :test, :extra => 'foo')
+    parsed.first.should == 'test.haml'
+    parsed.last.should == c[:mocked].view_opts(p, :test, true, :extra => 'foo')
+    parsed.last.should_not == c[:mocked].view_opts(p, :test, false, :extra => 'foo')
+    parsed.last.should have_key(:extra)
+    parsed[1].should equal(p)
+  end
+  
+  it "should call carton's get on find_one(packet, mode, id)" do
+    a= MockModelResourceTwo.new
+    a.find_one(Orange::Packet.new(Orange::Core.new, {}), :show).should == false
+    a.find_one(Orange::Packet.new(Orange::Core.new, {}), :show, 1).should == 'mock_get'
+  end
+  
+  it "should call carton's all on find_list(packet, mode)" do
+    a= MockModelResourceTwo.new
+    a.find_list(Orange::Packet.new(Orange::Core.new, {}), :show).should == 'mock_all'
+  end
+  
+  it "should return an empty hash by default for find_extras" do
+    a= MockModelResourceTwo.new
+    a.find_extras(Orange::Packet.new(Orange::Core.new, {}), :show).should == {}
+  end
+  
+  
+end

data/spec/resources/routable_resource_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__)  + '/../spec_helper')
+
+describe Orange::RoutableResource do
+  it "should be spec'ed" 
+end

data/spec/spec_helper.rb

@@ -1,16 +1,20 @@
-require 'spec/mock/mock_app'
-require 'spec/mock/mock_pulp'
-require 'spec/mock/mock_core'
-require 'spec/mock/mock_mixins'
-require 'spec/mock/mock_router'
-require 'spec/mock/mock_resource'
-require 'spec/mock/mock_middleware'
-require 'rack/test'
-
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'orange'
+
+require 'mock/mock_app'
+require 'mock/mock_pulp'
+require 'mock/mock_core'
+require 'mock/mock_carton'
+require 'mock/mock_model_resource'
+require 'mock/mock_mixins'
+require 'mock/mock_router'
+require 'mock/mock_resource'
+require 'mock/mock_middleware'
+require 'rack/test'
+
+
 Spec::Runner.configure do |config|
   config.include(Rack::Test::Methods)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: orange
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - David Haslem
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-17 00:00:00 -05:00
+date: 2009-12-28 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -131,14 +131,14 @@ files:
 - lib/orange/middleware/static.rb
 - lib/orange/middleware/static_file.rb
 - lib/orange/middleware/template.rb
-- lib/orange/model_resource.rb
 - lib/orange/packet.rb
 - lib/orange/resource.rb
 - lib/orange/resources/flex_router.rb
 - lib/orange/resources/mapper.rb
+- lib/orange/resources/model_resource.rb
 - lib/orange/resources/page_parts.rb
 - lib/orange/resources/parser.rb
-- lib/orange/routable_resource.rb
+- lib/orange/resources/routable_resource.rb
 - lib/orange/stack.rb
 - README.markdown
 has_rdoc: true
@@ -174,21 +174,37 @@ test_files:
 - spec/carton_spec.rb
 - spec/core_spec.rb
 - spec/magick_spec.rb
+- spec/middleware/access_control_spec.rb
+- spec/middleware/base_spec.rb
+- spec/middleware/database_spec.rb
+- spec/middleware/globals_spec.rb
+- spec/middleware/recapture_spec.rb
+- spec/middleware/rerouter_spec.rb
+- spec/middleware/restful_router_spec.rb
+- spec/middleware/route_context_spec.rb
+- spec/middleware/route_site_spec.rb
+- spec/middleware/show_exceptions_spec.rb
+- spec/middleware/site_load_spec.rb
+- spec/middleware/static_file_spec.rb
+- spec/middleware/static_spec.rb
+- spec/middleware/template_spec.rb
 - spec/mock/mock_app.rb
+- spec/mock/mock_carton.rb
 - spec/mock/mock_core.rb
 - spec/mock/mock_middleware.rb
 - spec/mock/mock_mixins.rb
+- spec/mock/mock_model_resource.rb
 - spec/mock/mock_pulp.rb
 - spec/mock/mock_resource.rb
 - spec/mock/mock_router.rb
-- spec/model_resource_spec.rb
 - spec/orange_spec.rb
 - spec/packet_spec.rb
 - spec/resource_spec.rb
 - spec/resources/flex_router_spec.rb
 - spec/resources/mapper_spec.rb
+- spec/resources/model_resource_spec.rb
 - spec/resources/parser_spec.rb
-- spec/routable_resource_spec.rb
+- spec/resources/routable_resource_spec.rb
 - spec/spec_helper.rb
 - spec/stack_spec.rb
 - spec/stats.rb

data/lib/orange/model_resource.rb

@@ -1,170 +0,0 @@
-require 'orange/routable_resource'
-
-module Orange
-  class ModelResource < RoutableResource
-    extend ClassInheritableAttributes
-    cattr_inheritable :model_class
-    
-    def self.use(my_model_class)
-      @model_class = my_model_class
-    end
-    
-    
-    def model_class
-      self.class.model_class
-    end
-    
-    def view(packet, *args)
-      opts = args.extract_options!.with_defaults({:path => ''})
-      props = model_class.form_props(packet['route.context'])
-      resource_id = opts[:id] || packet['route.resource_id'] || false
-      mode = opts[:mode] || packet['route.resource_action'] || 
-        (resource_id ? :show : :list)  
-      
-      haml_opts = {:props => props, :resource => self.class.to_s, :model_name => @my_orange_name}.merge!(opts)
-      
-      case mode
-      when :show
-        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
-        orange[:parser].haml('show.haml', packet, haml_opts)
-      when :edit
-        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
-        orange[:parser].haml('edit.haml', packet, haml_opts)
-      when :create
-        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
-        orange[:parser].haml('create.haml', packet, haml_opts)
-      when :table_row
-        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
-        orange[:parser].haml('table_row.haml', packet, haml_opts)
-      when :list
-        haml_opts.with_defaults! :list => findList(packet, mode)
-        orange[:parser].haml('list.haml', packet, haml_opts)
-      else
-        self.__send__(mode, packet, haml_opts)
-      end
-    end
-    
-    def findOne(packet, mode, id = false)
-      return false unless id
-      model_class.get(id) 
-    end
-    
-    def findList(packet, mode)
-      model_class.all || []
-    end
-    
-    def viewExtras(packet, mode)
-      {}
-    end
-    
-    def route(path, packet)
-      parts = path.split('/')
-      if parts[0] =~ /^[0-9]+$/
-        route_id = parts.shift 
-      else 
-        route_id = false
-      end
-      parts.unshift('show') if parts.empty? && route_id
-      new_path = parts.join('/')
-      packet['route.resource_id'] = route_id if route_id
-      super(new_path, packet)
-    end
-    
-    def new(packet, *opts)
-      if packet.request.post?
-        model_class.new(packet.request.params[@my_orange_name.to_s]).save
-      end
-      packet.reroute(@my_orange_name, :orange)
-    end
-    
-    def delete(packet, *opts)
-      if packet.request.delete?
-        m = model_class.get(packet['route.resource_id'])
-        m.destroy! if m
-      end
-      packet.reroute(@my_orange_name, :orange)
-    end
-    
-    def save(packet, *opts)
-      if packet.request.post?
-        m = model_class.get(packet['route.resource_id'])
-        if m
-          m.update(packet.request.params[@my_orange_name.to_s])
-        else 
-        end
-      end
-      packet.reroute(@my_orange_name, :orange)
-    end
-    
-    
-    def show(packet, *opts)
-      view(packet, :mode => :show, *opts)
-    end
-    
-    def edit(packet, *opts)
-      view(packet, :mode => :edit, *opts)
-    end
-    
-    def create(packet, *opts)
-      view(packet, :mode => :create, *opts)
-    end
-    
-    def table_row(packet, *opts)
-      view(packet, :mode => :table_row, *opts)
-    end
-    
-    def list(packet, *opts)
-      view(packet, :mode => :list, *opts)
-    end
-    
-    def index(packet, *opts)
-      view(packet, :mode => :list, *opts)
-    end
-  
-  end
-  
-  class Packet
-    def form_link(text, link, confirm = false, *args)
-      opts = args.extract_options!
-      meth = (opts[:method]? "<input type='hidden' name='_method' value='#{opts[:method]}' />" : '')
-      if confirm
-        "<form action='#{link}' method='post' class='mini' onsubmit='return confirm(\"#{confirm}\")'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
-      else
-        "<form action='#{link}' method='post' class='mini'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
-      end
-    end
-    
-    def view(model_name, *args)
-      orange[model_name].view(self, *args)
-    end
-    
-    def view_attribute(prop, model_name, *args)
-      args = args.extract_options!
-      val = args[:value] || ''
-      label = args[:label] || false
-      show = args[:show] || false
-      name = prop[:name]
-      if !show
-        case prop[:type]
-        when :title
-          ret = "<input class='title' type='text' value='#{val}' name='#{model_name}[#{name}]' />"
-        when :text
-          ret = "<input type='text' value='#{val}' name='#{model_name}[#{name}]' />"
-        when :fulltext
-          ret = "<textarea name='#{model_name}[#{name}]'>#{val}</textarea>"
-        end
-        ret = "<label for=''>#{name}</label><br />" + ret if label
-      else
-        case prop[:type]
-        when :title
-          ret = "<h3 class='#{model_name}-#{name}'>#{val}</h3>"
-        when :text
-          ret = "<p class='#{model_name}-#{name}'>#{val}</p>"
-        when :fulltext
-          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
-        end
-      end
-      ret
-    end
-  end
-end

data/spec/model_resource_spec.rb

@@ -1,5 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Orange::ModelResource do
-  it "should be spec'ed"
-end

data/spec/routable_resource_spec.rb

@@ -1,5 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Orange::RoutableResource do
-  it "should be spec'ed" 
-end