hexp 0.0.1.pre → 0.0.1.pre2

data/.gitignore

@@ -16,3 +16,6 @@ tmp
 .yardoc
 _yardoc
 doc/
+
+#yardstick report
+measurements/report.txt

data/.travis.yml

@@ -3,7 +3,6 @@ before_install: gem install bundler
 bundler_args: --without yard guard benchmarks
 script: "bundle exec rake ci:metrics"
 rvm:
-  - ree
   - 1.9.2
   - 1.9.3
   - 2.0.0

data/Gemfile

@@ -1,7 +1,11 @@
 source 'https://rubygems.org'
 
+gem 'nokogiri'
+gem 'equalizer',             github: 'dkubb/equalizer'
+
 group :development do
   gem 'devtools', :git => 'https://github.com/datamapper/devtools.git'
-  gem 'json', '~> 1.7.7'
+  gem 'json', '~> 1.8.0'
   eval File.read('Gemfile.devtools')
 end
+

data/Gemfile.lock

@@ -1,3 +1,11 @@
+GIT
+  remote: git://github.com/dkubb/equalizer.git
+  revision: 7b0a30dee57ed0378df6b32e5defda64adaff0da
+  specs:
+    equalizer (0.0.5)
+      adamantium (~> 0.0.7)
+      backports (~> 3.2, >= 3.2.0)
+
 GIT
   remote: https://github.com/datamapper/devtools.git
   revision: f0e3a3a42673266c46b983bc79a4ab6e1623bccc
@@ -7,7 +15,7 @@ GIT
 
 GIT
   remote: https://github.com/troessner/reek.git
-  revision: 79e1b9bb5400d5aba172cbab5e65531daab24b3e
+  revision: f302390f533dd6b59f837821d63249d0c729f931
   specs:
     reek (1.3.1)
       ruby2ruby (~> 2.0.2)
@@ -33,9 +41,6 @@ GEM
       thor
     descendants_tracker (0.0.1)
     diff-lcs (1.2.4)
-    equalizer (0.0.5)
-      adamantium (~> 0.0.6)
-      backports (~> 3.0, >= 3.0.3)
     ffi (1.8.1)
     ffi-hunspell (0.3.0)
       ffi (~> 1.0)
@@ -60,7 +65,7 @@ GEM
       rspec (~> 2.11)
     ice_nine (0.7.0)
     inflecto (0.0.2)
-    json (1.7.7)
+    json (1.8.0)
     kramdown (1.0.2)
     libnotify (0.8.0)
       ffi (>= 1.0.11)
@@ -71,7 +76,7 @@ GEM
     lumberjack (1.0.3)
     method_source (0.8.1)
     mime-types (1.23)
-    multi_json (1.7.3)
+    multi_json (1.7.4)
     mutant (0.2.20)
       abstract_type (~> 0.0.3)
       adamantium (~> 0.0.7)
@@ -84,6 +89,7 @@ GEM
       rspec (~> 2.13.0)
       to_source (~> 0.2.19)
     mutant-melbourne (2.0.3)
+    nokogiri (1.5.9)
     pelusa (0.2.2)
     pry (0.9.12.2)
       coderay (~> 1.0.5)
@@ -142,17 +148,19 @@ DEPENDENCIES
   backports (~> 3.3, >= 3.3.0)
   coveralls (~> 0.6.6)
   devtools!
+  equalizer!
   flay (~> 2.2.0)
   flog (~> 4.0.0)
   guard (~> 1.8.0)
   guard-bundler (~> 1.0.0)
   guard-rspec (~> 2.5.4)
   jruby-openssl (~> 0.8.5)
-  json (~> 1.7.7)
+  json (~> 1.8.0)
   kramdown (~> 1.0.1)
   libnotify (~> 0.8.0)
   listen (~> 1.0.2)
   mutant (~> 0.2.20)
+  nokogiri
   pelusa (~> 0.2.2)
   rake (~> 10.0.4)
   rb-fchange (~> 0.0.6)

data/README.md

@@ -1,16 +1,115 @@
-hexp
-====
-
 [![Gem Version](https://badge.fury.io/rb/hexp.png)][gem]
 [![Build Status](https://secure.travis-ci.org/plexus/hexp.png?branch=master)][travis]
 [![Dependency Status](https://gemnasium.com/plexus/hexp.png)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/plexus/hexp.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/plexus/hexp/badge.png?branch=master)][coveralls]
 
-[gem]: https://rubygems.org/gems/dm-mapper
+[gem]: https://rubygems.org/gems/hexp
 [travis]: https://travis-ci.org/plexus/hexp
 [gemnasium]: https://gemnasium.com/plexus/hexp
 [codeclimate]: https://codeclimate.com/github/plexus/hexp
 [coveralls]: https://coveralls.io/r/plexus/hexp
 
-HTML expressions
+A bit about hexps
+-----------------
+
+**What on earth is a Hexp?**
+
+Hexps are basically snippets of HTML written in nothing but Ruby, here's an example.
+
+````ruby
+@message = "Hexps are fun for the whole family, from 9 to 99 years old."
+@hexp = H[:div, {class: 'hexp-intro'}, [
+    [:p, @message]
+  ]
+]
+````
+
+**Don't people use templates for this kind of thing?**
+
+They do, this is an alternative approach. With templates you need to think about which parts need to be HTML-escaped, or you can make errors like forgetting a closing tag. With hexps you no longer need to think about escaping.
+
+**Wait how is that?**
+
+With traditional approaches you can insert plain text in your template, or snippets of HTML. The first must be escaped, the second should not. For your template they are all just strings, so you, the programmer, need to distinguish between the two in a way. For example by using `html_escape` on one (explicit escaping), or `html_safe` on the other (implicit escaping).
+
+When using hexps you never deal with strings that actually contain HTML. Helper methods would return hexps instead, and you can combine those into bigger hexps. Strings inside a hexp are always just that, so they will always be escaped without you thinking about it.
+
+**So that's it, easier escaping?**
+
+Well that's not all, by having a simple lightweight representation of HTML that is _a real data structure_, you can really start programming your HTML. If you have an object that responds to `to_hexp`, you can use that object inside a hexp, so you can use Object Orientation for your user interface. Like so
+
+````ruby
+class ProfileLink < Struct.new(:user)
+  def to_hexp
+    H[:a, {class: "profile-link", href: "/user/#{user.id}"}, user.name]
+  end
+end
+
+class Layout < Struct.new(:content)
+  def to_hexp
+    H[:html, [
+      [:body, [content]]
+    ]
+  end
+end
+
+render inline: Layout.new(ProfileLink.new(@user)).to_html
+````
+
+**Does it get any better?**
+
+It does! The really neat part is having filters that process this HTML tree before it gets serialized to text. This could be good for
+
+- populating form fields
+- adding extra admin buttons when logged in
+- cleanly separate aspects of your app (e.g. discount codes) from 'core' implementation
+- becoming filthy rich and/or ridiculously happy
+
+**What's up with the funny name?**
+
+Hexp stands for HTML expressions. It's a reference to s-expressions as they are known in LISP languages, a simple way to represent data as nested lists.
+
+How to use it
+-------------
+
+Hexp objects come in two flavors : `Hexp::Node` and `Hexp::List`. A `Node` consists of three parts : its `tag`, `attributes` and `children`. A `List` is just that, a list (of nodes).
+
+To construct a `Node` use `H[tag, attributes, children]`. Use a `Symbol` for the `tag`, a `Hash` for the `attributes`, and an `Array` for the `children`. Attributes or children can be omitted when they are empty.
+
+The list of children will automatically be converted to `Hexp::List`, similarly for any nested nodes you can simply use `[tag, attributes, children]` without the `H`, all nodes in the tree will be converted to proper `Hexp::Node` objects.
+
+The entire API is centered around these two classes, and one of them you can think of as essentially just an `Array`, in other words Hexp is super easy to learn. Try it out in `irb`, have a look at the examples, and *build cool stuff*!
+
+A note on immutability
+----------------------
+
+All Hexp objects are deep frozen on creation, you can never alter them afterwards. Operations always return a new `Hexp::Node` rather than working in place.
+
+This might seem stringent when you are not used to this style of coding, but it's a pattern that generally promotes good code.
+
+Can I already use it
+--------------------
+
+Hold your horses, this is *very* alpha level code! Feedback is very much appreciated, so try it out, and let me know what you think. Basic functionality is there, but it's far from finished, and the API will probably still change based on feedback. You have been warned.
+
+Is it any good?
+---------------
+
+Yes
+
+How to install
+--------------
+
+At this point you're best off grabbing the Git repo, e.g. with bundler
+
+````sh
+# Gemfile
+
+gem 'hexp', github: 'plexus/hexp'
+````
+
+Who is behind this
+------------------
+
+Hexp is conceived and created by [Arne Brasseur](http://arnebrasseur.net)

data/config/devtools.yml

@@ -0,0 +1,2 @@
+---
+unit_test_timeout: 0.1

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
-threshold: 10
-total_score: 74
+threshold: 7
+total_score: 75.0

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 11.7
+threshold: 17.4

data/config/mutant.yml

@@ -1,2 +1,3 @@
-name: hexp
-namespace: Hexp
+---
+name: your_lib
+namespace: YourLib

data/config/reek.yml

@@ -1,6 +1,6 @@
 ---
 Attribute:
-  enabled: true
+  enabled: false
   exclude: []
 BooleanParameter:
   enabled: true
@@ -14,33 +14,41 @@ ControlParameter:
 DataClump:
   enabled: true
   exclude: []
-  max_copies: 0
-  min_clump_size: 1
+  max_copies: 2
+  min_clump_size: 2
 DuplicateMethodCall:
   enabled: true
   exclude: []
-  max_calls: 1
+  max_calls: 2
   allow_calls: []
 FeatureEnvy:
   enabled: true
-  exclude: []
+  exclude:
+    - Hexp::Node::Domize#set_attributes
+    - Hexp::Node::Normalize#children
+    - Hexp::Node::Normalize#normalized_children
+    - Hexp::Node::PP#pp_attributes
+    - Hexp::Node::PP#pp_children
 IrresponsibleModule:
   enabled: true
   exclude: []
 LongParameterList:
   enabled: true
   exclude: []
-  max_params: 1
-  overrides: {}
+  max_params: 2
+  overrides:
+    initialize:
+      max_params: 3
 LongYieldList:
   enabled: true
   exclude: []
-  max_params: 0
+  max_params: 2
 NestedIterators:
   enabled: true
   exclude: []
   max_allowed_nesting: 1
-  ignore_iterators: []
+  ignore_iterators:
+    - any?
 NilCheck:
   enabled: true
   exclude: []
@@ -51,15 +59,16 @@ RepeatedConditional:
 TooManyInstanceVariables:
   enabled: true
   exclude: []
-  max_instance_variables: 12
+  max_instance_variables: 3
 TooManyMethods:
   enabled: true
   exclude: []
-  max_methods: 15
+  max_methods: 10
 TooManyStatements:
   enabled: true
-  exclude: []
-  max_statements: 5
+  exclude:
+  - each
+  max_statements: 4
 UncommunicativeMethodName:
   enabled: true
   exclude: []
@@ -96,5 +105,8 @@ UnusedParameters:
   exclude: []
 UtilityFunction:
   enabled: true
-  exclude: []
+  exclude:
+    - Hexp::List#initialize
+    - Hexp::Node::Domize#set_attributes
+    - Hexp::TextNode#attributes
   max_helper_calls: 0

data/config/yardstick.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 100
+threshold: 81

data/examples/filter.rb

@@ -0,0 +1,54 @@
+$:.unshift('/home/arne/github/hexp/lib')
+require 'hexp/h'
+
+class X
+  def to_hexp
+    [:p, {class: 'foo'}, [
+        [:br],
+        'awesome',
+        [:br]]]
+  end
+end
+
+hexp =  H[:p, [
+             [:div, {id: 'main'}, [
+                   X.new,
+                   X.new]],
+             [:hr]]]
+
+
+hexp = hexp.filter do |node|
+  if node.attributes['class'] == 'foo'
+    [[:p, 'foo coming up!'], node]
+  else
+    [node]
+  end
+end
+
+puts hexp.pp
+
+puts hexp.to_html
+
+
+# >> H[:p, [
+# >>   H[:div, {"id"=>"main"}, [
+# >>       H[:p, [
+# >>             "foo coming up!"]],
+# >>       H[:p, {"class"=>"foo"}, [
+# >>             H[:br],
+# >>             "awesome",
+# >>             H[:br]]],
+# >>       H[:p, [
+# >>             "foo coming up!"]],
+# >>       H[:p, {"class"=>"foo"}, [
+# >>             H[:br],
+# >>             "awesome",
+# >>             H[:br]]]]],
+# >>   H[:hr]]]
+# >> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
+# >> <p><div id="main">
+# >> <p>foo coming up!</p>
+# >> <p class="foo"><br>awesome<br></p>
+# >> <p>foo coming up!</p>
+# >> <p class="foo"><br>awesome<br></p>
+# >> </div><hr></p>

data/lib/hexp.rb

@@ -1,5 +1,25 @@
+require 'delegate'
+require 'forwardable'
+
+require 'nokogiri'
+require 'ice_nine'
+require 'equalizer'
+
 module Hexp
+  def self.deep_freeze(*args)
+    IceNine.deep_freeze(*args)
+  end
 end
 
 require 'hexp/version'
-require 'hexp/array'
+
+require 'hexp/node'
+require 'hexp/node/normalize'
+require 'hexp/node/domize'
+require 'hexp/node/pp'
+
+require 'hexp/text_node'
+require 'hexp/list'
+require 'hexp/dom'
+
+require 'hexp/nokogiri/equality'

data/lib/hexp/dom.rb

@@ -0,0 +1,9 @@
+module Hexp
+  module DOM
+    Document = Nokogiri::HTML::Document
+    Node     = Nokogiri::XML::Node
+    Text     = Nokogiri::XML::Text
+
+
+  end
+end

data/lib/hexp/h.rb

@@ -0,0 +1,2 @@
+require 'hexp'
+H=Hexp::Node

data/lib/hexp/list.rb

@@ -0,0 +1,25 @@
+module Hexp
+  # A list of nodes
+  #
+  # @example
+  #   Hexp::List[
+  #     Hexp::Node[:marquee, "Try Hexp for instanst satisfaction!"],
+  #     Hexp::Node[:hr],
+  #   ]
+  #
+  class List < SimpleDelegator
+    include Equalizer.new(:__getobj__)
+
+    def initialize(nodes)
+      super Hexp.deep_freeze nodes
+    end
+
+    def self.[](*args)
+      new(args)
+    end
+
+    def inspect
+      __getobj__.inspect
+    end
+  end
+end

data/lib/hexp/node.rb

@@ -0,0 +1,63 @@
+module Hexp
+  # A Hexp Node
+  class Node
+    include Equalizer.new(:tag, :attributes, :children)
+    extend Forwardable
+
+    attr_reader :tag, :attributes, :children
+    def_delegators :@children, :empty?
+
+    # Normalize the arguments
+    #
+    # @param args [Array] args a Hexp node
+    # @return [Hexp::Node]
+    #
+    # @example
+    #    Hexp::Node[:p, {'class' => 'foo'}, [[:b, "Hello, World!"]]]
+    #
+    # @api public
+    def initialize(*args)
+      @tag, @attributes, @children = Hexp.deep_freeze(
+        Normalize.new(args).call
+      )
+    end
+
+    def self.[](*args)
+      new(*args)
+    end
+
+    def to_hexp
+      self
+    end
+
+    def to_html
+      to_dom.to_html
+    end
+
+    def to_dom
+      Domize.new(self).call
+    end
+
+    def inspect
+      self.class.inspect_name + to_a.reject(&:empty?).inspect
+    end
+
+    def to_a
+      [tag, attributes, children]
+    end
+
+    def pp
+      self.class::PP.new(self).call
+    end
+
+    class << self
+      def inspect_name
+        if defined?(H) && H == self
+          'H'
+        else
+          self.name
+        end
+      end
+    end
+  end
+end

data/lib/hexp/node/domize.rb

@@ -0,0 +1,45 @@
+module Hexp
+  class Node
+    # Turn nodes into DOM objects
+    class Domize
+      attr_reader :dom
+
+      def initialize(hexp, dom = Hexp::DOM)
+        @raw = hexp
+        @dom = dom
+      end
+
+      def call
+        dom::Document.new.tap do |doc|
+          @doc = doc
+          doc << domize(@raw)
+        end
+      end
+
+      private
+
+      def domize(hexp)
+        dom::Node.new(hexp.tag.to_s, @doc).tap do |node|
+          set_attributes(node, hexp.attributes)
+          set_children(node, hexp.children)
+        end
+      end
+
+      def set_attributes(node, attributes)
+        attributes.each do |key,value|
+          node[key] = value
+        end
+      end
+
+      def set_children(node, children)
+        children.each do |child|
+          if child.instance_of?(TextNode)
+            node << dom::Text.new(child, @doc)
+          else
+            node << domize(child)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hexp/node/normalize.rb

@@ -0,0 +1,89 @@
+module Hexp
+  class Node
+    # Normalize a node
+    #
+    class Normalize
+      # Set a node to be normalized
+      #
+      # @param [Array] node A non-strict hexp
+      #
+      # @example
+      #     Hexp::Node::Normalize.new([:p, {class:'foo'}])
+      #
+      # @api public
+      #
+      def initialize(node)
+        @raw = node
+      end
+
+      # Normalize to strict hexp nodes, cfr SPEC.md for details
+      #
+      # @return [Array] strict hexp node
+      #
+      # @api private
+      #
+      def call
+        [@raw.first, normalized_attributes, normalized_children]
+      end
+
+      private
+
+      # Pulls the attributes hash out of a non-strict hexp
+      #
+      # @return [Hash] the attributes hash
+      #
+      # @api private
+      #
+      def attributes
+        attrs = @raw[1]
+        return attrs if attrs.instance_of?(Hash)
+        {}
+      end
+
+      def normalized_attributes
+        Hash[*
+          attributes.flat_map do |key, value|
+            [key, value].map(&:to_s)
+          end
+        ]
+      end
+
+      # Pulls the children list out of a non-strict hexp
+      #
+      # @return [Array] the list of child hexps, non-strict
+      #
+      # @api private
+      #
+      def children
+        @raw[1..2].each do |arg|
+          return Array(arg) unless [Symbol, Hash].any?{|klz| arg.instance_of?(klz)}
+        end
+        []
+      end
+
+      # Normalize the third element of a hexp node, the list of children
+      #
+      # @return [Array] list of normalized hexps
+      #
+      # @api private
+      #
+      def normalized_children
+        Hexp::List[*
+          children.map do |child|
+            case child
+            when String, TextNode
+              Hexp::TextNode.new(child)
+            when Array
+              Hexp::Node[*child]
+            else
+              if child.respond_to? :to_hexp
+                Hexp::Node[*child.to_hexp]
+              end
+            end
+          end
+        ]
+      end
+    end
+
+  end
+end

data/lib/hexp/node/pp.rb

@@ -0,0 +1,38 @@
+module Hexp
+  class Node
+    # Pretty-print a node and its contents
+    class PP
+      def initialize(node)
+        @node = node
+      end
+
+      def call
+        [
+          @node.class.inspect_name,
+          pp_tag,
+          PP.indent(pp_attributes + pp_children).strip
+        ].join
+      end
+
+      def pp_tag
+        "[#{@node.tag.inspect}"
+      end
+
+      def pp_attributes
+        attrs = @node.attributes
+        return '' if attrs.empty?
+        ', ' + attrs.inspect
+      end
+
+      def pp_children
+        children = @node.children
+        return ']' if children.empty?
+        ", [\n#{ children.map(&:pp).join(",\n") }]]"
+      end
+
+      def self.indent(string, indent = 2)
+        string.lines.map {|line|  " "*indent + line}.join
+      end
+    end
+  end
+end

data/lib/hexp/nokogiri/equality.rb

@@ -0,0 +1,65 @@
+module Hexp
+  module Nokogiri
+    # Used in test to see if two Nokogiri objects have the same content,
+    # i.e. are equivalent as far as we are concerned
+    class Equality
+      CLASSES = [
+        ::Nokogiri::HTML::Document,
+        ::Nokogiri::HTML::DocumentFragment,
+        ::Nokogiri::XML::Document,
+        ::Nokogiri::XML::Node,
+        ::Nokogiri::XML::Text,
+        ::Nokogiri::XML::Element,
+        ::Nokogiri::XML::DocumentFragment,
+        ::Nokogiri::XML::DTD,
+      ]
+
+      def initialize(this, that)
+        @this, @that = this, that
+        [this, that].each do |input|
+          raise "#{input.class} is not a Nokogiri element." unless CLASSES.include?(input.class)
+        end
+      end
+
+      def call
+        [ equal_class?,
+          equal_name?,
+          equal_children?,
+          equal_attributes?,
+          equal_text? ].all?
+      end
+
+      def equal_class?
+        @this.class == @that.class
+      end
+
+      def equal_name?
+        @this.name == @that.name
+      end
+
+      def equal_children?
+        return true unless @this.respond_to? :children
+        @this.children.count == @that.children.count &&
+          compare_children.all?
+      end
+
+      def compare_children
+        @this.children.map.with_index do |child, idx|
+          self.class.new(child, @that.children[idx]).call
+        end
+      end
+
+      def equal_attributes?
+        return true unless @this.respond_to? :attributes
+        @this.attributes.keys.all? do |key|
+          @this[key] == @that[key]
+        end
+      end
+
+      def equal_text?
+        return true unless @this.instance_of?(::Nokogiri::XML::Text)
+        @this.text == @that.text
+      end
+    end
+  end
+end

data/lib/hexp/text_node.rb

@@ -0,0 +1,26 @@
+module Hexp
+  # Represents text inside HTML, at the moment a wrapper
+  # around a plain String. Needs work
+  class TextNode < SimpleDelegator
+    def inspect
+      __getobj__.inspect
+    end
+
+    def tree_walk
+      yield self
+    end
+
+    def attributes
+      {}.freeze
+    end
+
+    def pp
+      inspect
+    end
+
+    def to_a
+      [:text, self, Hexp::List[]]
+    end
+
+  end
+end

data/lib/hexp/version.rb

@@ -1,3 +1,3 @@
 module Hexp
-  VERSION = '0.0.1.pre'
+  VERSION = '0.0.1.pre2'
 end

data/spec/shared_helper.rb

@@ -1 +1,8 @@
 require 'hexp'
+require 'devtools/spec_helper'
+
+RSpec::Matchers.define :dom_eq do |other_dom|
+  match do |dom|
+    Hexp::Nokogiri::Equality.new(dom, other_dom).call
+  end
+end

data/spec/spec_helper.rb

@@ -23,4 +23,4 @@ if ENV['COVERAGE'] == 'true'
 
 end
 
-require 'shared_helper' # requires hexp
+require 'shared_helper'

data/spec/unit/hexp/node/domize_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Hexp::Node::Domize do
+  def build_doc(&blk)
+    Nokogiri::HTML::Builder.new(&blk).doc
+  end
+
+  subject { Hexp::Node::Domize.new(hexp).call }
+
+  context 'with the same single node' do
+    let(:dom) { build_doc { html } }
+    let(:hexp) { Hexp::Node[:html] }
+
+    it { should dom_eq(dom) }
+  end
+
+  context 'with a different single node' do
+    let(:dom) { build_doc { html } }
+    let(:hexp) { Hexp::Node[:body] }
+
+    it { should_not dom_eq(dom) }
+  end
+
+  context 'with nested nodes' do
+    let(:dom) { build_doc { html { div(class: 'big') } } }
+    let(:hexp) { Hexp::Node[:html, [ [:div, class: 'big'] ]] }
+
+    it { should dom_eq(dom) }
+  end
+
+  context 'with equal text nodes' do
+    let(:dom) { build_doc {
+        html do
+          div(class: 'big')
+          text "awesometown!"
+        end
+    } }
+    let(:hexp) {
+      Hexp::Node[:html, [
+          [:div, class: 'big'],
+          "awesometown!"
+        ]
+      ]
+    }
+
+    it { should dom_eq(dom) }
+  end
+
+  context 'with differing text nodes' do
+    let(:dom) { build_doc {
+        html do
+          div(class: 'big')
+          text "awesomevillage!"
+        end
+    } }
+    let(:hexp) {
+      Hexp::Node[:html, [
+          [:div, class: 'big'],
+          "awesometown!"
+        ]
+      ]
+    }
+
+    it { should_not dom_eq(dom) }
+  end
+end

data/spec/unit/hexp/node/normalize_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Hexp::Node::Normalize, '#call' do
+  subject { Hexp::Node[*node] }
+
+  describe 'with a single element' do
+    let (:node) { [:div] }
+
+    it 'should treat the first as the tag' do
+      subject.tag.should == :div
+    end
+    it 'should set an empty attribute list' do
+      subject.attributes.should == {}
+    end
+    it 'should set an empty children list' do
+      subject.children.should == Hexp::List[]
+    end
+  end
+
+  describe 'with two parameters' do
+    let (:node) { [:div, {class: 'foo'}] }
+
+    it 'should treat the first as the tag' do
+      subject.tag.should == :div
+    end
+    it 'should treat the second as the attribute list, if it is a Hash' do
+      subject.attributes.should == {'class' => 'foo'}
+    end
+    it 'should treat the second as a list of children, if it is an Array' do
+      subject.children.should == Hexp::List[]
+    end
+  end
+
+  describe 'with a single text child node' do
+    let(:node) { [:div, "this is text in the div"] }
+
+    it 'should set is as the single child' do
+      subject.children.should == Hexp::List["this is text in the div"]
+    end
+  end
+
+  describe 'with child nodes' do
+    let(:node) {
+      [:div, [
+          [:h1, "Big Title"],
+          [:p, {class: 'greeting'}, "hello world"],
+          "Some loose text"
+        ]
+      ]
+    }
+
+    it 'must normalize them recursively' do
+      subject.children.should == Hexp::List[
+        Hexp::Node[:h1, {},                  Hexp::List["Big Title"]   ],
+        Hexp::Node[:p,  {class: 'greeting'}, Hexp::List["hello world"] ],
+        "Some loose text"
+      ]
+    end
+  end
+
+  describe 'with an object that responds to to_hexp' do
+    let(:hexpable) {
+      Class.new do
+        def to_hexp
+          Hexp::Node[:em, "I am in your hexpz"]
+        end
+      end
+    }
+    let(:node) {
+      [:div, [ hexpable.new ] ]
+    }
+
+    it 'must expand that object' do
+      subject.children.should == Hexp::List[
+        Hexp::Node[:em, {}, Hexp::List["I am in your hexpz"] ]
+      ]
+    end
+
+  end
+
+end

data/spec/unit/hexp/node/pp_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'pp' do
+  subject { object.pp }
+
+  context 'with no attributes or children' do
+    let(:object) { Hexp::Node[:p, {}] }
+    it { should == 'Hexp::Node[:p]'}
+  end
+
+  context 'with a single child' do
+    let(:object) { Hexp::Node[:p, [ [:abbr, {title: 'YAGNI'}, "You ain't gonna need it"] ]] }
+    it { should == %q^Hexp::Node[:p, [
+                        Hexp::Node[:abbr, {"title"=>"YAGNI"}, [
+                          "You ain't gonna need it"]]]]^.gsub(' '*22, '')
+    }
+  end
+end

data/spec/unit/hexp/node/to_a_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'to_a' do
+  subject { object.to_a }
+  let(:object) { Hexp::Node.new(:p, class: 'foo') }
+
+  it { should == [:p, {'class' => 'foo'}, Hexp::List[]] }
+end

data/spec/unit/hexp/node/to_dom_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'to_dom' do
+  subject { Hexp::Node[:blink] }
+
+  it 'should delegate to Domize' do
+    Hexp::Node::Domize.should_receive(:new).with(subject).and_return( ->{ 'result' } )
+    subject.to_dom.should == 'result'
+  end
+end

data/spec/unit/hexp/node/to_hexp_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'to_hexp' do
+  let(:object) {Hexp::Node.new(:p) }
+  subject { object.to_hexp }
+
+  it { should == subject }
+end

data/spec/unit/hexp/node/to_html_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Hexp::Node, 'to_html' do
+  subject { Hexp::Node[:tt] }
+
+  it 'should render HTML' do
+    subject.to_html.should =~ %r{<tt></tt>}
+  end
+end

data/spec/unit/hexp/nokogiri/equality_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Hexp::Nokogiri::Equality do
+  let(:doc) { Nokogiri::HTML::Document.new }
+
+  context 'two empty documents' do
+    it 'should be equal' do
+      described_class.new(Nokogiri::HTML::Document.new, Nokogiri::HTML::Document.new).call.should be_true
+    end
+  end
+
+  context 'two nodes with the same attributes' do
+    it 'should be equal' do
+      node1 = Nokogiri::XML::Node.new('div', doc)
+      node1['class'] = 'hello'
+      node2 = Nokogiri::XML::Node.new('div', doc)
+      node2['class'] = 'hello'
+
+      described_class.new(node1, node2).call.should be_true
+    end
+  end
+
+  context 'one node has an attribute more' do
+    it 'should be equal' do
+      node1 = Nokogiri::XML::Node.new('div', doc)
+      node1['class'] = 'hello'
+      node2 = Nokogiri::XML::Node.new('div', doc)
+      node2['class'] = 'hello'
+      node2['id'] = 'zigzag'
+
+      described_class.new(node1, node2).call.should be_true
+    end
+  end
+
+  context 'two nodes with the same children' do
+    it 'should be equal' do
+      node1 = Nokogiri::XML::Node.new('div', doc)
+      node1 << Nokogiri::XML::Node.new('p', doc)
+      node2 = Nokogiri::XML::Node.new('div', doc)
+      node2 << Nokogiri::XML::Node.new('p', doc)
+
+      described_class.new(node1, node2).call.should be_true
+    end
+  end
+
+  context 'two nodes with a child of a different name' do
+    it 'should not be equal' do
+      node1 = Nokogiri::XML::Node.new('div', doc)
+      node1 << Nokogiri::XML::Node.new('p', doc)
+      node2 = Nokogiri::XML::Node.new('div', doc)
+      node2 << Nokogiri::XML::Node.new('em', doc)
+
+      described_class.new(node1, node2).call.should be_false
+    end
+  end
+
+  context 'one node has a child more than the other, otherwise identical' do
+    it 'should not be equal' do
+      node1 = Nokogiri::XML::Node.new('div', doc)
+      node1 << Nokogiri::XML::Node.new('p', doc)
+      node2 = Nokogiri::XML::Node.new('div', doc)
+      node2 << Nokogiri::XML::Node.new('p', doc)
+      node2 << Nokogiri::XML::Node.new('em', doc)
+
+      described_class.new(node1, node2).call.should be_false
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hexp
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.0.1.pre2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-23 00:00:00.000000000 Z
+date: 2013-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_nine
@@ -43,18 +43,35 @@ files:
 - README.md
 - Rakefile
 - SPEC.md
+- config/devtools.yml
 - config/flay.yml
 - config/flog.yml
 - config/mutant.yml
 - config/reek.yml
 - config/yardstick.yml
+- examples/filter.rb
 - hexp.gemspec
 - lib/hexp.rb
-- lib/hexp/array.rb
+- lib/hexp/dom.rb
+- lib/hexp/h.rb
+- lib/hexp/list.rb
+- lib/hexp/node.rb
+- lib/hexp/node/domize.rb
+- lib/hexp/node/normalize.rb
+- lib/hexp/node/pp.rb
+- lib/hexp/nokogiri/equality.rb
+- lib/hexp/text_node.rb
 - lib/hexp/version.rb
 - spec/shared_helper.rb
 - spec/spec_helper.rb
-- spec/unit/hexp/array_spec.rb
+- spec/unit/hexp/node/domize_spec.rb
+- spec/unit/hexp/node/normalize_spec.rb
+- spec/unit/hexp/node/pp_spec.rb
+- spec/unit/hexp/node/to_a_spec.rb
+- spec/unit/hexp/node/to_dom_spec.rb
+- spec/unit/hexp/node/to_hexp_spec.rb
+- spec/unit/hexp/node/to_html_spec.rb
+- spec/unit/hexp/nokogiri/equality_spec.rb
 homepage: https://github.com/plexus/hexp
 licenses: []
 post_install_message: 
@@ -69,7 +86,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3692654222847691207
+      hash: 4219632061257453794
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -85,4 +102,11 @@ summary: HTML expressions
 test_files:
 - spec/shared_helper.rb
 - spec/spec_helper.rb
-- spec/unit/hexp/array_spec.rb
+- spec/unit/hexp/node/domize_spec.rb
+- spec/unit/hexp/node/normalize_spec.rb
+- spec/unit/hexp/node/pp_spec.rb
+- spec/unit/hexp/node/to_a_spec.rb
+- spec/unit/hexp/node/to_dom_spec.rb
+- spec/unit/hexp/node/to_hexp_spec.rb
+- spec/unit/hexp/node/to_html_spec.rb
+- spec/unit/hexp/nokogiri/equality_spec.rb

data/lib/hexp/array.rb

@@ -1,43 +0,0 @@
-module Hexp
-  class Array < ::Array
-    def self.[](*args)
-      super(*normalize(args))
-    end
-
-    def self.normalize(args)
-      idx = 0
-      case args[idx]
-      when Symbol
-        tag = args[idx] ; idx+=1
-        attrs = case args[idx]
-                when Hash
-                  idx += 1 ; args[idx-1]
-                else
-                  {}
-                end
-        children = normalize_children args[idx]
-        [tag, attrs, children]
-      end
-    end
-
-    def self.normalize_children(children)
-      case children
-      when String
-        [ children ]
-      when ::Array
-        children.map do |child|
-          case child
-          when String
-            child
-          when ::Array
-            Hexp::Array[*child]
-          else
-            raise "bad input #{child}"
-          end
-        end
-      else
-        []
-      end
-    end
-  end
-end

data/spec/unit/hexp/array_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-H=Hexp::Array
-
-describe Hexp::Array do
-  describe 'normalization' do
-    describe 'with a single parameter' do
-      it 'should return a triplet' do
-        H[:div].count.should == 3
-      end
-      it 'should treat the first as the tag' do
-        H[:div][0].should == :div
-      end
-      it 'should set an empty attribute list' do
-        H[:div][1].should == {}
-      end
-      it 'should set an empty children list' do
-        H[:div][2].should == []
-      end
-    end
-
-    describe 'with two parameters' do
-      it 'should treat the first as the tag' do
-        H[:div, {class: 'foo'}][0].should == :div
-      end
-      it 'should treat the second as the attribute list, if it is a Hash' do
-        H[:div, {class: 'foo'}][1].should == {class: 'foo'}
-      end
-      it 'should treat the second as a list of children, if it is an Array' do
-        H[:div, []][2].should == []
-      end
-    end
-
-    describe 'with a single text child node' do
-      it 'should set is as the single child' do
-        H[:div, "this is text in the div"][2].should == ["this is text in the div"]
-      end
-    end
-
-    describe 'with child nodes' do
-      it 'must normalize them recursively' do
-        H[:div, [
-            [:h1, "Big Title"],
-            [:p, {class: 'greeting'}, "hello world"],
-            "Some loose text"
-          ]
-        ][2].should == [
-            [:h1, {},                  ["Big Title"]   ],
-            [:p,  {class: 'greeting'}, ["hello world"] ],
-            "Some loose text"
-          ]
-      end
-    end
-
-    describe 'with bad input' do
-      it 'should raise exception' do
-        expect { H[:p, {}, [123]] }.to raise_exception
-      end
-    end
-  end
-end