belletrist 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d59cf0de5fc3b77ee612b1bec7fc8a41db26bf7475e1f4943967871f41f024d
-  data.tar.gz: 62755a4c1c86779d64f29857cfce47fecb3740562ce53105cb35b6666cfaabd5
+  metadata.gz: 7a59242bc76875cc57af10fc601d9f873eaeb3b5423f84a7f7d52b28360434db
+  data.tar.gz: 4c4ddb3a7ba0e25b0b354ce4fc753a5523b9e5b02b8621b72f6a04e23e00103f
 SHA512:
-  metadata.gz: a7a9d2b6c69834b2054f364271abff3362ccf37fbdcc789c482c6d2243225cf041cbc388b4bf9f7185501be7a12848152fdb15840dc8254faa1239c1833cc0a3
-  data.tar.gz: 2918a2a44daa4495d1955378e6d8962d312d635fb99ba600a7a81480525b1a9340b08f9ac59768c2a89df310477525562ed49d2c5f6de5a0a361473b5d3d618e
+  metadata.gz: 933f94556b186d146d75ec205be968ab2928bf8be727a1d162f2e1de8585cb027ee6b626ee12b499644e33015d7a11152ac7948c1ee50007a93f90e44d73bc62
+  data.tar.gz: d642df58fde3590cfdbfc6985cbfb320c34eafff083a5d40483668e7c402af684a5b5b24d876de48d711665ef18c3ae4a75c273313f980fa61e1b235f2d6965d

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 This file contains general, high level explanations of the differences between versions. Please check the commmit
 history for further details.
 
+## 1.1.0
+* Added JSON DSL. Supports the same `with` mechanism as the HTML DSL, and generally functions similarly.
+* Rewrote `HTML::Element` to inherit directly from `Belletrist::BaseCollector`.
+  * This change allows subclassing `HTML::Element` for components to be much more ergonomic. See: README.
+
 ## 1.0.3
 * Actually added the LICENSE file to the gem.
 

data/README.md

@@ -1,10 +1,10 @@
 # Belletrist
-Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML is supported, but
-that will grow as my needs do, or if other people want or contribute any other DSLs, which would be pretty cool I think.
+Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML and JSON are
+supported but that will grow as my needs do, or if other people want or contribute any other DSLs.
 
-Important to note is that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule of
-"what goes in, must come out". Belletrist DSLs must output well-formed documents so long as the developer provides
-Belletrist valid input, if that contract is broken the result is undefined.
+It is important to note that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule
+of "what goes in, must come out", and as such Belletrist DSLs must output well-formed documents so long as the developer
+provides Belletrist valid input. If that contract is broken the result is undefined.
 
 ## Requirements of a Belletrist DSL
  * All input must be sanitized, and sanitization is not optional.
@@ -14,11 +14,15 @@ Belletrist valid input, if that contract is broken the result is undefined.
 Below are some examples of how you can use the different DSLs provided by Belletrist.
 
 ### HTML
+Generation of a simple HTML document:
 ```ruby
 require 'belletrist'
 
 da_rulez = ['Be hip!', 'Be cool!', 'Don\'t be square!']
 
+# HTML5 is the default DOCTYPE.
+# HTML5 DOCTYPE:  Belletrist::HTML::Document.new(Belletrist::HTML::V5)
+# HTML4 DOCTYPE:  Belletrist::HTML::Document.new(Belletrist::HTML::V4)
 document = Belletrist::HTML::Document.new
 document.head do
   title 'Some Kind of Web Page'
@@ -34,4 +38,64 @@ end
 
 # String conversation is serialization of the input.
 print document.to_s
+```
+Subclassing `Belletrist::HTML:Element` to create components:
+```ruby
+require 'belletrist'
+
+class SubElement < Belletrist::HTML::Element
+  def initialize
+    super('div')
+  end
+  
+  def component
+    p 'I am rendered from a custom component!'
+  end
+end
+
+document = Belletrist::HTML::Document.new
+document.body do 
+  h1 'Look at my cool new element!'
+  with SubElement.new
+end
+```
+
+### JSON
+Using the DSL directly:
+```ruby
+require 'belletrist'
+
+dict = {a_string: 'Hello, world!', a_number: 1}
+list = [1, 1, 2, 3, 5, 8]
+
+obj = Belletrist::JSON::Object.new
+obj.title 'An example JSON object'
+obj.empty nil
+
+obj.sub do 
+  object_key dict
+  array_key list
+end
+
+obj.double_fib.map list do |item|
+  push item * 2
+end
+```
+Sending a Hash to a new JSON object:
+```ruby
+require 'belletrist'
+
+fib = [1, 1, 2, 3, 5, 8]
+
+dict = {
+  title: 'An example JSON object',
+  empty: nil,
+  sub: {
+    object_key: {a_string: 'Hello, world!', a_number: 1},
+    array_key: fib
+  },
+  double_map: fib.map { |item| item * item }
+}
+
+obj = Belletrist::JSON::Object.new(dict)
 ```

data/belletrist.gemspec

@@ -6,13 +6,12 @@ Gem::Specification.new do |s|
   s.licenses    = ['MIT']
   s.summary     = 'A collection of Ruby DSLs for data file generation.'
   s.description = <<-EOF
-Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML is supported, but
-that will grow as my needs do, or if other people want or contribute any other DSLs, which would be pretty cool I think.
-
-Important to note is that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule of
-"what goes in, must come out". Belletrist DSLs must output well-formed documents so long as the developer provides
-Belletrist valid input, if that contract is broken the result is undefined.
-  EOF
+Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML and JSON are
+supported but that will grow as my needs do, or if other people want or contribute any other DSLs. It is important to
+note that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule of "what goes in,
+must come out", and as such Belletrist DSLs must output well-formed documents so long as the developer provides
+Belletrist valid input. If that contract is broken the result is undefined.
+EOF
   s.authors     = ['Juniper']
   s.email       = 'me@junisoft.org'
   s.files       = Dir['lib/**/*.rb'] + %w[README.md CHANGELOG.md belletrist.gemspec LICENSE]

data/lib/belletrist/abstract.rb

@@ -26,7 +26,7 @@ module Belletrist
 
     def with(ele, &block)
       @elements.push ele
-      ele.children.instance_eval(&block) if block
+      ele.instance_eval(&block) if block
       ele
     end
 
@@ -39,5 +39,9 @@ module Belletrist
     def responds_to?(method)
       true
     end
+
+    def inspect
+      to_s
+    end
   end
 end

data/lib/belletrist/html.rb

@@ -3,19 +3,7 @@
 require_relative './abstract'
 
 module Belletrist::HTML
-  class Base
-    attr_reader :children
-
-    def initialize
-      @children = Collector.new
-    end
-
-    def inspect
-      self.to_s
-    end
-  end
-
-  class Element < Base
+  class Element < Belletrist::BaseCollector
     ESCAPE_HTML = {
       "&" => "&amp;",
       "<" => "&lt;",
@@ -29,7 +17,7 @@ module Belletrist::HTML
     attr_accessor :text
     attr_reader :name
 
-    def initialize(name, args)
+    def initialize(name, args=[])
       super()
       @name = name.to_s
       @attr = []
@@ -43,10 +31,14 @@ module Belletrist::HTML
         end
       end
 
-      component(@children)
+      component
+    end
+
+    def component
     end
 
-    def component(c)
+    def new_element(name, args)
+      Element.new(name, args)
     end
 
     private def import_attribute(hash)
@@ -68,24 +60,21 @@ module Belletrist::HTML
       text.gsub(ESCAPE_HTML_PATTERN, ESCAPE_HTML)
     end
 
-    def map(arr, &block)
-      arr.each do |item|
-        @children.instance_exec item, &block
-      end
-    end
-
     def to_s
       spacer = ''
       spacer = ' ' if @attr.length > 0
-      "<#{s_key(@name)}#{spacer}#{@attr.join(' ')}>#{s_txt(@text)}#{@children}</#{s_key(@name)}>"
+      "<#{s_key(@name)}#{spacer}#{@attr.join(' ')}>#{s_txt(@text)}#{@elements.map { |e| e.to_s }.join('')}</#{s_key(@name)}>"
     end
   end
 
-  class Document < Base
-    def initialize(spec=V5)
+  class Document
+    def initialize(spec=V5, lang=nil)
       super()
-      @head = Collector.new
-      @body = Collector.new
+      body_args = []
+      body_args.push lang if lang
+
+      @head = Element.new 'head'
+      @body = Element.new 'body', body_args
       @spec = spec
     end
 
@@ -100,13 +89,7 @@ module Belletrist::HTML
     end
 
     def to_s
-      "#{@spec}<html><head>#{@head}</head><body>#{@body}</body></html>"
-    end
-  end
-
-  class Collector < Belletrist::BaseCollector
-    def new_element(name, args)
-      Element.new(name, args)
+      "#{@spec}<html>#{@head}#{@body}</html>"
     end
   end
 

data/lib/belletrist/json.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative './abstract'
+
+module Belletrist::JSON
+  def self.to_value(v)
+    if v.nil?
+      'null'
+    elsif v.is_a?(String)
+      "\"#{v.gsub(/"/, '\"')}\""
+    else
+      v.to_s
+    end
+  end
+
+  class Object < Belletrist::BaseCollector
+    class Entry
+      attr_reader :key, :value
+
+      def initialize(key, value)
+        super()
+
+        @key = key.to_s
+        @value = value
+      end
+
+      def map(values, &block)
+        if @value.is_a?(Object) and @value.length == 0
+          @value = List.new
+        end
+
+        if @value.is_a?(List)
+          @value.map values, &block
+        end
+      end
+
+      private def method_missing(symbol, *args, &block)
+        @value.send(symbol, *args, &block)
+      end
+    end
+
+    def initialize(dict={})
+      super()
+      dict.each do |entry|
+        key, val = entry
+        unless key.is_a?(Symbol)
+          key = key.to_sym
+        end
+
+        self.send(key, val)
+      end if dict
+    end
+
+    private def new_element(ele, args)
+      args = {} if args.length == 0
+      args = args.pop if args.length == 1
+
+      if args.is_a?(Hash)
+        args = Object.new(args)
+      elsif args.is_a?(Array)
+        args = List.new(args)
+      end
+
+      Entry.new(ele, args)
+    end
+
+    def length
+      @elements.length
+    end
+
+    def to_s
+      value = '{'
+      @elements.each_index do |i|
+        item = @elements[i]
+        value += "\"#{item.key}\":#{JSON.to_value(item.value)}"
+        value += ',' unless i + 1 == @elements.length
+      end
+      value + '}'
+    end
+  end
+
+  class List
+    attr_reader :elements
+
+    def initialize(arr=[])
+      super()
+      @elements = Array.new
+
+      arr.each do |item|
+        self.push item
+      end if arr
+    end
+
+    def push(value)
+      @elements.push(correct_type(value))
+    end
+
+    def unshift(value)
+      @elements.unshift(correct_type(value))
+    end
+
+    def map(values, &block)
+      values.each do |item|
+        self.instance_exec item, &block
+      end
+    end
+
+    private def correct_type(value)
+      if value.is_a?(Hash)
+        Object.new(value)
+      elsif value.is_a?(Array)
+        List.new(value)
+      else
+        value
+      end
+    end
+
+    def to_s
+      value = '['
+      @elements.each_index do |i|
+        item = @elements[i]
+        value += JSON.to_value(item)
+        value += ',' unless i + 1 == @elements.length
+      end
+      value + ']'
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/belletrist/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belletrist
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/lib/belletrist.rb

@@ -2,6 +2,7 @@
 
 require_relative 'belletrist/version'
 require_relative 'belletrist/html'
+require_relative 'belletrist/json'
 
 module Belletrist
 end

metadata

@@ -1,22 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: belletrist
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Juniper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-17 00:00:00.000000000 Z
+date: 2023-12-18 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML is supported, but
-  that will grow as my needs do, or if other people want or contribute any other DSLs, which would be pretty cool I think.
-
-  Important to note is that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule of
-  "what goes in, must come out". Belletrist DSLs must output well-formed documents so long as the developer provides
-  Belletrist valid input, if that contract is broken the result is undefined.
+  Belletrist is a collection of Ruby DSLs for generation of different data file types. Currently, HTML and JSON are
+  supported but that will grow as my needs do, or if other people want or contribute any other DSLs. It is important to
+  note that Belletrist has a focus on performance, not correctness. Belletrist ascribes to the rule of "what goes in,
+  must come out", and as such Belletrist DSLs must output well-formed documents so long as the developer provides
+  Belletrist valid input. If that contract is broken the result is undefined.
 email: me@junisoft.org
 executables: []
 extensions: []
@@ -29,6 +28,7 @@ files:
 - lib/belletrist.rb
 - lib/belletrist/abstract.rb
 - lib/belletrist/html.rb
+- lib/belletrist/json.rb
 - lib/belletrist/version.rb
 homepage: https://codeberg.org/juniper/Belletrist
 licenses: