spontaneous 0.1.0.alpha1

data/test/unit/test_boxes.rb

@@ -0,0 +1,497 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+
+class BoxesTest < MiniTest::Spec
+
+  context "Box definitions" do
+    setup do
+      S::Schema.reset!
+      class ::Piece < Spontaneous::Piece; end
+      class ::MyBoxClass < Box; end
+      class ::MyContentClass < Piece; end
+      class ::MyContentClass2 < MyContentClass; end
+      MyContentClass.field :description
+    end
+
+    teardown do
+      Object.send(:remove_const, :Piece)
+      Object.send(:remove_const, :MyContentClass2)
+      Object.send(:remove_const, :MyContentClass)
+      Object.send(:remove_const, :MyBoxClass)
+    end
+
+    should "start empty" do
+      MyContentClass.boxes.length.should == 0
+    end
+
+    should "have a flag showing there are no defined boxes" do
+      MyContentClass.has_boxes?.should be_false
+    end
+
+    should "be definable with a name" do
+      MyContentClass.box :images0
+      MyContentClass.boxes.length.should == 1
+      MyContentClass.boxes.first.name.should == :images0
+      MyContentClass.has_boxes?.should be_true
+    end
+
+    should "always return a symbol for the name" do
+      MyContentClass.box 'images0'
+      MyContentClass.boxes.first.name.should == :images0
+    end
+
+    should "create a method of the same name" do
+      MyContentClass.box :images1
+      MyContentClass.box :images2, :type => :MyBoxClass
+      instance = MyContentClass.new
+      instance.images1.class.superclass.should == Box
+      instance.images2.class.superclass.should == MyBoxClass
+    end
+
+    should "be available by name" do
+      MyContentClass.box :images1
+      MyContentClass.box :images2, :type => :MyBoxClass
+      MyContentClass.boxes[:images1].should == MyContentClass.boxes.first
+      MyContentClass.boxes[:images2].should == MyContentClass.boxes.last
+      instance = MyContentClass.new
+      instance.boxes[:images1].class.superclass.should == Box
+      instance.boxes[:images2].class.superclass.should == MyBoxClass
+    end
+
+    should "accept a custom instance class" do
+      MyContentClass.box :images1, :type => MyBoxClass
+      MyContentClass.boxes.first.instance_class.superclass.should == MyBoxClass
+    end
+
+    should "accept a custom instance class as a string" do
+      MyContentClass.box :images1, :type => 'MyBoxClass'
+      MyContentClass.boxes.first.instance_class.superclass.should == MyBoxClass
+    end
+
+    should "accept a custom instance class as a symbol" do
+      MyContentClass.box :images1, :type => :MyBoxClass
+      MyContentClass.boxes.first.instance_class.superclass.should == MyBoxClass
+    end
+
+    should "Instantiate a box of the correct class" do
+      MyContentClass.box :images1
+      MyContentClass.box :images2, :type => :MyBoxClass
+      instance = MyContentClass.new
+      instance.boxes.first.class.superclass.should == Box
+      instance.boxes.last.class.superclass.should == MyBoxClass
+    end
+
+    should "give access to the prototype within the instance" do
+      MyContentClass.box :images1
+      instance = MyContentClass.new
+      instance.boxes[:images1]._prototype.should == MyContentClass.boxes[:images1]
+    end
+
+    should "Use the name as the title by default" do
+      MyContentClass.box :band_and_band
+      MyContentClass.box :related_items
+      MyContentClass.boxes.first.title.should == "Band & Band"
+      MyContentClass.boxes.last.title.should == "Related Items"
+    end
+
+    should "have 'title' option" do
+      MyContentClass.box :images4, :title => "Custom Title"
+      MyContentClass.boxes.first.title.should == "Custom Title"
+    end
+
+    should "inherit boxes from superclass" do
+      MyContentClass.box :images1, :type => :MyBoxClass
+      MyContentClass2.box :images2
+      MyContentClass2.boxes.length.should == 2
+      instance = MyContentClass2.new
+      instance.images1.class.superclass.should == MyBoxClass
+      instance.images2.class.superclass.should == Box
+      instance.boxes.length.should == 2
+    end
+
+    context "ranges" do
+      setup do
+        MyContentClass.box :images1
+        MyContentClass.box :images2
+        MyContentClass.box :images3
+        MyContentClass.box :images4
+        MyContentClass.box :images5
+        MyContentClass2.box :images6
+        @instance = MyContentClass.new
+        @instance2 = MyContentClass2.new
+      end
+      should "allow access to groups of boxes through ranges" do
+        @instance.boxes[1..-2].map { |b| b.box_name }.should == [:images2, :images3, :images4]
+        @instance2.boxes[1..-2].map { |b| b.box_name }.should == [:images2, :images3, :images4, :images5]
+      end
+
+      should "allow you to pass a list of names" do
+        @instance.boxes[:images1, :images4].map { |b| b.box_name }.should == [:images1, :images4]
+        @instance2.boxes[:images1, :images6].map { |b| b.box_name }.should == [:images1, :images6]
+      end
+
+      should "allow a mix of names and indexes" do
+        @instance.boxes[0..2, :images5].map { |b| b.box_name }.should == [:images1, :images2, :images3, :images5]
+      end
+      should "allow access to groups of boxes through tags"
+      #   MyContentClass.box :images5, :tag => :main
+      #   MyContentClass.box :posts, :tag => :main
+      #   MyContentClass.box :comments
+      #   MyContentClass.box :last, :tag => :main
+      #   @instance = MyBoxClass.new
+      #   @instance.boxes.tagged(:main).length.should == 3
+      #   @instance.boxes.tagged('main').map {|e| e.name }.should == [:images5, :posts, :last]
+      # end
+    end
+    context "with superclasses" do
+      setup do
+        MyContentClass.box :images6, :tag => :main
+
+        @subclass1 = Class.new(MyContentClass) do
+          box :monkeys, :tag => :main
+          box :apes
+        end
+        @subclass2 = Class.new(@subclass1) do
+          box :peanuts
+        end
+      end
+      should "inherit boxes from its superclass" do
+        @subclass2.boxes.length.should == 4
+        @subclass2.boxes.map { |s| s.name }.should == [:images6, :monkeys, :apes, :peanuts]
+        # @subclass2.boxes.tagged(:main).length.should == 2
+        instance = @subclass2.new
+        instance.boxes.length.should == 4
+      end
+
+      should "allow customisation of the box order" do
+        new_order = [:peanuts, :apes, :images6, :monkeys]
+        @subclass2.box_order *new_order
+        @subclass2.boxes.map { |s| s.name }.should == new_order
+      end
+
+      should "take order of instance boxes from class defn" do
+        new_order = [:peanuts, :apes, :images6, :monkeys]
+        @subclass2.box_order *new_order
+        instance = @subclass2.new
+        instance.boxes.map { |e| e.box_name.to_sym }.should == new_order
+      end
+    end
+
+
+
+    should "accept values for the box's fields"
+    should "allow overwriting of class definitions using a block"
+  end
+
+  context "Box classes" do
+    setup do
+      Schema.reset!
+      Spontaneous.template_root = File.expand_path('../../fixtures/templates/boxes', __FILE__)
+      class ::Piece < Spontaneous::Piece; end
+      class ::MyContentClass < ::Piece; end
+      class ::MyBoxClass < Box; end
+      MyBoxClass.field :title, :string
+      MyBoxClass.field :description, :string
+      MyContentClass.box :images, :class => :MyBoxClass, :fields => {
+        :title => "Default Title",
+        :description => "Default Description"
+      }
+      @content = MyContentClass.new
+    end
+
+    teardown do
+      Object.send(:remove_const, :Piece)
+      Object.send(:remove_const, :MyContentClass)
+      Object.send(:remove_const, :MyBoxClass)
+    end
+
+    should "have fields" do
+      MyBoxClass.fields.length.should == 2
+      MyBoxClass.field :another, :string
+      MyBoxClass.fields.length.should == 3
+    end
+
+    context "with fields" do
+
+      should "save their field values" do
+        @content.images.title = "something"
+        @content.images.description = "description here"
+        @content.save
+        @content.reload
+        @content.images.title.value.should == "something"
+        @content.images.description.value.should == "description here"
+      end
+
+      should "take initial values from box definition" do
+        @content.images.title.value.should == "Default Title"
+        @content.images.description.value.should == "Default Description"
+      end
+    end
+
+    should "allow inline definition of fields" do
+      MyContentClass.box :partners do
+        field :name, :string
+        field :logo, :image
+        field :description, :string
+      end
+      instance = MyContentClass.new
+      instance.partners.name.must_be_instance_of(Spontaneous::FieldTypes::StringField)
+      instance.partners.name = "Howard"
+      instance.partners.description = "Here is Howard"
+      instance.save
+      instance = Content[instance.id]
+      instance.partners.name.value.should == "Howard"
+      instance.partners.description.value.should == "Here is Howard"
+    end
+
+    should "default to template in root with the same name" do
+    end
+
+    # context "with styles" do
+    #   setup do
+    #     MyBoxClass.field :title, :string
+    #     MyBoxClass.style :christy
+    #     class ::InheritedStyleBox < MyBoxClass; end
+    #     class ::WithTemplateBox < Box; end
+    #     class ::WithoutTemplateBox < Box; end
+    #     class ::BlankContent < Content; end
+    #     @content = MyContentClass.new
+    #     @content.images.title = "whisty"
+    #   end
+
+    #   teardown do
+    #     Object.send(:remove_const, :InheritedStyleBox)
+    #     Object.send(:remove_const, :WithTemplateBox)
+    #     Object.send(:remove_const, :WithoutTemplateBox)
+    #     Object.send(:remove_const, :BlankContent)
+    #   end
+
+    #   should "render using explicit styles" do
+    #     @content.images.render.should == "christy: whisty\\n"
+    #   end
+
+    #   should_eventually "allow defining style in definition" do
+    #     BlankContent.box :images do
+    #       style :inline_style
+    #     end
+    #     instance = BlankContent.new
+    #     instance.images.style.filename.should == "inline_style.html.cut"
+    #   end
+
+    #   should "render using default template style" do
+    #     BlankContent.box :images, :class => :WithTemplateBox
+    #     instance = BlankContent.new
+    #     instance.images.render.should == "with_template_box.html.cut\\n"
+    #   end
+
+    #   should "render using global default box styles" do
+    #     entry = Object.new
+    #     entry.stubs(:render).returns("<entry>")
+    #     BlankContent.box :images, :class => :WithoutTemplateBox
+    #     instance = BlankContent.new
+    #     instance.images.stubs(:pieces).returns([entry])
+    #     instance.images.render.should == "<entry>"
+    #   end
+
+    #   should "find templates named after box in owning classes template dir" do
+    #     BlankContent.box :things
+    #     instance = BlankContent.new
+    #     instance.things.render.should == "blank_content/things.html.cut\\n"
+    #   end
+
+    #   should "not use templates with box name found in root template dir" do
+    #     BlankContent.box :thangs
+    #     instance = BlankContent.new
+    #     instance.thangs.render.should == ""
+    #   end
+
+    #   should "inherit styles from their superclass" do
+    #     BlankContent.box :images, :class => :InheritedStyleBox
+    #     instance = BlankContent.new
+    #     instance.images.title = "ytsirhc"
+    #     instance.images.render.should == "christy: ytsirhc\\n"
+    #   end
+    # end
+
+  end
+
+  context "Box content" do
+    setup do
+      class ::Piece < Spontaneous::Piece; end
+      class ::BlankContent < ::Piece; end
+      class ::StyledContent < ::Piece; end
+
+      BlankContent.style :blank1
+      BlankContent.style :blank2
+      BlankContent.style :blank3
+      BlankContent.box :images
+      BlankContent.box :words
+
+      StyledContent.box :one do
+        allow :BlankContent, :style => :blank2
+      end
+
+      StyledContent.box :two do
+        allow :BlankContent, :styles => [:blank3, :blank2]
+      end
+
+      @parent = BlankContent.new
+    end
+
+    teardown do
+      Object.send(:remove_const, :Piece)
+      Object.send(:remove_const, :BlankContent)
+      Object.send(:remove_const, :StyledContent)
+    end
+
+    should "be addable" do
+      child1 = BlankContent.new
+      child2 = BlankContent.new
+      child3 = BlankContent.new
+      @parent.images << child1
+      @parent.words << child2
+      child1.box.schema_id.should == @parent.images.schema_id
+      child2.box.schema_id.should == @parent.words.schema_id
+      @parent.save
+      child1.images << child3
+      child1.save
+      @parent = Content[@parent.id]
+      child1.reload; child2.reload; child3.reload
+      @parent.images.pieces.should == [child1]
+      @parent.words.pieces.should == [child2]
+      @parent.pieces.should == [child1, child2]
+      child1.images.pieces.should == [child3]
+      child1.pieces.should == [child3]
+
+      @parent.images.pieces.first.box.should == @parent.images
+      @parent.words.pieces.first.box.should == @parent.words
+      @parent.pieces.first.box.should == @parent.images
+    end
+
+    should "choose correct style" do
+      styled = StyledContent.new
+      child1 = BlankContent.new
+      child2 = BlankContent.new
+      child3 = BlankContent.new
+      styled.one << child1
+      styled.two << child2
+      styled.save
+      styled = Content[styled.id]
+      styled.one.pieces.first.style.name.should == :blank2
+      styled.two.pieces.first.style.name.should == :blank3
+    end
+
+    should "allow selection of subclasses" do
+    end
+  end
+  context "Allowed types" do
+    setup do
+      class ::Allowed1 < Content
+        style :frank
+        style :freddy
+      end
+      class ::Allowed2 < Content
+        style :john
+        style :paul
+        style :ringo
+        style :george
+      end
+      class ::Allowed3 < Content
+        style :arthur
+        style :lancelot
+      end
+      class ::Allowed4 < Content; end
+
+      class ::Allowed11 < ::Allowed1; end
+      class ::Allowed111 < ::Allowed1; end
+
+      class ::Parent < Box
+        allow :Allowed1
+        allow Allowed2, :styles => [:ringo, :george]
+        allow 'Allowed3'
+      end
+
+      class ::ChildClass < ::Parent
+      end
+
+      class ::Allowable < Content
+        box :parents, :type => :Parent
+      end
+
+      class ::Mixed < Box
+        allow_subclasses :Allowed1
+      end
+    end
+
+    teardown do
+      [:Parent, :Allowed1, :Allowed11, :Allowed111, :Allowed2, :Allowed3, :Allowed4, :ChildClass, :Allowable, :Mixed].each { |k| Object.send(:remove_const, k) } rescue nil
+    end
+
+    should "have a list of allowed types" do
+      Parent.allowed.length.should == 3
+    end
+
+    should "have understood the type parameter" do
+      Parent.allowed[0].instance_class.should == Allowed1
+      Parent.allowed[1].instance_class.should == Allowed2
+      Parent.allowed[2].instance_class.should == Allowed3
+    end
+
+    # TODO: decide on whether testing class definitions is a good idea
+    # should "raise an error when given an invalid type name" do
+    #   lambda { Parent.allow :WhatTheHellIsThis }.must_raise(NameError)
+    # end
+
+    should "allow all styles by default" do
+      Parent.allowed[2].styles.should == Allowed3.styles
+    end
+
+    should "have a list of allowable styles" do
+      Parent.allowed[1].styles.length.should == 2
+      Parent.allowed[1].styles.map { |s| s.name }.should == [:ringo, :george]
+    end
+
+    # TODO: decide on whether verifying style names is a good idea
+    # should "raise an error if we try to use an unknown style" do
+    #   lambda { Parent.allow :Allowed3, :styles => [:merlin, :arthur]  }.must_raise(Spontaneous::UnknownStyleException)
+    # end
+
+    should "use a configured style when adding a defined allowed type" do
+      a = Allowable.new
+      b = Allowed2.new
+      a.parents << b
+      a.parents.pieces.first.style.prototype.should == Allowed2.styles[:ringo]
+    end
+
+    should "know what the available styles are for an entry" do
+      a = Allowable.new
+      b = Allowed2.new
+      c = Allowed3.new
+      a.parents << b
+      a.parents << c
+      a.parents.available_styles(b).map { |s| s.name }.should == [:ringo, :george]
+      a.parents.available_styles(c).map { |s| s.name }.should == [:arthur, :lancelot]
+    end
+
+    should "inherit allowed types from superclass" do
+      ChildClass.allowed.should == Parent.allowed
+    end
+
+    should "include a subtype's allowed list as well as the supertype's" do
+      ChildClass.allow :Allowed4
+      ChildClass.allowed.map {|a| a.instance_class }.should == (Parent.allowed.map {|a| a.instance_class } + [Allowed4])
+    end
+
+    should "propagate allowed types to slots" do
+      instance = Allowable.new
+      instance.parents.allowed_types.should == Parent.allowed_types
+    end
+
+    should "correctly allow addition of subclasses" do
+      Mixed.allowed_types.should == [Allowed11, Allowed111]
+    end
+  end
+end
+

