hashtml 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.idea
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+hashtml
+=======
+
+HashTML is a gem for parsing HTML documents to Ruby Hash-like objects

data/hashtml.gemspec

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'lib', 'hashtml', 'version')
+
+Gem::Specification.new do |gem|
+  gem.authors     = ["Mauro Rodrigues"]
+  gem.email       = ["maurorodrigues15@gmail.com"]
+  gem.description = %q{HashTML is a gem for parsing HTML documents to Ruby Hash-like objects.}
+  gem.summary     = %q{A HTML to Hash to HTML helper.}
+  gem.homepage    = 'https://github.com/MRod15/hashtml'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.name          = "hashtml"
+  gem.require_paths = ['lib']
+  gem.version       = HashTML::VERSION
+  gem.license       = "MIT"
+
+  gem.add_dependency 'nokogiri', '~> 1.5.5'
+end

data/lib/hashtml.rb

@@ -0,0 +1,242 @@
+require 'nokogiri'
+require File.join(File.dirname(__FILE__), 'hashtml', 'hash.rb')
+#
+# HashTML translates between HTML documents and Ruby Hash-like objects.
+# This work is loosely inspired on the work done by CobraVsMongoose.
+# (see http://cobravsmongoose.rubyforge.org/)
+#
+class HashTML
+
+  attr_reader :root_node
+
+  # Returns a Hash corresponding to the data structure of the given HTML,
+  # which should be a Nokogiri::HTML::Document or anything that responds to to_s
+  # with a string of valid HTML.
+  #@param html [Nokogiri::HTML::Document], or
+  #@param html [String] document to parse
+  #@return [Hash]
+  #@example
+  #  html = '<span id="row_29" class="step param">true</span>'
+  #  HashTML.new(xml).to_h
+  #  # => {
+  #         "span" => {
+  #           :children => [
+  #             {
+  #               :text => "true"
+  #             }
+  #           ],
+  #           :attributes => {
+  #             "id" => "row_29",
+  #             "class" => "step param"
+  #           }
+  #         }
+  #       }
+  #
+  def initialize(html)
+    doc        = (html.is_a?(Nokogiri::HTML::Document) ? html : Nokogiri::HTML(html.to_s))
+    @root_node = HashTML::Node.new(doc)
+  end
+
+
+  # Returns an HTML string corresponding to the data structure of the given Hash.
+  #@return [String]
+  #@example
+  #  hash = { "span" =>
+  #           {
+  #             :children => [ { :text => "true" } ],
+  #             :attributes => { "id" => "row_29", "class" => "step param" }
+  #           }
+  #         }
+  #  HTMLParser.hash_to_html(hash)
+  #  # => "<span id="row_29" class="step param">true</span>"
+  #
+  def to_html
+    @root_node.to_html
+  end
+
+  def to_h
+    @root_node.to_h
+  end
+
+  def method_missing(method, *args)
+    method           = method.to_s
+    attributes, _nil = args
+    attributes       ||= {}
+    if method.end_with?("?")
+      key = method[0..-2]
+      _check_for_presence(key, attributes)
+    else
+      _get_value(method, attributes)
+    end
+  end
+
+  private
+
+  def _check_for_presence(key, attributes={})
+    !!_get_value(key, attributes)
+  end
+
+  def _get_value(key, attributes={})
+    #$logger.debug("Looking for '#{key}'")
+    #$logger.debug('It\'s the root node!')
+    return nil unless @root_node.name == key
+    return @root_node unless attributes
+    return ((@root_node.attributes and @root_node.attributes.include_pairs?(attributes)) ? @root_node : nil)
+  end
+
+  class InvalidAttributeValuePairError < StandardError
+  end
+
+  public
+
+  class << self
+    def to_hashtml(hash)
+      convert_to_hashtml(hash)
+    end
+
+    def to_html(hash)
+      convert_to_hashtml(hash).to_html
+    end
+
+    private
+    def convert_to_hashtml(hash)
+      #$logger.warn(hash)
+      hashtml = nil
+      hash.each do |key, value|
+        return HashTML::Text.new(value) if key == :text
+        hashtml            = HashTML::Node.new
+        hashtml.name       = key
+        hashtml.attributes = (value[:attributes] or {})
+        hashtml.children   = value[:children].map { |child| convert_to_hashtml(child) }
+      end
+      #$logger.debug hashtml
+      hashtml
+    end
+  end
+
+  class Node
+    attr_accessor :name, :attributes, :children
+
+    def initialize(node=nil)
+      return unless node
+      #$logger.warn "Analysing node: #{node.name}\n#{node}"
+      @name       = node.name
+      @attributes = node.respond_to?(:attributes) ? get_html_node_attributes(node) : {}
+      @children   = get_html_node_children(node)
+      #$logger.debug(@children, 'Children:')
+    end
+
+    def to_h
+      { @name => { children: @children.map { |child| child.to_h }, attributes: @attributes } }
+    end
+
+    def to_html
+      space          = (@attributes.any? ? ' ' : '')
+      children_html  = @children.map { |child| child.to_html }.join
+      attribute_list = @attributes.map { |k, v| "#{k}=\"#{v}\"" }.join(' ')
+      "<#{@name}#{space}#{attribute_list}>#{children_html}</#{@name}>"
+    end
+
+    def method_missing(method, *args)
+      method                      = method.to_s
+      #$logger.debug(method)
+      #$logger.debug(args)
+      attributes, new_value, _nil = args
+      attributes                  ||= {}
+      if method.end_with?("?")
+        key = method[0..-2]
+        _check_for_presence(key, attributes)
+      elsif method.end_with?("=")
+        key       = method[0..-2]
+        new_value, attributes = attributes, {} if new_value.nil?
+        _change_value(key, attributes, new_value)
+      else
+        _get_value(method, attributes)
+      end
+    end
+
+    private
+
+    def _check_for_presence(key, attributes={})
+      !!_get_value(key, attributes)
+    end
+
+    def _get_value(key, attributes={})
+      #$logger.debug("Looking for '#{key}'")
+      #$logger.debug('It\'s a child node!')
+      if key == 'text'
+        #$logger.debug('Getting node text...')
+        return @children.map { |child| child.text if child.is_a?(HashTML::Text) }.reject(&:nil?).join
+      else
+        @children.each do |child|
+          next if child.is_a?(HashTML::Text)
+          #$logger.debug child.attributes
+          return child if (child.name == key and child.attributes.include_pairs?(attributes))
+        end
+      end
+      nil
+    end
+
+    def _change_value(key, attributes, new_value)
+      #$logger.debug("Looking for '#{key}'")
+      #$logger.debug('It\'s a child node!')
+      if key == 'text'
+        #$logger.debug("Changing node text to '#{new_value}'...")
+        #$logger.warn(@children)
+        new_children = @children.select { |child| !child.is_a?(HashTML::Text) }
+        @children    = new_children.empty? ? [HashTML::Text.new(new_value)] : [new_children, HashTML::Text.new(new_value)]
+        #$logger.warn(@children)
+      else
+        #$logger.debug('Changing node value...')
+        @children.each_with_index do |child, index|
+          next if child.is_a?(HashTML::Text)
+          if child.name == key and child.attributes.include_pairs?(attributes)
+            @children[index] = new_value
+          end
+        end
+      end
+    end
+
+    def get_html_node_children(node)
+      #$logger.debug "Node children:\n#{node.children}"
+      node.children.map do |child|
+        #$logger.info("Child:\n#{child}\nChild class: '#{child.class}'")
+        #$logger.info(child)
+        case child.class.to_s
+          when 'Nokogiri::XML::Text', 'Nokogiri::XML::CDATA'
+            HashTML::Text.new(child.to_s)
+          when 'Nokogiri::XML::Element'
+            HashTML::Node.new(child)
+          else
+            nil
+        end
+      end.reject(&:nil?)
+    end
+
+    def get_html_node_attributes(node)
+      #$logger.debug "Node attributes: #{node.attributes}"
+      Hash[node.attributes.map { |name, value| [name, value.value] }]
+    end
+
+  end
+
+  class Text
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_h
+      { text: @text }
+    end
+
+    def to_html
+      @text
+    end
+  end
+
+  class ParseError < RuntimeError
+  end
+
+end

data/lib/hashtml/hash.rb

@@ -0,0 +1,10 @@
+
+class Hash
+
+  # Checks if an 'hash' is a subset of the object
+  #@param hash [Hash] pairs to verify
+  #@return [Boolean]
+  def include_pairs?(hash)
+    hash.select { |k, v| k if self[k] != v }.empty?
+  end
+end

data/lib/hashtml/version.rb

@@ -0,0 +1,3 @@
+module HashTML
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: hashtml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mauro Rodrigues
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+description: HashTML is a gem for parsing HTML documents to Ruby Hash-like objects.
+email:
+- maurorodrigues15@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.md
+- hashtml.gemspec
+- lib/hashtml.rb
+- lib/hashtml/hash.rb
+- lib/hashtml/version.rb
+homepage: https://github.com/MRod15/hashtml
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A HTML to Hash to HTML helper.
+test_files: []
+has_rdoc: