orange 0.5.5 → 0.5.7

data/lib/orange-more/subsites/views/subsites/index.haml

@@ -1,2 +0,0 @@
-%p
-  %a{:href => ''} Add new Subsite

data/lib/orange-more/testimonials.rb

@@ -1 +0,0 @@
-require File.join('orange-more', 'testimonials', 'plugin')

data/lib/orange-more/testimonials/cartons/testimonials_carton.rb

@@ -1,15 +0,0 @@
-class OrangeTestimonial < Orange::SiteCarton
-  id
-  admin do
-    title :name
-    text :position
-    text :company
-    text :tags
-    fulltext :blurb
-  end
-  
-  def self.with_tag(tag)
-    all(:tags.like => "%#{tag}%")
-  end
-
-end

data/lib/orange-more/testimonials/plugin.rb

@@ -1,13 +0,0 @@
-Dir.glob(File.join(File.dirname(__FILE__), 'cartons', '*.rb')).each {|f| require f }
-Dir.glob(File.join(File.dirname(__FILE__), 'resources', '*.rb')).each {|f| require f }
-
-module Orange::Plugins
-  class Testimonials < Base
-    views_dir   File.join(File.dirname(__FILE__), 'views')
-    
-    resource    Orange::TestimonialsResource.new
-  end
-end
-
-Orange.plugin(Orange::Plugins::Testimonials.new)
-

data/lib/orange-more/testimonials/resources/testimonials_resource.rb

@@ -1,42 +0,0 @@
-module Orange
-  class TestimonialsResource < Orange::ModelResource
-    use OrangeTestimonial
-    call_me :testimonials
-    def stack_init
-      orange[:admin, true].add_link("Content", :resource => @my_orange_name, :text => 'Testimonials')
-      orange[:radius].define_tag "testimonials" do |tag|
-        packet = tag.locals.packet
-     	  if tag.attr["tag"] && for_site(packet).with_tag(tag.attr["tag"]).count >0
-          m = for_site(packet).with_tag(tag.attr["tag"]).first(:offset => rand(for_site(packet).with_tag(tag.attr["tag"]).count)) #selects testimonial based on tag
-	      elsif for_site(packet).count > 0 && !tag.attr.include?("tag")
-      	  m = for_site(packet).first(:offset => rand(for_site(packet).count)) #selects a random testimonial
-	      end
-        unless m.nil?
-          template = tag.attr["template"] || "testimonials"
-          orange[:testimonials].testimonial(packet, {:model => m, :template => template})
-        else
-          ""
-        end
-      end
-    end
-    
-    def afterNew(packet, obj, params = {})
-      obj.orange_site = packet['subsite'].blank? ? packet['site'] : packet['subsite']
-    end
-    
-    def for_site(packet, opts = {})
-      site_filtered = model_class.all(:orange_site => packet['subsite'].blank? ? packet['site'] : packet['subsite'])
-      if site_filtered.count > 0
-        site_filtered
-      else
-        # Return unfiltered if no site-specific ones
-        model_class.all
-      end
-    end
-    
-    def testimonial(packet, opts = {})
-      template = opts[:template].to_sym || :testimonials
-      do_view(packet, template, opts)
-    end
-  end
-end

data/lib/orange-more/testimonials/views/testimonials/testimonials.haml

@@ -1,4 +0,0 @@
-%h2 #{model.name} Said:
-%h4 Position: #{model.position}
-%h4 At: #{model.company}
-%p= model.blurb

data/spec/orange-core/application_spec.rb

@@ -1,183 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Orange::Application do
-  before(:all) do
-    class MockApplication
-      set :banana, 'foo'
-      attr_accessor :quux, :wibble
-      def init
-        opts[:init] = true
-        @quux = true
-      end
-      def stack_init
-        opts[:stack_init] = true
-        @wibble = true
-      end
-    end
-    # allow deep introspection into rack builder
-    class Rack::Builder 
-      attr_accessor :ins
-      # introspection into the Builder object's list of items
-      # builder uses Proc magic to chain the middleware together,
-      # so we undo it.
-      def ins_no_procs
-        @ins.map{|x| x.instance_of?(Proc)? x.call(nil) : x }
-      end
-    end
-    class Orange::Stack 
-      attr_accessor :build
-      def middlewarez
-        build.ins_no_procs
-      end
-    end
-  end
-  
-  def app
-    MockApplication.app
-  end
-  
-  it "should be a subclass of Orange::Application" do
-    MockApplication.new(Orange::Core.new).should be_a_kind_of(Orange::Application)
-  end
-  
-  it "should have a stack method" do
-    MockApplication.should respond_to(:stack)
-  end
-  
-  it "should have a different app stack after using stack method" do
-    lambda {
-      MockApplication.stack do
-      end
-    }.should change(MockApplication, :app)
-  end
-
-  it "should respond to the app method" do
-    MockApplication.should respond_to(:app)
-  end
-  
-  it "should return an Orange::Stack with the app method" do
-    MockApplication.stack do
-    end
-    MockApplication.app.should be_an_instance_of(Orange::Stack)
-  end
-  
-  it "should be able to set options" do
-    MockApplication.set(:test4, Time.now.to_f-5)
-    opts_test4 = MockApplication.opts[:test4]
-    MockApplication.set(:test4, Time.now.to_f)
-    MockApplication.opts[:test4].should_not == opts_test4
-    MockApplication.opts[:banana].should == 'foo'
-  end
-  
-  it "should be able to accept instance option setting" do
-    x= MockApplication.new(Orange::Core.new, {:test => 'go'}){
-      baz 'bar'
-    }
-    x.opts.should have_key(:baz)
-    x.opts.should have_key(:banana)
-    x.opts[:baz].should == 'bar'
-    x.opts[:test].should == 'go'
-  end
-  
-  it "should override class variables with instance ones" do
-    x= MockApplication.new(Orange::Core.new)
-    y= MockApplication.new(Orange::Core.new){
-      banana 'bar'
-    }
-    x.opts.should have_key(:banana)
-    y.opts.should have_key(:banana)
-    x.opts[:banana].should == 'foo'
-    y.opts[:banana].should == 'bar'
-    x.opts[:banana].should_not == y.opts[:banana]
-  end
-  
-  it "should be able to access options via #opts" do
-    x= MockApplication.new(Orange::Core.new){
-      baz 'bar'
-    }
-    x.opts.should be_an_instance_of(Hash)
-    x.opts.should respond_to(:[])
-    x.opts.should have_key(:baz)
-    x.opts[:baz].should == 'bar'
-  end
-  
-  it "should call init after being initialized" do
-    x=MockApplication.new(Orange::Core.new){
-      init false
-    }
-    x.opts[:init].should be_true
-    x.quux.should be_true
-  end
-  
-  it "should call stack_init after stack loaded" do
-    c = Orange::Core.new
-    app = MockApplication.new(c){
-      stack_init false
-    }
-    c.fire(:stack_loaded, false) # Falsify the stack_load call
-    app.opts[:stack_init].should be_true
-    app.wibble.should be_true
-  end
-  
-  it "should raise a default error if route isn't redefined" do
-    x= MockApplication.new(Orange::Core.new)
-    lambda{ 
-      x.route(Orange::Packet.new(x.orange, {})) 
-    }.should raise_error(Exception, 'default response from Orange::Application.route')
-  end
-  
-  it "should return the orange core on #orange" do
-    c = Orange::Core.new
-    x= MockApplication.new(c)
-    x.orange.should eql(c)
-  end
-  
-  it "should change the core on #set_core(orange_core)" do
-    c1 = Orange::Core.new
-    c2 = Orange::Core.new
-    x= MockApplication.new(c1)
-    c1.should_not eql(c2)
-    lambda {
-      x.set_core(c2)
-    }.should change(x, :orange)
-  end
-  
-  it "should allow setting the core via #app" do
-    c = Orange::Core.new
-    x= MockApplication.app(c)
-    x.orange.should equal(c)
-  end
-  
-  it "should allow setting the core via #stack" do
-    c = Orange::Core.new
-    MockApplication.stack(c) do
-      run MockApplication.new(orange)
-    end
-    x= MockApplication.app
-    x.orange.should equal(c)
-    x.middlewarez.first.orange.should equal(c)
-    p = Orange::Packet.new(c, {'orange.core' => c})
-    Orange::Packet.should_receive(:new).with(c, {'orange.core' => c}).and_return(p)
-    lambda{
-      x.call({}) # We don't care about the error, we care about the should_receive
-    }.should raise_error 
-  end
-  
-  it "should respond correctly to call" do
-    x= MockApplication.new(Orange::Core.new)
-    lambda{
-      x.call({})
-    }.should raise_error(Exception, 'default response from Orange::Application.route')
-    r = TestRouter.new
-    lambda{
-      x.call({'orange.env' => {'route.router' => r}})
-    }.should change(r, :x)
-  end
-  
-  it "should auto initialize the self.opts" do
-    lambda{
-      MockApplication2.opts
-    }.should_not raise_error
-  end
-    
-end

