objective_elements 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853b8807d8ce1caddf258fb0bd4f023ec38157cffec51180d809d28d7a6c664d
-  data.tar.gz: a8255aef5bece7857da7ccab4aa31f5aad1e0abd54f3376567057934a5d9ca9c
+  metadata.gz: c40decb6ef274c91eb3c04c8b88e3fe8cfebf9be34173044faa8541bee7e1a8c
+  data.tar.gz: c89f6d58e729c5a3a60095244fcdbcdb30b1f109214b0faf91b9b3c4fd27cf83
 SHA512:
-  metadata.gz: de70f8907e7bf70b545a4b0eddac86ccae60690440cc36205db8376d0272035fcd3acd606bd0c90c5ed46d3f4cae0afb630d30b75c82350c939809a50f7ac229
-  data.tar.gz: bce5362bede8ca1436db6f0d1f38c95a4d0f8b51bb2490c59b74458d43675541620636a9545733439cfd694118c041604f691b7910b3346b502a69ccaf143d86
+  metadata.gz: 7ba86d122bbacc96b7fa989cb122a63582cb9e6619a5e42777ed7eb69bf80b2837feca836c0f430c870a60c34e0f22906b10e808e1debd1c6ebe7f6b9ab6da56
+  data.tar.gz: 236c0aa5c7768d653ad702b63b66ffc2261416ac0cad3ba9bc404684f7428d41584468f9951b5967125f14b33000c26b5e79f7910dea6081e43f4879d03e65c7

data/README.md

@@ -57,29 +57,42 @@ too, but hey! Now you don't have to. Here's a demo:
 ## Demo
 
 ```ruby
+# gemfile:
+gem 'objective_elements',  '~>1.0.0'
+
+# Anywhyere else:
+require 'objective_elements'
+
 p = DoubleTag.new 'p'
 p.to_s
 # <p>
 # </p>
 
 # Add attributes as a hash. keys can be strings or symbols, values can be arrays or strings:
-p.add_attributes class: 'stumpy grumpy', 'id' => 'the-ugly-one'
+p.attributes << { class: 'stumpy grumpy', 'id' => 'the-ugly-one' }
 
 # Add attributes as a string!
-p.add_attributes 'class="slimy" data-awesomeness="11"'
+p.attributes << 'class="slimy" data-awesomeness="11"'
+
+# Get attributes by calling a method!
+p.data-awesomeness 
+# '11'
+
+# Set them, too! (Note: This doesn't work for class or method)
+p.id = 'killer'
 
 # Add content. It can be anything, or an array of anythings.
 p.add_content "Icky"
 
 p.to_s
-# <p class="stumpy grumpy slimy" id="the-ugly-one" data-awesomeness="11">
+# <p class="stumpy grumpy slimy" id="killer" data-awesomeness="11">
 #   Icky
 # </p>
 
 # Want a oneliner?
 p.oneline = true
 p.to_s
-# <p class="stumpy grumpy slimy" id="the-ugly-one" data-awesomeness="11">Icky</p>
+# <p class="stumpy grumpy slimy" id="killer" data-awesomeness="11">Icky</p>
 p.oneline = false
 
 # Build a tag all at once:
@@ -93,11 +106,10 @@ p.add_content DoubleTag.new(
 # 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, so
-# this works:
+# Implicit string conversion means cool stuff like this works:
 "#{div}"
 # <div>
-#   <p class="stumpy mopey grumpy slimy" id="the-ugly-one" data-awesomeness="11">
+#   <p class="stumpy grumpy slimy" id="killer" data-awesomeness="11">
 #     Icky
 #     <a href="awesome-possum.com">Link!</a>
 #   </p>
@@ -138,9 +150,40 @@ So we're on the same page, here's the terminology I'm using:
 
 ## Usage
 
-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 you care about: `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.
+
+### Attributes
+Attributes are their own class, and can be accessed by the `.attributes` method on both single and
+double tags. Important methods: 
+
+` << (attribute)` - Add new attributes, can accept a hash or a string. Hash keys will be converted
+to symbols if they are not already, and values will be split on spaces into an array if they are not
+already. Attributes can also be given as a string in the standard HTML syntax (`class="myclass"
+id="my-id"`).  **Every other method which adds attributes in some way, calls this method**. This
+means that any time you are adding attributes, you can use any format which this method understands.
+ 
+`.delete(attribute)` - Delete one or more attributes. Accepts a string, symbol, or an array of
+strings and/or symbols.
+
+`.replace(attribute)` - Replaces one or more attributes and values.
+
+`.content[:attribute_name]` - Retrieve the content for a given attribute, as an array of strings.
+Must be a symbol. You'll mostly need this when you don't know which attribute you need ahead of ti
+me, or to access class and method attributes because you can't use the methods below:
+
+`.content[:attribute_name] = ` - Don't do it. Use `<<` or `.replace`.
+
+`.(attribute_name)` - Convenience method/syntactic sugar: Returns the value of a given attribute
+name, as a space-separated string. This relies on method_missing, which means that any overlap with
+already existing methods won't work.  **You can't access `class` or `method` html attributes this
+way, because basic objects in ruby already have those methods.**
+
+`.(attribute_name) = value` - Same as above. Equivalent to `.replace(attribute)`. Interestingly,
+`method = ` and `class = ` both work (`.class` is defined on the basic object class, but `.class=`
+is not.). That said, you probably shouldn't use them because it will be confusing to understand
+later.
 
 ### SingleTag Properties:
 
@@ -148,42 +191,36 @@ kind.
  - String
  - Mandatory
  - Which type of tag it is, such as 'hr' or 'img'
-     
  #### attributes
-  - Hash 
-  - Optional
-  - Keys are stored as symbols, values are stored as arrays of strings: `{class: ['stumpy', 'slimy']}`
-  - add them with `.add_attributes`, which can accept a few different formats.
+ - Instance of the class described above.
+
 
 ### SingleTag Methods (that you care about)
 
-`SingleTag.new(element, attributes: {})`
+`SingleTag.new(element, attributes: nil)`
 
 `.to_s` - The big one. Returns your HTML as a string, nondestructively.
 
-`.add_attributes(new)` - The strongly recommended way to add new attributes. Can accept a hash (keys
-can be either symbols or strings, values can be either arrays or strings), or a string in the
-standard HTML syntax (`attribute="value" attribute2="value2 value3"`). Returns self. 
-
-`.reset_attributes(new)` - Deletes all attributes, calls add_attributes on supplied argument if
-given.
-
-`.delete_attributes(keys)` - Accepts a single attribute, or an array of attributes (keys or
-strings), and deletes it.
-
-`.rewrite_attributes` - Accepts anything add_attributes understands, but replaces existing
-attributes instead of appending to them.
-
 `.add_parent(DoubleTag)` - returns supplied DoubleTag, with self added as a child.
 
+`.attributes` - attr_reader for HTML attributes. This is how you can access any attribute method
+described above.
+
+`.reset_attributes` - Removes all attributes
 
+`.attributes=(attributes)` - Sets attributes to the supplied argument
 
 `attr_reader :attributes`
 `attr_accessor :element`
 
+`.(attribute_name)` / `.(attribute_name) = ` - Forwarded to attributes object. Allows you to set or
+retrieve the value of attributes other than `class` and `method`, without having to type
+`.attributes` in front of it.
+
 ### DoubleTag Properties:
 
-#### `DoubleTag` Inherits all of `SingleTag`'s properties and methods, and adds content and a closing tag.
+#### `DoubleTag` Inherits all of `SingleTag`'s properties and methods, and adds content and a
+closing tag.
 
  #### content
 
@@ -232,7 +269,7 @@ appropriate indentation applied, this is how you can get it.
 
  ```ruby
  
- require 'ojbective_elements'
+ require 'objective_elements'
 
  class MyDoubleTag < DoubleTag
   def indent
@@ -257,27 +294,31 @@ MyDoubleTag.new('p', content: 'hello').to_s
 
     ```html
 
+    <p>
       Here is some
       <strong>strong</strong>
       text.
+    </p>
 
     ```
     or this (default behavior):
 
     ```html
 
+    <p>
       Here is some
       <strong>
         strong
       </strong>
       text.
+    </p>
 
     ```
     But you can't do this without string interpolation or something:
 
     ```html
 
