RubyGems - demeler - Versions diffs - 1.0.0 - Mend

demeler 1.0.0

Files changed (11) hide show

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60dd5907473caf7a0f8963ed8a5ef41c7c56ba7a
+  data.tar.gz: 9ef767a5cbf325bf6456b2a08d1b9a668e0317b7
+SHA512:
+  metadata.gz: 885c065028088be8c1d2545c3cd31d755b9a9cf6a1dc747a376cf8c1502bd12647ba12a59abf14b07016689446c37f3da10473c153387c919d0fea824dd01ee6
+  data.tar.gz: 4409d084b43ec05c2ccd3060023840a237695ed0038acfedc00c7f91088d60f3366a441f19437526bda1926edbdb7f30b35bbc67acc0901d9a4b4cf9ad17b7f2

data/.gitignore ADDED Viewed

File without changes

data/CHANGELOG.md ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ # 1.0.0
2	+ * Initial version.

data/LICENSE.md ADDED Viewed

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+## Copyright ©2017 Michael J. Welch, Ph.D.
+Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the "Software"), to dealin the Software without restriction, including without limitation the rightsto use, copy, modify, merge, publish, distribute, sublicense, and/or sellcopies of the Software, and to permit persons to whom the Software isfurnished to do so, subject to the following conditions:
+###The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.
+###THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THESOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,383 @@
+# Demeler Gem
+### Copyright (c) 2017 Michael J Welch, Ph.D. mjwelchphd@gmail.com
+All files in this distribution are subject to the terms of the MIT license.
+This gem builds HTML code on-the-fly. The advantages are: (1) HTML code is properly formed with respect to tags and nesting; and (2) the code is dynamic, i.e., values from an object containing data (if used) are automatically extracted and inserted into the resultant HTML code, and (3) if there are errors, the error message is generated also.
+The French word démêler means "to unravel," and that's sort of what this gem does. Démêler is pronounced "day-meh-lay." It unravels your inputs to form HTML code. The diacritical marks are not used in the name for compatibility.
+This class doesn't depend on any particular framework, but I use it with Ruby Sequel.
+## The Demeler gem generates HTML from three inputs:
+* A Ruby source file you write;
+* A Hash-based object you provide, like Sequel::Model objects
+* An errors list inside the Hash-based object
+Let's start with the most basic form, a simple example. Run `irb` and enter this:
+```ruby
+require 'demeler'
+html = Demeler.build(nil,true) do
+  html do
+    head do
+      title "Hello, World!"
+    end
+    body do
+      h1 "Hello, World!"
+    end
+  end
+end
+puts html
+```
+You'll get the html code like this:
+```html
+<!-- begin generated output -->
+<html>
+ <head>
+  <title>Hello, World!</title>
+ </head>
+ <body>
+  <h1>Hello, World!</h1>
+ </body>
+</html>
+<!-- end generated output -->
+```
+### Why bother with Demeler? Why not just write HTML?
+There are several reasons to use this gem:
+* You write in Ruby code
+* Demeler balances out all the HTML tags
+* Demeler optionally formats the HTML, producing human readable output
+* Demeler can receive an object with data (such as a Sequel::Model object), and automatically insert the values
+* Demeler can insert error messages your controller inserts into the object
+## You can also use the gem directly
+You can instantiate a Demeler object, and call its methods:
+```ruby
+require 'demeler'
+d = Demeler.new
+d.html do
+  d.head do
+    d.title("Hello, World!")
+  end
+  d.body do
+    d.h1("Hello, World!")
+  end
+end
+puts d.to_html
+```
+## Fields from an object can be inserted automatically
+You can automatically load the values from a Sequel::Model object, or you can define an object and use it in place of Sequel. To define an object, use a definition similar to this:
+```ruby
+  class Obj<Hash
+    attr_accessor :errors
+    def initialize
+      @errors = {}
+    end
+  end
+```
+Your new object is just a Hash+, so you can assign it values like this:
+```ruby
+  obj = Obj.new
+  obj[:username] = "michael"
+  obj[:password] = "my-password"
+```
+The object can now be used to fill `input` fields in a form:
+```ruby
+  html = Demeler.build(obj,true) do
+    text :username
+    password :password
+  end
+  puts html
+```
+That code will automatically insert the values from `obj` for you.
+> _NOTE: When the first argument is a symbol, it is used as the name of the field._
+```html
+<!-- begin generated output -->
+<input name="username" type="text" value="michael" />
+<input name="password" type="password" value="my-password" />
+<!-- end generated output -->
+```
+### Demeler creates error messages, too
+You can put an error message into the object you created if your validation finds something wrong. Just insert a Hash element with the name of the element, and an array of lines, thusly:
+```ruby
+  obj = Obj.new
+  obj[:username] = "michael"
+  obj[:password] = "my-password"
+  obj.errors[:username] = ["This username is already taken"]
+  html = Demeler.build(obj,true) do
+    text :username
+    password :password
+  end
+  puts html
+```
+This will generate the HTML with the added message, as well:
+```html
+<!-- begin generated output -->
+<input name="username" type="text" value="michael" /><warn> <-- This username is already taken</warn>
+<input name="password" type="password" value="my-password" />
+<!-- end generated output -->
+```
+Notice that the error is surrounded by `<warn>...</warn>` tags. You can define how you want those to format the message using CSS. For example, if you just want the message to be displayed in red, use:
+```ruby
+  style "warn {color: red;}"
+```
+in your Demeler code like this:
+```ruby
+  html = Demeler.build(obj,true) do
+    style "warn {color: red;}"
+    text :username
+    password :password
+  end
+  puts html
+```
+## Adding attributes to your tags
+You can add attributes by just adding them to the end of the tag. For example, if I want the username input tag to display in with a blue background, I can use:
+```ruby
+  html = Demeler.build(obj,true) do
+    style ".blue {color: blue;}"
+    text :username, :class=>"blue"
+    password :password
+  end
+  puts html
+```
+The HTML code generated will be:
+```html
+<!-- begin generated output -->
+<style>.blue {color: blue;}</style>
+<input name="username" class="blue" type="text" value="michael" /><warn> <-- This username is already taken</warn>
+<input name="password" type="password" value="my-password" />
+<!-- end generated output -->
+```
+Any attribute can be added in this way.
+## Embedding text between tags on one line
+Normally, anything in brackets {} is embedded like this: `p{"Some text."}` yields:
+```html
+<!-- begin generated output -->
+<p>
+ Some text.
+</p>
+<!-- end generated output -->
+```
+You can make it come out on one line by using the :text attribute: `p :text=>"Some text."` yields:
+```html
+<!-- begin generated output -->
+<p>Some text.</p>
+<!-- end generated output -->
+```
+In most cases, this can be achieved just by eliminating the {}: `p "Some text." yields:
+```html
+<!-- begin generated output -->
+<p>Some text.</p>
+<!-- end generated output -->
+```
+This is because the solo string is converted to a :text argument automatically.
+## Demeler Interface Definitions
+The Demeler gem accepts any random tag you want to give it, but non-input tags and input tags are treated differently. Input tags are :button, :checkbox, :color, :date, :datetime_local, :email, :hidden, :image, :month, :number, :password, :range, :radio, :reset, :search, :select, :submit, :tel, :text, :time, :url, and :week. All other tags are non-input tags.
+Input tags are treated differently because they have special characteristics, like automatically setting from a form object passed to Demeler. Therefore, we'll start with non-input tags first.
+Non-input tags can accept a variety of parameter arrangements to allow for different situations. Each different situation is described below, and there are examples to help you understand.
+### Non-Input Tag Parameter Formats
+#### tag opts
+_Opts is a Hash with attributes._
+```ruby
+puts (Demeler.build(nil, true) do
+  div :class=>"div-class" do
+    "..."
+  end
+end)
+<!-- begin generated output -->
+<div class="div-class">
+ ...
+</div>
+<!-- end generated output -->
+```
+#### tag
+_A solo tag._
+```ruby
+puts (Demeler.build(nil, true) do
+  br
+end)
+<!-- begin generated output -->
+<br />
+<!-- end generated output -->
+```
+#### tag string
+_A solo string._
+```ruby
+puts (Demeler.build(nil, true) do
+  p "This is a paragraph."
+end)
+<!-- begin generated output -->
+<p>This is a paragraph.</p>
+<!-- end generated output -->
+```
+_Or for longer text, you can use the block format._
+```ruby
+puts (Demeler.build(nil, true) do
+  p { "Un débris de hameau où quatre maisons fleuries d'orchis émergent des blés drus et hauts. Ce sont les Bastides Blanches, à mi-chemin entre la plaine et le grand désert lavandier, à l'ombre des monts de Lure. C'est là que vivent douze personnes, deux ménages, plus Gagou l'innocent." }
+end)
+<!-- begin generated output -->
+<p>
+ Un débris de hameau où quatre maisons fleuries d'orchis émergent des blés drus et hauts. Ce sont les Bastides Blanches, à mi-chemin entre la plaine et le grand désert lavandier, à l'ombre des monts de Lure. C'est là que vivent douze personnes, deux ménages, plus Gagou l'innocent.
+</p>
+```
+#### tag symbol
+_The symbol is used as the name of the tag._ This option is used with input tags (see below).
+#### tag symbol, hash
+_This option generates_
+#### tag symbol, string
+_This option generates a tag with the name **symbol**, and the string between beginning and ending tags. If the tag is a :label, and the `label for` matches an `input name`, if the `input` has no `id`, one will be added.
+```ruby
+puts (Demeler.build(nil, true) do
+  label :username, "Enter Username"
+  text :username
+end)
+<!-- begin generated output -->
+<label for="username">Enter Username</label>
+<input name="username" type="text" id="username" />
+<!-- end generated output -->
+```
+_Tags other than `label` will have a `name` attribute instead of a `for` attribute._
+## A Bigger Example of a Demeler Script
+### Generate a login screen.
+This example will be expanded in the future.
+The Ruby code:
+```ruby
+html = Demeler.build(nil,true) do
+  h1("Please Login")
+  form(:method=>:post, :action=>"/authenticate") do
+    table do
+      tr do
+        td { label(:username, "User Name") }
+        td { text(:username, :size=>30) }
+      end
+      tr do
+        td { label(:password, "Password") }
+        td { password(:password, :size=>30) }
+      end
+      tr do
+        td {}
+        td { submit("Log In") }
+      end
+    end
+  end
+  p { alink("Forgot password?", :href=>"/forgot") }
+end
+```
+The generated HTML:
+```html
+<!-- begin generated output -->
+<h1>Please Login</h1>
+<form method="post" action="/authenticate">
+ <table>
+  <tr>
+   <td>
+    <label for="username">User Name</label>
+   </td>
+   <td>
+    <input name="username" size="30" type="text" id="username" />
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <label for="password">Password</label>
+   </td>
+   <td>
+    <input name="password" size="30" type="password" id="password" />
+   </td>
+  </tr>
+  <tr>
+   <td>
+   </td>
+   <td>
+    <input type="submit" value="Log In" />
+   </td>
+  </tr>
+ </table>
+</form>
+<p>
+ <a href="/forgot">Forgot password?</a>
+</p>
+<!-- end generated output -->
+```

data/demeler.gemspec ADDED Viewed

@@ -0,0 +1,15 @@
+require_relative File.dirname(__FILE__) + '/lib/demeler/version'
+include Version
+Gem::Specification.new do |s|
+  s.author        = "Michael J. Welch, Ph.D."
+  s.files         = Dir.glob(["CHANGELOG.md", "LICENSE.md", "README.md", "demeler.gemspec", "lib/*", "lib/demeler/*", "notes", "spec/*", ".gitignore"])
+  s.name          = 'demeler'
+  s.require_paths = ["lib"]
+  s.summary       = 'Yet another HTML generator.'
+  s.version       = VERSION
+  s.date          = MODIFIED
+  s.email         = 'mjwelchphd@gmail.com'
+  s.homepage      = 'http://rubygems.org/gems/demeler'
+  s.license       = 'MIT'
+  s.description   = "This gem takes your ruby input, plus an object such as a Sequel::Model object, and generates HTML code. If the object has values, they're inserted into the HTML, and if the object has error messages, code is generated to display them. You can use CSS, but it's not automated in this class of methods."
+end

data/lib/demeler/version.rb ADDED Viewed

@@ -0,0 +1,4 @@
+module Version
+  VERSION = "1.0.0"
+  MODIFIED = "2017-06-10"
+end

data/lib/demeler.rb ADDED Viewed

@@ -0,0 +1,401 @@
+# Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# Copyright (c) 2017 Michael J Welch, Ph.D. mjwelchphd@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+#
+# This work was based on Fellinger's Gestalt and Blueform, but is essentially
+# a completely new version which is not a drop-in replacement for either.
+# There's probably less than a dozen lines of Fellinger's original code left here.
+# Nevertheless, the basic concept is Fellinger's, and it's a good one.
+#
+# This gem builds HTML code on-the-fly. The advantages are: (1) HTML code is
+# properly formed with respect to tags and nesting; and (2) the code is dynamic,
+# i.e., values from an object containing data (if used) are automatically
+# extracted and inserted into the resultant HTML code, and if there are errors,
+# the error message is generated also.
+#
+# The French word démêler means "to unravel," and that's sort of what this gem
+# does. It unravels your inputs to form HTML code. The diacritical marks are
+# not used in the name for compatibility.
+#
+# This class doesn't depend on any particular framework, but I use it with
+# Ruby Sequel.
+class Demeler
+  attr_reader :out, :obj
+  # These calls are effectively generated in the same way as 'text' input
+  # tags. Method_missing just does a substitution to implement them.
+  MethodsLikeInputText = [:button, :color, :date, :datetime_local, :email, \
+    :hidden, :image, :month, :number, :password, :range, :reset, :search, \
+    :submit, :tel, :text, :time, :url, :week]
+  ##
+  # The default way to start building your markup.
+  # Takes a block and returns the markup.
+  #
+  # @param [Proc] block
+  #
+  def self.build(obj=nil, gen_html=false, &block)
+    demeler = self.new(obj, &block)
+    if gen_html then demeler.to_html else demeler.to_s end
+  end
+  ##
+  # Demeler.new builds HTML from Ruby code.
+  # You can either access #out, .to_s or .to_html to
+  # return the actual markup.
+  #
+  # A note of warning: you'll get extra spaces in textareas if you use .to_html.
+  #
+  # @param [object] obj--a Sequel::Model object, or Hash object with an added 'errors' field.
+  #
+  # To use this without Sequel, you can use an object like this:
+  # class Obj<Hash
+  #   attr_accessor :errors
+  #   def initialize
+  #     @errors = {}
+  #   end
+  # end
+  #
+  def initialize(obj=nil, &block)
+    raise ArgumentError.new("The object passed to Demeler must have an errors field containing a Hash") if obj && !defined?(obj.errors)
+    @obj = obj
+    clear
+    instance_eval(&block) if block_given?
+  end
+  ##
+  # Clear out the data in order to start over with the same Demeler obj
+  #
+  def clear
+    @level = 0
+    @out = []
+    @labels = []
+  end
+  ##
+  # Catch tag calls that have not been pre-defined.
+  #
+  # @param [String] meth The method that was called.
+  # @param [Hash] args Additional arguments passed to the called method.
+  # @param [Proc] block.
+  #
+  def method_missing(meth, *args, &block)
+    # This code allows for some input tags that work like <input type="text" ...> to
+    # work--for example g.password works in place of g.input(:type=>:password, ...)
+    if MethodsLikeInputText.index(meth) # TODO!
+      args << {} if !args[-1].kind_of?(Hash)
+      args.last[:type] = meth
+      meth = :input
+    end
+    tag_generator(meth, args, &block)
+  end
+  ##
+  # Workaround for Kernel#p to make <p /> tags possible.
+  #
+  # @param [Hash] args Extra arguments that should be processed before
+  #  creating the paragraph tag.
+  # @param [Proc] block
+  #
+  def p(*args, &block)
+    tag_generator(:p, args, &block)
+  end
+  ##
+  # The #alink method simplyfies the generation of <a>...</a> tags
+  #
+  # @param [Array] args Extra arguments that should be processed before
+  #  creating the 'a' tag.
+  # @param [Proc] block
+  #
+  def alink(text, args={})
+    raise ArgumentError.new("In Demeler#alink, expected String for argument 1, text") if !text.kind_of?(String)
+    raise ArgumentError.new("In Demeler#alink, expected Hash for argument 2, opts") if !args.kind_of?(Hash)
+    raise ArgumentError.new("In Demeler#alink, expected an href option in opts") if !args[:href]
+    opts = args.clone
+    opts[:text] = text
+    tag_generator(:a, opts)
+  end
+  ##
+  # The checkbox shortcut
+  #
+  # @param [Symbol] name Base Name of the control (numbers 1..n will be added)
+  # @param [Hash] opts Attributes for the control
+  # @param [Hash] value=>nomenclature pairs
+  #
+  # @example
+  #  g.checkbox(:vehicle, opts, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+  # @object [Sequel::Model]
+  #
+  #
+  # @note: first argument becomes the :name plus a number starting at 1, i.e., "vehicle1", etc.
+  #
+  def checkbox(name, opts, values)
+    raise ArgumentError.new("In Demeler#checkbox, expected Symbol for argument 1, name") if !name.kind_of?(Symbol)
+    raise ArgumentError.new("In Demeler#checkbox, expected Hash for argument 2, opts") if !opts.kind_of?(Hash)
+    raise ArgumentError.new("In Demeler#checkbox, expected Hash for argument 3, values") if !values.kind_of?(Hash)
+    n = 0
+    data = if @obj then @obj[name] else nil end
+    case data.class.name
+    when "String"
+      data = data.split(",")
+    when "Array"
+      # it's alreay in the form we want
+    when "Hash"
+      data = data.values
+    else
+      data = nil
+    end
+    values.each do |value,nomenclature|
+      sets = opts.clone
+      sets[:name] = "#{name}[#{n+=1}]".to_sym
+      sets[:type] = :checkbox
+      sets[:value] = value
+      sets[:text] = nomenclature
+      sets[:checked] = 'true' if data && data.index(value.to_s)
+      tag_generator(:input, sets)
+    end
+  end
+  ##
+  # The radio shortcut
+  #
+  # @param [Hash] args Attributes for the control
+  #
+  # @example
+  #  g.radio(:name=>:vehicle, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+  #
+  # @note: first argument is the :name; without the name, the radio control won't work
+  #
+  def radio(name, opts, values)
+    raise ArgumentError.new("In Demeler#radio, expected Symbol for argument 1, name") if !name.kind_of?(Symbol)
+    raise ArgumentError.new("In Demeler#radio, expected Hash for argument 2, opts") if !opts.kind_of?(Hash)
+    raise ArgumentError.new("In Demeler#radio, expected Hash for argument 3, values") if !values.kind_of?(Hash)
+    data = if @obj then @obj[name] else nil end
+    values.each do |value,nomenclature|
+      sets = opts.clone
+      sets[:name] = "#{name}".to_sym
+      sets[:type] = :radio
+      sets[:value] = value
+      sets[:text] = nomenclature
+      sets[:checked] = 'true' if data==value.to_s
+      tag_generator(:input, sets)
+    end
+  end
+  ##
+  # The select (select_tag) shortcut
+  #
+  # @param [Symbol] name The name of the SELECT statement
+  # @param [Hash] opts Options for the SELECT statement
+  # @param [Hash] args Attributes (OPTIONS) for the SELECT
+  #
+  # @example
+  #  g.select(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+  #
+  # @note: first argument is the :name=>"vehicle"
+  # @note: the second argument is a Hash or nil
+  #
+  def select(name, opts, values)
+    raise ArgumentError.new("In Demeler#select, expected Symbol for argument 1, name") if !name.kind_of?(Symbol)
+    raise ArgumentError.new("In Demeler#select, expected Hash for argument 2, opts") if !opts.kind_of?(Hash)
+    raise ArgumentError.new("In Demeler#select, expected Hash for argument 3, values") if !values.kind_of?(Hash)
+    opts = {:name=>name}
+    opts.merge!(opts)
+    data = if @obj then @obj[name] else nil end
+    tag_generator(:select, [opts]) do
+      values.each do |value,nomenclature|
+        sets = {:value=>value}
+        sets[:selected] = 'true' if data==value.to_s
+        sets[:text] = nomenclature
+        tag_generator(:option, [sets])
+      end
+    end
+  end
+  ##
+  # The submit shortcut
+  #
+  # @param [String] text The text which the button will display
+  # @param [Hash] opts Options for the SUBMIT statement
+  #
+  # @example
+  #  g.submit("Accept Changes", {})
+  #
+  def submit(text, opts={})
+    attr = {:type=>:submit}
+    attr[:value] = text
+    attr.merge!(opts)
+    tag_generator(:input, attr)
+  end
+  ##
+  # The tag_generator method
+  #
+  # @param [Symbol] meth The type of control to be generated
+  # @param [Hash] args Options for the tag being generated
+  # @param [Proc] block A block which will be called to get input or nest tags
+  #
+  # @note The :text option will insert text between the opening and closing tag;
+  #   It's useful to create one-line tags with text inserted.
+  #
+  def tag_generator(meth, args=[], &block)
+    # this check catches a loop before it bombs the Demeler class
+    raise StandardError.new("looping on #{meth.inspect}, @out=#{@out.inspect}") if (@level += 1)>500
+    # This part examines the variations in possible inputs,
+    # and rearranges them to suit tag_generator
+    case
+    when args.kind_of?(Hash)
+      # args is a hash (attributes only)
+      attr = args
+    when args.size==0
+      # args is empty array
+      attr = {}
+    when args.size==1 && args[0].kind_of?(String)
+      # args is array of 1 string
+      attr = {:text=>args[0]}
+    when args.size==1 && args[0].kind_of?(Symbol)
+      # args is array of 1 symbol (used as 'name')
+      attr = {:name=>args[0]}
+    when args.size==1 && args[0].kind_of?(Hash)
+      # args is array of 1 hash (same as args is a hash)
+      attr = args[0]
+    when args.size==2 && args[0].kind_of?(Symbol) && args[1].kind_of?(Hash)
+      # args is an array of symbol ('name') and hash ('attributes')
+      # both name and attributes, i.e., g.div(:list, :class=>'list-class')
+      attr = {:name=>args[0]}.merge(args[1])
+    when args.size==2 && args[0].kind_of?(Symbol) && args[1].kind_of?(String)
+      # args is array of symbol ('name') and string ('text')
+      # both name and text, i.e., g.label(:list, "List")
+      case meth
+      when :label
+        attr = {:for=>args[0]}.merge({:text=>args[1]})
+        @labels << args[0]
+      else
+        attr = {:name=>args[0]}.merge({:text=>args[1]})
+      end
+    else
+      raise ArgumentError.new("Too many arguments in Demeler#tag_generator: meth=>#{meth.inspect}, args=>#{args.inspect}")
+    end
+    # This part extracts a value out of the form's object (if any)
+    name = attr[:name]
+    case
+    when name.nil?
+    when @obj.nil?
+    when !attr[:value].nil?
+    when @obj[name].nil?
+    when @obj[name].kind_of?(String) && @obj[name].empty?
+    when meth==:textarea
+      attr[:text] = @obj[name] if !attr.has_key?(:text)
+    else
+      attr[:value] = @obj[name] if !attr.has_key?(:value)
+    end
+    # If a label was previously defined for this :input,
+    # add an :id attribute automatically
+    attr[:id] = name if meth==:input && !attr.has_key?(:id) && @labels.index(name)
+    # This part extracts the text (if any)--the text
+    # is used in place of a block for tags like 'label'
+    text = attr.delete(:text)
+    case
+    when text.nil?
+      text = []
+    when text.kind_of?(String)
+      text = [text]
+    when text.kind_of?(Array)
+    else
+      raise ArgumentError.new("In Demeler#tag_generator, expected Array or String for text (value for textarea, or ")
+    end
+    # make sure there's at least one (empty) string for textarea because
+    # a textarea tag with no "block" makes the browser act wierd, even if it's
+    # self-closing, i.e., <textarea ... />
+    text = [""] if meth==:textarea && text.empty? && !block_given?
+    # In case there is an error message for this field,
+    # prepare the message now to add following the field
+    if @obj && (list = @obj.errors[name])
+      raise ArgumentError.new("The error message, if any, must be an array of Strings") if !list.kind_of?(Array)
+      error = if [:input, :select].index(meth) then list.first else nil end
+      message = if error then "<warn> <-- #{error}</warn>" else nil end
+    else
+      message = ""
+    end
+    # This is where the actual HTML is generated--it's structured this
+    # way to be sure that only WHOLE tags are placed into @out--it's
+    # done this way to facilitate #to_html
+    case
+    when !text.empty?
+      temp = text.join("\n")
+      @out << "<#{meth}#{attr.map{|k,v| %[ #{k}="#{v}"]}.join}>#{temp}</#{meth}>#{message}"
+    when block_given?
+      @out << "<#{meth}#{attr.map{|k,v| %[ #{k}="#{v}"]}.join}>"
+      temp = yield
+      @out << temp if temp && temp.kind_of?(String)
+      @out << "</#{meth}>#{message}"
+    else
+      @out << "<#{meth}#{attr.map{|k,v| %[ #{k}="#{v}"]}.join} />#{message}"
+    end
+    @level -= 1
+    nil
+  end
+  ##
+  # Convert the final output of Demeler to a string.
+  # This method has the following alias: "to_str".
+  #
+  # @return [String]
+  #
+  def to_s
+    @out.join
+  end
+  ##
+  # This method is part of #to_html below.
+  #
+  def write_html(indent,part)
+#    "<!-- #{indent} --> #{' '*(if indent<0 then 0 else indent end)}#{part}\n"
+    "#{' '*(if indent<0 then 0 else indent end)}#{part}\n"
+  end
+  ##
+  # Method for converting the results of Demeler to a
+  # human readable string. This isn't recommended for
+  # production because it requires much more time to
+  # generate the HTML output than to_s.
+  #
+  # @return [String] The formatted form output
+  #
+  def to_html
+    # output the segments, but adjust the indentation
+    indent = 0
+    html = "<!-- begin generated output -->\n"
+    @out.each do |part|
+      case
+      when part =~ /^<\/.*>$/
+        indent -= 1
+        html << write_html(indent,part)
+      when part =~ /^<.*<\/.*>$/
+        html << write_html(indent,part)
+      when part =~ /^<.*\/>$/
+        html << write_html(indent,part)
+      when part =~ /^<.*>$/
+        html << write_html(indent,part)
+        indent += 1
+      else
+        html << write_html(indent,part)
+      end
+    end
+    # return the formatted string
+    html << "<!-- end generated output -->\n"
+    return html
+  end # to_html
+end

data/notes ADDED Viewed

@@ -0,0 +1,13 @@
+cd ~/demeler-gem
+gem build demeler.gemspec
+sudo gem uninstall demeler
+sudo gem install demeler
+#----------------------------------------
+To run tests (with 'bacon' installed):
+bacon -Ilib spec/demeler.rb

data/spec/demeler.rb ADDED Viewed

@@ -0,0 +1,336 @@
+require "demeler"
+require "bacon"
+# bacon -Ilib spec/demeler.rb
+class Obj<Hash
+  attr_accessor :errors
+  def initialize
+    @errors = {}
+  end
+end
+describe "Simple Demeler with no Object" do
+  before do
+    @d = Demeler.new
+  end
+  it "should be empty" do
+    @d.out.should.be.empty
+  end
+  it "should return p" do
+    @d.clear
+    @d.p
+    @d.to_s.should.equal "<p />"
+  end
+  it "should return p with embedded text" do
+    @d.clear
+    @d.p { "ABC" }
+    @d.to_s.should.equal "<p>ABC</p>"
+  end
+  it "should return p with embedded HTML" do
+    @d.clear
+    @d.p { @d.br }
+    @d.to_s.should.equal "<p><br /></p>"
+  end
+  it "should be a plain link" do
+    @d.clear
+    @d.alink("Registration", :href=>"registration")
+    @d.to_s.should.equal "<a href=\"registration\">Registration</a>"
+  end
+  it "should be a plain checkbox control" do
+    @d.clear
+    @d.checkbox(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<input name=\"vehicle[1]\" type=\"checkbox\" value=\"volvo\">Volvo</input><input name=\"vehicle[2]\" type=\"checkbox\" value=\"saab\">Saab</input><input name=\"vehicle[3]\" type=\"checkbox\" value=\"mercedes\">Mercedes</input><input name=\"vehicle[4]\" type=\"checkbox\" value=\"audi\">Audi</input>"
+  end
+  it "should be a plain radio control" do
+    @d.clear
+    @d.radio(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<input name=\"vehicle\" type=\"radio\" value=\"volvo\">Volvo</input><input name=\"vehicle\" type=\"radio\" value=\"saab\">Saab</input><input name=\"vehicle\" type=\"radio\" value=\"mercedes\">Mercedes</input><input name=\"vehicle\" type=\"radio\" value=\"audi\">Audi</input>"
+  end
+  it "should be a plain select control" do
+    @d.clear
+    @d.select(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<select name=\"vehicle\"><option value=\"volvo\">Volvo</option><option value=\"saab\">Saab</option><option value=\"mercedes\">Mercedes</option><option value=\"audi\">Audi</option></select>"
+  end
+  it "should be a plain submit control" do
+    @d.clear
+    @d.submit("Go!")
+    @d.to_s.should.equal "<input type=\"submit\" value=\"Go!\" />"
+  end
+  it "should add an :id if there is a matching label" do
+    @d.clear
+    @d.submit("Go!")
+    @d.label(:username, "Enter Username")
+    @d.text(:username)
+    @d.to_s.should.equal "<input type=\"submit\" value=\"Go!\" /><label for=\"username\">Enter Username</label><input name=\"username\" type=\"text\" id=\"username\" />"
+  end
+end
+describe "Complex Demeler with Object" do
+  before do
+    obj = Obj.new
+    obj[:a_button] = "Push Me"
+    obj[:a_checkbox1] = {"2"=>"saab","4"=>"audi"}
+    obj[:a_checkbox2] = ["saab", "mercedes"]
+    obj[:a_checkbox3] = "volvo,mercedes"
+    obj[:a_color] = "#00FF00"
+    obj[:a_date1] = "2017-06-01"
+    obj[:a_date2] = "2017-07-02"
+    obj[:an_email] = "mike@czarmail.com"
+    obj[:a_hidden] = "hidden_data"
+    obj[:a_month] = "2017-06"
+    obj[:a_number] = "3"
+    obj[:a_password] = "fricken-password"
+    obj[:a_radio] = "saab"
+    obj[:a_range] = 2
+    obj[:a_search] = "search for this"
+    obj[:a_tel] = "951-929-2015"
+    obj[:a_text] = "This is just scat."
+    obj[:a_textarea1] = "Text for area 1."
+    obj[:a_textarea2] = "More text for area 2.\nThis text has multiple lines."
+    obj[:a_textarea4] = "Line 1"
+    obj[:a_time] = "23:24"
+    obj[:a_url] = "https://www.czarmail.com"
+    obj[:a_week] = "2018-W03"
+    @d = Demeler.new(obj)
+  end
+  it "generate a style block" do
+    @d.clear
+    @d.style { "red { color: red; } warn { color: red; }" }
+    @d.to_s.should.equal "<style>red { color: red; } warn { color: red; }</style>"
+  end
+  it "should be a button control with data" do
+    @d.clear
+    @d.button(:name=>:a_button)
+    @d.to_s.should.equal "<input name=\"a_button\" type=\"button\" value=\"Push Me\" />"
+  end
+  it "should be a checkbox control with data" do
+    @d.clear
+    @d.checkbox(:a_checkbox1, {:class=>:check_class}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<input class=\"check_class\" name=\"a_checkbox1[1]\" type=\"checkbox\" value=\"volvo\">Volvo</input><input class=\"check_class\" name=\"a_checkbox1[2]\" type=\"checkbox\" value=\"saab\" checked=\"true\">Saab</input><input class=\"check_class\" name=\"a_checkbox1[3]\" type=\"checkbox\" value=\"mercedes\">Mercedes</input><input class=\"check_class\" name=\"a_checkbox1[4]\" type=\"checkbox\" value=\"audi\" checked=\"true\">Audi</input>"
+  end
+  it "should be a color control with data" do
+    @d.clear
+    @d.color(:a_color)
+    @d.to_s.should.equal "<input name=\"a_color\" type=\"color\" value=\"#00FF00\" />"
+  end
+  it "should be a date control with data" do
+    @d.clear
+    @d.date(:a_date1)
+    @d.to_s.should.equal "<input name=\"a_date1\" type=\"date\" value=\"2017-06-01\" />"
+  end
+  it "should be a date control with data and class" do
+    @d.clear
+    @d.date(:a_date2, :class=>:date_class)
+    @d.to_s.should.equal "<input name=\"a_date2\" class=\"date_class\" type=\"date\" value=\"2017-07-02\" />"
+  end
+  it "should be a text control with data" do
+    @d.clear
+    @d.email(:an_email)
+    @d.to_s.should.equal "<input name=\"an_email\" type=\"email\" value=\"mike@czarmail.com\" />"
+  end
+  it "should be a hidden field with data" do
+    @d.clear
+    @d.hidden(:a_hidden, :value=>3)
+    @d.to_s.should.equal "<input name=\"a_hidden\" value=\"3\" type=\"hidden\" />"
+  end
+  it "should be an image button" do
+    @d.clear
+    @d.image(:src=>"images/czar-mail-logo.svg", :width=>80, :height=>30)
+    @d.to_s.should.equal "<input src=\"images/czar-mail-logo.svg\" width=\"80\" height=\"30\" type=\"image\" />"
+  end
+  it "should be an image control" do
+    @d.clear
+    @d.img(:src=>"images/czar-mail-logo.svg", :width=>80, :height=>30)
+    @d.to_s.should.equal "<img src=\"images/czar-mail-logo.svg\" width=\"80\" height=\"30\" />"
+  end
+  it "should be a month control with data" do
+    @d.clear
+    @d.month(:a_month)
+    @d.to_s.should.equal "<input name=\"a_month\" type=\"month\" value=\"2017-06\" />"
+  end
+  it "should be a number control with data" do
+    @d.clear
+    @d.number(:a_number, :min=>1, :max=>5)
+    @d.to_s.should.equal "<input name=\"a_number\" min=\"1\" max=\"5\" type=\"number\" value=\"3\" />"
+  end
+  it "should be a password control with data" do
+    @d.clear
+    @d.password(:a_password)
+    @d.to_s.should.equal "<input name=\"a_password\" type=\"password\" value=\"fricken-password\" />"
+  end
+  it "should be a radio control with data" do
+    @d.clear
+    @d.radio(:a_radio, {:class=>:radio_class}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<input class=\"radio_class\" name=\"a_radio\" type=\"radio\" value=\"volvo\">Volvo</input><input class=\"radio_class\" name=\"a_radio\" type=\"radio\" value=\"saab\" checked=\"true\">Saab</input><input class=\"radio_class\" name=\"a_radio\" type=\"radio\" value=\"mercedes\">Mercedes</input><input class=\"radio_class\" name=\"a_radio\" type=\"radio\" value=\"audi\">Audi</input>"
+  end
+  it "should be a range control with data" do
+    @d.clear
+    @d.range(:a_range, :min=>1, :max=>10)
+    @d.to_s.should.equal "<input name=\"a_range\" min=\"1\" max=\"10\" type=\"range\" value=\"2\" />"
+  end
+  it "should be a reset control" do
+    @d.clear
+    @d.reset
+    @d.to_s.should.equal "<input type=\"reset\" />"
+  end
+  it "should be a search control with data" do
+    @d.clear
+    @d.search(:a_search)
+    @d.to_s.should.equal "<input name=\"a_search\" type=\"search\" value=\"search for this\" />"
+  end
+  it "should be a submit control" do
+    @d.clear
+    @d.submit("Go!", :name=>:a_submit)
+    @d.to_s.should.equal "<input type=\"submit\" value=\"Go!\" name=\"a_submit\" />"
+  end
+  it "should be a tel (telephone) control with data" do
+    @d.clear
+    @d.tel(:a_tel)
+    @d.to_s.should.equal "<input name=\"a_tel\" type=\"tel\" value=\"951-929-2015\" />"
+  end
+  it "should be a text control with data" do
+    @d.clear
+    @d.text(:a_text, :size=>20)
+    @d.to_s.should.equal "<input name=\"a_text\" size=\"20\" type=\"text\" value=\"This is just scat.\" />"
+  end
+  it "should be a textarea (1) control with data" do
+    @d.clear
+    @d.textarea(:a_textarea1, :rows=>4, :cols=>50)
+    @d.to_s.should.equal "<textarea name=\"a_textarea1\" rows=\"4\" cols=\"50\">Text for area 1.</textarea>"
+  end
+  it "should be a textarea (2) control with data" do
+    @d.clear
+    @d.textarea(:a_textarea2, :rows=>4, :cols=>50) {'2'}
+    @d.to_s.should.equal "<textarea name=\"a_textarea2\" rows=\"4\" cols=\"50\">More text for area 2.\nThis text has multiple lines.</textarea>"
+  end
+  it "should be a textarea (3) control with NO data" do
+    @d.clear
+    @d.textarea(:a_textarea3, :rows=>4, :cols=>50, :text=>["Line 1","Line 2","Line 3"])
+    @d.to_s.should.equal "<textarea name=\"a_textarea3\" rows=\"4\" cols=\"50\">Line 1\nLine 2\nLine 3</textarea>"
+  end
+  it "should be a textarea (4) control with data" do
+    @d.clear
+    @d.textarea(:a_textarea4, :rows=>4, :cols=>50)
+    @d.to_s.should.equal "<textarea name=\"a_textarea4\" rows=\"4\" cols=\"50\">Line 1</textarea>"
+  end
+  it "should be a time control with data" do
+    @d.clear
+    @d.time(:a_time)
+    @d.to_s.should.equal "<input name=\"a_time\" type=\"time\" value=\"23:24\" />"
+  end
+  it "should be a url control with data" do
+    @d.clear
+    @d.url(:a_url)
+    @d.to_s.should.equal "<input name=\"a_url\" type=\"url\" value=\"https://www.czarmail.com\" />"
+  end
+  it "should be a week control with data" do
+    @d.clear
+    @d.week(:a_week)
+    @d.to_s.should.equal "<input name=\"a_week\" type=\"week\" value=\"2018-W03\" />"
+  end
+  it "should be a red tag with data" do
+    @d.clear
+    @d.red(:text=>"This ought to be red.")
+    @d.to_s.should.equal "<red>This ought to be red.</red>"
+  end
+#=== Demeler Calls =====================================
+  it "should be demeler: args is a hash (attributes only)" do
+    @d.clear
+    @d.tag_generator(:div, {:class=>"div-class"}) { "..." }
+    @d.to_s.should.equal "<div class=\"div-class\">...</div>"
+  end
+  it "should be demeler: args is empty array" do
+    @d.clear
+    @d.tag_generator(:br, [])
+    @d.to_s.should.equal "<br />"
+  end
+  it "should be demeler: args is array of 1 string" do
+    @d.clear
+    @d.tag_generator(:textarea, ["Some text to edit."])
+    @d.to_s.should.equal "<textarea>Some text to edit.</textarea>"
+  end
+  it "should be demeler: args is array of 1 symbol (used as 'name')" do
+    @d.clear
+    @d.tag_generator(:div, [:div_name]) { "..." }
+    @d.to_s.should.equal "<div name=\"div_name\">...</div>"
+  end
+  it "should be demeler: args is array of 1 hash (same as args is a hash)" do
+    @d.clear
+    @d.tag_generator(:div, [{:class=>"div-name"}]) { "..." }
+    @d.to_s.should.equal "<div class=\"div-name\">...</div>"
+  end
+  it "should be demeler: args is an array of symbol ('name') and hash ('attributes')" do
+    @d.clear
+    @d.tag_generator(:div, [:list, :class=>'list-class']) { "..." }
+    @d.to_s.should.equal "<div name=\"list\" class=\"list-class\">...</div>"
+  end
+  it "should be demeler: args is array of symbol ('name') and string ('text' or 'for')" do
+    @d.clear
+    @d.tag_generator(:label, [:list, "List"])
+    @d.to_s.should.equal "<label for=\"list\">List</label>"
+  end
+  it "should have an error message" do
+    @d.clear
+    @d.obj.errors[:err] = ["Username already used."]
+    @d.tag_generator(:input, {:name=>:err, :value=>"bobama", :type=>:text})
+    @d.to_s.should.equal "<input name=\"err\" value=\"bobama\" type=\"text\" /><warn> <-- Username already used.</warn>"
+  end
+  it "should create user friendly HTML" do
+    @d.clear
+    @d.obj.errors[:err] = ["Username already used."]
+    @d.tag_generator(:input, {:name=>:err, :value=>"bobama", :type=>:text})
+    @d.to_html.should.equal "<!-- begin generated output -->\n<input name=\"err\" value=\"bobama\" type=\"text\" /><warn> <-- Username already used.</warn>\n<!-- end generated output -->\n"
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: demeler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael J. Welch, Ph.D.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2017-06-10 00:00:00.000000000 Z
+dependencies: []
+description: This gem takes your ruby input, plus an object such as a Sequel::Model
+  object, and generates HTML code. If the object has values, they're inserted into
+  the HTML, and if the object has error messages, code is generated to display them.
+  You can use CSS, but it's not automated in this class of methods.
+email: mjwelchphd@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- demeler.gemspec
+- lib/demeler.rb
+- lib/demeler/version.rb
+- notes
+- spec/demeler.rb
+homepage: http://rubygems.org/gems/demeler
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.5.1
+signing_key:
+specification_version: 4
+summary: Yet another HTML generator.
+test_files: []