data/spec/orange-core/carton_spec.rb

@@ -1,136 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Orange::Carton do
-  it "should call property with :id, Serial on #self.id" do
-    MockCartonBlank.should_receive(:property).with(:id, DataMapper::Types::Serial)
-    MockCartonBlank.id
-  end
-  
-  it "should call self.init after calling id" do
-    MockCartonBlankTwo.should_receive(:init)
-    MockCartonBlankTwo.id
-  end
-  
-  it "should give form properties" do
-    MockCarton.form_props(:live).length.should >= 1
-    MockCarton.form_props(:admin).length.should >= 2
-    MockCarton.form_props(:orange).length.should >= 3
-    MockCarton.form_props(:banana).should have(0).items
-  end
-  
-  it "should call instance eval on admin block" do
-    MockCartonBlank.should_receive(:instance_eval)
-    MockCartonBlank.admin {}
-  end
-  
-  it "should call instance eval on orange block" do
-    MockCartonBlank.should_receive(:instance_eval)
-    MockCartonBlank.orange {}
-  end
-  
-  it "should call instance eval on front block" do
-    MockCartonBlank.should_receive(:instance_eval)
-    MockCartonBlank.front {}
-  end
-  
-  it "should change props when calling front_property" do
-    lambda {
-      MockCarton.front_property :foo, String
-    }.should change(MockCarton, :form_props)
-    
-  end
-  
-  it "should change admin props when calling admin_property (but not front props)" do
-    old_props = MockCarton.form_props(:admin)
-    lambda {
-      MockCarton.admin_property :foo, String
-    }.should_not change(MockCarton, :form_props)
-    old_props.should_not == MockCarton.form_props(:admin)
-  end
-  
-  it "should change orange props when calling orange_property (but not front/admin props)" do
-    admin_props = MockCarton.form_props(:admin)
-    old_props = MockCarton.form_props(:orange)
-    lambda {
-      MockCarton.orange_property :foo, String
-    }.should_not change(MockCarton, :form_props)
-    admin_props.should == MockCarton.form_props(:admin)
-    old_props.should_not == MockCarton.form_props(:orange)
-  end
-  
-  it "should change the levels var when using front block" do
-    MockCartonBlank.should_receive(:test_levels){|me| me.levels.should include(:live)}
-    MockCartonBlank.front{ test_levels(self) }
-    MockCartonBlank.levels.should == false
-  end
-  
-  it "should change the levels var when using admin block" do
-    MockCartonBlank.should_receive(:test_levels){|me| 
-      me.levels.should_not include(:front)
-      me.levels.should include(:admin)
-    }
-    MockCartonBlank.admin{ test_levels(self) }
-    MockCartonBlank.levels.should == false
-  end
-  
-  it "should change the levels var when using orange block" do
-    MockCartonBlank.should_receive(:test_levels){|me| 
-      me.levels.should_not include(:front)
-      me.levels.should_not include(:admin)
-      me.levels.should include(:orange)
-    }
-    MockCartonBlank.orange{ test_levels(self) }
-    MockCartonBlank.levels.should == false
-  end
-  
-  it "should have a front property after calling #front" do
-    front = MockCarton.scaffold_properties.select{|i| i[:name] == :front}
-    front.should have_at_least(1).items
-    front.first[:levels].should include(:live)
-  end 
-  
-  it "should have an admin property after calling #admin" do
-    front = MockCarton.scaffold_properties.select{|i| i[:name] == :admin}
-    front.should have_at_least(1).items
-    front.first[:levels].should_not include(:live)
-    front.first[:levels].should include(:admin)
-  end
-  
-  it "should have an orange property after calling #orange" do
-    front = MockCarton.scaffold_properties.select{|i| i[:name] == :orange}
-    front.should have_at_least(1).items
-    front.first[:levels].should_not include(:live)
-    front.first[:levels].should_not include(:admin)
-    front.first[:levels].should include(:orange)
-  end
-  
-  it "should call property on title" do
-    MockCarton.should_receive(:property).with(an_instance_of(Symbol), String, anything())
-    MockCarton.title(:wibble)
-  end
-  
-  it "should call property on text" do
-    MockCarton.should_receive(:property).with(an_instance_of(Symbol), String, anything())
-    MockCarton.text(:wobble)
-  end
-
-  it "should call property on string" do
-    MockCarton.should_receive(:property).with(an_instance_of(Symbol), String, anything())
-    MockCarton.string(:wubble)
-  end
-  
-  it "should call property on fulltext" do
-    MockCarton.should_receive(:property).with(an_instance_of(Symbol), DataMapper::Types::Text, anything())
-    MockCarton.fulltext(:cudge)
-  end
-  
-  it "should define a constant (resource class)" do
-    lambda{
-      MockCartonBlankTwo_Resource.nil?
-    }.should raise_error(NameError)
-    MockCartonBlankTwo.as_resource
-    lambda{
-      MockCartonBlankTwo_Resource.nil?
-    }.should_not raise_error
-  end
-end