-    Here is some <strong>strong</strong> text. 
+    <p>Here is some <strong>strong</strong> text.</p>
 
     ```
     This doesn't affect how the browser will render it, but it might bug you if you're particular about

data/lib/objective_elements.rb

@@ -1,4 +1,5 @@
 module ObjectiveElements
   require_relative 'objective_elements/single_tag'
   require_relative 'objective_elements/double_tag'
+  require_relative 'objective_elements/html_attributes'
 end

data/lib/objective_elements/double_tag.rb

@@ -1,44 +1,34 @@
 # Non-Self-Closing tag. Can have content, but doesn't have to.
 class DoubleTag < SingleTag
-  attr_accessor :content, :oneline
-  # content is an array of anything. Entries will be inserted sequentially in
-  # between the opening and closing tags.
+  attr_accessor :oneline
+  attr_reader :content
 
-  def initialize(element, attributes: nil, content: [], oneline: false)
+  # Content represents everything between the opening and closing tags.
+
+  def initialize(element, attributes: nil, content: nil, oneline: false)
     @oneline = oneline
-    reset_content(content)
+    self.content = content
     super(element, attributes: attributes)
   end
 
-  def closing_tag
-    "</#{element}>"
+  def content=(new)
+    reset_content
+    add_content(new)
   end
 
-  # Deletes all content, replaces with parameter (if supplied)
-  def reset_content(new = nil)
+  def reset_content
     @content = []
-    add_content(new) if new
-    self
   end
 
   def add_content(addition)
-    @content << addition
+    @content << addition if addition
     @content.flatten!
     self
   end
-
-  def indent
-    "\ \ "
-  end
+  alias << add_content
 
   def to_a
-    lines = content.map do |c|
-      if c.is_a? SingleTag
-        c.to_a
-      else
-        c.to_s.dup
-      end
-    end
+    lines = content.map { |c| build_content_line c }
     lines = lines.flatten.map { |l| l.prepend oneline ? '' : indent }
     lines.unshift(opening_tag).push(closing_tag)
   end
@@ -46,4 +36,18 @@ class DoubleTag < SingleTag
   def to_s
     to_a.join(oneline ? '' : "\n") + "\n"
   end
+
+  private
+
+  def build_content_line(element)
+    element.is_a?(SingleTag) ? element.to_a : element.to_s.dup
+  end
+
+  def indent
+    "\ \ "
+  end
+
+  def closing_tag
+    "</#{element}>"
+  end
 end

data/lib/objective_elements/html_attributes.rb

@@ -0,0 +1,108 @@
+# Represents standard HTML attributes, such as class="myclass"
+class HTMLAttributes
+  attr_reader :content
+  def initialize(new = nil)
+    @content = {}
+    self << new
+  end
+
+  def to_s
+    return_string = ''
+    @content.each_pair do |k, v|
+      return_string << "#{k}=\"#{v.join ' '}\" "
+    end
+
+    return_string.strip
+  end
+
+  # 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 <<(new)
+    # Don't break everything if this is passed an empty value:
+    return self unless new
+
+    if new.is_a? Hash
+      add_hash(new)
+    else
+      add_string(new)
+    end
+
+    self
+  end
+
+  def delete(trash)
+    # accepts an array or a single element
+    [trash].flatten
+           .map(&:to_sym)
+           .each { |k| @content.delete k }
+
+    self
+  end
+
+  def replace(new)
+    formatted_new = if new.is_a? String
+                      hashify_input(new)
+                    else
+                      new.transform_keys(&:to_sym)
+                    end
+
+    delete formatted_new.keys
+
+    add_hash formatted_new
+
+    self
+  end
+
+  def empty?
+    @content.empty?
+  end
+
+  def method_missing(method, arg = nil)
+    if method[-1] == '='
+      raise 'must supply new value' unless arg
+
+      replace(method[0..-2] => arg)
+    elsif @content.key? method
+      @content[method].join(' ')
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    (method[-1] == '=') ||
+      (@content.key? method) ||
+      super
+  end
+
+  private
+
+  def add_string(new_string)
+    add_hash hashify_input new_string
+  end
+
+  def add_hash(new)
+    formatted_new = {}
+    new.each_pair do |k, v|
+      v = v.split ' ' if v.is_a? String
+      formatted_new[k.to_sym] = v
+    end
+
+    @content.merge! formatted_new do |_key, oldval, newval|
+      oldval.concat newval
+    end
+    self
+  end
+
+  def hashify_input(new_string)
+    # looking for something like:
+    # 'class="something something-else" id="my-id"'
+    new_hash = {}
+    new_string.scan(/ ?([^="]+)="([^"]+)"/).each do |m|
+      # [['class','something something-else'],['id','my-id']]
+      new_hash[m.shift] = m.pop
+    end
+    new_hash
+  end
+end

data/lib/objective_elements/single_tag.rb

@@ -1,8 +1,8 @@
 # Collection of HTML element tags
 # Describes a basic, self-closing HTML tag.
 class SingleTag
-  attr_reader :attributes
   attr_accessor :element
+  attr_reader :attributes
 
   # element is a string, such as 'div' or 'p'.
 
@@ -11,68 +11,16 @@ class SingleTag
 
   def initialize(element, attributes: nil)
     @element = element
-    reset_attributes(attributes)
-  end
-
-  # Deletes all current attributes, overwrites them with supplied hash.
-  def reset_attributes(new = nil)
-    @attributes = {}
-    add_attributes(new) if new
-
-    self
+    self.attributes = attributes
   end
 
-  # 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)
-    # Don't break everything if this is passed an empty value:
-    return self unless new
-
-    if new.is_a? String
-      add_string_attributes(new)
-    else
-      add_hash_attributes(new)
-    end
-
-    self
-  end
-  alias add_attribute add_attributes
-
-  def delete_attributes(keys)
-    # accepts an array or a single element
-    to_delete = if keys.is_a? Array
-                  keys.map(&:to_sym)
-                else
-                  [keys.to_sym]
-                end
-
-    to_delete.each { |k| @attributes.delete k }
-
-    self
-  end
-  alias delete_attribute delete_attributes
-
-  def rewrite_attribute(new)
-    formatted_new = if new.is_a? String
-                      hashify_attributes(new)
-                    else
-                      new.transform_keys(&:to_sym)
-                    end
-
-    delete_attributes formatted_new.keys
-
-    add_hash_attributes formatted_new
+  def attributes=(new)
+    @attributes = HTMLAttributes.new(new)
   end
 
-  # Turns attributes into a string we can insert.
-  def render_attributes
-    attribute_string = ''
-    @attributes.each_pair do |k, v|
-      attribute_string << "#{k}=\"#{v.join ' '}\" "
-    end
-    attribute_string.strip
+  # Deletes all current attributes, overwrites them with supplied hash.
+  def reset_attributes
+    @attributes = HTMLAttributes.new
   end
 
   # Returns parent, with self added as a child
@@ -80,12 +28,6 @@ class SingleTag
     parent.add_content(self)
   end
 
-  def opening_tag
-    output =  '<' + @element
-    output << ' ' + render_attributes unless @attributes.empty?
-    output << '>'
-  end
-
   def to_a
     [opening_tag]
   end
@@ -95,33 +37,24 @@ class SingleTag
     opening_tag + "\n"
   end
 
-  private
-
-  def add_string_attributes(new_string)
-    add_hash_attributes hashify_attributes new_string
+  # Allows us to work with attributes as methods:
+  def method_missing(method, arg = nil)
+    if @attributes.respond_to?(method)
+      @attributes.send(method, arg)
+    else
+      super
+    end
   end
 
-  def hashify_attributes(new_string)
-    # looking for something like:
-    # 'class="something something-else" id="my-id"'
-    new_hash = {}
-    new_string.scan(/ ?([^="]+)="([^"]+)"/).each do |m|
-      # [['class','something something-else'],['id','my-id']]
-      new_hash[m.shift] = m.pop
-    end
-    new_hash
+  def respond_to_missing?(method, include_private = false)
+    @attributes.respond_to?(method) || super
   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
+  private
 
-    @attributes.merge! formatted_new do |_key, oldval, newval|
-      oldval.concat newval
-    end
-    self
+  def opening_tag
+    output =  '<' + @element
+    output << ' ' + @attributes.to_s unless @attributes.empty?
+    output << '>'
   end
 end

data/lib/objective_elements/version.rb

@@ -1,3 +1,3 @@
 module ObjectiveElements
-  VERSION = '0.4.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: objective_elements
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Robert Buchberger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-17 00:00:00.000000000 Z
+date: 2018-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,7 @@ files:
 - bin/setup
 - lib/objective_elements.rb
 - lib/objective_elements/double_tag.rb
+- lib/objective_elements/html_attributes.rb
 - lib/objective_elements/single_tag.rb
 - lib/objective_elements/version.rb
 - objective_elements.gemspec