weaver 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 64d0021b8ab6a2f1c556c7708d40daa45c13b508
-  data.tar.gz: c3b8f985efa4e770335708c0f59653de2fab749e
+SHA256:
+  metadata.gz: 58b4fd7e453a9af4450002b361dd04c8470bf5df46c0efa0b2fa22d5b6ba0291
+  data.tar.gz: cb2eab30ee9995f172650fb38ea2eb8425518b930712018b8e8d155544aa6231
 SHA512:
-  metadata.gz: 4e5339d77dcd36e560dd84ce6448a81fd07837d4a1da90a8cbbe94f38e52bff1634f40d50aa698278b4d3b460c467269aa5f0fc16283fabf3e5ce7ab62958f67
-  data.tar.gz: 9d04d3c42cc0a707d9302dac8c47b2f2911d5807b1a1a8c82c0a2b030af2c330b0f156b03d48915aa5bd2416664d8107161f74ed5593e8394b588aa8bc55ac54
+  metadata.gz: 9fcf769a71319280c0b2b0373baaf22547d7e09d250513d3dcc033c09c7b18915dc86ab97f683b286e7fcc5906791bc6e7db8a044ea0bcf901fe49a5d3a5d0d8
+  data.tar.gz: 8ac7ecf0c589fed852fd973395d056f867d444e5c77ab5576b689d6402086f730bce10ed5866136904ee8f247b1bb9a5a83fbbb6e4894cefa16a8d607ae32982

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "weaver"
+require 'bundler/setup'
+require 'weaver'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "weaver"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/exe/weaver

@@ -5,160 +5,150 @@ require 'optimist'
 require 'sinatra/base'
 
 class Website < Sinatra::Base
+  set :static, true # set up static file routing
+  set :public_folder, File.join(Gem.loaded_specs['weaver'].full_gem_path, 'data', 'weaver')	# set up the static dir (with images/js/css inside)
+  set :bind, '0.0.0.0'
+  set :port, ENV['PORT'] || 4567
 
-	set :static, true 							# set up static file routing
-	set :public_folder, File.join(Gem.loaded_specs['weaver'].full_gem_path, "data", "weaver")	# set up the static dir (with images/js/css inside)
-	set :bind, '0.0.0.0'
-	set :port, ENV['PORT'] || 4567
+  def getWeavefile(viewname)
+    pathToFile = viewname.split('/').delete_if(&:empty?)
 
-	def getWeavefile(viewname)
+    viewFile = nil
 
-		pathToFile = viewname.split("/").delete_if(&:empty?)
+    remainingPath = []
 
-		viewFile = nil
+    loop do
+      path = "#{File.join(['source'] + pathToFile)}.weave"
+      indexPath = File.join(['source'] + pathToFile + ['index.weave'])
 
-		remainingPath = []
+      # puts path
+      # puts indexPath
 
-		loop do 
-			path = "#{File.join(['source'] + pathToFile)}.weave"
-			indexPath = File.join(["source"] + pathToFile + ["index.weave"])
+      viewFile = path if File.exist?(path)
+      viewFile = indexPath if File.exist?(indexPath)
 
-			#puts path
-			#puts indexPath
+      break if viewFile || pathToFile.empty?
 
-			viewFile = path if File.exists?(path)
-			viewFile = indexPath if File.exists?(indexPath)
+      remainingPath << pathToFile.last
 
-			break if viewFile or pathToFile.length == 0
+      pathToFile = pathToFile.first pathToFile.size - 1
+    end
 
-			remainingPath << pathToFile.last
+    { viewFile: viewFile, path: remainingPath }
+  end
 
-			pathToFile = pathToFile.first pathToFile.size-1
-		end 
+  get '/*' do
+    if params[:splat].first.start_with? 'images/'
+      return send_file(params[:splat].first, disposition: 'inline')
+    end
 
-		{ viewFile: viewFile, path: remainingPath }
-	end
-
-	get '/*' do
-
-		if params[:splat].first.start_with? "images/"
-			return send_file(params[:splat].first, :disposition => 'inline')
-		end
+    if params[:splat].first.start_with? 'js/'
+      return send_file(params[:splat].first, disposition: 'inline')
+    end
 
-		if params[:splat].first.start_with? "js/"
-			return send_file(params[:splat].first, :disposition => 'inline')
-		end
+    if params[:splat].first.start_with? 'css/'
+      return send_file(params[:splat].first, disposition: 'inline')
+    end
 
-		if params[:splat].first.start_with? "css/"
-			return send_file(params[:splat].first, :disposition => 'inline')
-		end
+    viewname = params[:splat].first
+    result = getWeavefile viewname
+    viewFile = result[:viewFile]
+    path = File.join(result[:path].reverse)
 
+    if viewFile
 
-		viewname = params[:splat].first
-		result = getWeavefile viewname
-		viewFile = result[:viewFile]
-		path = File.join(result[:path].reverse)
+      site = Weaver::Weave.new(viewFile)
 
-		if viewFile
+      if site.pages.key?(path)
 
-			site = Weaver::Weave.new(viewFile)
-
-			if site.pages.has_key?(path)
-
-				level = viewname.split(/\//, 0).length
-				site.pages[path].generate(level)
-
-			else
-				puts "Not found: #{viewname} in #{viewFile}"
-				puts "Path is: #{path}"
-				status 404
-			end
-		else
-			puts "Not found: #{viewname} in #{viewFile}"
-				puts "Path is: #{path}"
-			status 404
-		end
-	end
+        level = viewname.split(%r{/}, 0).length
+        site.pages[path].generate(level)
 
+      else
+        puts "Not found: #{viewname} in #{viewFile}"
+        puts "Path is: #{path}"
+        status 404
+      end
+    else
+      puts "Not found: #{viewname} in #{viewFile}"
+      puts "Path is: #{path}"
+      status 404
+    end
+  end
 end
 
-def build!(args)
-
-	opts = Optimist::options do
-		banner <<-EOS
+def build!(_args)
+  opts = Optimist.options do
+    banner <<-EOS
 Generate website
 
 Usage:
    weaver build [options]
 where [options] are:
-		EOS
+    EOS
 
-		opt :root, "The root URL to be used in links (e.g.) https://astrobunny.net", type: :string, default: "/"
-	end
+    opt :root, 'The root URL to be used in links (e.g.) https://astrobunny.net', type: :string, default: '/'
+  end
 
-	puts "Building site..."
-	
-	buildDir = "#{Dir.pwd}/build" 
+  puts 'Building site...'
 
-	cp_r_options = {preserve: true}
+  buildDir = "#{Dir.pwd}/build"
 
-	FileUtils::rm_rf buildDir
-	FileUtils.cp_r(File.join(Gem.loaded_specs['weaver'].full_gem_path, "data", "weaver"), buildDir, cp_r_options)
-	if Dir.exist? "images"
-		FileUtils.cp_r("images", buildDir, cp_r_options)
-	end
-	if Dir.exist? "js"
-		Dir["js/*.*"].each do |x|
-			FileUtils.cp_r(x, File.join(buildDir, "js"), cp_r_options)
-		end
-	end
-	if Dir.exist? "css"
-		Dir["css/*.*"].each do |x|
-			FileUtils.cp_r(x, File.join(buildDir, "css"), cp_r_options)
-		end
-	end
+  cp_r_options = { preserve: true }
 
-	files = Dir["source/**/*.weave"]
-	files.each do |file|
-		baseDir = file.chomp('.weave').chomp('index').sub(/^source\//, "")
+  FileUtils.rm_rf buildDir
+  FileUtils.cp_r(File.join(Gem.loaded_specs['weaver'].full_gem_path, 'data', 'weaver'), buildDir, cp_r_options)
+  FileUtils.cp_r('images', buildDir, cp_r_options) if Dir.exist? 'images'
+  if Dir.exist? 'js'
+    Dir['js/*.*'].each do |x|
+      FileUtils.cp_r(x, File.join(buildDir, 'js'), cp_r_options)
+    end
+  end
+  if Dir.exist? 'css'
+    Dir['css/*.*'].each do |x|
+      FileUtils.cp_r(x, File.join(buildDir, 'css'), cp_r_options)
+    end
+  end
 
-		site = Weaver::Weave.new(file, opts)
+  files = Dir['source/**/*.weave']
+  files.each do |file|
+    baseDir = file.chomp('.weave').chomp('index').sub(%r{^source/}, '')
 
-		site.pages.each do |localPath, page|
-			resultPath = File.join(baseDir, localPath)
+    site = Weaver::Weave.new(file, opts)
 
-			level = resultPath.split(/\//, 0).select{|x| x.length != 0}.length
+    site.pages.each do |localPath, page|
+      resultPath = File.join(baseDir, localPath)
 
-			puts "Writing: #{file} -> #{resultPath} (Level: #{level})"
+      level = resultPath.split(%r{/}, 0).reject(&:empty?).length
 
-			fileName = File.join([buildDir, resultPath, "index.html"])
-			FileUtils::mkdir_p File.dirname(fileName)
-			File.write(fileName, page.generate(level))
-		end
-	end
+      puts "Writing: #{file} -> #{resultPath} (Level: #{level})"
 
+      fileName = File.join([buildDir, resultPath, 'index.html'])
+      FileUtils.mkdir_p File.dirname(fileName)
+      File.write(fileName, page.generate(level))
+    end
+  end
 end
 
 def preview!
-	puts "Weaver Preview Mode in: #{Dir.pwd}"
+  puts "Weaver Preview Mode in: #{Dir.pwd}"
 
-	Website.run!
+  Website.run!
 end
 
 def create!(args)
+  if args.length != 1
+    puts 'Usage: weaver create <folder>'
+    return
+  end
 
-	if args.length != 1
-		puts "Usage: weaver create <folder>"
-		return
-	end
-
-	gemfile = <<-GEMFILE
+  gemfile = <<-GEMFILE
 source 'https://rubygems.org'
 
 gem 'weaver', '~> #{Weaver::VERSION}'
-	GEMFILE
+  GEMFILE
 
-	source = <<-SOURCE
+  source = <<-SOURCE
 topnav_page "", "My first weaver page" do
 	header do
 		col 12 do
@@ -174,25 +164,25 @@ topnav_page "", "My first weaver page" do
 		end
 	end
 end
-	SOURCE
-
-	to_create = "#{args[0]}"
-	FileUtils::mkdir_p "#{to_create}"
-	FileUtils::mkdir_p "#{to_create}/cache"
-	File.write("#{to_create}/cache/this_directory_is_used_by_weaver_as_a_cache","")
-	FileUtils::mkdir_p "#{to_create}/source"
-	FileUtils::mkdir_p "#{to_create}/images"
-	FileUtils::mkdir_p "#{to_create}/js"
-	FileUtils::mkdir_p "#{to_create}/css"
-	File.write "#{to_create}/Gemfile", gemfile
-	File.write "#{to_create}/source/index.weave", source
+  SOURCE
+
+  to_create = (args[0]).to_s
+  FileUtils.mkdir_p to_create.to_s
+  FileUtils.mkdir_p "#{to_create}/cache"
+  File.write("#{to_create}/cache/this_directory_is_used_by_weaver_as_a_cache", '')
+  FileUtils.mkdir_p "#{to_create}/source"
+  FileUtils.mkdir_p "#{to_create}/images"
+  FileUtils.mkdir_p "#{to_create}/js"
+  FileUtils.mkdir_p "#{to_create}/css"
+  File.write "#{to_create}/Gemfile", gemfile
+  File.write "#{to_create}/source/index.weave", source
 end
 
 command = ARGV.shift
-if command == "build"
-	build!(ARGV)
-elsif command == "create"
-	create!(ARGV)
+if command == 'build'
+  build!(ARGV)
+elsif command == 'create'
+  create!(ARGV)
 else
-	preview!
+  preview!
 end

data/lib/weaver.rb

@@ -1,2659 +1,29 @@
-require "weaver/version"
+require 'weaver/version'
 
 require 'fileutils'
 require 'json'
 require 'active_support/core_ext/object/to_query'
 
-module Weaver
-
-	class Elements
-
-		def initialize(page, anchors)
-			@inner_content = []
-			@anchors = anchors
-			@page = page
-		end
-
-		def method_missing(name, *args, &block)
-			tag = "<#{name} />"
-
-			if args[0].is_a? String
-				inner = args.shift
-			end
-			if block
-				elem = Elements.new(@page, @anchors)
-				elem.instance_eval(&block)
-				inner = elem.generate
-			end
-
-			if !inner
-
-				options = args[0] || []
-				opts = options.map { |key,value| "#{key}=\"#{value}\"" }.join " "
-
-				tag = "<#{name} #{opts} />"
-			elsif args.length == 0
-				tag = "<#{name}>#{inner}</#{name}>"
-			elsif args.length == 1 and args[0].is_a? Hash
-				options = args[0]
-				opts = options.map { |key,value| "#{key}=\"#{value}\"" }.join " "
-				tag = "<#{name} #{opts}>#{inner}</#{name}>"
-			end
-
-			@inner_content << tag
-			tag
-		end
-
-		def root
-			@page.root
-		end
-
-		def request_js(path)
-			@page.request_js(path)
-		end
-
-		def request_css(path)
-			@page.request_css(path)
-		end
-
-		def on_page_load(script)
-			@page.on_page_load(script)
-		end
-
-		def write_script_once(script)
-			@page.write_script_once(script)
-		end
-
-		def background(&block)
-			@page.background(block)
-		end
-
-		def on_page_load(script)
-			@page.on_page_load(script)
-		end
-
-		def icon(type)
-			iconname = type.to_s.gsub(/_/, "-")
-			if type.is_a? Symbol
-				i class: "fa fa-#{iconname}" do
-				end
-			else
-				i class: "fa" do
-					text type
-				end
-			end
-		end
-
-		def wform(options={}, &block)
-        	theform = Form.new(@page, @anchors, options, &block)
-        	@inner_content << theform.generate
-        	@page.scripts << theform.generate_script
-		end
-
-        def ibox(options={}, &block)
-        	panel = Panel.new(@page, @anchors, options)
-        	panel.instance_eval(&block)
-        	@inner_content << panel.generate
-        end
-
-        def center(content=nil, options={}, &block)
-
-        	if !options[:style]
-        		options[:style] = ""
-        	end
-
-        	options[:style] += "; text-align: center;"
-        	if !content
-        		div options, &block
-        	else
-        		div content, options, &block
-        	end
-        end
-
-        def panel(title, &block)
-        	div class: "panel panel-default" do
-        		div class: "panel-heading" do
-	    				h5 title
-	    			end 
-        		div class: "panel-body", &block
-        	end
-        end
-
-		def tabs(&block)
-			tabs = Tabs.new(@page, @anchors)
-			tabs.instance_eval(&block)
-
-        	@inner_content << tabs.generate
-		end
-
-		def syntax(lang=:javascript, &block)
-			code = Code.new(@page, @anchors, lang)
-			code.instance_eval(&block)
-
-			@inner_content << code.generate
-
-			@page.scripts << code.generate_script
-		end
-
-        def image(name, options={})
-
-        	style = "#{options[:style]}"
-        	if options[:rounded_corners] == true
-        		style += " border-radius: 8px"
-        	elsif options[:rounded_corners] == :top
-        		style += " border-radius: 8px 8px 0px 0px"
-        	else
-        		style += " border-radius: #{options[:rounded_corners]}px" if options[:rounded_corners]
-
-        	end
-
-        	img_options = {
-        		class: "img-responsive #{options[:class]}", 
-    			src: "#{@page.root}images/#{name}", 
-    			style: style
-        	}
-        	img_options[:id] = options[:id] if options[:id]
-
-        	img img_options
-        end
-
-        def crossfade_image(image_normal, image_hover)
-			div class: "crossfade" do
-				image image_hover, class: "bottom"
-				image image_normal, class: "top"
-			end
-			image image_hover
-			@page.request_css "css/crossfade_style.css"
-        end
-
-        def gallery(images, thumbnails=images, options={}, &block)
-
-			@page.request_css "css/plugins/blueimp/css/blueimp-gallery.min.css"
-
-		    div class:"lightBoxGallery" do
-				(0...images.length).to_a.each do |index|
-
-					title = options[:titles][index] if options[:titles]
-
-					 a href:"#{images[index]}", title: "#{title}", :"data-gallery"=> "" do
-					 	img src:"#{thumbnails[index]}", style: "margin: 5px;"
-					 end
-				end
-
-				div id:"blueimp-gallery", class:"blueimp-gallery" do
-					div class:"slides" do end
-					h3 class:"title" do end
-					a class:"prev" do end
-					a class:"next" do end
-					a class:"close" do end
-					a class:"play-pause" do end
-					ol class:"indicator" do end
-				end
-		    end
-
-			@page.request_js "js/plugins/blueimp/jquery.blueimp-gallery.min.js"
-
-        end
-
-		def breadcrumb(patharray)
-			ol class: "breadcrumb" do
-				patharray.each do |path|
-					li path
-				end
-			end
-		end
-
-		def p(*args, &block)
-			method_missing(:p, *args, &block)
-		end
-
-		def text(theText)
-			@inner_content << theText
-		end
-
-		def badge(label, options={})
-			options[:type] ||= "plain"
-
-			kind = "label"
-			kind = "badge" if options[:rounded]
-			tag_options = options.clone
-			tag_options[:class] = "#{kind} #{kind}-#{options[:type]}"
-
-			span tag_options do
-				text label
-			end
-		end
-
-		def hyperlink(url, title=nil, &block)
-			if !title
-				title = url
-			end
-
-			if url.start_with? "/"
-				url.sub!(/^\//, @page.root)
-				if block
-					a href: url, &block
-				else
-					a title, href: url
-				end
-			else
-
-				if block
-					a href: url, target: "_blank" do
-						span do
-							span &block
-							icon :external_link
-						end
-					end
-				else
-					a href: url, target: "_blank" do
-						span do
-							text title
-							text " "
-							icon :external_link
-						end
-					end
-				end
-			end
-
-			
-
-		end
-
-		def accordion(&block)
-			acc = Accordion.new(@page, @anchors)
-			acc.instance_eval(&block)
-
-			@inner_content << acc.generate
-		end
-
-		def widget(options={}, &block)
-			#gray-bg
-			#white-bg
-			#navy-bg
-			#blue-bg
-			#lazur-bg
-			#yellow-bg
-			#red-bg
-			#black-bg
-
-			color = "#{options[:color]}-bg" || "navy-bg"
-
-			div :class => "widget style1 #{color}", &block
-		end
-
-		def row(options={}, &block)
-			options[:class] = "row"
-			div options do
-				instance_eval(&block)
-			end
-		end
-
-		def twothirds(&block)
-			opts =
-			{
-				xs: 12,
-				sm: 12,
-				md: 8,
-				lg: 8
-			}
-			col(4, opts, &block)
-		end
-
-		def half(&block)
-			opts =
-			{
-				xs: 12,
-				sm: 12,
-				md: 12,
-				lg: 6
-			}
-			col(4, opts, &block)
-		end
-
-		def third(&block)
-			opts =
-			{
-				xs: 12,
-				sm: 12,
-				md: 4,
-				lg: 4
-			}
-			col(4, opts, &block)
-		end
-
-		def quarter(&block)
-			opts =
-			{
-				xs: 12,
-				sm: 12,
-				md: 6,
-				lg: 3
-			}
-			col(3, opts, &block)
-		end
-
-		def col(occupies, options={}, &block)
-
-			xs = options[:xs] || occupies
-			sm = options[:sm] || occupies
-			md = options[:md] || occupies
-			lg = options[:lg] || occupies
-
-			hidden = ""
-
-			xs_style = "col-xs-#{xs}" unless options[:xs] == 0
-			sm_style = "col-sm-#{sm}" unless options[:sm] == 0
-			md_style = "col-md-#{md}" unless options[:md] == 0
-			lg_style = "col-lg-#{lg}" unless options[:lg] == 0
-
-			hidden += "hidden-xs " if options[:xs] == 0
-			hidden += "hidden-sm " if options[:sm] == 0
-			hidden += "hidden-md " if options[:md] == 0
-			hidden += "hidden-lg " if options[:lg] == 0
-
-			div_options = {
-				class: "#{xs_style} #{sm_style} #{md_style} #{lg_style} #{hidden}",
-				style: options[:style]
-			}
-
-			div div_options do 
-				instance_eval(&block)
-			end
-		end
-
-
-		def jumbotron(options={}, &block)
-
-			additional_style = ""
-
-			if options[:background]
-				additional_style += " background-image: url('#{@page.root}images/#{options[:background]}'); background-position: center center; background-size: cover;"
-			end
-
-			if options[:height]
-				additional_style += " height: #{options[:height]}px;"
-			end
-
-			if options[:min_height]
-				additional_style += " min-height: #{options[:min_height]}px;"
-			end
-
-			if options[:max_height]
-				additional_style += " max-height: #{options[:max_height]}px;"
-			end
-
-			div :class => "jumbotron", style: additional_style, &block
-		end
-
-		def modal(id=nil, &block)
-			mm = ModalDialog.new(@page, @anchors, id, &block)
-			@inner_content << mm.generate
-		end
-
-		def _button(options={}, &block)
-
-			anIcon = options[:icon]
-			title = options[:title]
-
-			if title.is_a? Hash
-				options.merge! title
-				title = anIcon
-				anIcon = nil
-			end
-
-			style = options[:style] || :primary
-			size = "btn-#{options[:size]}" if options[:size]
-			blockstyle = "btn-block" if options[:block]
-			outline = "btn-outline" if options[:outline]
-			dim = "dim" if options[:threedee]
-			dim = "dim btn-large-dim" if options[:bigthreedee]
-			dim = "btn-rounded" if options[:rounded]
-			dim = "btn-circle" if options[:circle]
-
-			buttonOptions = {
-				:type => options[:type] || "button",
-				:class => "btn btn-#{style} #{size} #{blockstyle} #{outline} #{dim}",
-				:id => options[:id]
-			}
-
-			if block
-				closer = ""
-
-				closer = "; return false;" if options[:nosubmit]
-
-				action = Action.new(@page, @anchors, &block)
-				buttonOptions[:onclick] = "#{action.name}(this)"
-				buttonOptions[:onclick] = "#{action.name}(this, #{options[:data]})#{closer}" if options[:data]
-				@page.scripts << action.generate
-			end
-
-			type = :button
-
-			buttonOptions[:"data-toggle"] = "button" if options[:toggle]
-			type = :a if options[:toggle]
-
-
-			method_missing type, buttonOptions do
-				if title.is_a? Symbol
-					icon title
-				else
-					icon anIcon if anIcon
-					text " " if anIcon
-					text title
-				end
-			end
-		end
-
-		def normal_button(anIcon, title={}, options={}, &block)
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def block_button(anIcon, title={}, options={}, &block)
-			options[:block] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def outline_button(anIcon, title={}, options={}, &block)
-			options[:outline] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def big_button(anIcon, title={}, options={}, &block)
-			options[:size] = :lg
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def small_button(anIcon, title={}, options={}, &block)
-			options[:size] = :sm
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def tiny_button(anIcon, title={}, options={}, &block)
-			options[:size] = :xs
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def embossed_button(anIcon, title={}, options={}, &block)
-			options[:threedee] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def big_embossed_button(anIcon, title={}, options={}, &block)
-			options[:bigthreedee] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def rounded_button(anIcon, title={}, options={}, &block)
-			options[:rounded] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def circle_button(anIcon, title={}, options={}, &block)
-			options[:circle] = true
-			options[:icon] = anIcon
-			options[:title] = title
-			_button(options, &block)
-		end
-
-		def math(string)
-			text "$$$MATH$$$#{string}$$$ENDMATH$$$"
-		end
-
-		def table(options={}, &block)
-
-
-			table_name = options[:id] || @page.create_anchor("table")
-			table_style = ""
-
-
-			if options[:style] != nil
-				table_style = options[:style]
-			end
-
-			classname = "table"
-
-			classname += " table-bordered" if options[:bordered]
-			classname += " table-hover" if options[:hover]
-			classname += " table-striped" if options[:striped]
-
-			table_options = {
-				class: classname,
-				id: table_name,
-				style: table_style
-			}
-
-			if options[:system] == :data_table
-				@page.request_js "js/plugins/dataTables/jquery.dataTables.js"
-				@page.request_js "js/plugins/dataTables/dataTables.bootstrap.js"
-				@page.request_js "js/plugins/dataTables/dataTables.responsive.js"
-				@page.request_js "js/plugins/dataTables/dataTables.tableTools.min.js"
-
-				@page.request_css "css/plugins/dataTables/dataTables.bootstrap.css"
-				@page.request_css "css/plugins/dataTables/dataTables.responsive.css"
-				@page.request_css "css/plugins/dataTables/dataTables.tableTools.min.css"
-
-				@page.scripts << <<-DATATABLE_SCRIPT
-		$('##{table_name}').DataTable();
-				DATATABLE_SCRIPT
-			end
-
-			if options[:system] == :foo_table
-				table_options[:"data-filtering"] = true
-				table_options[:"data-sorting"] = true
-				table_options[:"data-paging"] = true
-				table_options[:"data-show-toggle"] = true
-				table_options[:"data-toggle-column"] = "last"
-
-				table_options[:"data-paging-size"] = "#{(options[:max_items_per_page] || 8).to_i}"
-				table_options[:class] = table_options[:class] + " toggle-arrow-tiny"
-
-
-				@page.request_js "js/plugins/footable/footable.all.min.js"
-
-				@page.request_css "css/plugins/footable/footable.core.css"
-
-				@page.scripts << <<-DATATABLE_SCRIPT
-		$('##{table_name}').footable({
-			paging: {
-				size: #{(options[:max_items_per_page] || 8).to_i}
-			}
-		});
-		$('##{table_name}').append(this.html).trigger('footable_redraw');
-		
-
-
-				DATATABLE_SCRIPT
-
-				@page.onload_scripts << <<-SCRIPT
-				SCRIPT
-			end
-
-
-			method_missing(:table, table_options, &block)
-			ul class: "pagination"
-		end
-
-		def table_from_source(url, options={}, &block)
-
-			dyn_table = DynamicTable.new(@page, @anchors, url, options, &block)
-
-			text dyn_table.generate_table
-
-			@page.scripts << dyn_table.generate_script
-
-		end
-
-		def table_from_hashes(hashes, options={})
-
-			keys = {}
-			hashes.each do |hash|
-				hash.each do |key,value|
-					keys[key] = ""
-				end
-			end
-
-			table options do
-
-				thead do
-					keys.each do |key, _| 
-						th key.to_s
-					end
-				end
-
-				tbody do
-
-					hashes.each do |hash|
-
-						tr do
-							keys.each do |key, _|
-								td "#{hash[key]}" || "&nbsp;"
-							end
-						end
-					end
-				end
-			end
-		end
-
-		def generate
-			@inner_content.join
-		end
-	end
-
-	class ModalDialog
-
-		def initialize(page, anchors, id, &block)
-			@page = page
-			@anchors = anchors
-			@id = id || @page.create_anchor("modal")
-
-			@header_content = Elements.new(@page, @anchors)
-			@body_content = Elements.new(@page, @anchors)
-			@footer_content = Elements.new(@page, @anchors)
-
-			instance_eval(&block) if block
-		end
-
-		def id
-			@id
-		end
-
-		def header(&block)
-			@header_content.instance_eval(&block)
-		end
-
-		def body(&block)
-			@body_content.instance_eval(&block)
-		end
-
-		def footer(&block)
-			@footer_content.instance_eval(&block)
-		end
-
-		def generate
-        	elem = Elements.new(@page, @anchors)
-
-        	id = @id
-        	header_content = @header_content
-			body_content = @body_content
-			footer_content = @footer_content
-
-        	elem.instance_eval do
-				div class: "modal fade", id: id, tabindex: -1, role: "dialog" do 
-					div class: "modal-dialog", role: "document" do
-						div class: "modal-content" do
-							div class: "modal-header" do
-								button "&times;", type: "button", class: "close", :"data-dismiss" => "modal", :"aria-label" => "Close"
-								text header_content.generate
-							end
-							div class: "modal-body" do
-								text body_content.generate
-							end
-							div class: "modal-footer" do
-								text footer_content.generate
-							end
-						end
-					end
-				end
-        	end
-
-        	elem.generate
-			
-		end
-	end
-
-	class DynamicTableCell < Elements
-
-		attr_accessor :transform_script
-
-		def data_button(anIcon, title={}, options={}, &block)
-			options[:icon] = anIcon
-			options[:title] = title
-			options[:data] = "$(this).closest('td').data('object')"
-			_button(options, &block)
-		end
-
-		def transform(script)
-			@transform_script = script
-		end
-
-	end
-
-	class JavaScriptObject
-		def initialize(&block)
-			@object = {}
-			instance_eval(&block) if block
-		end
-
-		def string(name, string)
-			@object[name] = {type: :string, value: string}
-		end
-
-		def variable(name, var_name)
-			@object[name] = {type: :var, value: var_name}
-		end
-
-		def generate
-			result = @object.map {
-				|key,value| 
-
-				value_expression = value[:value]
-
-				if value[:type] == :string
-					value_expression = "\"#{value[:value]}\""
-				end
-
-				"#{key}: #{value_expression}"
-
-			}.join ","
-
-			"{#{result}}"
-		end
-
-	end
-
-	class DynamicTable
-
-		def initialize(page, anchors, url, options={}, &block)
-			@page = page
-			@anchors = anchors
-			@url = url
-			@options = options
-			@columns = nil
-			@query_object = nil
-
-			self.instance_eval(&block) if block
-
-			@options[:id] ||= @page.create_anchor "dyn_table"
-			@table_name = @options[:id]
-			@head_name = "#{@table_name}_head"
-			@body_name = "#{@table_name}_body"
-
-
-		end
-
-		def column(name, options={}, &block)
-			if @columns == nil
-				@columns = []
-			end
-
-			title = options[:title] || name
-			format = nil
-			transform = nil
-
-			if options[:icon]
-        		elem = Elements.new(@page, @anchors)
-        		elem.instance_eval do
-        			icon options[:icon]
-        			text " #{title}"
-        		end
-        		title = elem.generate
-			end
-
-			if block
-        		elem = DynamicTableCell.new(@page, @anchors)
-        		elem.instance_eval(&block)
-				format = elem.generate
-				if elem.transform_script
-					func_name = @page.create_anchor "transform"
-					@page.write_script_once <<-SCRIPT
-document.transform_#{func_name} = function (input)
-{
-#{elem.transform_script}
-}
-					SCRIPT
-
-					transform = func_name
-				end
-			end
-
-			@columns << {name: name, title: title, format: format, transform: transform}
-
-		end
-
-		def generate_table
-
-			table_name = @table_name
-			head_name = @head_name
-			body_name = @body_name
-			options = @options
-
-			columns = @columns || [ {title: "Key"}, {title: "Value"} ]
-
-        	elem = Elements.new(@page, @anchors)
-        	elem.instance_eval do
-
-				table options do
-					thead id: head_name do
-						columns.each do |column, _|
-							if column.is_a? Hash
-								th column[:title].to_s
-							else
-								th column.to_s
-							end 
-						end
-					end
-
-					tbody id: body_name do
-					end
-				end
-        	end
-
-        	elem.generate
-		end
-
-		def query(&block)
-			@query_object = JavaScriptObject.new(&block)
-		end
-
-		def generate_script
-
-			query_object_declaration = '{}'
-			query_string = ""
-
-			if @query_object
-				query_object_declaration = @query_object.generate
-				query_string = "+ \"?\" + $.param(query_object)"
-			end
-
-			member_expr = ""
-			if @options[:member]
-				member_expr = ".#{@options[:member]}"
-			end
-
-			<<-DATATABLE_SCRIPT
-
-	function refresh_table_#{@table_name}()
-	{
-		var query_object = #{query_object_declaration};
-
-		$.get( "#{@url}" #{query_string}, function( returned_data )
-		{
-			var data = returned_data#{member_expr};
-			var data_object = {};
-			if (data !== null && typeof data === 'object')
-			{
-				data_object = data;
-			}
-			else
-			{
-				data_object = JSON.parse(data);
-			}
-
-			var head = $("##{@head_name}")
-			var body = $("##{@body_name}")
-
-			if($.isPlainObject(data_object))
-			{
-				for (var key in data_object)
-				{
-					var row = $('<tr>');
-					row.append($('<td>').text(key));
-					row.append($('<td>').text(data_object[key]));
-					body.append(row);
-				}
-			}
-
-			if ($.isArray(data_object))
-			{
-
-				var columnData = JSON.parse(#{@columns.to_json.inspect});
-				var columns = {};
-				var columnTitles = [];
-				head.empty();
-				if (#{@columns == nil})
-				{
-					// Set up columns
-					for (var index in data_object)
-					{
-						for (var key in data_object[index])
-						{
-							columns[key] = Object.keys(columns).length;
-						}
-					}
-					for (var key in columns)
-					{
-						columnTitles.push(key);
-					}
-				}
-				else
-				{
-					for (var key in columnData)
-					{
-						columns[columnData[key]["name"]] = Object.keys(columns).length;
-						columnTitles.push(columnData[key]["title"]);
-					}
-				}
-
-				var row = $('<tr>');
-				for (var key in columnTitles)
-				{
-					var columnTitle = $('<th>').html(columnTitles[key]);
-					row.append(columnTitle);
-				}
-				head.append(row);
-
-				for (var index in data_object)
-				{
-					var row = $('<tr>');
-					for (var columnIndex = 0; columnIndex < Object.keys(columns).length; columnIndex++) {
-						var cell_data = data_object[index][ Object.keys(columns)[columnIndex] ];
-
-						if (columnData && columnData[columnIndex]["format"])
-						{
-							var format = columnData[columnIndex]["format"];
-							var matches = format.match(/###.+?###/g)
-
-							var result = format;
-							for (var matchIndex in matches)
-							{
-								var member_name = matches[matchIndex].match(/[^#]+/)[0];
-								result = result.replaceAll(matches[matchIndex], data_object[index][member_name]);
-							}
-
-							if (columnData && columnData[columnIndex]["transform"])
-							{
-								result = document["transform_" + columnData[columnIndex]["transform"]](result);
-							}
-							row.append($('<td>').html( result ).data("object", data_object[index]) );
-						}
-						else
-						{
-							if (columnData && columnData[columnIndex]["transform"])
-							{
-								cell_data = document["transform_" + columnData[columnIndex]["transform"]](cell_data);
-							}
-							row.append($('<td>').text( cell_data ).data("object", data_object[index]) );
-						}
-					}
-					body.append(row);
-				}
-			}
-
-		});
-	}
-
-	refresh_table_#{@table_name}();
-
-			DATATABLE_SCRIPT
-		end
-	end
-
-	class Action
-		def initialize(page, anchors, &block)
-			@page = page
-			@anchors = anchors
-
-			actionsArray = @anchors["action"]
-
-			if !@anchors["action"]
-				@anchors["action"] = []
-			end
-
-			actionsArray = @anchors["action"]
-
-			@actionName = "action#{actionsArray.length}"
-			actionsArray << @actionName
-
-			@code = ""
-
-			self.instance_eval(&block)
-		end
-
-		def script(code)
-			@code = code
-		end
-
-		def generate
-			#puts @code
-			<<-FUNCTION
-function #{@actionName}(caller, data) {
-	#{@code}
-}
-			FUNCTION
-		end
-
-		def name
-			@actionName
-		end
-	end
-
-	class Code
-		def initialize(page, anchors, lang)
-			@page = page
-			@anchors = anchors
-			@content = ""
-			@options = {}
-
-			codeArray = @anchors["code"]
-
-			if !@anchors["code"]
-				@anchors["code"] = []
-			end
-
-			codeArray = @anchors["code"]
-
-			@codeName = "code#{codeArray.length}"
-			codeArray << @codeName
-
-			@page.request_css "css/plugins/codemirror/codemirror.css"
-			@page.request_js "js/plugins/codemirror/codemirror.js"
-
-			language lang
-
-		end
-
-		def language(lang)
-			# TODO improve langmap
-			langmap = {
-				javascript: {mime: "text/javascript", file: "javascript/javascript"}
-			}
-
-			if langmap[lang]
-				@options[:mode] = langmap[lang][:mime]
-				@page.request_js "js/plugins/codemirror/mode/#{langmap[lang][:file]}.js"
-			else
-				@options[:mode] = "text/x-#{lang}"
-				@page.request_js "js/plugins/codemirror/mode/#{lang}/#{lang}.js"
-			end
-
-		end
-
-		def content(text)
-			@content = text
-		end
-
-		def theme(name)
-			@options[:theme] = name
-
-			@page.request_css "css/plugins/codemirror/#{name}.css"
-		end
-
-		def generate_script
-
-			@options[:lineNumbers] ||= true
-			@options[:matchBrackets] ||= true
-			@options[:styleActiveLine] ||= true
-			@options[:mode] ||= "javascript"
-			@options[:readOnly] ||= true
-
-			<<-CODESCRIPT
-		$(document).ready(function()
-		{
-			CodeMirror.fromTextArea(document.getElementById("#{@codeName}"), 
-				JSON.parse('#{@options.to_json}')
-			);
-	    });
-	        CODESCRIPT
-		end
-
-		def generate
-
-			content = @content
-			codeName = @codeName
-
-        	elem = Elements.new(@page, @anchors)
-
-        	elem.instance_eval do
-				textarea id: codeName do
-					text content
-				end
-        	end
-
-        	elem.generate
-		end
-	end
-
-	class TextfieldJavascript
-
-		def initialize(id)
-			@id = id
-		end
-
-		def onchange(script)
-			@change_script = script
-		end
-
-		def validate(script)
-			@validate_script = script
-		end
-
-		def generate(&block)
-			if block
-			instance_eval(&block)
-				<<-SCRIPT
-
-if (!document.validators)
-{
-	document.validators = {};
-}
-
-document.validators["##{@id}"] = function()
-{
-	var valid = function(data) {
-		#{@validate_script};
-		return true;
-	}($("##{@id}").val());
-
-	var object = $("##{@id}");
-	#{@change_script};
-
-	if (valid)
-	{
-		object.removeClass("required");
-		object.removeClass("error");
-		object.removeAttr("aria-invalid");
-	}
-	else
-	{
-		object.addClass("required");
-		object.addClass("error");
-		object.attr("aria-required", "true");
-		object.attr("aria-invalid", "true");
-	}
-}
-
-$("##{@id}").keyup(function() { document.validators["##{@id}"](); })
-$("##{@id}").blur(function() { document.validators["##{@id}"](); })
-$("##{@id}").focusout(function() { document.validators["##{@id}"](); })
-
-				SCRIPT
-			end
-		end
-	end
-
-	class FormElements < Elements
-
-		attr_accessor :options, :scripts
-
-		def initialize(page, anchors, formName, options={})
-			super(page, anchors)
-			@formName = formName
-			@options = options
-			@scripts = []
-		end
-
-		def passwordfield(name, textfield_label=nil, options={}, &block)
-
-			if textfield_label.is_a? Hash
-				options = textfield_label
-				textfield_label = nil
-			end
-
-			options[:type] = "password"
-			textfield(name, textfield_label, options, &block)
-		end
-
-		def textfield(name, textfield_label=nil, options={}, &block)
-
-			if textfield_label.is_a? Hash
-				options = textfield_label
-				textfield_label = nil
-			end
-
-			textfield_name = options[:id] || @page.create_anchor("textfield")
-			options[:type] ||= "text"
-			options[:placeholder] ||= ""
-			options[:name] = name
-
-			input_options = {}
-			input_options[:type] = options[:type]
-			input_options[:placeholder] = options[:placeholder]
-			input_options[:id] = textfield_name
-			input_options[:name] = options[:name]
-			input_options[:rows] = options[:rows]
-			input_options[:class] = "form-control"
-			input_options[:value] = options[:value]
-			input_options[:style] = options[:style]
-
-			input_options[:autocomplete] = options[:autocomplete] || "on"
-			input_options[:autocorrect] = options[:autocorrect] || "on"
-			input_options[:autocapitalize] = options[:autocapitalize] || "off"
-
-			if options[:mask]
-				@page.request_css "css/plugins/jasny/jasny-bootstrap.min.css"
-				@page.request_js "js/plugins/jasny/jasny-bootstrap.min.js"
-
-				input_options[:"data-mask"] = options[:mask]
-			end
-
-			div :class => "form-group #{options[:extra_class]}", id: "#{input_options[:id]}-group" do
-				label textfield_label if textfield_label
-
-					div_class = " "
-					if options[:front_text] || options[:back_text]
-						div_class = "input-group m-b"
-					end
-
-					div :"class" => div_class do
-						span "#{options[:front_text]}", class: "input-group-addon" if options[:front_text]
-						if input_options[:rows] and input_options[:rows] > 1
-							textarea input_options do
-							end
-						else
-							input input_options
-						end
-						span "#{options[:back_text]}", class: "input-group-addon" if options[:back_text]
-					end
-			end
-
-			textjs = TextfieldJavascript.new(input_options[:id])
-
-			@page.on_page_load textjs.generate(&block) if block
-
-			@scripts << <<-SCRIPT
-	object["#{name}"] = $('##{textfield_name}').val();
-			SCRIPT
-		end
-
-		def hiddenfield(name, value, options={})
-			hiddenfield_name = options[:id] || @page.create_anchor("hiddenfield")
-
-			input_options = {}
-			input_options[:type] = "hidden"
-			input_options[:value] = value
-			input_options[:id] = hiddenfield_name
-			input_options[:name] = name
-
-			input input_options
-
-			@scripts << <<-SCRIPT
-	object["#{name}"] = $('##{hiddenfield_name}').val();
-			SCRIPT
-
-		end
-	
-		def dropdown(name, dropdown_label, choice_array, options={})
-			select_name = options[:id] || @page.create_anchor("select")
-
-			options[:class] = "form-control"
-			options[:name] = name
-			options[:id] = select_name
-			options[:placeholder] ||= " "
-
-			form_options = options.clone
-
-			if options[:multiple]
-
-				if options[:multiple_style] == :chosen
-					@page.request_css "css/plugins/chosen/chosen.css"
-					@page.request_js "js/plugins/chosen/chosen.jquery.js"
-
-					@page.write_script_once <<-SCRIPT
-	var config = {
-		'.chosen-select'           : {placeholder_text_multiple: "#{options[:placeholder]}"},
-		'.chosen-select-deselect'  : {allow_single_deselect:true},
-		'.chosen-select-no-single' : {disable_search_threshold:10},
-		'.chosen-select-no-results': {no_results_text:'Oops, nothing found!'},
-		'.chosen-select-width'     : {width:"95%"}
-	}
-	for (var selector in config) {
-		$(selector).chosen(config[selector]);
-	}
-					SCRIPT
-
-					form_options[:class] = "chosen-select"
-					form_options[:style] = "width: 100%"
-				end
-
-				@scripts << <<-SCRIPT
-	var selections = []; 
-	$("##{select_name} option:selected").each(function(i, selected){ 
-  		selections[i] = $(selected).text(); 
-	});
-	object["#{name}"] = selections;
-				SCRIPT
-
-			else
-				@scripts << <<-SCRIPT
-	object["#{name}"] = $( "##{select_name} option:selected" ).text();
-				SCRIPT
-			end
-
-
-			div :class => "form-group" do
-				label dropdown_label, :class => "control-label"
-
-				div :class => "input-group", style: "width: 100%" do
-
-					method_missing :select, form_options do
-
-						choice_array.each do |choice|
-							if "#{options[:value]}" == "#{choice}"
-								option choice, selected: true
-							else
-								option choice
-							end
-						end
-					end
-				end
-			end
-
-
-		end
-
-		def knob(name, options={})
-
-			knob_name = @page.create_anchor "knob"
-
-			@page.request_js "js/plugins/jsKnob/jquery.knob.js"
-			@page.write_script_once <<-SCRIPT
-	$(".dial").knob();
-			SCRIPT
-
-			knob_options = {}
-
-			knob_options[:id] = knob_name
-			knob_options[:type] = "text"
-			knob_options[:value] = options[:value] || "0"
-			knob_options[:class] = "dial"
-
-			options.each do |key,value|
-				knob_options["data-#{key}".to_sym] = value
-			end
-
-			knob_options[:"data-fgColor"] = "#1AB394"
-			knob_options[:"data-width"] = "85"
-			knob_options[:"data-height"] = "85"
-
-			input knob_options
-
-			@scripts << <<-SCRIPT
-	object["#{name}"] = $('##{knob_name}').val();
-			SCRIPT
-		end
-
-		def radio(name, choice_array, options={})
-
-			radio_name = @page.create_anchor "radio"
-
-			choice_array = choice_array.map do |choice|
-				if choice.is_a? Hash
-					{value: choice[:value], label: choice[:label]}
-				else
-					{value: choice, label: choice}
-				end
-			end
-
-			active = choice_array[0][:value]
-			if options[:value] and choice_array.index { |x| x[:value] == options[:value] } != nil
-				active = options[:value]
-			end
-
-			div_options = {}
-			curobject = self
-			if options[:form] == :button
-				div_options[:"data-toggle"] = "buttons"
-			end
-			div div_options do
-				choice_array.each do |choice|
-
-					value = choice[:value]
-					label = choice[:label]
-
-					the_options = Hash.new(options)
-
-					if active == value
-						the_options[:checked] = ""
-					end
-
-					if options[:form] == :button
-						the_options[:type] = "radio"
-						the_options[:value] = value
-						the_options[:name] = name
-						the_options[:form] = :button
-						text curobject.boolean_element(label, the_options)
-					else
-						the_options[:type] = "radio"
-						the_options[:value] = value
-						the_options[:name] = name
-						text curobject.boolean_element(label, the_options)
-					end
-				end
-			end
-
-
-			@scripts << <<-SCRIPT
-	object["#{name}"] = $('input[name=#{name}]:checked', '##{@formName}').val()
-			SCRIPT
-		end
-
-		def checkbox(name, checkbox_label, options={})
-			checkbox_name = options[:id] || @page.create_anchor("checkbox")
-			options[:type] = "checkbox"
-			options[:name] = name
-			options[:id] = checkbox_name
-			text boolean_element(checkbox_label, options)
-			@scripts << <<-SCRIPT
-	object["#{name}"] = $('##{checkbox_name}').is(":checked");
-			SCRIPT
-		end
-
-
-		def submit(anIcon, title={}, options={}, &block)
-			options[:icon] = anIcon
-			options[:title] = title
-			options[:type] = "submit"
-			options[:data] = "get_#{@formName}_object()"
-			options[:nosubmit] = true if block
-			_button(options, &block)
-		end
-
-		def boolean_element(checkbox_label, options={})
-
-			@page.request_css "css/plugins/iCheck/custom.css"
-			@page.request_js "js/plugins/iCheck/icheck.min.js"
-
-			@page.write_script_once <<-SCRIPT
-$(document).ready(function () {
-    $('.i-checks').iCheck({
-        checkboxClass: 'icheckbox_square-green',
-        radioClass: 'iradio_square-green',
-    });
-});
-			SCRIPT
-
-			label_options = {}
-			elem = Elements.new(@page, @anchors)
-			elem.instance_eval do
-
-				if options[:form] == :button
-					options.delete(:form)
-					label class: "btn btn-primary btn-block btn-outline" do
-						input options
-						text "#{checkbox_label}"
-					end
-				else
-					div class: "i-checks" do
-						label label_options do
-							input options do
-								text " #{checkbox_label}"
-							end
-						end
-					end
-				end
-
-			end
-
-			elem.generate
-		end
-	end
-
-	class Form
-		def initialize(page, anchors, options={}, &block)
-
-			@formName = options[:id] || page.create_anchor("form")
-
-			@form_element = FormElements.new(page, anchors, @formName, options)
-
-			@form_element.instance_eval(&block)
-		end
-
-		def generate_script
-			<<-SCRIPT
-function get_#{@formName}_object()
-{
-	var object = {}
-#{@form_element.scripts.join "\n"}
-	return object;
-}
-			SCRIPT
-		end
-
-		def generate
-			inner = @form_element.generate
-			formName = @formName
-			options = @form_element.options
-
-			elem = Elements.new(@page, @anchors)
-			elem.instance_eval do
-
-				form_opts = {
-					id: formName, 
-					role: "form"
-				}
-
-				form_opts[:action] = options[:action] if options[:action]
-				form_opts[:method] = options[:method] if options[:method]
-				form_opts[:class] = options[:class] if options[:class]
-
-				method_missing :form, form_opts do
-					text inner
-				end
-			end
-
-			elem.generate
-		end
-	end
-
-	class Panel < Elements
-		def initialize(page, anchors, options={})
-			super(page, anchors)
-			@title = nil
-			@footer = nil
-			@type = :ibox
-			@body = true
-			@extra = nil
-			@min_height = nil
-			@page = page
-			@options = options
-		end
-
-		def generate
-			inner = super
-
-        	types =
-        	{
-        		:ibox  => 	{ outer: "ibox float-e-margins",header: "ibox-title",    body: "ibox-content" , footer: "ibox-footer"},
-        		:panel => 	{ outer: "panel panel-default", header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:primary => { outer: "panel panel-primary", header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:success => { outer: "panel panel-success", header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:info => 	{ outer: "panel panel-info",  	header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:warning => { outer: "panel panel-warning", header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:danger => 	{ outer: "panel panel-danger",  header: "panel-heading", body: "panel-body"   , footer: "panel-footer"},
-        		:blank => 	{ outer: "panel blank-panel",   header: "panel-heading", body: "panel-body"   , footer: "panel-footer"}
-        	}
-
-        	title = @title
-        	footer = @footer
-        	hasBody = @body
-        	extra = @extra
-        	options = @options
-        	classNames = types[@type]
-			min_height = @min_height
-
-        	elem = Elements.new(@page, @anchors)
-
-        	outer_class = classNames[:outer]
-
-        	if options[:collapsed]
-        		outer_class = "ibox collapsed"
-        	end
-
-        	elem.instance_eval do
-				div class: outer_class do
-					if title
-						div class: classNames[:header] do
-							h5 title
-
-							div class: "ibox-tools" do
-								if options[:collapsible] or options[:collapsed]
-									a class: "collapse-link" do
-										icon :"chevron-up"
-									end
-								end
-								if options[:expandable]
-									a class: "fullscreen-link" do
-										icon :expand
-									end
-								end
-								if options[:closable]
-									a class: "close-link" do
-										icon :times
-									end
-								end
-							end
-						end
-					end
-					if hasBody
-						div class: classNames[:body], style: "min-height: #{min_height}px" do 
-							text inner
-						end
-					end
-					if extra
-						text extra
-					end
-					if footer
-						div class: classNames[:footer] do 
-							text footer
-						end
-					end
-
-				end
-        	end
-
-        	elem.generate
-		end
-
-		def min_height(val)
-			@min_height = val
-		end
-
-		def type(aType)
-			@type = aType
-		end
-
-		def body(hasBody)
-			@body = hasBody
-		end
-
-		def title(title=nil, &block)
-			@title = title
-			if block
-				elem = Elements.new(@page, @anchors)
-				elem.instance_eval(&block)
-				@title = elem.generate
-			end
-		end
-
-		def extra(&block)
-			if block
-				elem = Elements.new(@page, @anchors)
-				elem.instance_eval(&block)
-				@extra = elem.generate
-			end
-		end
-
-		def footer(footer=nil, &block)
-			@footer = footer
-			if block
-				elem = Elements.new(@page, @anchors)
-				elem.instance_eval(&block)
-				@footer = elem.generate
-			end
-		end
-
-	end
-
-	class Accordion
-		def initialize(page, anchors)
-			@anchors = anchors
-			@tabs = {}
-			@paneltype = :panel
-			@is_collapsed = false
-			@page = page
-
-			if !@anchors["accordia"]
-				@anchors["accordia"] = []
-			end
-
-			accArray = @anchors["accordia"]
-
-			@accordion_name = "accordion#{accArray.length}"
-			accArray << @accordion_name
-		end
-
-		def collapsed(isCollapsed)
-			@is_collapsed = isCollapsed
-		end
-
-		def type(type)
-			@paneltype = type
-		end
-
-		def tab(title, options={}, &block)
-			
-			if !@anchors["tabs"]
-				@anchors["tabs"] = []
-			end
-
-			tabArray = @anchors["tabs"]
-
-			elem = Elements.new(@page, @anchors)
-			elem.instance_eval(&block)
-
-			tabname = "tab#{tabArray.length}"
-			tabArray << tabname
-
-			@tabs[tabname] = 
-			{
-				title: title,
-				elem: elem
-			}
-
-			if options[:mixpanel_event_name]
-				@tabs[tabname][:mixpanel_event_name] = options[:mixpanel_event_name]
-			end
-
-			if options[:mixpanel_event_props]
-				@tabs[tabname][:mixpanel_event_props] = options[:mixpanel_event_props]
-			end
-
-		end
-
-		def generate
-			tabbar = Elements.new(@page, @anchors)
-
-			tabs = @tabs
-			paneltype = @paneltype
-			accordion_name = @accordion_name
-			is_collapsed = @is_collapsed
-
-			tabbar.instance_eval do
-
-				div :class => "panel-group", id: accordion_name do
-
-					cls = "panel-collapse collapse in"
-					cls = "panel-collapse collapse" if is_collapsed
-					tabs.each do |anchor, value|
-
-						ibox do
-							type paneltype
-							body false
-							title do
-								div :class => "panel-title" do
-									options = {
-										:"data-toggle" => "collapse", 
-										:"data-parent" => "##{accordion_name}", 
-										href: "##{anchor}"
-									}
-
-									if value[:mixpanel_event_name]
-										props = {}
-										if value[:mixpanel_event_props].is_a? Hash
-											props = value[:mixpanel_event_props]
-										end
-										options[:onclick] = "mixpanel.track('#{value[:mixpanel_event_name]}', #{props.to_json.gsub('"',"'")})"
-									end
-
-									a options do
-										if value[:title].is_a? Symbol
-											icon value[:title]
-										else
-											text value[:title]
-										end
-									end
-								end
-							end
-
-							extra do 
-								div id: anchor, :class => cls do
-									div :class => "panel-body" do
-										text value[:elem].generate
-									end
-								end
-							end
-						end
-
-						cls = "panel-collapse collapse"
-					end
-
-				end
-
-			end
-
-			tabbar.generate
-		end
-
-	end
-
-	class Tabs
-		def initialize(page, anchors)
-			@anchors = anchors
-			@tabs = {}
-			@page = page
-			@orientation = :normal # :left, :right
-		end
-
-		def tab(title, &block)
-			
-			if !@anchors["tabs"]
-				@anchors["tabs"] = []
-			end
-
-			tabArray = @anchors["tabs"]
-
-			elem = Elements.new(@page, @anchors)
-			elem.instance_eval(&block)
-
-			tabname = "tab#{tabArray.length}"
-			tabArray << tabname
-
-			@tabs[tabname] = 
-			{
-				title: title,
-				elem: elem
-			}
-		end
-
-		def orientation(direction)
-			@orientation = direction
-		end
-
-		def generate
-
-			tabbar = Elements.new(@page, @anchors)
-			tabs = @tabs
-			orientation = @orientation
-
-			tabbar.instance_eval do
-
-				div :class => "tabs-container" do
-
-					div :class => "tabs-#{orientation}" do
-
-						ul :class => "nav nav-tabs" do
-							cls = "active"
-							tabs.each do |anchor, value|
-								li :class => cls do
-									a :"data-toggle" => "tab", href: "##{anchor}" do
-										if value[:title].is_a? Symbol
-											icon value[:title]
-										else
-											text value[:title]
-										end
-									end
-								end
-
-								cls = ""
-							end
-						end
-
-						div :class => "tab-content" do
-
-							cls = "tab-pane active"
-							tabs.each do |anchor, value|
-								div id: "#{anchor}", :class => cls do
-									div :class => "panel-body" do
-										text value[:elem].generate
-									end
-								end
-								cls = "tab-pane"
-							end
-						end
-					end
-
-				end
-			end
-
-			tabbar.generate
-		end
-	end
-
-	class Page
-	
-		attr_accessor :scripts, :onload_scripts
-
-		def initialize(title, global_settings, options, &block)
-			@title = title
-			@content = ""
-			@body_class = nil
-			@anchors = {}
-			@global_settings = global_settings
-			@options = options
-			@scripts = []
-			@top_content = ""
-
-			@scripts_once = {}
-			@onload_scripts = []
-
-			@requested_scripts = {}
-			@requested_css = {}
-
-			@background = Elements.new(self, @anchors)
-
-			@block = Proc.new &block
-		end
-
-		def create_anchor(name)
-
-			if !@anchors[name]
-				@anchors[name] = []
-			end
-
-			anchor_array = @anchors[name]
-
-			anchor_name = "#{name}#{anchor_array.length}"
-			anchor_array << anchor_name
-
-			anchor_name
-		end
-
-		def root
-			return @global_settings[:root]
-		end
-
-		def request_js(path)
-			@requested_scripts[path] = true
-		end
-
-		def request_css(path)
-			@requested_css[path] = true
-		end
-
-		def on_page_load(script)
-			@onload_scripts << script
-		end
-
-		def write_script_once(script)
-			@scripts_once[script] = true
-		end
-
-		def background(&block)
-			@background.instance_eval(&block)
-		end
-
-		def top(&block)
-			elem = Elements.new(self, @anchors)
-			elem.instance_eval(&block)
-
-			@top_content = elem.generate
-		end
-
-		def generate(back_folders, options={})
-
-			if @options[:cache_file] 
-				expired = @options[:cache_expired]
-				cache_exist = File.exist?("cache/cachedpage#{@options[:cache_file]}")
-
-				if cache_exist and !expired
-					puts "Weaver Hit cache for file: #{@options[:cache_file]}"
-					puts "- expired: #{expired}"
-					puts "- cache_exist: #{cache_exist}"
-					return File.read("cache/cachedpage#{@options[:cache_file]}");
-				end
-				puts "Weaver Miss cache for file: #{@options[:cache_file]}"
-				puts "- expired: #{expired}"
-				puts "- cache_exist: #{cache_exist}"
-			end
-
-			scripts = @scripts.join("\n")
-
-			mod = "../" * back_folders
-
-			style = <<-ENDSTYLE
-	<link href="#{mod}css/style.css" rel="stylesheet">
-			ENDSTYLE
-
-			if options[:style] == :empty
-				style = ""
-			end
-
-			body_tag = "<body>"
-
-			body_tag = "<body class='#{@body_class}'>" if @body_class
-
-			loading_bar = ""
-			loading_bar = "<script src='#{mod}js/plugins/pace/pace.min.js'></script>" if @loading_bar_visible
-
-			extra_scripts = @requested_scripts.map {|key,value| <<-SCRIPT_DECL
-    <script src="#{mod}#{key}"></script>
-				SCRIPT_DECL
-			}.join "\n"
-
-			extra_css = @requested_css.map {|key,value| <<-STYLESHEET_DECL
-    <link href="#{mod}#{key}" rel="stylesheet">
-				STYLESHEET_DECL
-			}.join "\n"
-
-			extra_one_time_scripts = @scripts_once.map {|key,value| <<-SCRIPT_DECL
-#{key}
-				SCRIPT_DECL
-			}.join "\n"
-
-			onload_scripts = @onload_scripts.map {|value| <<-SCRIPT_DECL
-#{value}
-				SCRIPT_DECL
-			}.join "\n"
-
-			extra_stuff = ""
-
-			if @global_settings[:mixpanel_token]
-				extra_stuff += '<!-- start Mixpanel --><script type="text/javascript">(function(e,a){if(!a.__SV){var b=window;try{var c,l,i,j=b.location,g=j.hash;c=function(a,b){return(l=a.match(RegExp(b+"=([^&]*)")))?l[1]:null};g&&c(g,"state")&&(i=JSON.parse(decodeURIComponent(c(g,"state"))),"mpeditor"===i.action&&(b.sessionStorage.setItem("_mpcehash",g),history.replaceState(i.desiredHash||"",e.title,j.pathname+j.search)))}catch(m){}var k,h;window.mixpanel=a;a._i=[];a.init=function(b,c,f){function e(b,a){var c=a.split(".");2==c.length&&(b=b[c[0]],a=c[1]);b[a]=function(){b.push([a].concat(Array.prototype.slice.call(arguments,
-0)))}}var d=a;"undefined"!==typeof f?d=a[f]=[]:f="mixpanel";d.people=d.people||[];d.toString=function(b){var a="mixpanel";"mixpanel"!==f&&(a+="."+f);b||(a+=" (stub)");return a};d.people.toString=function(){return d.toString(1)+".people (stub)"};k="disable time_event track track_pageview track_links track_forms register register_once alias unregister identify name_tag set_config reset opt_in_tracking opt_out_tracking has_opted_in_tracking has_opted_out_tracking clear_opt_in_out_tracking people.set people.set_once people.unset people.increment people.append people.union people.track_charge people.clear_charges people.delete_user".split(" ");
-for(h=0;h<k.length;h++)e(d,k[h]);a._i.push([b,c,f])};a.__SV=1.2;b=e.createElement("script");b.type="text/javascript";b.async=!0;b.src="undefined"!==typeof MIXPANEL_CUSTOM_LIB_URL?MIXPANEL_CUSTOM_LIB_URL:"file:"===e.location.protocol&&"//cdn4.mxpnl.com/libs/mixpanel-2-latest.min.js".match(/^\/\//)?"https://cdn4.mxpnl.com/libs/mixpanel-2-latest.min.js":"//cdn4.mxpnl.com/libs/mixpanel-2-latest.min.js";c=e.getElementsByTagName("script")[0];c.parentNode.insertBefore(b,c)}})(document,window.mixpanel||[]);
-mixpanel.init("'+@global_settings[:mixpanel_token]+'");</script><!-- end Mixpanel -->'
-			end
-
-			if @global_settings[:google_tracking_code]
-				extra_stuff += <<-GOOGLE
-<!-- Global site tag (gtag.js) - Google Analytics -->
-<script async src="https://www.googletagmanager.com/gtag/js?id=#{@global_settings[:google_tracking_code]}"></script>
-<script>
-  window.dataLayer = window.dataLayer || [];
-  function gtag(){dataLayer.push(arguments);}
-  gtag('js', new Date());
-
-  gtag('config', '#{@global_settings[:google_tracking_code]}');
-</script>
-				GOOGLE
-			end
-
-
-			result =<<-SKELETON
-<!DOCTYPE html>
-<html>
-<!-- Generated using weaver: https://github.com/davidsiaw/weaver -->
-<head>
-
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-
-    <title>#{@title}</title>
-
-    <link href="#{mod}css/bootstrap.min.css" rel="stylesheet">
-    <link href="#{mod}font-awesome/css/font-awesome.css" rel="stylesheet">
-    <link href="#{mod}css/plugins/iCheck/custom.css" rel="stylesheet">
-
-    #{style}
-
-    <link href="#{mod}css/animate.css" rel="stylesheet">
-    
-#{extra_css}
-
-#{extra_stuff}
-
-</head>
-
-#{body_tag}
-
-<div id="background" style="z-index: -999; position:absolute; left:0px; right:0px; width:100%; height:100%">
-#{@background.generate}
-</div>
-
-<div id="content" style="z-index: 0">
-#{@top_content}
-#{@content}
-</div>
-
-    <!-- Mainly scripts -->
-    <script src="#{mod}js/jquery-3.1.1.min.js"></script>
-    <script src="#{mod}js/jquery-ui-1.10.4.min.js"></script>
-    <script src="#{mod}js/bootstrap.min.js"></script>
-    <script src="#{mod}js/plugins/metisMenu/jquery.metisMenu.js"></script>
-    <script src="#{mod}js/plugins/slimscroll/jquery.slimscroll.min.js"></script>
-	<script type="text/x-mathjax-config">
-		MathJax.Hub.Config({
-			asciimath2jax: {
-				delimiters: [['$$$MATH$$$','$$$ENDMATH$$$']]
-			}
-		});
-	</script>
-    <script src="#{mod}js/MathJax/MathJax.js?config=AM_HTMLorMML-full" async></script>
-
-#{extra_scripts}
-
-
-    <!-- Custom and plugin javascript -->
-    <script src="#{mod}js/weaver.js"></script>
-    #{loading_bar}
-
-    <script>
-#{scripts}
-#{extra_one_time_scripts}
-
-$( document ).ready(function() {
-
-#{onload_scripts}
-
-});
-    </script>
-
-    
-
-</body>
-
-</html>
-
-			SKELETON
-
-			if @options[:cache_file]
-				FileUtils.mkdir_p "cache"
-				File.write("cache/cachedpage#{@options[:cache_file]}", result);
-			end
-
-			return result
-
-		end
-	end
-
-	class Row < Elements
-		attr_accessor :extra_classes, :style
-
-		def initialize(page, anchors, options)
-			@columns = []
-			@free = 12
-			@extra_classes = options[:class] || ""
-			@style = options[:style]
-			@anchors = anchors
-			@page = page
-		end
-
-		def col(occupies, options={}, &block)
-			raise "Not enough columns!" if @free < occupies
-			elem = Elements.new(@page, @anchors)
-			elem.instance_eval(&block)
-
-			@columns << { occupy: occupies, elem: elem, options: options }
-			@free -= occupies 
-		end
-
-		def generate
-
-			@columns.map { |col|
-
-				xs = col[:options][:xs] || col[:occupy]
-				sm = col[:options][:sm] || col[:occupy]
-				md = col[:options][:md] || col[:occupy]
-				lg = col[:options][:lg] || col[:occupy]
-
-				hidden = ""
-
-				xs_style = "col-xs-#{xs}" unless col[:options][:xs] == 0
-				sm_style = "col-sm-#{sm}" unless col[:options][:sm] == 0
-				md_style = "col-md-#{md}" unless col[:options][:md] == 0
-				lg_style = "col-lg-#{lg}" unless col[:options][:lg] == 0
-
-				hidden += "hidden-xs " if col[:options][:xs] == 0
-				hidden += "hidden-sm " if col[:options][:sm] == 0
-				hidden += "hidden-md " if col[:options][:md] == 0
-				hidden += "hidden-lg " if col[:options][:lg] == 0
-
-				<<-ENDCOLUMN
-		<div class="#{xs_style} #{sm_style} #{md_style} #{lg_style} #{hidden}">
-			#{col[:elem].generate}
-		</div>
-				ENDCOLUMN
-			}.join
-		end
-	end
-
-	class Menu
-		attr_accessor :items
-		def initialize()
-			@items = []
-		end
-
-		def nav(name, icon=:question, url=nil, options={}, &block)
-			if url and !block
-				@items << { name: name, link: url, icon: icon, options: options }
-			elsif block
-				menu = Menu.new
-				menu.instance_eval(&block)
-				@items << { name: name, menu: menu, icon: icon, options: options }
-			else
-				@items << { name: name, link: "#", icon: icon, options: options }
-			end
-		end
-	end
-
-	class StructuredPage < Page
-
-		def initialize(title, global_settings, options, &block)
-			@rows = []
-			super
-		end
-
-		def header(&block)
-			row(class: "wrapper border-bottom white-bg page-heading", &block)
-		end
-
-		def row(options={}, &block)
-			r = Row.new(self, @anchors, options)
-			r.instance_eval(&block)
-			@rows << r
-		end
-
-
-	end
-
-	class NavPage < StructuredPage
-		def initialize(title, global_settings, options, &block)
-			super
-			@menu = Menu.new
-		end
-
-		def menu(&block)
-			@menu.instance_eval(&block)
-		end
-
-		def brand(text, link="/")
-			@brand = text
-			@brand_link = link
-		end
-
-	end
-
-	class SideNavPage < NavPage
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(level)
-			instance_eval &@block
-			rows = @rows.map { |row|
-				<<-ENDROW
-	<div class="row #{row.extra_classes}" style="#{row.style}">
-#{row.generate}
-	</div>
-				ENDROW
-			}.join
-
-			menu = @menu
-
-			navigation = Elements.new(self, @anchors)
-			navigation.instance_eval do
-
-				menu.items.each do |item|
-					li item[:options] do
-						if item.has_key? :menu
-
-							hyperlink "/#" do
-								icon item[:icon]
-								span :class => "nav-label" do
-									text item[:name]
-								end
-								span :class => "fa arrow" do
-									text ""
-								end
-							end
-
-							open = ""
-							open = "collapse in" if item[:options][:open]
-            				ul :class => "nav nav-second-level #{open}" do
-            					item[:menu].items.each do |inneritem|
-            						li inneritem[:options] do
-            							if inneritem.has_key?(:menu)
-            								raise "Second level menu not supported"
-            							else
-											hyperlink "#{inneritem[:link]}" do
-												icon inneritem[:icon]
-												span :class => "nav-label" do
-													text inneritem[:name]
-												end
-											end
-            							end
-            						end
-            					end
-                    		end
-						elsif
-							hyperlink "#{item[:link]}" do
-								icon item[:icon]
-								span :class => "nav-label" do
-									text item[:name]
-								end
-							end
-						end
-					end
-				end
-
-			end
-
-			brand_content = "" 
-
-			if @brand
-				brand_content = <<-BRAND_CONTENT
-
-	                <li>
-	                    <a href="#{root}"><i class="fa fa-home"></i> <span class="nav-label">#{@brand}</span> <span class="label label-primary pull-right"></span></a>
-	                </li>
-				BRAND_CONTENT
-			end
-
-			@loading_bar_visible = true
-			@content =
-			<<-ENDBODY
-	<div id="wrapper">
-
-		<nav class="navbar-default navbar-static-side" role="navigation">
-			<div class="sidebar-collapse">
-				<ul class="nav" id="side-menu">
-
-#{brand_content}
-#{navigation.generate}
-
-				</ul>
-			</div>
-		</nav>
-		<div id="page-wrapper" class="gray-bg">
-			<div class="row border-bottom">
-		        <nav class="navbar navbar-static-top  " role="navigation" style="margin-bottom: 0">
-					<div class="navbar-header">
-					    <a class="navbar-minimalize minimalize-styl-2 btn btn-primary " href="#"><i class="fa fa-bars"></i> </a>
-					</div>
-		            <ul class="nav navbar-top-links navbar-right">
-		                <!-- NAV RIGHT -->
-		            </ul>
-		        </nav>
-	        </div>
-#{rows}
-		</div>
-	</div>
-			ENDBODY
-
-			super
-		end
-	end
-
-	class TopNavPage < NavPage
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(level)
-			instance_eval &@block
-			rows = @rows.map { |row|
-				<<-ENDROW
-	<div class="row #{row.extra_classes}" style="#{row.style}">
-#{row.generate}
-	</div>
-				ENDROW
-			}.join
-
-			@body_class = "top-navigation"
-			@loading_bar_visible = true
-
-			menu = @menu
-
-			navigation = Elements.new(self, @anchors)
-			navigation.instance_eval do
-
-				menu.items.each do |item|
-					li item[:options] do
-						if item.has_key? :menu
-
-                    		li :class => "dropdown" do
-                    			a :"aria-expanded" => "false", 
-                    				role: "button", 
-                    				href: "#", 
-                    				:class => "dropdown-toggle", 
-                    				:"data-toggle" => "dropdown" do
-
-									icon item[:icon]
-                    				text item[:name]
-                    				span :class => "caret" do
-                    					text ""
-                    				end
-
-                    			end
-                				ul role: "menu", :class => "dropdown-menu" do
-                					item[:menu].items.each do |inneritem|
-                						li inneritem[:options] do
-                							if inneritem.has_key?(:menu)
-                								raise "Second level menu not supported"
-                							else
-	                							hyperlink inneritem[:link], inneritem[:name]
-                							end
-                						end
-                					end
-                				end
-                    		end
-						elsif
-							hyperlink "#{item[:link]}" do
-								span :class => "nav-label" do
-									icon item[:icon]
-									text item[:name]
-								end
-							end
-						end
-					end if item[:options][:position] != :right
-				end
-
-			end
-
-			navigation_right = Elements.new(self, @anchors)
-			navigation_right.instance_eval do
-
-				menu.items.each do |item|
-					li item[:options] do
-						if item.has_key? :menu
-
-                    		li :class => "dropdown" do
-                    			a :"aria-expanded" => "false", 
-                    				role: "button", 
-                    				href: "#", 
-                    				:class => "dropdown-toggle", 
-                    				:"data-toggle" => "dropdown" do
-
-									icon item[:icon]
-                    				text item[:name]
-                    				span :class => "caret" do
-                    					text ""
-                    				end
-
-                    			end
-                				ul role: "menu", :class => "dropdown-menu" do
-                					item[:menu].items.each do |inneritem|
-                						li inneritem[:options] do
-                							if inneritem.has_key?(:menu)
-                								raise "Second level menu not supported"
-                							else
-	                							hyperlink inneritem[:link], inneritem[:name]
-                							end
-                						end
-                					end
-                				end
-                    		end
-						elsif
-							hyperlink "#{item[:link]}" do
-								span :class => "nav-label" do
-									icon item[:icon]
-									text item[:name]
-								end
-							end
-						end
-					end if item[:options][:position] == :right
-				end
-
-			end
-
-
-			brand_content = "" 
-
-			if @brand
-				brand_content = <<-BRAND_CONTENT
-
-				    <div class="navbar-header">
-
-						<a href="#{root}" class="navbar-brand">#{@brand}</a>
-		            </div>
-				BRAND_CONTENT
-			end
-
-			@content =
-			<<-ENDBODY
-	<div id="wrapper">
-
-        <div id="page-wrapper" class="gray-bg">
-	        <div class="row border-bottom white-bg">
-
-				<nav class="navbar navbar-static-top" role="navigation">
-	                <button aria-controls="navbar" aria-expanded="false" data-target="#navbar" data-toggle="collapse" class="navbar-toggle collapsed" type="button">
-	                    <i class="fa fa-reorder"></i>
-	                </button>
-#{brand_content}
-
-		            <div class="navbar-collapse collapse" id="navbar">
-		                <ul class="nav navbar-nav">
-#{navigation.generate}
-		                </ul>
-		                <ul class="nav navbar-top-links navbar-right">
-#{navigation_right.generate}
-		                </ul>
-		            </div>
-
-
-
-				</nav>
-			</div>
-
-
-	        <div class="wrapper-content">
-	            <div class="container">
-#{rows}
-	            </div>
-			</div>
-		</div>
-	</div>
-			ENDBODY
-
-			super
-		end
-	end
-
-	class NonNavPage < StructuredPage
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(level)
-			instance_eval &@block
-			rows = @rows.map { |row|
-				<<-ENDROW
-	<div class="row #{row.extra_classes}">
-#{row.generate}
-	</div>
-				ENDROW
-			}.join
-
-			@body_class = "gray-bg"
-
-			@content = <<-CONTENT
-	<div id="wrapper">
-	        <div class="wrapper-content">
-	            <div class="container">
-#{rows}
-	            </div>
-			</div>
-		</div>
-			CONTENT
-			super
-		end
-	end
-
-	class RawPage < Page
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(back_folders, options={})
-
-			elem = Elements.new(self, {})
-			elem.instance_eval(&@block)
-
-			elem.generate
-		end
-
-	end
-
-	class EmptyPage < Page
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(level)
-			elem = Elements.new(self, {})
-			elem.instance_eval(&@block)
-			@body_class = "gray-bg"
-			@content = <<-CONTENT
-	<div id="wrapper">
-	        <div class="wrapper-content">
-	            <div class="container">
-#{elem.generate}
-	            </div>
-			</div>
-		</div>
-			CONTENT
-			super
-		end
-	end
-
-
-	class CenterPage < Page
-		def initialize(title, global_settings, options, &block)
-			super
-		end
-
-		def generate(level)
-
-			elem = Elements.new(self, {})
-			elem.instance_eval(&@block)
-
-			@body_class = "gray-bg"
-			@content = <<-CONTENT
-	<div class="middle-box text-center animated fadeInDown">
-		<div>
-			#{elem.generate}
-		</div>
-	</div>
-			CONTENT
-			super
-		end
-	end
-
-	class Weave
-		attr_accessor :pages
-		def initialize(file, options={})
-			@pages = {}
-			@file = file
-			@global_settings = options
-
-			@global_settings[:root] = @global_settings[:root] || "/"
-			@global_settings[:root] = "#{@global_settings[:root]}/" unless @global_settings[:root].end_with? "/"
-			instance_eval(File.read(file), file)
-		end
-
-		def set_global(key, value)
-			@global_settings[key] = value
-		end
-
-		def center_page(path, title=nil, options={}, &block)
-
-			if title == nil
-				title = path
-				path = ""
-			end
-
-			p = CenterPage.new(title, @global_settings, options, &block)
-			@pages[path] = p
-		end
-
-		def sidenav_page(path, title=nil, options={}, &block)
-
-			if title == nil
-				title = path
-				path = ""
-			end
-
-			p = SideNavPage.new(title, @global_settings, options, &block)
-			@pages[path] = p
-		end
-
-		def topnav_page(path, title=nil, options={}, &block)
-
-			if title == nil
-				title = path
-				path = ""
-			end
-
-			p = TopNavPage.new(title, @global_settings, options, &block)
-			@pages[path] = p
-		end
-
-		def nonnav_page(path, title=nil, options={}, &block)
-
-			if title == nil
-				title = path
-				path = ""
-			end
-
-			p = NonNavPage.new(title, @global_settings, options, &block)
-			@pages[path] = p
-		end
-		
-
-		def empty_page(path, title=nil, options={}, &block)
-
-			if title == nil
-				title = path
-				path = ""
-			end
-
-			p = EmptyPage.new(title, @global_settings, options, &block)
-			@pages[path] = p
-		end
-
-		def raw_page(path="", options={}, &block)
-
-			# raw pages dont even have a title
-
-			p = RawPage.new("", @global_settings, options, &block)
-			@pages[path] = p
-		end
-
-		def include(file)
-			dir = File.dirname(@file)
-			filename = File.join([dir, file])
-			File.read(filename)
-			load filename
-		end
-	end
-end
+require 'weaver/weave'
+
+require 'weaver/page_types/page'
+require 'weaver/page_types/center_page'
+require 'weaver/page_types/empty_page'
+require 'weaver/page_types/raw_page'
+require 'weaver/page_types/nonnav_page'
+require 'weaver/page_types/sidenav_page'
+require 'weaver/page_types/topnav_page'
+
+require 'weaver/elements'
+
+require 'weaver/element_types/accordion'
+require 'weaver/element_types/action'
+require 'weaver/element_types/code'
+require 'weaver/element_types/dynamic_table'
+require 'weaver/element_types/form'
+require 'weaver/element_types/javascript_object'
+require 'weaver/element_types/modal_dialog'
+require 'weaver/element_types/panel'
+require 'weaver/element_types/row'
+require 'weaver/element_types/tabs'
+require 'weaver/element_types/textfield_javascript'