data/spec/orange-core/core_spec.rb

@@ -1,248 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Orange::Core do
-  before(:all) do
-    class Orange::Core; attr_reader :resources, :events, :file; end;
-  end
-  
-  it "should allow core mixin via class mixin method" do
-    c= Orange::Core.new
-    c.should_not respond_to(:mixin_core_one)
-    Orange::Core.mixin MockMixinCore1
-    c2= Orange::Core.new
-    c.should respond_to(:mixin_core_one)
-    c2.should respond_to(:mixin_core_one)
-  end
-  
-  it "should allow pulp mixin via class pulp method" do
-    c= Orange::Core.new
-    p= Orange::Packet.new(c, {})
-    p.should_not respond_to(:pulp_core_one)
-    Orange::Core.add_pulp MockPulpCore1
-    p2= Orange::Packet.new(c, {})
-    p.should respond_to(:pulp_core_one)
-    p2.should respond_to(:pulp_core_one)
-  end
-  
-  it "should allow core mixin via instance mixin method" do
-    c= Orange::Core.new
-    c.should_not respond_to(:mixin_core_two)
-    c.mixin MockMixinCore2
-    c2= Orange::Core.new
-    c.should respond_to(:mixin_core_two)
-    c2.should respond_to(:mixin_core_two)
-  end
-  
-  it "should allow pulp mixin via instance pulp method" do
-    c= Orange::Core.new
-    p= Orange::Packet.new(c, {})
-    p.should_not respond_to(:pulp_core_two)
-    c.add_pulp MockPulpCore2
-    p2= Orange::Packet.new(c, {})
-    p.should respond_to(:pulp_core_two)
-    p2.should respond_to(:pulp_core_two)
-  end
-  
-  it "should have three contexts by default" do
-    Orange::Core::DEFAULT_CORE_OPTIONS.should have_key(:contexts)
-    Orange::Core::DEFAULT_CORE_OPTIONS[:contexts].should have(3).items
-  end
-  
-  it "should default to live context" do
-    Orange::Core::DEFAULT_CORE_OPTIONS.should have_key(:default_context)
-    Orange::Core::DEFAULT_CORE_OPTIONS[:default_context].should == :live
-  end
-  
-  it "should load at least two resources by default" do
-    c= Orange::Core.new
-    c.resources.size.should >= 2
-    c.loaded?(:mapper).should be_true
-    c.loaded?(:parser).should be_true
-  end
-  
-  it "should have two events by default" do
-    c= Orange::Core.new
-    c.events.should have(2).events
-    c.events.should have_key(:stack_reloading)
-    c.events.should have_key(:stack_loaded)
-  end
-  
-  it "should return a directory that contains core.rb when calling core_dir" do
-    c= Orange::Core.new
-    c.core_dir.should match(/orange-core$/)
-    File.should exist(File.join(c.core_dir, 'core.rb'))
-    File.should exist(File.join(c.core_dir, 'stack.rb'))
-    File.should exist(File.join(c.core_dir, 'application.rb'))
-    File.should exist(File.join(c.core_dir, 'carton.rb'))
-    File.should exist(File.join(c.core_dir, 'views'))
-    File.should exist(File.join(c.core_dir, 'templates'))
-    File.should exist(File.join(c.core_dir, 'assets'))
-  end
-  
-  it "should return the directory of the super class when calling core_dir on subclass" do
-    c= MockCoreSubclass.new
-    c.core_dir.should match(/orange-core$/)
-    File.should exist(File.join(c.core_dir, 'core.rb'))
-    File.should exist(File.join(c.core_dir, 'stack.rb'))
-    File.should exist(File.join(c.core_dir, 'application.rb'))
-    File.should exist(File.join(c.core_dir, 'carton.rb'))
-    File.should exist(File.join(c.core_dir, 'views'))
-    File.should exist(File.join(c.core_dir, 'templates'))
-    File.should exist(File.join(c.core_dir, 'assets'))
-  end
-  
-  it "should call afterLoad after init" do
-    c1= MockCoreSubclass.new
-    class MockCoreSubclass
-      def afterLoad
-        options[:called_afterload_for_subclass] = true
-      end
-    end
-    c2= MockCoreSubclass.new
-    c1.options[:called_afterload_for_subclass].should_not == c2.options[:called_afterload_for_subclass]
-    c1.options.should_not have_key(:called_afterload_for_subclass)
-    c2.options.should have_key(:called_afterload_for_subclass)
-    c2.options[:called_afterload_for_subclass].should be_true
-  end
-  
-  it "should allow changing of default core_dir" do
-    c= Orange::Core.new
-    c.options[:core_dir] = "/non/existent/dir"
-    c.core_dir.should_not == File.dirname(c.file)
-    c.core_dir.should == "/non/existent/dir"
-    File.should exist(File.join(File.dirname(c.file), 'core.rb'))
-  end
-  
-  it "should return Dir.pwd for app_dir by default" do
-    Orange::Core.new.app_dir.should == Dir.pwd
-  end
-  
-  it "should return assigned app_dir if option set" do
-    c= Orange::Core.new
-    c.options[:app_dir] = "/non/existent/dir"
-    c.app_dir.should_not == Dir.pwd
-    c.app_dir.should == "/non/existent/dir"
-  end
-  
-  it "should return assigned app_dir with extra path if args passed" do
-    c= Orange::Core.new
-    c.options[:app_dir] = "/non/existent/dir"
-    c.app_dir('foo', 'bar').should_not == c.app_dir
-    c.app_dir('foo', 'bar').should == "/non/existent/dir/foo/bar"
-  end
-  
-  it "should allow options" do
-    c= Orange::Core.new(:opt_1 => true){ opt_2 true }
-    c.options[:opt_1].should == true
-    c.options[:opt_2].should == true
-    c.options.should have_key(:opt_1)
-    c.options.should_not have_key(:opt_3)
-  end
-  
-  it "should load a resource when passed resource instance" do
-    c= Orange::Core.new
-    c.load(MockResource.new, :mock_one)
-    c.resources.should have_key(:mock_one)
-    c.resources[:mock_one].should be_an_instance_of(MockResource)
-    
-  end
-  
-  it "should default to lowercase resource name to symbol as resource short name" do
-    c= Orange::Core.new
-    c.load(MockResource.new)
-    sym = MockResource.to_s.gsub(/::/, '_').downcase.to_sym
-    c.resources.should have_key(sym)
-    c.should be_loaded(sym)
-  end
-  
-  it "should say a resource is loaded after calling load for resource" do
-    c= Orange::Core.new
-    c.load(MockResource.new, :mock_one)
-    c.should be_loaded(:mock_one)
-    c.resources.should have_key(:mock_one)
-  end
-  
-  it "should return self on orange" do
-    c= Orange::Core.new
-    c.orange.should eql(c)
-  end
-  
-  it "should add event to events list when register called" do
-    c= Orange::Core.new
-    c.register(:mock_event) {|x| x }
-    c.events.should_not be_empty
-    c.events.should have_key(:mock_event)
-    c.events[:mock_event].should be_an_instance_of(Array)
-    c.events[:mock_event].should have(1).callback
-    c.register(:mock_event) {|x| x }
-    c.events[:mock_event].should have(2).callbacks
-  end
-  
-  it "should add events in specified order when registered with position" do
-    c= Orange::Core.new
-    c.register(:mock_event, 5) {|x| '5' }
-    c.events.should_not be_empty
-    c.events.should have_key(:mock_event)
-    c.events[:mock_event].compact.should have(1).callback
-    5.times{ |i| c.events[:mock_event][i].should be_nil }
-    c.register(:mock_event, 2) {|x| '2' }
-    c.events[:mock_event].compact.should have(2).callbacks
-    c.events[:mock_event][2].call(nil).should eql '2'
-    c.events[:mock_event][6].call(nil).should eql '5'
-    c.events[:mock_event].compact.first.call(nil).should eql '2'
-    c.events[:mock_event].compact.last.call(nil).should eql '5'
-    c.register(:mock_event, 5) {|x| '5.2' }
-    c.events[:mock_event].compact.should have(3).callbacks
-    c.events[:mock_event][2].call(nil).should eql '2'
-    c.events[:mock_event][5].call(nil).should eql '5.2'
-    c.events[:mock_event][7].call(nil).should eql '5'
-    c.events[:mock_event].compact.first.call(nil).should eql '2'
-    c.events[:mock_event].compact.last.call(nil).should eql '5'
-  end
-  
-  it "should fire registered events when fire called" do
-    class OtherMockCore < Orange::Core 
-      attr_accessor :mock_counter
-      def afterLoad
-        @mock_counter = 0
-      end
-    end
-    c= OtherMockCore.new
-    c.mock_counter.should == 0
-    c.register(:mock_event) {|i| c.mock_counter += i }
-    c.register(:mock_event_two) {|i| c.mock_counter -= i }
-    c.mock_counter.should == 0
-    c.fire(:mock_event, 3)
-    c.mock_counter.should_not == 0
-    c.mock_counter.should == 3
-    c.fire(:mock_event_two, 2)
-    c.mock_counter.should_not == 0
-    c.mock_counter.should == 1
-    c.register(:mock_event) {|i| c.mock_counter += i }
-    c.fire(:mock_event, 3)
-    c.mock_counter.should_not == 1
-    c.mock_counter.should == 7
-  end
-  
-  it "should have an options hash" do
-    Orange::Core.new.options.should be_an_instance_of(Hash)
-  end
-  
-  it "should allow access to the resources via []" do
-    c= Orange::Core.new
-    c.load(MockResource.new, :mock)
-    c[:mock].should be_an_instance_of(MockResource)
-    c[:mock].should be_an_kind_of(Orange::Resource)
-    c[:mock].mock_method.should eql 'MockResource#mock_method'
-  end
-  
-  it "should have option to silently ignore resource calls" do
-    c= Orange::Core.new
-    lambda {
-      c[:mock].test
-    }.should raise_error
-    lambda {
-      c[:mock, true].test
-    }.should_not raise_error
-  end
-end