hexp 0.0.1 → 0.2.0

data/config/rubocop.yml

@@ -0,0 +1,31 @@
+AllCops:
+  Includes:
+    - '../**/*.rake'
+  Excludes:
+    - '../vendor/**'
+
+# Avoid parameter lists longer than five parameters.
+ParameterLists:
+  Max: 3
+  CountKeywordArgs: true
+
+# Avoid more than `Max` levels of nesting.
+BlockNesting:
+  Max: 3
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    inject:   'reduce'
+    find:     'detect'
+    find_all: 'select'
+
+# Do not force public/protected/private keyword to be indented at the same
+# level as the def keyword. My personal preference is to outdent these keywords
+# because I think when scanning code it makes it easier to identify the
+# sections of code and visually separate them. When the keyword is at the same
+# level I think it sort of blends in with the def keywords and makes it harder
+# to scan the code and see where the sections are.
+AccessControl:
+  Enabled: false

data/config/yardstick.yml

@@ -1,2 +1,40 @@
 ---
-threshold: 77.5
+threshold: 93.7
+rules:
+  ApiTag::Presence:
+    enabled: true
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: false
+    exclude:
+      - Hexp::Nokogiri::Equality#call
+      - Hexp::Nokogiri::Equality#equal_class?
+      - Hexp::Nokogiri::Equality#equal_name?
+      - Hexp::Nokogiri::Equality#equal_children?
+      - Hexp::Nokogiri::Equality#compare_children
+      - Hexp::Nokogiri::Equality#equal_attributes?
+      - Hexp::Nokogiri::Equality#equal_text?
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []

data/examples/from_nokogiri.rb

@@ -0,0 +1,77 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'hexp'
+require 'minitest/autorun'
+
+module Hexp
+  def self.from_nokogiri(node)
+    attrs = node.attributes.map do |k,v|
+      [k.to_sym, v.value]
+    end
+    children = node.children.map do |child|
+      case child
+      when ::Nokogiri::XML::Text
+        Hexp::TextNode.new(child.text)
+      when ::Nokogiri::XML::Node
+        from_nokogiri(child)
+      end
+    end
+    H[node.name.to_sym, Hash[attrs], children]
+  end
+end
+
+class Nokogiri::XML::Node
+  def to_hexp
+    Hexp.from_nokogiri(self)
+  end
+end
+
+class Nokogiri::XML::Document
+end
+
+describe Hexp, 'from_nokigiri' do
+  def doc
+    @doc ||= Nokogiri::HTML::Document.new
+  end
+
+  it 'should convert a single node' do
+    h3 = Nokogiri::XML::Node.new "h3", doc
+    Hexp.from_nokogiri(h3).must_equal H[:h3]
+  end
+
+  it 'should extract arguments, if there are any' do
+    h3 = Nokogiri::XML::Node.new "h3", doc
+    h3[:class] = 'foo'
+    Hexp.from_nokogiri(h3).must_equal H[:h3, {class: 'foo'}]
+  end
+
+  it 'should convert children' do
+    div  = Nokogiri::XML::Node.new "div", doc
+    p    = Nokogiri::XML::Node.new "p", doc
+    span = Nokogiri::XML::Node.new "span", doc
+    div << p
+    div << span
+
+    Hexp.from_nokogiri(div).must_equal H[:div, [[:p], [:span]]]
+  end
+
+  it 'should convert text nodes' do
+    div  = Nokogiri::XML::Node.new "div", doc
+    p    = Nokogiri::XML::Node.new "p", doc
+    text = Nokogiri::XML::Text.new "text", doc
+    div << p
+    div << text
+
+    Hexp.from_nokogiri(div).must_equal H[:div, [[:p], "text"]]
+  end
+end
+
+# >> Run options: --seed 54619
+# >>
+# >> # Running tests:
+# >>
+# >> ....
+# >>
+# >> Finished tests in 0.003244s, 1233.0547 tests/s, 1233.0547 assertions/s.
+# >>
+# >> 4 tests, 4 assertions, 0 failures, 0 errors, 0 skips

data/examples/selector_rewriter_chaining.rb

@@ -0,0 +1,14 @@
+d=H[:div, %w(foo bar baz).map{|klz| [:p, class: klz]}]
+
+#=> H[:div, [H[:p, {"class"=>"foo"}], H[:p, {"class"=>"bar"}], H[:p, {"class"=>"baz"}]]]
+
+d.select {|node|node.class? 'bar'} #=> #<Hexp::Node::Selector>
+  .wrap(:span)                     #=> #<Hexp::Node::Rewriter>
+  .attr('data-x', '77')            #=> #<Hexp::Node::Rewriter>
+  .wrap(:foo, 'hello' => 'jow')    #=> #<Hexp::Node::Rewriter>
+  .attr('faz', 'foz').to_html(:include_doctype => false)
+
+# <div>
+# <p class="foo"></p>
+# <foo hello="jow" faz="foz"><span data-x="77"><p class="bar"></p></span></foo><p class="baz"></p>
+# </div>

data/examples/todo.rb

@@ -0,0 +1,138 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+$:.unshift File.expand_path('../../examples', __FILE__)
+
+require 'sinatra'
+require 'hexp'
+require 'widget'
+
+class EntryStore
+  def self.store(entry)
+    @counter ||= 0
+    @entries ||= {}
+    entry.id = (@counter+=1) unless entry.id
+    @entries[entry.id] = entry
+  end
+
+  def self.find(id)
+    @entries[id]
+  end
+
+  def self.all
+    @entries ||= {}
+    @entries.values || []
+  end
+
+  def self.delete(id)
+    @entries.delete(id)
+  end
+end
+
+class Entry < Widget(:span)
+  attribute :id, Integer
+  attribute :description, String
+
+  def widget
+    [ description ]
+  end
+end
+
+class EntryList
+  def initialize(entries)
+    @entries = entries
+  end
+
+  def to_hexp
+    H[:ul,
+      @entries.map do |entry|
+        H[:li, entry]
+      end
+    ]
+  end
+end
+
+class AddEntryForm
+  def to_hexp
+    H[:form, {method: 'POST', action: '/'}, [
+        H[:input, {type: 'text', name: 'entry_description'}],
+        H[:input, {type: 'submit'}, "Add"]
+      ]
+    ]
+  end
+end
+
+class Layout
+  include Hexp
+
+  def initialize(*contents)
+    @contents = contents
+    p @contents
+  end
+
+  def to_hexp
+    H[:html, [
+        H[:head],
+        H[:body,  @contents ]
+      ]
+    ]
+  end
+end
+
+class ListPage
+  include Hexp
+  TITLE = 'Todo List'
+
+  def to_hexp
+    hexp = Layout.new(
+      EntryList.new(EntryStore.all),
+      AddEntryForm.new
+    )
+    hexp = add_title(hexp)
+    hexp = wrap_entry_forms(hexp)
+  end
+
+  def title
+    H[:title, TITLE]
+  end
+
+  def add_title(tree)
+    tree.rewrite do |node|
+      if node.tag == :head
+        H[:head, node.attributes, node.children + [title]]
+      end
+    end
+  end
+
+  def wrap_entry_forms(tree)
+    tree.rewrite do |node|
+      if node.class? 'entry'
+        H[:form, {method: 'POST', action: "/#{node.attr('data-id')}"}, [
+            node,
+            H[:input, type: 'hidden', name: '_method', value: 'DELETE'],
+            H[:input, type: 'submit', value: '-']
+          ]
+        ]
+      end
+    end
+  end
+end
+
+get '/' do
+  ListPage.new.to_html
+end
+
+post '/' do
+  @entry = Entry.new(description: params['entry_description'])
+  EntryStore.store(@entry)
+
+  ListPage.new.to_html
+end
+
+delete '/:id' do
+  EntryStore.delete params[:id].to_i
+
+  ListPage.new.to_html
+end
+
+get '/handlebars' do
+  Entry.handlebars.to_html
+end

data/examples/widget.rb

@@ -0,0 +1,64 @@
+$:.unshift File.expand_path '../../lib', __FILE__
+
+require 'hexp'
+require 'virtus'
+
+class Widget
+  include Hexp
+  include Virtus
+
+  attribute :tag,  Symbol, default: :div
+  attribute :data, Hash
+
+  def to_hexp
+    H[tag, html_attributes, widget]
+  end
+
+  def html_attributes
+    attrs = Hash[data.map {|k,v| ["data-#{k}", v]}].merge(class: [self.class.widget_name, 'widget']*' ' )
+    if attribute_set.any?{|attribute| attribute.name == :id} && self.id
+      attrs['data-id'] = self.id
+    end
+    attrs
+  end
+
+  def self.widget_name
+    self.name.downcase
+  end
+
+  def self.handlebars
+    H[:script, {:type => 'application/x-handlebars-template', :id => widget_name+'-template'},
+      self.new(
+        Hash[
+          attribute_set
+            .reject {|attribute| [:data, :tag].include?(attribute.name)    }
+            .map    {|attribute| [attribute.name, "{{#{attribute.name}}}"] }
+        ]
+      )
+    ]
+  end
+end
+
+def Widget(tag)
+  Class.new(Widget) do
+    attribute :tag, Symbol, default: tag
+  end
+end
+
+
+# class Entry < Widget(:p)
+#   attribute :name, String
+#   attribute :date, String # !> assigned but unused variable - type
+
+#   def widget
+#     [
+#       [:span, name],
+#       [:span, date]
+#     ]
+#   end
+# end
+
+# puts Entry.new(name: 'foo', date: '2013-06-17', data: {id: 17}).to_html
+# puts
+# puts Entry.handlebars.to_html
+ # !> instance variable @default not initialized

data/hexp.gemspec

@@ -10,13 +10,18 @@ Gem::Specification.new do |gem|
   gem.description = 'HTML expressions'
   gem.summary     = gem.description
   gem.homepage    = 'https://github.com/plexus/hexp'
+  gem.license     = 'MIT'
 
   gem.require_paths    = %w[lib]
   gem.files            = `git ls-files`.split($/)
   gem.test_files       = `git ls-files -- spec`.split($/)
   gem.extra_rdoc_files = %w[README.md]
 
-  gem.add_dependency 'nokogiri', '~> 1.5.9'
-  gem.add_dependency 'ice_nine', '~> 0.7.0'
-  gem.add_dependency 'equalizer', '~> 0.0.5'
+  gem.add_runtime_dependency 'sass'      , '~> 3.2'
+  gem.add_runtime_dependency 'nokogiri'  , '~> 1.6'
+  gem.add_runtime_dependency 'ice_nine'  , '~> 0.8'
+  gem.add_runtime_dependency 'equalizer' , '~> 0.0'
+
+  gem.add_development_dependency 'rake',  '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 2.14'
 end

data/lib/hexp.rb

@@ -1,27 +1,128 @@
 require 'delegate'
 require 'forwardable'
 
-require 'nokogiri'
+require 'nokogiri' # TODO => replace with Builder
+require 'sass'
 require 'ice_nine'
 require 'equalizer'
 
 module Hexp
+  # Inject the Hexp::DSL module into classes that include Hexp
+  #
+  # @param klazz [Class] The class that included Hexp
+  #
+  # @return [Class]
+  # @api private
+  #
+  def self.included(klazz)
+    klazz.send(:include, Hexp::DSL)
+  end
+
+  # Deep freeze an object
+  #
+  # Delegates to IceNine
+  #
+  # @param args [Array] arguments to pass on
+  # @return Object
+  # @api private
+  #
   def self.deep_freeze(*args)
     IceNine.deep_freeze(*args)
   end
+
+  # Variant of ::Array with slightly modified semantics
+  #
+  # Array() is often used to wrap a value in an Array, unless it's already
+  # an array. However if your object implements #to_a, then Array() will use
+  # that value. Because of this objects that aren't Array-like will get
+  # converted as well, such as Struct objects.
+  #
+  # This implementation relies on #to_ary, which signals that the Object is
+  # a drop-in replacement for an actual Array.
+  #
+  # @param arg [Object]
+  # @return [Array]
+  # @api private
+  #
+  def self.Array(arg)
+    if arg.respond_to? :to_ary
+      arg.to_ary
+    else
+      [ arg ]
+    end
+  end
+
+  # Parse HTML to Hexp
+  #
+  # The input have a single root element. If there are multiple only the first
+  # will be converted. If there is no root element (e.g. an empty document, or
+  # only a DTD or comment) then an error is raised
+  #
+  # @example
+  #   Hexp.parse('<div>hello</div>') #=> H[:div, "hello"]
+  #
+  # @param html [String] A HTML document
+  # @return [Hexp::Node]
+  # @api public
+  #
+  def self.parse(html)
+    root = Nokogiri(html).root
+    raise Hexp::ParseError, "Failed to parse HTML : no document root" if root.nil?
+    Hexp::Nokogiri::Reader.new.call(root)
+  end
+
+  # Use builder syntax to create a Hexp
+  #
+  # (see Hexp::Builder)
+  #
+  # @example
+  #   list = Hexp.build do
+  #     ul do
+  #      3.times do |i|
+  #        li i.to_s
+  #      end
+  #     end
+  #   end
+  #
+  # @param args [Array]
+  # @return [Hexp::Builder]
+  # @api public
+  #
+  def self.build(*args, &block)
+    Hexp::Builder.new(*args, &block)
+  end
+
 end
 
 require 'hexp/version'
+require 'hexp/dsl'
+
+
+require 'hexp/node/attributes'
+require 'hexp/node/children'
 
 require 'hexp/node'
 require 'hexp/node/normalize'
 require 'hexp/node/domize'
 require 'hexp/node/pp'
+require 'hexp/node/rewriter'
+require 'hexp/node/selector'
+require 'hexp/node/css_selection'
 
 require 'hexp/text_node'
 require 'hexp/list'
 require 'hexp/dom'
 
-require 'hexp/nokogiri/equality'
+require 'hexp/css_selector'
+require 'hexp/css_selector/sass_parser'
+require 'hexp/css_selector/parser'
+
+require 'hexp/errors'
+
+require 'hexp/nokogiri/equality' # TODO => replace this with equivalent-xml
+require 'hexp/nokogiri/reader'
+require 'hexp/sass/selector_parser'
 
 require 'hexp/h'
+
+require 'hexp/builder'