saxxy 0.1.0

data/spec/saxxy/context_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+require "saxxy/node_rule"
+require "saxxy/node_action"
+require "saxxy/context"
+
+
+describe Saxxy::Context do
+  let(:rule) { Saxxy::NodeRule.new("div") }
+
+  it "should include activatable" do
+    Saxxy::Context.ancestors.should include(Saxxy::Activatable)
+  end
+
+  describe "#initialize" do
+    it "should start with empty child_contexts and actions" do
+      subject.actions.should be_empty
+      subject.child_contexts.should be_empty
+    end
+
+    it "should start with an activation rule if one is given" do
+      subject.activation_rule.should be_nil
+      Saxxy::Context.new(rule).activation_rule.should == rule
+    end
+  end
+
+  # #register action is used to register either an action or a child context
+  describe "#register" do
+    it "should add an action in the actions array if argument is a NodeAction" do
+      action = Saxxy::NodeAction.new(rule)
+      expect { subject.register("foo") }.to_not change { subject.actions }
+      expect { subject.register(action) }.to change { subject.actions }.by([action])
+    end
+
+    it "should add a child context and change its parent to self if argument is a Context" do
+      ctx = Saxxy::Context.new(rule)
+      ctx.parent_context.should be_nil
+      subject.register(ctx).child_contexts.should == [ctx]
+      ctx.parent_context.should == subject
+    end
+  end
+
+  describe "#has_parent?" do
+    it "returns false if the context has no parent" do
+      ctx = Saxxy::Context.new(rule)
+      ctx.has_parent?.should be_false
+      subject.register(ctx)
+      ctx.has_parent?.should be_true
+    end
+  end
+
+end

data/spec/saxxy/context_tree_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "saxxy/node_rule"
+require "saxxy/node_action"
+require "saxxy/context_tree"
+
+
+describe Saxxy::ContextTree do
+  let(:subject) { Saxxy::ContextTree.new {} }
+
+  describe "#initialize" do
+    it "sets root to a new context without a rule" do
+      subject.root.should be_a(Saxxy::Context)
+      subject.root.activation_rule.should be_nil
+    end
+
+    it "should call the eval_subtree! with the provided block" do
+      block = ->(){}
+      Saxxy::ContextTree.any_instance.should_receive(:eval_subtree!).with(&block)
+      Saxxy::ContextTree.new(&block)
+    end
+  end
+
+  # Maybe we should make the #on action idempotent on the sense that it will merge
+  # the actions (the blocks) if it is called with the same arguments more than once.
+  describe "#on" do
+    it "should not change the root context" do
+      expect { subject.on("div", { class: /foo/ }) }.to_not change { subject.root }
+    end
+
+    it "creates an action and registers it on the root context" do
+      expect { subject.on("div", { class: /foo/ }) }.to change { subject.root.actions.size }.by(1)
+    end
+
+    it "creates a rule for the action with the specified arguments" do
+      subject.on("div", { class: /foo/ })
+      subject.root.actions[0].activation_rule.element.should == "div"
+      subject.root.actions[0].activation_rule.attributes.should == { "class" => /foo/ }
+    end
+  end
+
+  describe "#under" do
+    it "should add a child context to the root" do
+      expect { subject.under("div", { class: /foo/ }) }.to change { subject.root.child_contexts.length }.by(1)
+    end
+
+    it "should create a tree of contexts if it has nested #under calls" do
+      subject.under("div") do
+        under("span") { under("ul") }
+        under("div", class: "bar") { under("ul") { under("li", class: /foo/); under("span") } }
+      end
+      subject.root.should have(1).child_contexts
+      subject.root.child_contexts[0].should have(2).child_contexts
+      subject.root.child_contexts[0].child_contexts[0].should have(1).child_contexts
+      subject.root.child_contexts[0].child_contexts[0].child_contexts[0].should have(0).child_contexts
+      subject.root.child_contexts[0].child_contexts[1].should have(1).child_contexts
+      subject.root.child_contexts[0].child_contexts[1].child_contexts[0].should have(2).child_contexts
+    end
+
+    it "should build an activation rule for the child context from arguments" do
+      args = ["div", { class: /foo/ }]
+      subject.under(*args)
+      ctx = subject.root.child_contexts[0]
+      ctx.activation_rule.element.should == "div"
+      ctx.activation_rule.attributes.should == { "class" => /foo/ }
+    end
+  end
+
+end

data/spec/saxxy/event_registry_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+require "saxxy/node_rule"
+require "saxxy/node_action"
+require "saxxy/event_registry"
+
+
+describe Saxxy::EventRegistry do
+
+  def actions(reg = subject)
+    reg.instance_variable_get("@actions")
+  end
+
+
+  describe "#initialize" do
+    it "sets the actions to an empty hash" do
+      actions(Saxxy::EventRegistry.new).should == {}
+    end
+  end
+
+
+  describe "#register_event_from_action" do
+    let(:rule) { Saxxy::NodeRule.new("div", { title: "foo" }) }
+    let(:action) { Saxxy::NodeAction.new(rule) }
+
+    it "should create the action entry with events as the value if it does not exist yet" do
+      actions().should == {}
+      event = subject.register_event_from_action(action)
+      actions().should == { action => [event] }
+    end
+
+    it "should append the event to the action entry" do
+      ev1 = subject.register_event_from_action(action)
+      ev2 = subject.register_event_from_action(action)
+      actions()[action].should == [ev1, ev2]
+    end
+  end
+
+
+  describe "#events" do
+    let(:rule1) { Saxxy::NodeRule.new("div", { class: /foo/ }) }
+    let(:rule2) { Saxxy::NodeRule.new("div", { title: "foo" }) }
+    let(:action1) { Saxxy::NodeAction.new(rule1) }
+    let(:action2) { Saxxy::NodeAction.new(rule2) }
+
+    it "should return an array consisting of the last event of each action" do
+      5.times { subject.register_event_from_action(action1) }
+      last_ev1 = subject.register_event_from_action(action1)
+      5.times { subject.register_event_from_action(action2) }
+      last_ev2 = subject.register_event_from_action(action2)
+      subject.events.should == [last_ev1, last_ev2]
+    end
+  end
+
+
+  describe "#push_text" do
+    let(:rule1) { Saxxy::NodeRule.new("div", { class: /foo/ }) }
+    let(:rule2) { Saxxy::NodeRule.new("div", { title: "foo" }) }
+    let(:action1) { Saxxy::NodeAction.new(rule1) }
+    let(:action2) { Saxxy::NodeAction.new(rule2) }
+
+    it "should add the text to the events (last events)" do
+      5.times { subject.register_event_from_action(action1) }
+      last_ev1 = subject.register_event_from_action(action1)
+      5.times { subject.register_event_from_action(action2) }
+      last_ev2 = subject.register_event_from_action(action2)
+      expect { subject.push_text("foo") }.to change {
+        [last_ev1, last_ev2].map(&:text)
+      }.from(["", ""]).to(["foo", "foo"])
+    end
+  end
+
+
+  describe "#deactivate_events_on" do
+    let(:rule1) { Saxxy::NodeRule.new("div", { class: /foo/ }) }
+    let(:rule2) { Saxxy::NodeRule.new("span", { title: "foo" }) }
+
+    it "should call deactivate_events_on on every event with the element name as argument" do
+      last_ev1 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1))
+      last_ev2 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      last_ev1.should_receive(:deactivate_on).with("div")
+      last_ev2.should_receive(:deactivate_on).with("div")
+      subject.deactivate_events_on("div")
+    end
+
+    it "should not remove inactive events" do
+      last_ev1 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1))
+      last_ev2 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      expect { subject.deactivate_events_on("div") }.to_not change { actions()[a1] }
+      expect { subject.deactivate_events_on("div") }.to_not change { actions()[a2] }
+    end
+
+    it "should remove active events that match the element name" do
+      last_ev11 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1)).tap do |e|
+        e.activate_on("div", "class" => "foo")
+      end
+      last_ev12 = subject.register_event_from_action(a1).tap { |e| e.activate_on("div", "class" => "foo") }
+      last_ev21 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      expect {
+        subject.deactivate_events_on("div")
+      }.to change { actions()[a1] }.from([last_ev11, last_ev12]).to([last_ev11])
+    end
+
+    it "should delete the action if the last event gets removed" do
+      last_ev1 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1)).tap do |e|
+        e.activate_on("div", "class" => "foo")
+      end
+      last_ev2 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      expect {
+        subject.deactivate_events_on("div")
+      }.to change { actions()[a1] }.from([last_ev1]).to(nil)
+    end
+
+    it "should not remove already activated events that don't match the element name" do
+      last_ev1 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1)).tap do |e|
+        e.activate_on("div", "class" => "foo")
+      end
+      last_ev2 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      expect { subject.deactivate_events_on("span") }.to_not change { actions()[a1] }
+      expect { subject.deactivate_events_on("span") }.to_not change { actions()[a2] }
+    end
+
+    it "should append the text of the removed event to the next one in the queue" do
+      last_ev11 = subject.register_event_from_action(a1 = Saxxy::NodeAction.new(rule1)).tap do |e|
+        e.append_text("foo")
+        e.activate_on("div", "class" => "foo")
+      end
+      last_ev12 = subject.register_event_from_action(a1).tap do |e|
+        e.append_text(" bar")
+        e.activate_on("div", "class" => "foo")
+      end
+      last_ev21 = subject.register_event_from_action(a2 = Saxxy::NodeAction.new(rule2))
+      expect {
+        subject.deactivate_events_on("div")
+      }.to change { last_ev11.text }.from("foo").to("foo bar")
+    end
+  end
+end

data/spec/saxxy/event_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "saxxy/node_action"
+require "saxxy/node_rule"
+require "saxxy/event"
+
+
+describe Saxxy::Event do
+
+  def event(action = Saxxy::NodeAction.new(Saxxy::NodeRule.new("div")))
+    Saxxy::Event.new(action)
+  end
+
+  it "should include activatable" do
+    Saxxy::Event.ancestors.should include(Saxxy::Activatable)
+  end
+
+  describe "#initialize" do
+    it "should set the action to the argument" do
+      action = Saxxy::NodeAction.new(Saxxy::NodeRule.new("div"))
+      event(action).action.should == action
+    end
+
+    it "should call initialize_activatable with the activation rule that action has" do
+      rule = Saxxy::NodeRule.new("div")
+      Saxxy::Event.any_instance.should_receive(:initialize_activatable).with(rule)
+      event(Saxxy::NodeAction.new(rule))
+    end
+
+    it "should set the text instance variable to an empty string" do
+      event().text.should == ""
+    end
+  end
+
+  describe "#append_text" do
+    it "appends the text provided as an argument to the @text instance variable" do
+      e = event()
+      expect { e.append_text("foo") }.to change { e.text }.from("").to("foo")
+    end
+  end
+
+  describe "#fire" do
+    it "should delegate the call to the action with the text as the argument" do
+      e = event()
+      e.action.should_receive(:call).with(e.text, nil, {})
+      e.fire
+    end
+  end
+
+end

data/spec/saxxy/node_action_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "saxxy/node_rule"
+require "saxxy/node_action"
+
+
+describe Saxxy::NodeAction do
+  let(:rule) { Saxxy::NodeRule.new("div") }
+
+  describe "#initialize" do
+    it "initializes with an activation rule and with a block" do
+      block = ->() { "this is a test block" }
+      action = Saxxy::NodeAction.new(rule, &block)
+      action.action.should == block
+      action.activation_rule.should == rule
+    end
+
+    it "initializes with the id block if none is given" do
+      Saxxy::NodeAction.new(rule).action.call("foo").should == "foo"
+    end
+  end
+
+  describe "#matches" do
+    it "should delegate the call to activation_rule" do
+      action = Saxxy::NodeAction.new(rule)
+      args = ["div", { class: /foo/ }]
+      action.activation_rule.should_receive(:matches).with(*args)
+      action.matches(*args)
+    end
+  end
+
+  describe "#call" do
+    it "should delegate the call to an instance exec on the binding i.e. context if a context is given" do
+      a_context = Object.new
+      action = Saxxy::NodeAction.new(rule, a_context)
+      a_context.should_receive(:instance_exec).with(["foo"], &action.action)
+      action.call("foo")
+    end
+
+    it "should delegate the call to an instance exec on itself if no context is given" do
+      action = Saxxy::NodeAction.new(rule)
+      action.should_receive(:instance_exec).with(["foo"], &action.action)
+      action.call("foo")
+    end
+  end
+
+end

data/spec/saxxy/node_rule_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+require "saxxy/node_rule"
+
+
+describe Saxxy::NodeRule do
+
+  describe "#matches" do
+    it "should return false if @element does not match first argument as string" do
+      nr = Saxxy::NodeRule.new("div")
+      nr.element.should eql("div")
+      nr.matches("span").should be_false
+    end
+
+    it "should return false if @element does not match first argument as regexp" do
+      nr = Saxxy::NodeRule.new(/div/)
+      nr.element.should be_a(Regexp)
+      nr.matches("span").should be_false
+    end
+
+    it "should return true if @element matches first argument as string and empty @attributes" do
+      nr = Saxxy::NodeRule.new("div")
+      nr.attributes.should be_empty
+      nr.matches("div").should be_true
+    end
+
+    it "should return true if @element matches first argument as regexp and empty @attributes" do
+      nr = Saxxy::NodeRule.new(/^d[iv]+?/)
+      nr.attributes.should be_empty
+      nr.matches("div").should be_true
+    end
+
+    it "should return false if @element matches first argument as string
+        and non-empty @attributes with keys not in second argument's keys" do
+      nr = Saxxy::NodeRule.new("div", { class: /fooo?/ })
+      nr.attributes.should_not be_empty
+      nr.matches("div", { foo: "bar" }).should be_false
+    end
+
+    it "should return false if @element matches first argument as regexp
+        and non-empty @attributes with keys not in second argument's keys" do
+      nr = Saxxy::NodeRule.new(/div/, { class: /fooo?/ })
+      nr.attributes.should_not be_empty
+      nr.matches("div", { foo: "bar" }).should be_false
+    end
+
+
+    it "should return true if @element matches first argument as string
+        and non-empty @attributes with keys in second argument's keys and
+        at the same time same values should match" do
+      nr = Saxxy::NodeRule.new("div", { class: /fooo?/ })
+      nr.attributes.should_not be_empty
+      nr.matches("div", { foo: "bar", class: "foo" }).should be_true
+    end
+
+    it "should return true if @element matches first argument as regexp
+        and non-empty @attributes with keys in second argument's keys and
+        at the same time same values should match" do
+      nr = Saxxy::NodeRule.new(/div/, { class: "foo" })
+      nr.attributes.should_not be_empty
+      nr.matches("div", { foo: "bar", class: "foo" }).should be_true
+    end
+  end
+
+
+  describe "#match_attributes" do
+    it "should return true on any attrs hash if the attributes are empty" do
+      nr = Saxxy::NodeRule.new(/div/)
+      nr.match_attributes({class: "some class", title: "bar"}).should be_true
+    end
+
+    it "should return true if an attribute exists and is nil
+        and the matching does not contain this attribute" do
+      nr = Saxxy::NodeRule.new(/div/, class: nil)
+      nr.match_attributes({}).should be_true
+    end
+
+    it "should return true if an attribute exists and is nil
+        and the matching does contain this attribute and is nil" do
+      nr = Saxxy::NodeRule.new(/div/, class: nil)
+      nr.match_attributes({ class: nil }).should be_true
+    end
+
+    it "should return false if an attribute exists and is nil
+        and the matching does contain this attribute and is not nil" do
+      nr = Saxxy::NodeRule.new(/div/, class: nil)
+      nr.match_attributes({ class: "foo" }).should be_false
+    end
+
+    it "should return true if it has a subset of the matching attributes" do
+      nr = Saxxy::NodeRule.new(/div/, title: "foo", class: "bar")
+      nr.match_attributes({ title: "foo", class: "bar", rel: "baz" }).should be_true
+    end
+
+    it "should return false if it has a superset of the matching attributes" do
+      nr = Saxxy::NodeRule.new(/div/, title: "foo", class: "bar", rel: "baz")
+      nr.match_attributes({ title: "foo", class: "bar" }).should be_false
+    end
+  end
+end