demeler 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60dd5907473caf7a0f8963ed8a5ef41c7c56ba7a
-  data.tar.gz: 9ef767a5cbf325bf6456b2a08d1b9a668e0317b7
+  metadata.gz: c0c386f96ecc1bd387757913d8c06df79c31a705
+  data.tar.gz: bed41140c85456d8d829e8b9919bbc70b9a7d838
 SHA512:
-  metadata.gz: 885c065028088be8c1d2545c3cd31d755b9a9cf6a1dc747a376cf8c1502bd12647ba12a59abf14b07016689446c37f3da10473c153387c919d0fea824dd01ee6
-  data.tar.gz: 4409d084b43ec05c2ccd3060023840a237695ed0038acfedc00c7f91088d60f3366a441f19437526bda1926edbdb7f30b35bbc67acc0901d9a4b4cf9ad17b7f2
+  metadata.gz: 5a75c02f4294c9da6b8fe6159c274c05a793c2ce2a31c90815f677723082b12d1117c0366543cc0fb08878442510d1d348af1520d3a344ec8aed1b53941109aa
+  data.tar.gz: c6eff11ee04f5a3b2f95f5938b5ed3f3ade2de6b158141bb3ce79f7683b2b38a738888fb7264f92ebdee7d0ac01713ac08f88645b81dddcddc7970cb696e23ed

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+

data/CHANGELOG.md

@@ -1,2 +1,12 @@
+# 1.0.1
+* Changed the `clear` method to return self so that clear can be chained.
+* Corrected some of the comments above individual methods.
+* Made some corrections and additions to the README.
+* Made `write_html` a private method because it's only used by `to_html`.
+* Added an argument to `build` and `initialize` to allow a session variable to be passed through.
+* Corrected a problem with the `select` control in that the attributes were not being applied.
+* Added a variable to `build` and `initialize` to be able to pass through a user argument. I called it `session` because that's what it would commonly be used for, but you could pass anything and access it in your Demeler code. For example, if you needed session _and_ some other variables, you would just pass them all in a Hash, including session.
+
+
 # 1.0.0
-* Initial version.
+* Initial version.

data/README.md

@@ -1,9 +1,16 @@
 # Demeler Gem
 
-### Copyright (c) 2017 Michael J Welch, Ph.D. mjwelchphd@gmail.com
+**Copyright (c) 2017 Michael J Welch, Ph.D. <mjwelchphd@gmail.com>**
+
+_NOTE: I appologize that the documentation isn't better than it is, but I'm running way behind in my work trying to make this into a gem in order to preserve and share it._
+
 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.
+This gem builds HTML code on-the-fly. The advantages are:
+
+1. HTML code is properly formed with respect to tags and nesting;
+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.
 
@@ -12,8 +19,8 @@ This class doesn't depend on any particular framework, but I use it with Ruby Se
 
 ## 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
+* A Hash-based object you provide, like Sequel::Model objects; and
+* An errors list inside the Hash-based object.
 
 Let's start with the most basic form, a simple example. Run `irb` and enter this:
 
@@ -187,7 +194,7 @@ 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:
+Normally, anything in brackets {} is embedded like this; `p{"Some text."}` yields:
 
 ```html
 <!-- begin generated output -->
@@ -197,7 +204,7 @@ Normally, anything in brackets {} is embedded like this: `p{"Some text."}` yield
 <!-- end generated output -->
 ```
 
-You can make it come out on one line by using the :text attribute: `p :text=>"Some text."` yields:
+You can make it come out on one line by using the `:text` attribute; `p :text=>"Some text."` yields:
 
 ```html
 <!-- begin generated output -->
@@ -205,7 +212,7 @@ You can make it come out on one line by using the :text attribute: `p :text=>"So
 <!-- end generated output -->
 ```
 
-In most cases, this can be achieved just by eliminating the {}: `p "Some text." yields:
+In most cases, this can be achieved just by eliminating the {}; `p "Some text." yields:
 
 ```html
 <!-- begin generated output -->
@@ -215,101 +222,289 @@ In most cases, this can be achieved just by eliminating the {}: `p "Some text."
 
 This is because the solo string is converted to a :text argument automatically.
 
+## How to create an input control
 
-## Demeler Interface Definitions
+A standard input control is just a tag and options. Take the `text` control, for example.
 
-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.
+`text :username, :size=>30, :value=>"joe.e.razsolli"` => `<input name="username" size="30" value="joe.e.razsolli" type="text" />`
 
-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.
+The button, color, date, datetime_local, email, hidden, image, month, number, password, range, reset, search, submit, tel, text, time, url, and week tags all work the that way.
 
-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.
+The textarea control, on the other hand, puts it's value between the tags, so it uses a :text attribute instead of a :value attribute.
 
-### Non-Input Tag Parameter Formats
+`textarea :username, :size=>30, :text="joe.e.razsolli` => `<textarea name="username" size="30">joe.e.razsolli</textarea>`
 
-#### tag opts
+The textarea tag can take its text from a block, also.
 
-_Opts is a Hash with attributes._
+`textarea(:username, :size=>30) { "joe.e.razsolli" }` => `<textarea name="username" size="30">joe.e.razsolli</textarea>`
 
-```ruby
-puts (Demeler.build(nil, true) do
-  div :class=>"div-class" do
-    "..."
-  end
-end)
+Notice for the block form, you have to enclose the parameters to the textarea call in parenthesis.
 
-<!-- begin generated output -->
-<div class="div-class">
- ...
-</div>
-<!-- end generated output -->
-```
-#### tag
+## How to Create a Checkbox, Radio, or Select Control
 
-_A solo tag._
+For a checkbox, radio, or select control, use the formats below.
 
-```ruby
-puts (Demeler.build(nil, true) do
-  br
-end)
+`checkbox(:vehicle, opts, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")` =>
+```html
+<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>
+```
 
-<!-- begin generated output -->
-<br />
-<!-- end generated output -->
+`radio(:vehicle, opts, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")` =>
+```html
+<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>
 ```
 
-#### tag string
+`select(:vehicle, opts, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")` =>
+```html
+<select name="vehicle">
+ <option value="volvo">Volvo</option>
+ <option value="saab">Saab</option>
+ <option value="mercedes">Mercedes</option>
+ <option value="audi">Audi</option>
+</select>
+```
 
-_A solo string._
+Opts represents a Hash with tag attributes.
 
-```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._
+## Reference Guide
+
+### def self.build(obj=nil, gen_html=false, session={}, &block)
+
+This is the main Demeler call used to build your HTML. This call uses your code in the block, so it makes no sense to call `build` without a block.
+
+Name | Type | Value
+---- | ---- | -----
+obj | Hash+ | An object to use to get values and error messages.
+gen_html | Boolean | Create formatted HTML (true), or compact HTML (false: default).
+session | Hash | A variable meant to pass a session in a web server, but you can use it for passing any other value as well. _This value is for the caller's use and is not used by Demeler._
+block | Proc | The block with your code.
+
+### def initialize(obj=nil, session={}, &block)
+
+Initialize sets up the initial conditions in Demeler, and is called by `new`.
+
+Name | Type | Value
+---- | ---- | -----
+obj | Hash+ | An object to use to get values and error messages.
+session | Hash | A variable meant to pass a session in a web server, but you can use it for passing any other value as well. _This value is for the caller's use and is not used by Demeler._
+block | Proc | The block with your code.
+
+### def clear
+
+Clear resets the output variables in order to reuse Demeler without having to reinstantiate it.
+
+### method_missing(meth, *args, &block)
+
+This is a Ruby method which catches method calls that have no real method. For example, when you code a `body` tag, there is no method in Demeler to handle that, so it is caught be `missing_method`. Missing_method passes the call along to `tag_generator` to be coded.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The name of the missing method being caught.
+*args | Array | An array of arguments from the call that was intercepted. Tag_generator will try to make sense of them.
+block | Proc | The block with your code.
+
+### def p(*args, &block)
+
+The `p` method is a workaround to make 'p' tags work in `build`.
+
+Name | Type | Value
+---- | ---- | -----
+*args | Array | An array of arguments from the call that was intercepted. Tag_generator will try to make sense of them.
+block | Proc | The block with your code.
+
+### def alink(text, args={})
+
+The `alink` method is a shortcut to build an `a` tag. You could also write a `a` tag like so:
 
 ```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)
+Demeler.build do
+  a(:href=>"/") { "Home" }
+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>
+but the alink method is a shortcut. Code it like this:
+
+```ruby
+Demeler.build do
+  alink("Home", :href=>"/")
+end
 ```
 
-#### tag symbol
+Yes, I know. Six of one, half-dozen of another. It had a legacy beginning, and I kept it in here.
 
-_The symbol is used as the name of the tag._ This option is used with input tags (see below).
+Name | Type | Value
+---- | ---- | -----
+text | String | The text to be inserted into the tag.
+*args | Hash | An hash of attributes which must include the :href attribute.
 
-#### tag symbol, hash
+### def checkbox(name, opts, values)
 
-_This option generates_
+This is a shortcut to build `checkbox` tags. A properly formed check box is created for each value in the `values` list. If the form object has one or more values set, those boxes will be checked.
 
+Each check box name will begin with `name` and have a number added, beginning with 1.
 
-#### tag symbol, string
+Name | Type | Value
+---- | ---- | -----
+name | Symbol | The name of the control. It will be prepended with a number.
+opts | Hash | The attributes and options for the control.
+values | Hash | The names and values of the check boxes.
 
-_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.
+The data value in the form object may be a String, Array or Hash. If this is a string, the values are comma separated. If this is an array, the elements are the values. If this is a hash, the values (right hand side of each pair) are the values.
 
-```ruby
-puts (Demeler.build(nil, true) do
-  label :username, "Enter Username"
-  text :username
-end)
+### radio(name, opts, values)
+
+This is a shortcut to build radio buttons. All the radio buttons in a set are named the same, and only vary in value. Unlike the checkbox control, the radio control only has one value at a time. The opts are applied to each radio button.
 
+Name | Type | Value
+---- | ---- | -----
+name | Symbol | The name of the control.
+opts | Hash | The attributes and options for the control.
+values | Hash | The names and values of the radio boxes.
+
+The data value in the form object may be a String, Array or Hash. If this is a string, the values are comma separated. If this is an array, the elements are the values. If this is a hash, the values (right hand side of each pair) are the values.
+
+### def select(name, opts, values)
+
+The select control is unique in that it has `select` tags surrounding a list of `option` tags. Based on the attributes (opts), you can create a pure dropdown list, or a scrolling list. See https://www.w3schools.com for more info on HTML.
+
+Name | Type | Value
+---- | ---- | -----
+name | Symbol | The name of the control.
+opts | Hash | The attributes and options for the control.
+values | Hash | The names and values of the radio boxes.
+
+The data value in the form object may be a String, Array or Hash. If this is a string, the values are comma separated. If this is an array, the elements are the values. If this is a hash, the values (right hand side of each pair) are the values.
+
+### def submit(text, opts={})
+
+The submit shortcut creates a `input` control of type 'submit'.
+
+Name | Type | Value
+---- | ---- | -----
+text | String | The text displayed on the face of the button.
+opts | Hash | The attributes and options for the control.
+
+### def tag_generator(meth, args=[], &block)
+
+You don't normally call `tag_generator` (although you can if you wish to). Tag_generator has many forms which are documented one by one below.
+
+### def tag_generator(meth, opts, &block)
+
+This form is used for most simple input controls.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+opts | Hash | The attributes, i.e., :class="user-class", etc.
+block | Proc | The block
+
+### def tag_generator(meth, &block)
+
+This form is used for most simple controls which have no options specified.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+block | Proc | The block
+
+### def tag_generator(meth, [text], &block)
+
+This form is used for controls which consist of text between opening and closing tags.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+text | String | The string becomes the :text=>string attribute.
+block | Proc | The block
+
+### def tag_generator(meth, [name], &block)
+
+This form is used for simple input controls which have only a name, i.e., `text(:username)`. You would use a control like this with a form object probably.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+name | Symbol | The name of the control.
+block | Proc | The block
+
+### def tag_generator(meth, [opts], &block)
+
+This form is used for simple input controls which have only a name, i.e., `text(:username)`. You would use a control like this with a form object probably. This option is equivalent to the first option which is the same except the opts are not in an array.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+opts | Hash | The attributes, i.e., :class="user-class", etc.
+block | Proc | The block
+
+### def tag_generator(meth, [name, opts], &block)
+
+This form is the same as the preceeding one, except the name is specified seperately for convenience.
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+name | Symbol | The name of the control.
+opts | Hash | The attributes, i.e., :class="user-class", etc.
+block | Proc | The block
+
+### def tag_generator(meth, [name, text], &block)
+
+This form is the same as the preceeding one, except the text is placed between opening and closing tages, but if the meth is 'label', a `for="text"` attribute is created; otherwise, a `name="text"`. (This is the call that implements `label` tags, obviously.)
+
+Name | Type | Value
+---- | ---- | -----
+meth | Symbol | The method, i.e., the tag name: :p, :br, :input, etc.
+name | Symbol | The name of the control.
+text | String | The string becomes the :text=>string attribute.
+block | Proc | The block
+
+## How the form object is harvested
+
+For Demeler to pick up data from the form object and automatically set `value` attributes, you need to have the following conditions:
+
+* There must be a `name` attribute;
+* There must be a form object given in the `build` or `new` method;
+* The form object must contain the named key in the object's hash; and
+* The retrieved data must not be `nil` and, if the retrieved data is a String, it must not be `empty`.
+
+The data will create a:
+
+* (for `textarea`) :text attribute; or
+* (for all others) :value attribute.
+
+## Outputting the HTML
+
+There are two ways to output the HTML: formatted and compressed.
+
+Formatted code is human readable, like this:
+
+```html
 <!-- begin generated output -->
-<label for="username">Enter Username</label>
-<input name="username" type="text" id="username" />
+<select name="vehicle" class="x">
+ <option value="volvo">Volvo</option>
+ <option value="saab">Saab</option>
+ <option value="mercedes">Mercedes</option>
+ <option value="audi">Audi</option>
+</select>
 <!-- end generated output -->
 ```
 
-_Tags other than `label` will have a `name` attribute instead of a `for` attribute._
+whereas compressed code looks like this:
+
+```html
+<select name=\"vehicle\" class=\"x\"><option value=\"volvo\">Volvo</option><option value=\"saab\">Saab</option><option value=\"mercedes\">Mercedes</option><option value=\"audi\">Audi</option></select>
+```
+
+Compressed HTML is faster to generate, and is recommended for production.
 
 ## A Bigger Example of a Demeler Script
 

data/lib/demeler.rb

@@ -21,7 +21,7 @@
 # Ruby Sequel.
 
 class Demeler
-  attr_reader :out, :obj
+  attr_reader :out, :obj, :session
 
   # These calls are effectively generated in the same way as 'text' input
   # tags. Method_missing just does a substitution to implement them.
@@ -33,10 +33,13 @@ class Demeler
   # The default way to start building your markup.
   # Takes a block and returns the markup.
   #
+  # @param [object] obj a Sequel::Model object, or Hash object with an added 'errors' field.
+  # @param [boolean] gen_html A flag to control final output: true=>formatted, false=>compressed.
+  # @param [Hash] session The session variable from the caller, although it can be anything because Demeler doesn't use it.
   # @param [Proc] block
   #
-  def self.build(obj=nil, gen_html=false, &block)
-    demeler = self.new(obj, &block)
+  def self.build(obj=nil, gen_html=false, session={}, &block)
+    demeler = self.new(obj, session, &block)
     if gen_html then demeler.to_html else demeler.to_s end
   end
 
@@ -48,6 +51,8 @@ class Demeler
   # 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.
+  # @param [Hash] session The session variable from the caller, although it can be anything because Demeler doesn't use it.
+  # @param [Proc] block
   #
   # To use this without Sequel, you can use an object like this:
   # class Obj<Hash
@@ -57,9 +62,10 @@ class Demeler
   #   end
   # end
   #
-  def initialize(obj=nil, &block)
+  def initialize(obj=nil, session={}, &block)
     raise ArgumentError.new("The object passed to Demeler must have an errors field containing a Hash") if obj && !defined?(obj.errors)
     @obj = obj
+    @session = session
     clear
     instance_eval(&block) if block_given?
   end
@@ -71,6 +77,7 @@ class Demeler
     @level = 0
     @out = []
     @labels = []
+    self
   end
 
   ##
@@ -103,13 +110,14 @@ class Demeler
   end
 
   ##
-  # The #alink method simplyfies the generation of <a>...</a> tags
+  # The #alink method simplyfies the generation of <a>...</a> tags.
   #
+  # @param [String] The link line to be displayed
   # @param [Array] args Extra arguments that should be processed before
   #  creating the 'a' tag.
   # @param [Proc] block
   #
-  def alink(text, args={})
+  def alink(text, args={})Hash
     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]
@@ -162,10 +170,12 @@ class Demeler
   ##
   # The radio shortcut
   #
-  # @param [Hash] args Attributes for the control
+  # @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.radio(:name=>:vehicle, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+  #  g.radio(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
   #
   # @note: first argument is the :name; without the name, the radio control won't work
   #
@@ -190,7 +200,7 @@ class Demeler
   #
   # @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
+  # @param [Hash] values A list of :name=>value pairs the control will have
   #
   # @example
   #  g.select(:vehicle, {}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
@@ -198,14 +208,13 @@ class Demeler
   # @note: first argument is the :name=>"vehicle"
   # @note: the second argument is a Hash or nil
   #
-  def select(name, opts, values)
+  def select(name, args, 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 2, args") if !args.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)
+    opts = {:name=>name}.merge(args)
     data = if @obj then @obj[name] else nil end
-    tag_generator(:select, [opts]) do
+    tag_generator(:select, opts) do
       values.each do |value,nomenclature|
         sets = {:value=>value}
         sets[:selected] = 'true' if data==value.to_s
@@ -357,14 +366,6 @@ class Demeler
     @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
@@ -398,4 +399,14 @@ class Demeler
     return html
   end # to_html
 
+private
+
+  ##
+  # This method is part of #to_html.
+  #
+  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
+
 end

data/lib/demeler/version.rb

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

data/notes

@@ -1,13 +1,43 @@
 cd ~/demeler-gem
-gem build demeler.gemspec
 
-sudo gem uninstall demeler
+#----------------------------------------
 
+# To build the gem and install locally
+gem build demeler.gemspec
+sudo gem uninstall demeler
 sudo gem install demeler
 
 #----------------------------------------
 
 To run tests (with 'bacon' installed):
-
 bacon -Ilib spec/demeler.rb
 
+#----------------------------------------
+
+# To set globals in Git
+git config --global user.name "Michael J. Welch, Ph.D."
+git config --global user.email mjwelchphd@gmail.com
+git config --global core.editor xed
+git config --list
+
+#----------------------------------------
+
+# To push up to GitHub
+git remote add origin https://github.com/mjwelchphd/demeler.git
+git push -u origin master
+
+#----------------------------------------
+
+# To upload the gem to rubygems.org
+gem push demeler-1.0.1.gem
+
+#----------------------------------------
+
+# To run 'irb' for testing
+cd ~/demeler-gem
+irb -Ilib
+
+require_relative 'lib/demeler'
+load './lib/demeler.rb'
+
+

data/spec/demeler.rb

@@ -57,8 +57,8 @@ describe "Simple Demeler with no Object" do
 
   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>"
+    @d.select(:vehicle, {:class=>"select-class"}, :volvo=>"Volvo", :saab=>"Saab", :mercedes=>"Mercedes", :audi=>"Audi")
+    @d.to_s.should.equal "<select name=\"vehicle\" class=\"select-class\"><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
@@ -74,7 +74,19 @@ describe "Simple Demeler with no Object" do
     @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 "Simple Demeler with Session" do
+  session = {:id=>1}
+  before do
+    @d = Demeler.new(nil, session)
+  end
 
+  it "should pass through the session variable" do
+    @d.clear
+    @d.out << session.inspect
+    @d.to_s.should.equal "{:id=>1}"
+  end
 end
 
 describe "Complex Demeler with Object" do
@@ -332,5 +344,4 @@ describe "Complex Demeler with Object" do
     @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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: demeler
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Michael J. Welch, Ph.D.