data/test/unit/test_config.rb

@@ -0,0 +1,156 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+class ConfigTest < MiniTest::Spec
+  include CustomMatchers
+  def setup
+  end
+
+  context "Config" do
+    setup do
+      # Spontaneous.send(:remove_const, :Config) rescue nil
+      # @lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+      # load @lib_dir + '/spontaneous/config.rb'
+      Config ||= ::Spontaneous::Config
+      @pwd = Dir.pwd
+      Dir.chdir(File.expand_path("../../fixtures/config", __FILE__))
+      Spontaneous.root = Dir.pwd
+      class ::TopLevel
+        def self.parameter=(something)
+          @parameter = something
+        end
+
+        def self.parameter
+          @parameter
+        end
+      end
+    end
+    teardown do
+      Object.send(:remove_const, :TopLevel)
+      Dir.chdir(@pwd)
+      # self.class.send(:remove_const, :Config) rescue nil
+    end
+
+    context "Config" do
+      setup do
+        @config = Config.new(:development)
+        @config.load(Spontaneous.root / 'config')
+      end
+      should "load the first time its accessed" do
+        @config.over_ridden.should == :development_value
+      end
+    end
+
+    context "Independent configuration loading" do
+      setup do
+        # defined?(Spontaneous).should be_nil
+        # Object.send(:remove_const, :Spontaneous) rescue nil
+        # defined?(Spontaneous).should be_nil
+        # require @lib_dir + '/spontaneous/config.rb'
+        # Config.environment = :development
+        @config = Config.new(:development)
+        @config.load(Spontaneous.root / 'config')
+      end
+
+      teardown do
+      end
+
+      should "be run from application dir" do
+        File.exist?('config').should be_true
+      end
+
+      should "read from the global environment file" do
+        @config.some_configuration.should == [:some, :values]
+      end
+
+      should "initialise in development mode" do
+        @config.environment.should == :development
+      end
+
+      # should "allow setting of environment" do
+      #   Config.environment.should == :development
+      #   Config.environment = :production
+      #   Config.environment.should == :production
+      # end
+
+      should "overwrite values depending on environment" do
+        @config.over_ridden.should == :development_value
+        config = Config.new(:production)
+        config.load(Spontaneous.root / 'config')
+        config.over_ridden.should == :production_value
+        config = Config.new(:staging)
+        config.load(Spontaneous.root / 'config')
+        config.over_ridden.should == :environment_value
+      end
+
+      should "allow setting of env values" do
+        @config.something_else.should be_nil
+        @config[:something_else] = "loud"
+        @config.something_else.should == "loud"
+      end
+
+      should "allow setting of env values through method calls" do
+        @config.something_else2.should be_nil
+        @config.something_else2 = "loud"
+        @config.something_else2.should == "loud"
+      end
+
+      should "dynamically switch values according to the configured env" do
+        @config.over_ridden.should == :development_value
+        config = Config.new(:production)
+        config.load(Spontaneous.root / 'config')
+        config.over_ridden.should == :production_value
+        config = Config.new(:staging)
+        config.load(Spontaneous.root / 'config')
+        config.over_ridden.should == :environment_value
+      end
+
+      should "allow local over-riding of settings" do
+        @config.wobbling.should be_nil
+        @config.wobbling = "badly"
+        @config.wobbling.should == "badly"
+      end
+
+      should "fallback to defaults" do
+        @config.new_setting.should be_nil
+        @config.defaults[:new_setting] = "new setting"
+        @config.new_setting.should == "new setting"
+      end
+
+      should "accept blocks/procs/lambdas as values" do
+        fish = "flying"
+        @config.useful_feature = Proc.new { fish }
+        @config.useful_feature.should == "flying"
+        @config.defaults[:new_dynamic_setting] = Proc.new { fish }
+        @config.new_dynamic_setting.should == "flying"
+      end
+
+      should "allow calling of global methods" do
+        TopLevel.parameter.should == :dev
+      end
+
+      teardown do
+        Dir.chdir(@pwd)
+      end
+      context "Spontaneous :back" do
+        setup do
+          @config = Config.new(:development, :back)
+          @config.load(Spontaneous.root / 'config')
+        end
+        should "read the correct configuration values" do
+          @config.port.should == 9001
+        end
+      end
+      context "Spontaneous :front" do
+        setup do
+          @config = Config.new(:development, :front)
+          @config.load(Spontaneous.root / 'config')
+        end
+        should "read the correct configuration values" do
+          @config.port.should == 9002
+        end
+      end
+    end
+  end
+end