RubyGems - rusty - Versions diffs - 0.1 - Mend

rusty 0.1

Files changed (28) hide show

data/.gitignore +2 -0
data/Gemfile +9 -0
data/Gemfile.lock +44 -0
data/LICENSE.BSD +26 -0
data/README.md +200 -0
data/Rakefile +13 -0
data/bin/watchr +27 -0
data/lib/rusty.rb +16 -0
data/lib/rusty/callback_binding.rb +71 -0
data/lib/rusty/dx.rb +127 -0
data/lib/rusty/helpers.rb +40 -0
data/lib/rusty/nokogiri_ext.rb +101 -0
data/lib/rusty/rule_set.rb +124 -0
data/lib/rusty/scope.rb +29 -0
data/lib/rusty/selector.rb +87 -0
data/lib/rusty/version.rb +8 -0
data/rusty.gemspec +24 -0
data/tasks/rdoc.rake +18 -0
data/tasks/test.rake +8 -0
data/test/helper.rb +17 -0
data/test/test_dx.rb +62 -0
data/test/test_helper.rb +39 -0
data/test/test_nokogiri_ext.rb +73 -0
data/test/test_rss_example.rb +58 -0
data/test/test_rule_set.rb +65 -0
data/test/test_scope.rb +97 -0
data/test/test_selector.rb +48 -0
metadata +103 -0

data/test/helper.rb ADDED

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+require 'ruby-debug'
+require 'simplecov'
+require 'test/unit'
+SimpleCov.start do
+  add_filter "test/helper.rb"
+end
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rusty'
+class Test::Unit::TestCase
+end

data/test/test_dx.rb ADDED

@@ -0,0 +1,62 @@
+require_relative './helper'
+class TestDx < Test::Unit::TestCase
+  def dx
+    @dx ||= Rusty::DX.new
+  end
+  def test_as_nil
+    assert_false dx.list?
+    assert_false dx.dict?
+    assert_equal(nil, dx.to_ruby)
+  end
+  def test_inspect
+    assert_equal("<nil>", dx.inspect)
+    dx << 1
+    assert_equal("<[1]>", dx.inspect)
+  end
+  def test_as_list
+    dx[3] # turn dx into a list, but still with no content
+    assert_true dx.list?
+    assert_false dx.dict?
+    assert_raise(ArgumentError) {
+      dx.foo = "bar"
+    }
+    assert_equal([], dx.to_ruby)
+  end
+  def test_create_list_by_pushing
+    dx << 1
+    assert_equal([1], dx.to_ruby)
+  end
+  def test_create_dict_by_key
+    dx.key?(:a)
+    assert_equal({}, dx.to_ruby)
+  end
+  def test_as_dict
+    dx.abc
+    dx.abc
+    assert_true dx.dict?
+    assert_false dx.list?
+    dx[2] = "bar"
+    assert_true dx.dict?
+    assert_false dx.list?
+    assert_equal({"abc"=>nil, 2=>"bar"}, dx.to_ruby)
+  end
+  def test_undefined_method
+    assert_raise(NoMethodError) {
+      dx.abc(1,2,3)
+    }
+  end
+end

data/test/test_helper.rb ADDED

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+require_relative './helper'
+class TestSelector < Test::Unit::TestCase
+  module RuleSet
+    extend Rusty::RuleSet
+    helper do
+      def a_helper_method
+      end
+    end
+    helper Rusty::Helpers::Text
+  end
+  def test_helpers
+    assert_equal 2, RuleSet.helpers.length
+  end
+  def test_callback_binding_klass_includes_helpers
+    callback_binding_klass = RuleSet.send(:callback_binding_klass)
+    assert callback_binding_klass.public_instance_methods.include?(:a_helper_method)
+    assert callback_binding_klass.public_instance_methods.include?(:text) # from Rusty::Helpers::Text
+  end
+  def test_text
+    helper = {}.extend(Rusty::Helpers::Text)
+    data = File.read(__FILE__).split(/__END__\n/).last
+    document = Nokogiri.XML(data)
+    assert_equal "1hr 40min - Rated Ohne Altersbeschränkung", helper.text(document.css("top span").first)
+  end
+end
+__END__
+<top>
+  <span>&#8206;1hr 40min&#8206;&#8206; - Rated Ohne Altersbeschränkung&#8206;</span>
+</top>

data/test/test_nokogiri_ext.rb ADDED

@@ -0,0 +1,73 @@
+require_relative './helper'
+class TestNokogiriExt < Test::Unit::TestCase
+  def data
+    @data ||= File.read(__FILE__).split(/__END__\n/).last
+  end
+  def document
+    @document ||= begin
+      Nokogiri.HTML(data)
+    end
+  end
+  def node(selector)
+    document.css(selector).first
+  end
+  def test_classes
+    body = node("body")
+    assert_equal %w(a b d), body.classes
+    assert_true body.has_class?("a")
+    assert_true body.has_class?("b")
+    assert_false body.has_class?("c")
+  end
+  def test_attributes_hash
+    assert_equal({"id" => "anchor", "foo" => "bar"}, node("a").attributes_hash)
+    assert_equal({}, node("div").attributes_hash)
+  end
+  def test_parents
+    assert_equal ["html", "body", "div", "p", "a"], node("a").self_and_parents.map(&:name)
+    assert_equal ["html", "body", "div", "p"], node("a").parents.map(&:name)
+    assert_equal ["html"], node("html").self_and_parents.map(&:name)
+    assert_equal [], node("html").parents.map(&:name)
+  end
+  def test_simplified_name
+    assert_equal "body.a.b.d", node("body").simplified_name
+    assert_equal "a#anchor", node("a").simplified_name
+  end
+  def test_meta_encoding
+    html4 = "<html><head><meta http-equiv='content-type' content='text/html; charset=UTF-8'></head></html>"
+    html5 = "<html><head><meta charset='UTF-8'></head></html>"
+    assert_equal "UTF-8", Nokogiri.HTML(html4).meta_encoding
+    assert_equal "UTF-8", Nokogiri.HTML(html5).meta_encoding
+  end
+  def test_with_meta_encoding
+    doc = Nokogiri::HTML.with_meta_encoding data
+    assert_equal("iso-8859-1", doc.meta_encoding)
+    assert_equal("iso-8859-1", doc.encoding)
+  end
+end
+__END__
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
+  </head>
+  <body class="a b d">
+    <div>
+      <p>
+      </p>
+      <p>
+        <a id="anchor" foo="bar"></a>
+      </p>
+    </div>
+  </body>
+</html>

data/test/test_rss_example.rb ADDED

@@ -0,0 +1,58 @@
+require_relative './helper'
+class TestRssExample < Test::Unit::TestCase
+  module SimleRSS
+    extend Rusty::RuleSet
+    helper Rusty::Helpers::Text
+    on "*"                  do end
+    on "rss channel *"      do rss[node.name] = text(node) end
+    on "rss channel item"   do rss.items << item end
+    on "rss channel item *" do item[node.name] = text(node) end
+  end
+  def test_rss
+    raw = File.read(__FILE__).split(/__END__\n/).last
+    data = SimleRSS.transform! Nokogiri.XML(raw)
+    expected = {
+      "rss"=> {
+        "title"=>"The Title",
+        "link"=>"http://the.link",
+        "description"=>"The description",
+        "language"=>"de-de",
+        "pubDate"=>"1363099965",
+        "items"=>[
+          {"title"=>"Item 1", "description"=>"description 1", "link"=>"http://the.first.link"},
+          {"title"=>"Item 2", "description"=>"description 2", "link"=>"http://the.second.link"}
+        ]
+      }
+    }
+    assert_equal(expected, data.to_ruby)
+  end
+end
+__END__
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<rss version="2.0">
+<channel>
+<title>The Title</title>
+<link>http://the.link</link>
+<description>The description</description>
+<language>de-de</language>
+<pubDate>1363099965</pubDate>
+    <item>
+    <title>Item 1</title>
+    <description>   description 1    </description>
+    <link>http://the.first.link</link>
+    </item>
+    <item>
+    <title>Item 2</title>
+    <description>   description 2    </description>
+    <link>http://the.second.link</link>
+    </item>
+</channel>
+</rss>

data/test/test_rule_set.rb ADDED

@@ -0,0 +1,65 @@
+require_relative './helper'
+class TestRuleSet < Test::Unit::TestCase
+  module RuleSet
+    extend Rusty::RuleSet
+    def self.rules_for_mode(mode); super; end
+    helper do
+      def a_helper_method
+      end
+    end
+    on "foo", "bar" do end
+    after "foo", "baz" do end
+    after "html, js, erlang" do end
+    on "p a" do end
+    on "a" do end
+    on ".a" do end
+  end
+  def test_registration
+    assert_equal ["foo", "bar", "p a", "a", ".a"], RuleSet.rules_for_mode(:on).keys
+    assert_equal %w(foo baz html js erlang), RuleSet.rules_for_mode(:after).keys
+  end
+  def test_best_rule
+    assert_equal "p a", RuleSet.best_rule(:on, node("a")).selector.name
+    assert_equal ".a",  RuleSet.best_rule(:on, node("body")).selector.name
+  end
+  private
+  def data
+    @data ||= File.read(__FILE__).split(/__END__\n/).last
+  end
+  def document
+    @document ||= begin
+      Nokogiri.HTML(data)
+    end
+  end
+  def node(selector)
+    document.css(selector).first
+  end
+end
+__END__
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
+  </head>
+  <body class="a b d">
+    <div>
+      <p>
+      </p>
+      <p>
+        <a id="anchor" foo="bar"></a>
+      </p>
+    </div>
+  </body>
+</html>

data/test/test_scope.rb ADDED

@@ -0,0 +1,97 @@
+require_relative './helper'
+class TestScope < Test::Unit::TestCase
+  def test_scope_names
+    named = Rusty::Scope.new node("named")
+    assert named.has_name?("named")
+    assert named.has_name?("x")
+    assert !named.has_name?("a")
+    top = Rusty::Scope.new node("top")
+    assert top.has_name?("top")
+    assert top.has_name?("document")
+  end
+  def test_one_step_delegation
+    top = Rusty::Scope.new node("top")
+    mid = Rusty::Scope.new node("mid"), top
+    bot = Rusty::Scope.new node("bot"), mid
+    e_top = Rusty::CallbackBinding.new(top)
+    e_mid = Rusty::CallbackBinding.new(mid)
+    e_bot = Rusty::CallbackBinding.new(bot)
+    object_ids = []
+    # one step delegation
+    #
+    # When evaluated in the context of e_mid, top must refer to
+    # the top Rusty::Scope
+    e_mid.instance_eval do
+      object_ids = [top.object_id]
+    end
+    assert_equal(object_ids, [top.object_id])
+  end
+  def test_two_step_delegation
+    top = Rusty::Scope.new node("top")
+    mid = Rusty::Scope.new node("mid"), top
+    bot = Rusty::Scope.new node("bot"), mid
+    e_top = Rusty::CallbackBinding.new(top)
+    e_mid = Rusty::CallbackBinding.new(mid)
+    e_bot = Rusty::CallbackBinding.new(bot)
+    # When evaluated in the context of e_bot,
+    # top must refer to the top Rusty::Scope
+    # mid must refer to the mid Rusty::Scope
+    # and mid.top must not refer to the top Rusty::Scope,
+    # but to a DX which belongs to mid.
+    object_ids = []
+    dx = nil
+    e_bot.instance_eval do
+      object_ids = [top.object_id, mid.object_id]
+      dx = mid.top
+    end
+    assert_equal(object_ids, [top.object_id, mid.object_id])
+    assert_kind_of(Rusty::DX, dx)
+  end
+  def test_setting_attributes
+    top = Rusty::Scope.new node("top")
+    mid = Rusty::Scope.new node("mid"), top
+    bot = Rusty::Scope.new node("bot"), mid
+    e_bot = Rusty::CallbackBinding.new(bot)
+    e_bot.instance_eval do
+      top.name = "top"
+      mid.name = "mid"
+      mid.top.name = "mid.top"
+      bot.name = "bot"
+    end
+    assert_equal({"name" => "top"}, top.to_ruby)
+    assert_equal({"name" => "mid", "top" => {"name" => "mid.top"}}, mid.to_ruby)
+    assert_equal({"name" => "bot"}, bot.to_ruby)
+  end
+  def document
+    @document ||= begin
+      data = File.read(__FILE__).split(/__END__\n/).last
+      Nokogiri.XML(data)
+    end
+  end
+  def node(name)
+    document.css(name).first
+  end
+end
+__END__
+<top>
+  <mid>
+    <bot>
+    </bot>
+  </mid>
+  <named class="x y z"></named>
+</top>

data/test/test_selector.rb ADDED

@@ -0,0 +1,48 @@
+require_relative './helper'
+class TestSelector < Test::Unit::TestCase
+  DATA = File.read(__FILE__).split(/__END__\n/).last
+  def __test_selectors(klass)
+    document = Nokogiri.XML(DATA)
+    # test matching selectors
+    assert klass.new("foo").match?(document.css("foo").first)
+    assert klass.new("fi fa foo").match?(document.css("foo").first)
+    assert klass.new("fi bar").match?(document.css("bar").first)
+    assert klass.new("fi bar").match?(document.css("bar").last)
+    # test non-matching selectors
+    assert_false klass.new("foox").match?(document.css("foo").first)
+    assert_false klass.new("fix fa foo").match?(document.css("foo").first)
+    assert_false klass.new("fix fa foo").match?(nil)
+    # test "*" special case
+    assert klass.new("*").match?(document.css("bar").last)
+    assert_false klass.new("*").match?(nil)
+  end
+  def test_css
+    __test_selectors Rusty::Selector::CSS
+  end
+  def test_cached_ss
+    __test_selectors Rusty::Selector::CachedCSS
+  end
+  def test_weight
+    assert Rusty::Selector::CSS.new("*").weight     < Rusty::Selector::CSS.new("a").weight
+    assert Rusty::Selector::CSS.new("a b c").weight < Rusty::Selector::CSS.new("a b c d").weight
+    assert Rusty::Selector::CSS.new("a b c").weight < Rusty::Selector::CSS.new("#a").weight
+  end
+end
+__END__
+<fi>
+  <fa>
+    <foo>
+      <bar>baz</bar>
+      <bar>baz</bar>
+    </foo>
+  </fa>
+</fi>