objective_elements 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38f809fad81753971aea9a020e001e734799fd78853c819885513971ed428b62
-  data.tar.gz: 7d619307a7d4fc03e9e76fb2eeccd820b7fdde4edd44085bebde10923e69bf8f
+  metadata.gz: e11c40fa73e065603e77081aef6c8df5e0a097a2ac47e0a5c2a69b04633aebbb
+  data.tar.gz: 7d9568d439b669be90cd8158d1078d339c0215720fee13c6a5e10561516881c9
 SHA512:
-  metadata.gz: a1a4a36ada92b3c8a69ba223c1d60f99cd82c9d35ae23be6035c253d7f4efb3cd961acc85482d4dcd241fb277ba86cb694ea0028a585bf7352aaf4788fa39f38
-  data.tar.gz: 92fe704f0977dc18660b1bfe79a7bd95f43c0b3332b10f5f49b975a17d314403d6899194e274eeed30804c673d977a5507911c36a6eae81d446c4aa1c0f2ca48
+  metadata.gz: ead034c3e4fb8ba2c72b5417386163467c856c7bd43aa3367fad91c22b63f1332c358e6b806bf3b48742c7a11d9bdd65f35de9751375efb9e655d682bd3872b4
+  data.tar.gz: 9c6f3afc6646ea72608a30034ca6f87de8f2590ffac58b6b83c68a3c154cc6c00d06de8bcd82d68159a0078267860b1b7f17728f59c0b4eb01a40885774b2f12

data/README.md

@@ -1,29 +1,28 @@
 # Objective Elements
 
-This is a tiny gem that builds nicely formatted HTML using sane, readable Ruby. I use it for jekyll 
-plugins, but you can use it anywhere. It's ~100 lines, with no runtime dependencies beyond bundler
-and rake.
+This is a tiny gem that builds nicely formatted HTML using sane, readable Ruby. I use it for jekyll
+plugins, but you can use it anywhere. It's ~100 lines, tested with rspec, and has no dependencies.
 
-Note: This gem doesn't actually know any HTML. It just knows how it should be formatted.
+This gem doesn't actually know any HTML. It just knows how to format it.
 
 ## How it works:
 
 * Instantiate a `SingleTag` or `DoubleTag`
 
-* Attributes are a Hash, Content is an array. Define them on initialization, or later on.
+* Add attributes & content in one of a few ways. Nest tags infinitely.
 
-* Render it with `.to_s`. Get normal HTML without the pain.
+* Render it with `.to_s`
 
 ## Motivation:
 
 Have you ever tried to build HTML with string concatenation and interpolation? It starts out simply
-enough, but once you account for all the what-ifs, the indentation, the closing tags, and the 
-spaces you only need sometimes, it turns into a horrible mess.
+enough, but once you account for all the what-ifs, the indentation, the closing tags, and the spaces
+you only need sometimes, it turns into a horrible mess.
 
 The problem, of course, is that building long, complex, varying blocks of text with string
 concatenation and interpolation is fragile, unreadable, and painful. You know this, but you're not
 going to write an entirely new class or pull in some big new dependency just for 10 lines of HTML.
-Instead, you just hammer through it and end up with code like this:
+Instead, you hammer through it and end up with code like this:
 
 ```ruby
 picture_tag = "<picture>\n"\
@@ -57,19 +56,20 @@ p.to_s
 # <p>
 # </p>
 
-# Add attributes and content however you like:
-p.add_attributes class: 'stumpy grumpy', id: 'the-ugly-one'
-p.add_attributes class: 'slimy'
-p.add_content 'Bippity Boppity Boo!'
+# Add attributes as a hash, values can be strings or symbols:
+p.add_attributes class: 'stumpy grumpy', 'id' => 'the-ugly-one'
+# Add them as a string!
+p.add_attributes 'class="slimy" data-awesomeness="11"'
+p.add_content "Icky"
 p.to_s
-# <p class="stumpy grumpy slimy" id="the-ugly-one">
-#   Bippity Boppity Boo!
+# <p class="stumpy grumpy slimy" id="the-ugly-one" data-awesomeness="11">
+#   Icky
 # </p>
 
 # Want a oneliner?
 p.oneline = true
 p.to_s
-# <p class="stumpy mopey grumpy slimy" id="the-ugly-one">Bippity Boppity Boo!</p>
+# <p class="stumpy mopey grumpy slimy" id="the-ugly-one" data-awesomeness="11">Icky</p>
 p.oneline = false
 
 # Build it up step by step, or all at once:
@@ -78,16 +78,16 @@ p.add_content DoubleTag.new(
   content: 'Link!',
   attributes: {href: 'awesome-possum.com'},
   oneline: true
-) 
+)
 # Add a parent tag!
 div = p.add_parent DoubleTag.new 'div'
 
-# Ruby implicitly calls .to_s on things when you try to perform string functions with them, meaning
-# cool things like this work:
+# Ruby implicitly calls .to_s on things when you try to perform string functions with them, so
+# things like this work:
 "#{div}"
 # <div>
-#   <p class="stumpy mopey grumpy slimy" id="the-ugly-one">
-#     Bippity Boppity Boo!
+#   <p class="stumpy mopey grumpy slimy" id="the-ugly-one" data-awesomeness="11">
+#     Icky
 #     <a href="awesome-possum.com">Link!</a>
 #   </p>
 # </div>
@@ -95,9 +95,18 @@ div = p.add_parent DoubleTag.new 'div'
 ```
 ## Installation
 
- - coming eventually. It'll be a gem and a require. For now, you can load it from this repo in your gemfile.
+ ```ruby
+ # Gemfile
  
-## Usage
+ gem 'objective_elements', '~> 0.2.0'
+ ```
+ 
+ ```ruby
+ # Wherever you need to use it:
+ 
+ require 'objective_elements'
+ ```
+## Terminology
 
 So we're on the same page, here's the terminology I'm using:
 ```
@@ -110,16 +119,25 @@ So we're on the same page, here's the terminology I'm using:
 - c    -  content
 - d    -  closing tag
 
-There are 2 classes: `SingleTag` is the base class, and `DoubleTag` inherits from it. A `SingleTag` is a
-self-closing tag, meaning it has no content and no closing tag. A `DoubleTag` is the other kind.
+There are 2 classes: `SingleTag` is the base class, and `DoubleTag` inherits from it. A `SingleTag`
+is a self-closing tag, meaning it has no content and no closing tag. A `DoubleTag` is the other
+kind.
+
+## Usage
 
 ### SingleTag Properties:
 
- - element:
-     **String**, mandatory. What kind of tag it is; such as 'img' or 'hr'
- - attributes:
-     **Hash** `{symbol: array or string}`, optional. Example: `{class: 'myclass plaid'}` or `{class:
-     ['myclass', 'plaid']}` 
+ #### element
+ - String
+ - Mandatory
+ - Which type of tag it is, such as 'hr' or 'img'
+ - Defined on initialization, cannot be changed afterwards. (Should it be? I'm on the fence about it.)
+     
+ #### attributes
+  - Hash 
+  - Optional
+  - Keys are symbols, values are arrays of strings. `{class: ['stumpy', 'slimy']}`
+  - add them with `.add_attributes`, which can accept a few different formats.
 
 ### SingleTag Methods (that you care about)
 
@@ -127,9 +145,12 @@ self-closing tag, meaning it has no content and no closing tag. A `DoubleTag` is
 
 `.to_s` - The big one. Returns your HTML as a string, nondestructively.
 
-`.reset_attributes(hash)` - Deletes all attributes, replaces with supplied argument if given.
+`.reset_attributes(new)` - Deletes all attributes, calls add_attributes on supplied argument if
+given.
 
-`.add_attributes(hash)` - Appends attributes instead of overwriting them.
+`.add_attributes(new)` - The only way we add new attributes. Can accept a hash (keys can be either
+symbols or strings), or a string in the standard HTML syntax (`attribute="value" attribute2="value2
+value3"`). Returns self. 
 
 `.add_parent(DoubleTag)` - returns supplied DoubleTag, with self added as a child.
 
@@ -138,35 +159,38 @@ self-closing tag, meaning it has no content and no closing tag. A `DoubleTag` is
 ### DoubleTag Properties:
 
 #### `DoubleTag` Inherits all of `SingleTag`'s properties and methods, but adds content and a closing tag.
- - content:
-     **Array**, optional, containing anything (but probably just strings and tags. Anything else
-     will be turned into a string with `.to_s`, which is an alias for `.inspect` most of the time).
 
-     Each element in the array corresponds to at least one line of HTML; multiline child tags will
-     get as many lines as they need (like you'd expect).
+ #### content
 
-     Child elements are not rendered until the parent is rendered, meaning you can access and
+   - Array
+   - Optional
+   - Contains anything (but probably just strings and tags. Anything else will be turned into a
+     string with `.to_s`, which is an alias for `.inspect` most of the time).
+   - Each element in the array corresponds to at least one line of HTML
+   - Multiline child tags will get as many lines as they need (like you'd expect).
+   - Child elements are not rendered until the parent is rendered, meaning you can access and
      modify them after defining a parent.
+   - add with `.add_content`, or modify the content array directly.
 
- - oneline:
-    **Boolean**, optional, defaults to false. When true, the entire element and its content will be
-    rendered as a single line. Useful for anchor tags and list items.
+ #### oneline
+  - Boolean
+  - optional, defaults to false.
+  - When true, the entire element and its content will be rendered as a single line. Useful for
+    anchor tags and list items.
 
 ### DoubleTag Methods (that you care about)
 
-`DoubleTag.new(element, attributes: {}, oneline: false, content: [])`
- - You can initialize it with content.
+`DoubleTag.new(element, attributes: {}, oneline: false, content: [])` - You can initialize it with
+content.
 
-`add_content(anything)`
- - Smart enough to handle both arrays and not-arrays without getting dorked up.
+`add_content(anything)` - Smart enough to handle both arrays and not-arrays without getting dorked
+up.
 
-`attr_accessor: content`
-- You can modify the content array directly if you like. If you're just adding items, you should use
-    `.add_content`
+`attr_accessor: content` - You can modify the content array directly if you like. If you're just
+adding items, you should use `.add_content`
 
-`.to_a`
-- Mostly used internally, but if you want an array of strings, each element a line with appropriate
-    indentation applied, this is how you can get it.
+`.to_a` - Mostly used internally, but if you want an array of strings, each element a line with
+appropriate indentation applied, this is how you can get it.
 
 ## Configuration
  
@@ -180,6 +204,8 @@ self-closing tag, meaning it has no content and no closing tag. A `DoubleTag` is
  Example:
 
  ```ruby
+ 
+ require 'ojbective_elements'
 
  class MyDoubleTag < DoubleTag
   def indent
@@ -197,11 +223,11 @@ MyDoubleTag.new('p', content: 'hello').to_s
 
  ## Limitations
 
-* It actually doesn't know a single HTML element on its own, so it does nothing to ensure that
-    your HTML is valid. Garbage in, garbage out.
+* It doesn't know a single HTML element on its own, so it does nothing to ensure your 
+  HTML is valid. Garbage in, garbage out.
 
 * A parent tag can't put siblings on the same line. You can either
-    do this (with `oneline: true` on the strong tag):
+  do this (with `oneline: true` on the strong tag):
 
     ```html
 
@@ -228,14 +254,14 @@ MyDoubleTag.new('p', content: 'hello').to_s
     Here is some <strong>strong</strong> text. 
 
     ```
-    It doesn't affect how the browser will render it, but it might bug you if you're particular about
+    This doesn't affect how the browser will render it, but it might bug you if you're particular about
     source code layout.
 
 * If you set 'oneline: true' on a parent DoubleTag, but not all its children DoubleTags, the output
-    will not be pretty. I advise against it.
+  will not be pretty. I advise against it.
 
 * It doesn't wrap long lines of text, and it doesn't indent text with newlines embedded. It's on the
-    TODO list.
+  TODO list.
 
 ## Contributing
 

data/lib/objective_elements/single_tag.rb

@@ -23,17 +23,13 @@ class SingleTag
   # This is the only way we add new attributes. Flexible about what you give
   # it-- accepts both strings and symbols for the keys, and both strings and
   # arrays for the values.
-  def add_attributes(new)
-    formatted_new = {}
-    new.each_pair do |k, v|
-      v = v.split ' ' if v.is_a? String
-      formatted_new[k.to_sym] = v
-    end
 
-    @attributes.merge! formatted_new do |_key, oldval, newval|
-      oldval.concat newval
+  def add_attributes(new)
+    if new.is_a? String
+      add_string_attributes(new)
+    else
+      add_hash_attributes(new)
     end
-    self
   end
   alias_method :add_attribute, :add_attributes
 
@@ -65,4 +61,32 @@ class SingleTag
   def to_s
     opening_tag + "\n"
   end
+
+  private
+
+  def add_string_attributes(new)
+    # looking for something like:
+    # 'class="something something-else" id="my-id"'
+    new_hash = {}
+    new.scan(/ ?([^="]+)="([^"]+)"/).each do |m|
+      # [['class','something something-else'],['id','my-id']]
+      new_hash[m.shift] = m.pop
+    end
+
+    add_hash_attributes(new_hash)
+  end
+
+  def add_hash_attributes(new)
+    formatted_new = {}
+    new.each_pair do |k, v|
+      v = v.split ' ' if v.is_a? String
+      formatted_new[k.to_sym] = v
+    end
+
+    @attributes.merge! formatted_new do |_key, oldval, newval|
+      oldval.concat newval
+    end
+    self
+  end
+
 end

data/lib/objective_elements/version.rb

@@ -1,3 +1,3 @@
 module ObjectiveElements
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: objective_elements
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Buchberger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-01 00:00:00.000000000 Z
+date: 2018-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler