No OneTemporary
Actions

Size

53 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/.gitmodules b/.gitmodules
	new file mode 100644
	index 0000000..d48938b
	--- /dev/null
	+++ b/.gitmodules
	@@ -0,0 +1,3 @@
	+[submodule "c_src/myhtml"]
	+ path = c_src/myhtml
	+ url = https://github.com/lexborisov/myhtml.git
	diff --git a/LICENSE b/LICENSE
	new file mode 100644
	index 0000000..6a67a0d
	--- /dev/null
	+++ b/LICENSE
	@@ -0,0 +1,458 @@
	+ GNU LESSER GENERAL PUBLIC LICENSE
	+ Version 2.1, February 1999
	+
	+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
	+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	+ Everyone is permitted to copy and distribute verbatim copies
	+ of this license document, but changing it is not allowed.
	+
	+(This is the first released version of the Lesser GPL. It also counts
	+ as the successor of the GNU Library Public License, version 2, hence
	+ the version number 2.1.)
	+
	+ Preamble
	+
	+ The licenses for most software are designed to take away your
	+freedom to share and change it. By contrast, the GNU General Public
	+Licenses are intended to guarantee your freedom to share and change
	+free software--to make sure the software is free for all its users.
	+
	+ This license, the Lesser General Public License, applies to some
	+specially designated software packages--typically libraries--of the
	+Free Software Foundation and other authors who decide to use it. You
	+can use it too, but we suggest you first think carefully about whether
	+this license or the ordinary General Public License is the better
	+strategy to use in any particular case, based on the explanations below.
	+
	+ When we speak of free software, we are referring to freedom of use,
	+not price. Our General Public Licenses are designed to make sure that
	+you have the freedom to distribute copies of free software (and charge
	+for this service if you wish); that you receive source code or can get
	+it if you want it; that you can change the software and use pieces of
	+it in new free programs; and that you are informed that you can do
	+these things.
	+
	+ To protect your rights, we need to make restrictions that forbid
	+distributors to deny you these rights or to ask you to surrender these
	+rights. These restrictions translate to certain responsibilities for
	+you if you distribute copies of the library or if you modify it.
	+
	+ For example, if you distribute copies of the library, whether gratis
	+or for a fee, you must give the recipients all the rights that we gave
	+you. You must make sure that they, too, receive or can get the source
	+code. If you link other code with the library, you must provide
	+complete object files to the recipients, so that they can relink them
	+with the library after making changes to the library and recompiling
	+it. And you must show them these terms so they know their rights.
	+
	+ We protect your rights with a two-step method: (1) we copyright the
	+library, and (2) we offer you this license, which gives you legal
	+permission to copy, distribute and/or modify the library.
	+
	+ To protect each distributor, we want to make it very clear that
	+there is no warranty for the free library. Also, if the library is
	+modified by someone else and passed on, the recipients should know
	+that what they have is not the original version, so that the original
	+author's reputation will not be affected by problems that might be
	+introduced by others.
	+
	+ Finally, software patents pose a constant threat to the existence of
	+any free program. We wish to make sure that a company cannot
	+effectively restrict the users of a free program by obtaining a
	+restrictive license from a patent holder. Therefore, we insist that
	+any patent license obtained for a version of the library must be
	+consistent with the full freedom of use specified in this license.
	+
	+ Most GNU software, including some libraries, is covered by the
	+ordinary GNU General Public License. This license, the GNU Lesser
	+General Public License, applies to certain designated libraries, and
	+is quite different from the ordinary General Public License. We use
	+this license for certain libraries in order to permit linking those
	+libraries into non-free programs.
	+
	+ When a program is linked with a library, whether statically or using
	+a shared library, the combination of the two is legally speaking a
	+combined work, a derivative of the original library. The ordinary
	+General Public License therefore permits such linking only if the
	+entire combination fits its criteria of freedom. The Lesser General
	+Public License permits more lax criteria for linking other code with
	+the library.
	+
	+ We call this license the "Lesser" General Public License because it
	+does Less to protect the user's freedom than the ordinary General
	+Public License. It also provides other free software developers Less
	+of an advantage over competing non-free programs. These disadvantages
	+are the reason we use the ordinary General Public License for many
	+libraries. However, the Lesser license provides advantages in certain
	+special circumstances.
	+
	+ For example, on rare occasions, there may be a special need to
	+encourage the widest possible use of a certain library, so that it becomes
	+a de-facto standard. To achieve this, non-free programs must be
	+allowed to use the library. A more frequent case is that a free
	+library does the same job as widely used non-free libraries. In this
	+case, there is little to gain by limiting the free library to free
	+software only, so we use the Lesser General Public License.
	+
	+ In other cases, permission to use a particular library in non-free
	+programs enables a greater number of people to use a large body of
	+free software. For example, permission to use the GNU C Library in
	+non-free programs enables many more people to use the whole GNU
	+operating system, as well as its variant, the GNU/Linux operating
	+system.
	+
	+ Although the Lesser General Public License is Less protective of the
	+users' freedom, it does ensure that the user of a program that is
	+linked with the Library has the freedom and the wherewithal to run
	+that program using a modified version of the Library.
	+
	+ The precise terms and conditions for copying, distribution and
	+modification follow. Pay close attention to the difference between a
	+"work based on the library" and a "work that uses the library". The
	+former contains code derived from the library, whereas the latter must
	+be combined with the library in order to run.
	+
	+ GNU LESSER GENERAL PUBLIC LICENSE
	+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
	+
	+ 0. This License Agreement applies to any software library or other
	+program which contains a notice placed by the copyright holder or
	+other authorized party saying it may be distributed under the terms of
	+this Lesser General Public License (also called "this License").
	+Each licensee is addressed as "you".
	+
	+ A "library" means a collection of software functions and/or data
	+prepared so as to be conveniently linked with application programs
	+(which use some of those functions and data) to form executables.
	+
	+ The "Library", below, refers to any such software library or work
	+which has been distributed under these terms. A "work based on the
	+Library" means either the Library or any derivative work under
	+copyright law: that is to say, a work containing the Library or a
	+portion of it, either verbatim or with modifications and/or translated
	+straightforwardly into another language. (Hereinafter, translation is
	+included without limitation in the term "modification".)
	+
	+ "Source code" for a work means the preferred form of the work for
	+making modifications to it. For a library, complete source code means
	+all the source code for all modules it contains, plus any associated
	+interface definition files, plus the scripts used to control compilation
	+and installation of the library.
	+
	+ Activities other than copying, distribution and modification are not
	+covered by this License; they are outside its scope. The act of
	+running a program using the Library is not restricted, and output from
	+such a program is covered only if its contents constitute a work based
	+on the Library (independent of the use of the Library in a tool for
	+writing it). Whether that is true depends on what the Library does
	+and what the program that uses the Library does.
	+
	+ 1. You may copy and distribute verbatim copies of the Library's
	+complete source code as you receive it, in any medium, provided that
	+you conspicuously and appropriately publish on each copy an
	+appropriate copyright notice and disclaimer of warranty; keep intact
	+all the notices that refer to this License and to the absence of any
	+warranty; and distribute a copy of this License along with the
	+Library.
	+
	+ You may charge a fee for the physical act of transferring a copy,
	+and you may at your option offer warranty protection in exchange for a
	+fee.
	+
	+ 2. You may modify your copy or copies of the Library or any portion
	+of it, thus forming a work based on the Library, and copy and
	+distribute such modifications or work under the terms of Section 1
	+above, provided that you also meet all of these conditions:
	+
	+ a) The modified work must itself be a software library.
	+
	+ b) You must cause the files modified to carry prominent notices
	+ stating that you changed the files and the date of any change.
	+
	+ c) You must cause the whole of the work to be licensed at no
	+ charge to all third parties under the terms of this License.
	+
	+ d) If a facility in the modified Library refers to a function or a
	+ table of data to be supplied by an application program that uses
	+ the facility, other than as an argument passed when the facility
	+ is invoked, then you must make a good faith effort to ensure that,
	+ in the event an application does not supply such function or
	+ table, the facility still operates, and performs whatever part of
	+ its purpose remains meaningful.
	+
	+ (For example, a function in a library to compute square roots has
	+ a purpose that is entirely well-defined independent of the
	+ application. Therefore, Subsection 2d requires that any
	+ application-supplied function or table used by this function must
	+ be optional: if the application does not supply it, the square
	+ root function must still compute square roots.)
	+
	+These requirements apply to the modified work as a whole. If
	+identifiable sections of that work are not derived from the Library,
	+and can be reasonably considered independent and separate works in
	+themselves, then this License, and its terms, do not apply to those
	+sections when you distribute them as separate works. But when you
	+distribute the same sections as part of a whole which is a work based
	+on the Library, the distribution of the whole must be on the terms of
	+this License, whose permissions for other licensees extend to the
	+entire whole, and thus to each and every part regardless of who wrote
	+it.
	+
	+Thus, it is not the intent of this section to claim rights or contest
	+your rights to work written entirely by you; rather, the intent is to
	+exercise the right to control the distribution of derivative or
	+collective works based on the Library.
	+
	+In addition, mere aggregation of another work not based on the Library
	+with the Library (or with a work based on the Library) on a volume of
	+a storage or distribution medium does not bring the other work under
	+the scope of this License.
	+
	+ 3. You may opt to apply the terms of the ordinary GNU General Public
	+License instead of this License to a given copy of the Library. To do
	+this, you must alter all the notices that refer to this License, so
	+that they refer to the ordinary GNU General Public License, version 2,
	+instead of to this License. (If a newer version than version 2 of the
	+ordinary GNU General Public License has appeared, then you can specify
	+that version instead if you wish.) Do not make any other change in
	+these notices.
	+
	+ Once this change is made in a given copy, it is irreversible for
	+that copy, so the ordinary GNU General Public License applies to all
	+subsequent copies and derivative works made from that copy.
	+
	+ This option is useful when you wish to copy part of the code of
	+the Library into a program that is not a library.
	+
	+ 4. You may copy and distribute the Library (or a portion or
	+derivative of it, under Section 2) in object code or executable form
	+under the terms of Sections 1 and 2 above provided that you accompany
	+it with the complete corresponding machine-readable source code, which
	+must be distributed under the terms of Sections 1 and 2 above on a
	+medium customarily used for software interchange.
	+
	+ If distribution of object code is made by offering access to copy
	+from a designated place, then offering equivalent access to copy the
	+source code from the same place satisfies the requirement to
	+distribute the source code, even though third parties are not
	+compelled to copy the source along with the object code.
	+
	+ 5. A program that contains no derivative of any portion of the
	+Library, but is designed to work with the Library by being compiled or
	+linked with it, is called a "work that uses the Library". Such a
	+work, in isolation, is not a derivative work of the Library, and
	+therefore falls outside the scope of this License.
	+
	+ However, linking a "work that uses the Library" with the Library
	+creates an executable that is a derivative of the Library (because it
	+contains portions of the Library), rather than a "work that uses the
	+library". The executable is therefore covered by this License.
	+Section 6 states terms for distribution of such executables.
	+
	+ When a "work that uses the Library" uses material from a header file
	+that is part of the Library, the object code for the work may be a
	+derivative work of the Library even though the source code is not.
	+Whether this is true is especially significant if the work can be
	+linked without the Library, or if the work is itself a library. The
	+threshold for this to be true is not precisely defined by law.
	+
	+ If such an object file uses only numerical parameters, data
	+structure layouts and accessors, and small macros and small inline
	+functions (ten lines or less in length), then the use of the object
	+file is unrestricted, regardless of whether it is legally a derivative
	+work. (Executables containing this object code plus portions of the
	+Library will still fall under Section 6.)
	+
	+ Otherwise, if the work is a derivative of the Library, you may
	+distribute the object code for the work under the terms of Section 6.
	+Any executables containing that work also fall under Section 6,
	+whether or not they are linked directly with the Library itself.
	+
	+ 6. As an exception to the Sections above, you may also combine or
	+link a "work that uses the Library" with the Library to produce a
	+work containing portions of the Library, and distribute that work
	+under terms of your choice, provided that the terms permit
	+modification of the work for the customer's own use and reverse
	+engineering for debugging such modifications.
	+
	+ You must give prominent notice with each copy of the work that the
	+Library is used in it and that the Library and its use are covered by
	+this License. You must supply a copy of this License. If the work
	+during execution displays copyright notices, you must include the
	+copyright notice for the Library among them, as well as a reference
	+directing the user to the copy of this License. Also, you must do one
	+of these things:
	+
	+ a) Accompany the work with the complete corresponding
	+ machine-readable source code for the Library including whatever
	+ changes were used in the work (which must be distributed under
	+ Sections 1 and 2 above); and, if the work is an executable linked
	+ with the Library, with the complete machine-readable "work that
	+ uses the Library", as object code and/or source code, so that the
	+ user can modify the Library and then relink to produce a modified
	+ executable containing the modified Library. (It is understood
	+ that the user who changes the contents of definitions files in the
	+ Library will not necessarily be able to recompile the application
	+ to use the modified definitions.)
	+
	+ b) Use a suitable shared library mechanism for linking with the
	+ Library. A suitable mechanism is one that (1) uses at run time a
	+ copy of the library already present on the user's computer system,
	+ rather than copying library functions into the executable, and (2)
	+ will operate properly with a modified version of the library, if
	+ the user installs one, as long as the modified version is
	+ interface-compatible with the version that the work was made with.
	+
	+ c) Accompany the work with a written offer, valid for at
	+ least three years, to give the same user the materials
	+ specified in Subsection 6a, above, for a charge no more
	+ than the cost of performing this distribution.
	+
	+ d) If distribution of the work is made by offering access to copy
	+ from a designated place, offer equivalent access to copy the above
	+ specified materials from the same place.
	+
	+ e) Verify that the user has already received a copy of these
	+ materials or that you have already sent this user a copy.
	+
	+ For an executable, the required form of the "work that uses the
	+Library" must include any data and utility programs needed for
	+reproducing the executable from it. However, as a special exception,
	+the materials to be distributed need not include anything that is
	+normally distributed (in either source or binary form) with the major
	+components (compiler, kernel, and so on) of the operating system on
	+which the executable runs, unless that component itself accompanies
	+the executable.
	+
	+ It may happen that this requirement contradicts the license
	+restrictions of other proprietary libraries that do not normally
	+accompany the operating system. Such a contradiction means you cannot
	+use both them and the Library together in an executable that you
	+distribute.
	+
	+ 7. You may place library facilities that are a work based on the
	+Library side-by-side in a single library together with other library
	+facilities not covered by this License, and distribute such a combined
	+library, provided that the separate distribution of the work based on
	+the Library and of the other library facilities is otherwise
	+permitted, and provided that you do these two things:
	+
	+ a) Accompany the combined library with a copy of the same work
	+ based on the Library, uncombined with any other library
	+ facilities. This must be distributed under the terms of the
	+ Sections above.
	+
	+ b) Give prominent notice with the combined library of the fact
	+ that part of it is a work based on the Library, and explaining
	+ where to find the accompanying uncombined form of the same work.
	+
	+ 8. You may not copy, modify, sublicense, link with, or distribute
	+the Library except as expressly provided under this License. Any
	+attempt otherwise to copy, modify, sublicense, link with, or
	+distribute the Library is void, and will automatically terminate your
	+rights under this License. However, parties who have received copies,
	+or rights, from you under this License will not have their licenses
	+terminated so long as such parties remain in full compliance.
	+
	+ 9. You are not required to accept this License, since you have not
	+signed it. However, nothing else grants you permission to modify or
	+distribute the Library or its derivative works. These actions are
	+prohibited by law if you do not accept this License. Therefore, by
	+modifying or distributing the Library (or any work based on the
	+Library), you indicate your acceptance of this License to do so, and
	+all its terms and conditions for copying, distributing or modifying
	+the Library or works based on it.
	+
	+ 10. Each time you redistribute the Library (or any work based on the
	+Library), the recipient automatically receives a license from the
	+original licensor to copy, distribute, link with or modify the Library
	+subject to these terms and conditions. You may not impose any further
	+restrictions on the recipients' exercise of the rights granted herein.
	+You are not responsible for enforcing compliance by third parties with
	+this License.
	+
	+ 11. If, as a consequence of a court judgment or allegation of patent
	+infringement or for any other reason (not limited to patent issues),
	+conditions are imposed on you (whether by court order, agreement or
	+otherwise) that contradict the conditions of this License, they do not
	+excuse you from the conditions of this License. If you cannot
	+distribute so as to satisfy simultaneously your obligations under this
	+License and any other pertinent obligations, then as a consequence you
	+may not distribute the Library at all. For example, if a patent
	+license would not permit royalty-free redistribution of the Library by
	+all those who receive copies directly or indirectly through you, then
	+the only way you could satisfy both it and this License would be to
	+refrain entirely from distribution of the Library.
	+
	+If any portion of this section is held invalid or unenforceable under any
	+particular circumstance, the balance of the section is intended to apply,
	+and the section as a whole is intended to apply in other circumstances.
	+
	+It is not the purpose of this section to induce you to infringe any
	+patents or other property right claims or to contest validity of any
	+such claims; this section has the sole purpose of protecting the
	+integrity of the free software distribution system which is
	+implemented by public license practices. Many people have made
	+generous contributions to the wide range of software distributed
	+through that system in reliance on consistent application of that
	+system; it is up to the author/donor to decide if he or she is willing
	+to distribute software through any other system and a licensee cannot
	+impose that choice.
	+
	+This section is intended to make thoroughly clear what is believed to
	+be a consequence of the rest of this License.
	+
	+ 12. If the distribution and/or use of the Library is restricted in
	+certain countries either by patents or by copyrighted interfaces, the
	+original copyright holder who places the Library under this License may add
	+an explicit geographical distribution limitation excluding those countries,
	+so that distribution is permitted only in or among countries not thus
	+excluded. In such case, this License incorporates the limitation as if
	+written in the body of this License.
	+
	+ 13. The Free Software Foundation may publish revised and/or new
	+versions of the Lesser General Public License from time to time.
	+Such new versions will be similar in spirit to the present version,
	+but may differ in detail to address new problems or concerns.
	+
	+Each version is given a distinguishing version number. If the Library
	+specifies a version number of this License which applies to it and
	+"any later version", you have the option of following the terms and
	+conditions either of that version or of any later version published by
	+the Free Software Foundation. If the Library does not specify a
	+license version number, you may choose any version ever published by
	+the Free Software Foundation.
	+
	+ 14. If you wish to incorporate parts of the Library into other free
	+programs whose distribution conditions are incompatible with these,
	+write to the author to ask for permission. For software which is
	+copyrighted by the Free Software Foundation, write to the Free
	+Software Foundation; we sometimes make exceptions for this. Our
	+decision will be guided by the two goals of preserving the free status
	+of all derivatives of our free software and of promoting the sharing
	+and reuse of software generally.
	+
	+ NO WARRANTY
	+
	+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
	+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
	+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
	+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
	+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
	+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
	+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
	+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
	+
	+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
	+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
	+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
	+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
	+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
	+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
	+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
	+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
	+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
	+DAMAGES.
	+
	+ END OF TERMS AND CONDITIONS
	\ No newline at end of file
	diff --git a/Makefile b/Makefile
	index 6180bf0..7b5b6a5 100644
	--- a/Makefile
	+++ b/Makefile
	@@ -1,59 +1,63 @@
	MIX = mix
	MYHTMLEX_CFLAGS = -g -O3 -std=c99 -pedantic -Wcomment -Wall
	# we need to compile position independent code
	MYHTMLEX_CFLAGS += -fpic -DPIC
	# myhtmlex is using stpcpy, as defined in gnu string.h
	# MYHTMLEX_CFLAGS += -D_GNU_SOURCE
	# base on the same posix c source as myhtml
	# MYHTMLEX_CFLAGS += -D_POSIX_C_SOURCE=199309
	# turn warnings into errors
	# MYHTMLEX_CFLAGS += -Werror
	# ignore unused variables
	# MYHTMLEX_CFLAGS += -Wno-unused-variable
	# ignore unused parameter warnings
	MYHTMLEX_CFLAGS += -Wno-unused-parameter

	# set erlang include path
	ERLANG_PATH = $(shell erl -eval 'io:format("~s", [lists:concat([code:root_dir(), "/erts-", erlang:system_info(version), "/include"])])' -s init stop -noshell)
	MYHTMLEX_CFLAGS += -I$(ERLANG_PATH)

	# expecting myhtml fetched as a mix dependency
	-MYHTML_PATH = deps/myhtml
	+ifeq ($(wildcard c_src/myhtml),)
	+ MYHTML_PATH = deps/myhtml
	+else
	+ MYHTML_PATH = c_src/myhtml
	+endif
	MYHTML_STATIC = $(MYHTML_PATH)/lib/libmyhtml_static.a
	MYHTMLEX_CFLAGS += -I$(MYHTML_PATH)/include

	# that would be used for a dynamically linked build
	# MYHTMLEX_CFLAGS += -L$(MYHTML_PATH)/lib

	MYHTMLEX_LDFLAGS = -shared

	# platform specific
	UNAME = $(shell uname -s)
	ifeq ($(wilcard Makefile.$(UNAME)),)
	include Makefile.$(UNAME)
	endif

	.PHONY: all myhtmlex

	all: myhtmlex

	myhtmlex: priv/myhtmlex.so
	$(MIX) compile

	deps/myhtml:
	$(MIX) deps.get

	-$(MYHTML_STATIC): deps/myhtml
	+$(MYHTML_STATIC): $(MYHTML_PATH)
	$(MAKE) -C $(MYHTML_PATH) library

	priv/myhtmlex.so: src/myhtmlex.c $(MYHTML_STATIC)
	test -d priv \|\| mkdir priv
	$(CC) $(MYHTMLEX_CFLAGS) $(MYHTMLEX_LDFLAGS) -o $@ $< $(MYHTML_STATIC)

	clean:
	$(MIX) clean
	$(RM) priv/myhtmlex.so

	clean-myhtml:
	$(MAKE) -C $(MYHTML_PATH) clean

	diff --git a/c_src/myhtml b/c_src/myhtml
	new file mode 160000
	index 0000000..fe2cf57
	--- /dev/null
	+++ b/c_src/myhtml
	@@ -0,0 +1 @@
	+Subproject commit fe2cf577570666d058a2b7167c26d3384a758e19
	diff --git a/lib/myhtmlex.ex b/lib/myhtmlex.ex
	index 2369eaa..9c41d7f 100644
	--- a/lib/myhtmlex.ex
	+++ b/lib/myhtmlex.ex
	@@ -1,21 +1,149 @@
	defmodule Myhtmlex do
	+ @moduledoc """
	+ A module to decode html into a tree structure.
	+
	+ Based on [Alexander Borisov's myhtml](https://github.com/lexborisov/myhtml),
	+ this binding gains the properties of being html-spec compliant and very fast.
	+
	+ ## Example
	+
	+ iex> Myhtmlex.decode("<h1>Hello world</h1>")
	+ {"html", [], [{"head", [], []}, {"body", [], [{"h1", [], ["Hello world"]}]}]}
	+
	+ Benchmark results on various file sizes on a 2,5Ghz Core i7:
	+
	+ Settings:
	+ duration: 1.0 s
	+
	+ ## FileSizesBench
	+ [15:28:42] 1/3: github_trending_js.html 341k
	+ [15:28:46] 2/3: w3c_html5.html 131k
	+ [15:28:48] 3/3: wikipedia_hyperlink.html 97k
	+
	+ Finished in 7.52 seconds
	+
	+ ## FileSizesBench
	+ benchmark name iterations average time
	+ wikipedia_hyperlink.html 97k 1000 1385.86 µs/op
	+ w3c_html5.html 131k 1000 2179.30 µs/op
	+ github_trending_js.html 341k 500 5686.21 µs/op
	+
	+ ## Thoughts
	+
	+ I need to a fast html-parsing library in Erlang/Elixir.
	+ So falling back to c, and to myhtml especially, is a natural move.
	+
	+ But Erlang interoperability is a tricky mine-field.
	+ This increase in parsing speed does not come for free.
	+
	+ The current implementation can be considered a proof-of-concept.
	+ The myhtml code is called as a dirty-nif and executed inside the Erlang-VM.
	+ Thus completely giving up the safety of the Erlang-VM. I am not saying that myhtml is unsafe, but
	+ the slightest Segfault brings down the whole Erlang-VM.
	+ So, I consider this mode of operation unsafe, and not recommended for production use.
	+
	+ The other option, that I have on my roadmap, is to call into a C-Node.
	+ A separate OS-process that receives calls from erlang and returns to the calling process.
	+
	+ Another option is to call into a Port driver.
	+ A separate OS-process that communicates via stdin/stdout.
	+
	+ So to recap, I want a fast and safe html-parsing library for Erlang/Elixir.
	+
	+ Not quite there, yet.
	+ """
	+
	+ @type tag() :: String.t \| atom()
	+ @type attr() :: {String.t, String.t}
	+ @type attr_list() :: [] \| [attr()]
	+ @type comment_node() :: {:comment, String.t}
	+ @type comment_node3() :: {:comment, [], String.t}
	+ @type tree() :: {tag(), attr_list(), tree()}
	+ \| {tag(), attr_list(), nil}
	+ \| comment_node()
	+ \| comment_node3()
	+ @type format_flag() :: :html_atoms \| :nil_self_closing \| :comment_tuple3
	+
	+ @doc """
	+ Returns a tree representation from the given html string.
	+
	+ ## Examples
	+
	+ iex> Myhtmlex.decode("<h1>Hello world</h1>")
	+ {"html", [], [{"head", [], []}, {"body", [], [{"h1", [], ["Hello world"]}]}]}
	+
	+ iex> Myhtmlex.decode("<span class='hello'>Hi there</span>")
	+ {"html", [],
	+ [{"head", [], []},
	+ {"body", [], [{"span", [{"class", "hello"}], ["Hi there"]}]}]}
	+
	+ iex> Myhtmlex.decode("<body><!-- a comment --!></body>")
	+ {"html", [], [{"head", [], []}, {"body", [], [comment: " a comment "]}]}
	+
	+ iex> Myhtmlex.decode("<br>")
	+ {"html", [], [{"head", [], []}, {"body", [], [{"br", [], []}]}]}
	+ """
	+ @spec decode(String.t) :: tree()
	def decode(bin) do
	Myhtmlex.Decoder.decode(bin)
	end

	+ @doc """
	+ Returns a tree representation from the given html string.
	+
	+ This variant allows you to pass in one or more of the following format flags:
	+
	+ * `:html_atoms` uses atoms for known html tags (faster), binaries for everything else.
	+ * `:nil_self_closing` uses `nil` to designate self-closing tags and void elements.
	+ For example `<br>` is then being represented like `{"br", [], nil}`.
	+ See http://w3c.github.io/html-reference/syntax.html#void-elements for a full list of void elements.
	+ * `:comment_tuple3` uses 3-tuple elements for comments, instead of the default 2-tuple element.
	+
	+ ## Examples
	+
	+ iex> Myhtmlex.decode("<h1>Hello world</h1>", format: [:html_atoms])
	+ {:html, [], [{:head, [], []}, {:body, [], [{:h1, [], ["Hello world"]}]}]}
	+
	+ iex> Myhtmlex.decode("<br>", format: [:nil_self_closing])
	+ {"html", [], [{"head", [], []}, {"body", [], [{"br", [], nil}]}]}
	+
	+ iex> Myhtmlex.decode("<body><!-- a comment --!></body>", format: [:comment_tuple3])
	+ {"html", [], [{"head", [], []}, {"body", [], [{:comment, [], " a comment "}]}]}
	+
	+ iex> html = "<body><!-- a comment --!><unknown /></body>"
	+ iex> Myhtmlex.decode(html, format: [:html_atoms, :nil_self_closing, :comment_tuple3])
	+ {:html, [],
	+ [{:head, [], []},
	+ {:body, [], [{:comment, " a comment "}, {"unknown", [], nil}]}]}
	+
	+ """
	+ @spec decode(String.t, format: [format_flag()]) :: tree()
	def decode(bin, format: flags) do
	Myhtmlex.Decoder.decode(bin, flags)
	end

	+ @doc """
	+ Returns a reference to an internally parsed myhtml_tree_t.
	+ """
	+ @spec open(String.t) :: reference()
	def open(bin) do
	Myhtmlex.Decoder.open(bin)
	end

	- def decode_tree(tree) do
	- Myhtmlex.Decoder.decode_tree(tree)
	+ @doc """
	+ Returns a tree representation from the given reference. See `decode/1` for example output.
	+ """
	+ @spec decode_tree(reference()) :: tree()
	+ def decode_tree(ref) do
	+ Myhtmlex.Decoder.decode_tree(ref)
	end

	- def decode_tree(tree, format: flags) do
	- Myhtmlex.Decoder.decode_tree(tree, flags)
	+ @doc """
	+ Returns a tree representation from the given reference. See `decode/2` for options and example output.
	+ """
	+ @spec decode_tree(reference(), format: [format_flag()]) :: tree()
	+ def decode_tree(ref, format: flags) do
	+ Myhtmlex.Decoder.decode_tree(ref, flags)
	end
	end
	+
	diff --git a/lib/myhtmlex/decoder.ex b/lib/myhtmlex/decoder.ex
	index 2516cf5..ed9d642 100644
	--- a/lib/myhtmlex/decoder.ex
	+++ b/lib/myhtmlex/decoder.ex
	@@ -1,26 +1,27 @@
	defmodule Myhtmlex.Decoder do
	+ @moduledoc false
	@on_load { :init, 0 }

	app = Mix.Project.config[:app]

	def init do
	path = :filename.join(:code.priv_dir(unquote(app)), 'myhtmlex')
	:ok = :erlang.load_nif(path, 0)
	end

	@spec decode(bin :: String.t) :: {atom(), list(), list()}
	def decode(bin)
	def decode(_), do: exit(:nif_library_not_loaded)

	def decode(bin, flags)
	def decode(_, _), do: exit(:nif_library_not_loaded)

	def open(bin)
	def open(_), do: exit(:nif_library_not_loaded)

	def decode_tree(tree)
	def decode_tree(_), do: exit(:nif_library_not_loaded)

	def decode_tree(tree, flags)
	def decode_tree(_, _), do: exit(:nif_library_not_loaded)
	end
	diff --git a/lib/myhtmlex/doc.ex b/lib/myhtmlex/doc.ex
	deleted file mode 100644
	index 2697056..0000000
	--- a/lib/myhtmlex/doc.ex
	+++ /dev/null
	@@ -1,18 +0,0 @@
	-defmodule Myhtmlex.Doc do
	- defstruct ref: nil, source: nil
	-end
	-
	-defimpl Inspect, for: Myhtmlex.Doc do
	- import Inspect.Algebra
	-
	- def inspect(%Myhtmlex.Doc{source: source}, opts) do
	- cut = String.slice(source, 0..60)
	- cut = if String.length(cut) < String.length(source) do
	- "#{cut}..."
	- else
	- cut
	- end
	- concat ["#Myhtmlex.Doc<source: ", to_doc(cut, opts), ">"]
	- end
	-end
	-
	diff --git a/mix.exs b/mix.exs
	index 70a42c6..b7084e7 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,48 +1,71 @@
	defmodule Mix.Tasks.Compile.Myhtml do
	def run(_) do
	if match? {:win32, _}, :os.type do
	IO.warn "Windows is not yet a target."
	exit(1)
	else
	- File.mkdir_p("priv")
	{result, _error_code} = System.cmd("make", ["priv/myhtmlex.so"], stderr_to_stdout: true)
	IO.binwrite result
	end
	:ok
	end
	end

	defmodule Myhtmlex.Mixfile do
	use Mix.Project

	def project do
	[
	app: :myhtmlex,
	version: "0.1.0",
	elixir: "~> 1.5",
	compilers: [:myhtml, :elixir, :app],
	start_permanent: Mix.env == :prod,
	+ description: "A module to decode HTML into a tree, porting all properties of the underlying library myhtml, being fast and correct in regards to the html spec.",
	+ package: package(),
	deps: deps()
	]
	end

	+ def package do
	+ [
	+ maintainers: ["Lukas Rieder"],
	+ licenses: ["GNU LGPL"],
	+ links: %{
	+ "Github" => "https://github.com/Overbryd/myhtmlex",
	+ "Issues" => "https://github.com/Overbryd/myhtmlex/issues",
	+ "MyHTML" => "https://github.com/lexborisov/myhtml"
	+ },
	+ files: [
	+ "lib",
	+ "src",
	+ "c_src",
	+ "Makefile",
	+ "Makefile.Darwin",
	+ "Makefile.Linux",
	+ "mix.exs",
	+ "README.md",
	+ "LICENSE"
	+ ]
	+ ]
	+ end
	+
	# Run "mix help compile.app" to learn about applications.
	def application do
	[
	extra_applications: [:logger]
	]
	end

	# Run "mix help deps" to learn about dependencies.
	defp deps do
	[
	- # myhtml c library
	- {:myhtml, github: "Overbryd/myhtml", branch: "feat/node-is-void-element", app: false},
	- # {:myhtml, github: "lexborisov/myhtml", tag: "v4.0.2", app: false},
	+ # in dev environment, manage myhtml c library with mix
	+ {:myhtml, github: "lexborisov/myhtml", branch: "master", app: false, only: :dev},
	# documentation helpers
	{:ex_doc, ">= 0.0.0", only: :dev},
	# benchmarking helpers
	{:benchfella, "~> 0.3.0", only: :dev}
	]
	end
	end
	diff --git a/mix.lock b/mix.lock
	index c600c08..ddb538a4 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,4 +1,4 @@
	%{"benchfella": {:hex, :benchfella, "0.3.5", "b2122c234117b3f91ed7b43b6e915e19e1ab216971154acd0a80ce0e9b8c05f5", [], [], "hexpm"},
	"earmark": {:hex, :earmark, "1.2.3", "206eb2e2ac1a794aa5256f3982de7a76bf4579ff91cb28d0e17ea2c9491e46a4", [], [], "hexpm"},
	"ex_doc": {:hex, :ex_doc, "0.16.3", "cd2a4cfe5d26e37502d3ec776702c72efa1adfa24ed9ce723bb565f4c30bd31a", [], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}], "hexpm"},
	- "myhtml": {:git, "https://github.com/Overbryd/myhtml.git", "697d2aad1392ef555fd3d632674d7ad7717d1e6a", [branch: "feat/node-is-void-element"]}}
	+ "myhtml": {:git, "https://github.com/lexborisov/myhtml.git", "fe2cf577570666d058a2b7167c26d3384a758e19", [branch: "master"]}}
	diff --git a/src/myhtmlex.c b/src/myhtmlex.c
	index bc4e070..2fde6b0 100644
	--- a/src/myhtmlex.c
	+++ b/src/myhtmlex.c
	@@ -1,423 +1,428 @@
	#include "myhtmlex.h"

	char*
	lowercase(char* c)
	{
	char* p = c;
	while(*p)
	{
	p = tolower((unsigned char)p);
	p++;
	}
	return c;
	}

	ERL_NIF_TERM
	make_atom(ErlNifEnv* env, const char* name)
	{
	ERL_NIF_TERM ret;
	if(enif_make_existing_atom(env, name, &ret, ERL_NIF_LATIN1)) {
	return ret;
	}
	return enif_make_atom(env, name);
	}

	ERL_NIF_TERM
	nif_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
	ERL_NIF_TERM result;
	myhtmlex_ref_t* ref;

	// fetch nif state
	myhtmlex_state_t* state = (myhtmlex_state_t*) enif_priv_data(env);

	// placeholder for the html binary we want to read from erlang caller
	ErlNifBinary html_bin;
	// read binary into &html_bin from argv[0] (first argument)
	if (!enif_inspect_iolist_as_binary(env, argv[0], &html_bin))
	{
	// blame the user if html_bin is not a binary
	return enif_make_badarg(env);
	}

	ref = enif_alloc_resource(state->myhtml_tree_rt, sizeof(myhtmlex_ref_t));
	ref->tree = myhtml_tree_create();
	myhtml_tree_init(ref->tree, state->myhtml);
	mystatus_t status = myhtml_parse(ref->tree, MyENCODING_UTF_8, (char*) html_bin.data, (size_t) html_bin.size);
	if (status != MyHTML_STATUS_OK)
	{
	// TODO: what is the correct reaction for a not ok state?
	return enif_make_badarg(env);
	}
	ref->root = myhtml_tree_get_document(ref->tree);

	result = enif_make_resource(env, ref);
	return result;
	}

	ERL_NIF_TERM
	nif_decode_tree(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
	ERL_NIF_TERM result;
	myhtmlex_ref_t* ref;
	unsigned char parse_flags = 0;

	// fetch nif state
	myhtmlex_state_t* state = (myhtmlex_state_t*) enif_priv_data(env);

	// fetch reference
	if (!enif_get_resource(env, argv[0], state->myhtml_tree_rt, (void **) &ref))
	{
	return enif_make_badarg(env);
	}
	// we should have received format flags in a list
	if (argc == 2)
	{
	if (!enif_is_list(env, argv[1]))
	{
	// blame the user if second argument is not a list
	return enif_make_badarg(env);
	}
	parse_flags = read_parse_flags(env, &argv[1]);
	}

	// build erlang tree
	result = build_tree(env, ref->tree, myhtml_node_last_child(ref->root), &parse_flags);

	// return tree to erlang
	return result;
	}

	ERL_NIF_TERM
	nif_decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
	ERL_NIF_TERM result;
	unsigned char parse_flags = 0;

	// fetch nif state
	myhtmlex_state_t* state = (myhtmlex_state_t*) enif_priv_data(env);

	// placeholder for the html binary we want to read from erlang caller
	ErlNifBinary html_bin;
	// read binary into &html_bin from argv[0] (first argument)
	if (argc < 1 \|\| !enif_inspect_iolist_as_binary(env, argv[0], &html_bin))
	{
	// blame the user if html_bin is not a binary
	return enif_make_badarg(env);
	}
	// we should have received format flags in a list
	if (argc == 2)
	{
	if (!enif_is_list(env, argv[1]))
	{
	// blame the user if second argument is not a list
	return enif_make_badarg(env);
	}
	parse_flags = read_parse_flags(env, &argv[1]);
	}

	// parse html into tree
	// use parse_single for now, threaded mode is buggy with some files
	mystatus_t status = myhtml_parse(state->tree, MyENCODING_UTF_8, (char*) html_bin.data, (size_t) html_bin.size);
	if (status != MyHTML_STATUS_OK)
	{
	// TODO: what is the correct reaction for a not ok state?
	return enif_make_badarg(env);
	}

	// build erlang tree
	myhtml_tree_node_t *root = myhtml_tree_get_document(state->tree);
	result = build_tree(env, state->tree, myhtml_node_last_child(root), &parse_flags);

	// return tree to erlang
	return result;
	}

	unsigned char
	read_parse_flags(ErlNifEnv* env, const ERL_NIF_TERM* options)
	{
	unsigned char parse_flags = 0;
	ERL_NIF_TERM flag;

	// only look at 2 flags max (more are not implemented yet)
	for (int i = 0; i < 2; i++)
	{
	if (!enif_get_list_cell(env, options, &flag, (ERL_NIF_TERM)options)) break;
	if (!enif_is_atom(env, flag)) return enif_make_badarg(env);
	// set parse flags
	if (enif_compare(flag, ATOM_HTML_ATOMS) == 0)
	{
	parse_flags \|= FLAG_HTML_ATOMS;
	}
	else if (enif_compare(flag, ATOM_NIL_SELF_CLOSING) == 0)
	{
	parse_flags \|= FLAG_NIL_SELF_CLOSING;
	}
	+ else if (enif_compare(flag, ATOM_COMMENT_TUPLE3) == 0)
	+ {
	+ parse_flags \|= FLAG_COMMENT_TUPLE3;
	+ }
	}

	return parse_flags;
	}

	ERL_NIF_TERM
	build_node_children(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* parent, unsigned char* parse_flags)
	{
	if (myhtml_node_is_close_self(parent) && (*parse_flags & FLAG_NIL_SELF_CLOSING))
	{
	return ATOM_NIL;
	}

	myhtml_tree_node_t* child = myhtml_node_last_child(parent);
	if (child == NULL)
	{
	if (myhtml_node_is_void_element(parent) && (*parse_flags & FLAG_NIL_SELF_CLOSING))
	{
	return ATOM_NIL;
	}
	else
	{
	return EMPTY_LIST;
	}
	}

	ERL_NIF_TERM list = enif_make_list(env, 0);

	while (child)
	{
	ERL_NIF_TERM node_tuple = build_tree(env, tree, child, parse_flags);
	list = enif_make_list_cell(env, node_tuple, list);

	// get previous child, building the list from reverse
	child = myhtml_node_prev(child);
	}

	return list;
	}

	ERL_NIF_TERM
	build_node_attrs(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* node)
	{
	myhtml_tree_attr_t* attr = myhtml_node_attribute_last(node);
	if (attr == NULL)
	{
	return EMPTY_LIST;
	}

	ERL_NIF_TERM list = enif_make_list(env, 0);

	while (attr)
	{
	ErlNifBinary name;
	ERL_NIF_TERM name_bin;
	ErlNifBinary value;
	ERL_NIF_TERM value_bin;
	ERL_NIF_TERM attr_tuple;

	size_t attr_name_len;
	const char *attr_name = myhtml_attribute_key(attr, &attr_name_len);
	size_t attr_value_len;
	const char *attr_value = myhtml_attribute_value(attr, &attr_value_len);

	if (attr_value) {
	enif_alloc_binary(attr_value_len, &value);
	memcpy(value.data, attr_value, attr_value_len);
	value_bin = enif_make_binary(env, &value);
	} else {
	enif_alloc_binary(attr_name_len, &value);
	memcpy(value.data, attr_name, attr_name_len);
	value_bin = enif_make_binary(env, &value);
	}
	enif_alloc_binary(attr_name_len, &name);
	memcpy(name.data, attr_name, attr_name_len);
	name_bin = enif_make_binary(env, &name);

	attr_tuple = enif_make_tuple2(env, name_bin, value_bin);
	list = enif_make_list_cell(env, attr_tuple, list);

	// get prev attribute, building the list from reverse
	attr = myhtml_attribute_prev(attr);
	}

	return list;
	}

	ERL_NIF_TERM
	build_tree(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* node, unsigned char* parse_flags)
	{
	ERL_NIF_TERM result;
	myhtml_tag_id_t tag_id = myhtml_node_tag_id(node);
	myhtml_namespace_t tag_ns = myhtml_node_namespace(node);

	if (tag_id == MyHTML_TAG__TEXT)
	{
	ErlNifBinary text;
	size_t text_len;
	const char* node_text = myhtml_node_text(node, &text_len);
	enif_alloc_binary(text_len, &text);
	memcpy(text.data, node_text, text_len);

	result = enif_make_binary(env, &text);
	}
	else if (tag_id == MyHTML_TAG__COMMENT)
	{
	ErlNifBinary comment;
	size_t comment_len;
	const char* node_comment = myhtml_node_text(node, &comment_len);
	enif_alloc_binary(comment_len, &comment);
	memcpy(comment.data, node_comment, comment_len);

	if (*parse_flags & FLAG_COMMENT_TUPLE3)
	{
	result = enif_make_tuple3(env,
	ATOM_COMMENT,
	EMPTY_LIST,
	enif_make_binary(env, &comment)
	);
	}
	else
	{
	result = enif_make_tuple2(env, ATOM_COMMENT, enif_make_binary(env, &comment));
	}
	}
	else
	{
	ERL_NIF_TERM tag;
	ERL_NIF_TERM children;
	ERL_NIF_TERM attrs;

	// get name of tag
	size_t tag_name_len;
	const char *tag_name = myhtml_tag_name_by_id(tree, tag_id, &tag_name_len);
	// get namespace of tag
	size_t tag_ns_len;
	const char *tag_ns_name_ptr = myhtml_namespace_name_by_id(tag_ns, &tag_ns_len);
	char *tag_ns_buffer;
	char buffer [tag_ns_len + tag_name_len + 1];
	char *tag_string = buffer;
	size_t tag_string_len;

	if (tag_ns != MyHTML_NAMESPACE_HTML)
	{
	// tag_ns_name_ptr is unmodifyable, copy it in our tag_ns_buffer to make it modifyable.
	tag_ns_buffer = malloc(tag_ns_len);
	strcpy(tag_ns_buffer, tag_ns_name_ptr);
	// lowercase tag buffer (can be removed, just a nice to have)
	tag_ns_buffer = lowercase(tag_ns_buffer);
	// prepend namespace to tag name, e.g. "svg:path"
	stpcpy(stpcpy(stpcpy(tag_string, tag_ns_buffer), ":"), tag_name);
	tag_string_len = tag_ns_len + tag_name_len + 1; // +1 for colon
	}
	else
	{
	stpcpy(tag_string, tag_name);
	tag_string_len = tag_name_len;
	}

	// put unknown and non-html tags it in a binary
	if (!(*parse_flags & FLAG_HTML_ATOMS) \|\| (tag_id == MyHTML_TAG__UNDEF \|\| tag_id == MyHTML_TAG_LAST_ENTRY \|\| tag_ns != MyHTML_NAMESPACE_HTML))
	{
	ErlNifBinary tag_b;
	enif_alloc_binary(tag_string_len, &tag_b);
	memcpy(tag_b.data, tag_string, tag_string_len);
	tag = enif_make_binary(env, &tag_b);
	}
	else
	{
	tag = make_atom(env, tag_string);
	}

	// attributes
	attrs = build_node_attrs(env, tree, node);

	// add children or nil as a self-closing flag
	children = build_node_children(env, tree, node, parse_flags);

	// free allocated resources
	if (tag_ns != MyHTML_NAMESPACE_HTML)
	{
	free(tag_ns_buffer);
	}

	result = enif_make_tuple3(env,
	tag,
	attrs,
	children
	);
	}

	return result;
	}

	void
	nif_cleanup_myhtmlex_ref(ErlNifEnv* env, void* obj)
	{
	myhtmlex_ref_t* ref = (myhtmlex_ref_t*) obj;
	// release myhtml resources
	myhtml_tree_destroy(ref->tree);
	}

	// Erlang NIF

	static int
	load(ErlNifEnv env, void *priv, ERL_NIF_TERM info)
	{
	myhtmlex_state_t* state = enif_alloc(sizeof(myhtmlex_state_t));
	if (state == NULL)
	{
	return 1;
	}

	state->myhtml_tree_rt = enif_open_resource_type(
	env,
	NULL,
	"myhtmlex_ref_t",
	&nif_cleanup_myhtmlex_ref,
	ERL_NIF_RT_CREATE \| ERL_NIF_RT_TAKEOVER,
	NULL
	);
	ATOM_NIL = make_atom(env, "nil");
	ATOM_COMMENT = make_atom(env, "comment");
	ATOM_HTML_ATOMS = make_atom(env, "html_atoms");
	ATOM_NIL_SELF_CLOSING = make_atom(env, "nil_self_closing");
	+ ATOM_COMMENT_TUPLE3 = make_atom(env, "comment_tuple3");
	EMPTY_LIST = enif_make_list(env, 0);

	// myhtml basic init
	state->myhtml = myhtml_create();
	myhtml_init(state->myhtml, MyHTML_OPTIONS_DEFAULT, 1, 0);
	state->tree = myhtml_tree_create();
	myhtml_tree_init(state->tree, state->myhtml);

	priv = (void) state;
	return 0;
	}

	static int
	reload(ErlNifEnv env, void *priv, ERL_NIF_TERM info)
	{
	return 0;
	}

	static int
	upgrade(ErlNifEnv env, void priv, void *old_priv, ERL_NIF_TERM info)
	{
	return load(env, priv, info);
	}

	static void
	unload(ErlNifEnv env, void priv)
	{
	myhtmlex_state_t* state = (myhtmlex_state_t*) priv;

	myhtml_tree_destroy(state->tree);
	myhtml_destroy(state->myhtml);
	enif_free(priv);
	return;
	}

	static ErlNifFunc funcs[] =
	{
	{"decode", 1, nif_decode, ERL_NIF_DIRTY_JOB_CPU_BOUND},
	{"decode", 2, nif_decode, ERL_NIF_DIRTY_JOB_CPU_BOUND},
	{"open", 1, nif_open, ERL_NIF_DIRTY_JOB_CPU_BOUND},
	{"decode_tree", 1, nif_decode_tree, ERL_NIF_DIRTY_JOB_CPU_BOUND},
	{"decode_tree", 2, nif_decode_tree, ERL_NIF_DIRTY_JOB_CPU_BOUND}
	};

	ERL_NIF_INIT(Elixir.Myhtmlex.Decoder, funcs, &load, &reload, &upgrade, &unload)

	diff --git a/src/myhtmlex.h b/src/myhtmlex.h
	index 83b39b7..b11c2cd 100644
	--- a/src/myhtmlex.h
	+++ b/src/myhtmlex.h
	@@ -1,55 +1,56 @@
	#ifndef MYHTMLEX_H
	#define MYHTMLEX_H

	#include <stdlib.h>
	#include <ctype.h>
	#include <string.h>
	#include "erl_nif.h"
	#include <myhtml/myhtml.h>
	#include <myhtml/mynamespace.h>

	char*
	lowercase(char* c);
	// myhtmlex.c
	ERL_NIF_TERM
	make_atom(ErlNifEnv* env, const char* name);
	ERL_NIF_TERM
	nif_decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
	ERL_NIF_TERM
	nif_decode_tree(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
	ERL_NIF_TERM
	nif_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
	ERL_NIF_TERM
	build_node_attrs(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* node);
	ERL_NIF_TERM
	build_tree(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* node, unsigned char* flags);
	ERL_NIF_TERM
	build_node_children(ErlNifEnv* env, myhtml_tree_t* tree, myhtml_tree_node_t* node, unsigned char* flags);
	void
	nif_cleanup_myhtml_tree(ErlNifEnv* env, void* obj);
	unsigned char
	read_parse_flags(ErlNifEnv* env, const ERL_NIF_TERM* options);

	// consts
	ERL_NIF_TERM ATOM_NIL;
	ERL_NIF_TERM ATOM_COMMENT;
	ERL_NIF_TERM ATOM_HTML_ATOMS;
	ERL_NIF_TERM ATOM_NIL_SELF_CLOSING;
	+ERL_NIF_TERM ATOM_COMMENT_TUPLE3;
	ERL_NIF_TERM EMPTY_LIST;
	const unsigned char FLAG_HTML_ATOMS = 1 << 0;
	const unsigned char FLAG_NIL_SELF_CLOSING = 1 << 1;
	const unsigned char FLAG_COMMENT_TUPLE3 = 1 << 2;

	typedef struct {
	myhtml_t* myhtml;
	myhtml_tree_t* tree;

	ErlNifResourceType* myhtml_tree_rt;
	} myhtmlex_state_t;

	typedef struct {
	myhtml_tree_t* tree;
	myhtml_tree_node_t *root;
	} myhtmlex_ref_t;

	#endif // included myhtmlex.h
	diff --git a/test/myhtmlex_test.exs b/test/myhtmlex_test.exs
	index 0a693d0..9f3a2f1 100644
	--- a/test/myhtmlex_test.exs
	+++ b/test/myhtmlex_test.exs
	@@ -1,122 +1,132 @@
	defmodule MyhtmlexTest do
	use ExUnit.Case
	doctest Myhtmlex

	test "builds a tree, formatted like mochiweb by default" do
	assert {"html", [], [
	{"head", [], []},
	{"body", [], [
	{"br", [], []}
	]}
	]} = Myhtmlex.decode("<br>")
	end

	test "builds a tree, html tags as atoms" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{:br, [], []}
	]}
	]} = Myhtmlex.decode("<br>", format: [:html_atoms])
	end

	test "builds a tree, nil self closing" do
	assert {"html", [], [
	{"head", [], []},
	{"body", [], [
	{"br", [], nil},
	{"esi:include", [], nil}
	]}
	]} = Myhtmlex.decode("<br><esi:include />", format: [:nil_self_closing])
	end

	test "builds a tree, multiple format options" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{:br, [], nil}
	]}
	]} = Myhtmlex.decode("<br>", format: [:html_atoms, :nil_self_closing])
	end

	test "attributes" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{:span, [{"id", "test"}, {"class", "foo garble"}], []}
	]}
	]} = Myhtmlex.decode(~s'<span id="test" class="foo garble"></span>', format: [:html_atoms])
	end

	test "single attributes" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{:button, [{"disabled", "disabled"}, {"class", "foo garble"}], []}
	]}
	]} = Myhtmlex.decode(~s'<button disabled class="foo garble"></span>', format: [:html_atoms])
	end

	test "text nodes" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	"text node"
	]}
	]} = Myhtmlex.decode(~s'<body>text node</body>', format: [:html_atoms])
	end

	test "broken input" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{:a, [{"<", "<"}], [" asdf"]}
	]}
	]} = Myhtmlex.decode(~s'<a <> asdf', format: [:html_atoms])
	end

	test "open" do
	ref = Myhtmlex.open(~s'<dif class="a"></div><div class="b"></div>')
	assert is_reference(ref)
	end

	test "open and decode_tree" do
	ref = Myhtmlex.open(~s'text node')
	assert is_reference(ref)
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	"text node"
	]}
	]} = Myhtmlex.decode_tree(ref, format: [:html_atoms])
	end

	test "namespaced tags" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{"svg:svg", [], [
	{"svg:path", [], []},
	{"svg:a", [], []}
	]}
	]}
	]} = Myhtmlex.decode(~s'<svg><path></path><a></a></svg>', format: [:html_atoms])
	end

	test "custom namespaced tags" do
	assert {:html, [], [
	{:head, [], []},
	{:body, [], [
	{"esi:include", [], nil}
	]}
	]} = Myhtmlex.decode(~s'<esi:include />', format: [:html_atoms, :nil_self_closing])
	end

	- test "open this nasty github file (works fine in parse single, parse threaded hangs)" do
	+ test "html comments" do
	+ assert {:html, [], [
	+ {:head, [], []},
	+ {:body, [], [
	+ comment: " a comment "
	+ ]}
	+ ]} = Myhtmlex.decode(~s'<body><!-- a comment --></body>', format: [:html_atoms])
	+ end
	+
	+ test "parse a larger file (131K)" do
	html = File.read!("bench/github_trending_js.html")
	ref = Myhtmlex.open(html)
	assert is_reference(ref)
	+ assert is_tuple(Myhtmlex.decode_tree(ref))
	end

	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jan 20, 11:35 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55568
Default Alt Text: (53 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions