weby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bad3a8a500f51db0006a12a6cecaa559b4e2e61e
+  data.tar.gz: a15dfd9e9d8423f143c1b85fe593b27daf0e9566
+SHA512:
+  metadata.gz: '0584d1392b70e7585fc3e60ae51291431bef8fdcc2a3cddb19ac337711e4518e325e6d7a7ed25bcb6906eabc7e67b3e0d1a05e8c8a38ed76ae277f046a3a94ff'
+  data.tar.gz: f98cdd4c56d9b3aee976e9362a87dacaba387dfde6dd986a995cf0afc8e3a5ab28de1052c0e3a28808bb356e2086ca3237e0d2ba81285d675f29344828e2dadc

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/GEMDESC

@@ -0,0 +1 @@
+Weby has been designed to easily write web interfaces. It can be used to generate HTML code in a template based fashion or you're free to create HTML in a programmatic way, or even a mix of them.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in weby.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2016-2017 Fabio Nicotra.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of PsyC nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 artix
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 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 THE SOFTWARE.

data/README.md

@@ -0,0 +1,225 @@
+# Weby
+
+Weby lets you easily handle and generate HTML, XHTML or XML code in Ruby.
+It can be used both as a templating system and as a programmatic HTML generator.
+You can even mix templating and programmatic HTML, so you're free to use it as you like.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'weby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install weby
+
+## Usage
+
+Here's some example:
+
+
+```ruby
+require 'rubygems'
+require 'weby'
+
+#Loading a template
+
+html = <<EOS
+<div id="main">
+    <h1>Hello</h1>
+    <ul>
+	<li></li>
+    </ul>
+    <select>
+	<option></option>
+    </select>
+    <table>
+	<tr>
+	    <td></td>
+	</tr>
+    </table>
+    <span wby-if="num.even?">An even number</span>
+    <span wby-if="num.odd?">An odd number</span>
+</div>
+EOS
+
+h = HTML.parse html
+
+puts h
+
+```
+
+Now let's see some evaluation feature:
+
+```ruby
+
+num = 2
+h.evaluate binding: binding
+puts h.to_html
+
+```
+This will output:
+
+```html
+    <div id="main">
+        <h1>Hello</h1>
+        <ul>
+            <li>
+        </ul>
+        <select>
+            <option></option>
+        </select>
+        <table>
+            <tr>
+                <td></td>
+            </tr>
+        </table>
+        <span>An even number</span>
+        
+    </div>
+```
+
+Now let's manipulate HTML elements:
+
+```ruby
+
+h.find('#main').append {
+    h2{'Title'}
+}
+h.append {
+    div(id: 'body'){'World'}
+}
+h.find('h1').add_class 'header'
+h.find('h1,h2').add_class 'title'
+puts h.to_html
+
+```
+
+Output:
+
+```html
+<div id="main">
+    <h1 class="header title">Hello</h1>
+    <ul>
+        <li>
+    </ul>
+    <select>
+        <option></option>
+    </select>
+    <table>
+        <tr>
+            <td></td>
+        </tr>
+    </table>
+    <span>An even number</span>
+    
+    <h2 class="title">Title</h2>
+</div>
+<div id="body">World</div>
+```
+
+We can also use some element as a template for given data:
+
+```ruby
+li = h.find 'ul li'
+li.as_template %w(Apple Banana)
+puts h
+```
+
+Output:
+
+```html
+
+...
+
+<ul>
+    <li>Apple</li>
+    <li>Banana</li>
+</ul>
+
+...
+
+```
+
+More complex templating:
+
+```ruby
+o = h.find 'option'
+o.as_template [
+    {value: '#fff', content: :white},
+    {value: '#000', content: :black}
+]
+```
+
+Will produce:
+
+```html
+
+...
+
+<select>
+    <option value="#fff">white</option>
+    <option value="#000">black</option>
+</select>
+
+...
+
+```
+
+```ruby
+tr = h.find 'tr'
+tr.as_template [
+    {
+        id: 'user-1',
+        select: {td: {content: 'User 1'}}
+    },
+    {
+        id: 'user-2',
+        select: {td: {content: 'User 2'}}
+    },
+]
+```
+
+```html
+<table>
+    <tr id="user-1">
+        <td>User 1</td>
+    </tr>
+    <tr id="user-2">
+        <td>User 2</td>
+    </tr>
+</table>
+```
+
+We can also easily manipulate style and data:
+
+```ruby
+main = h.find '#main'
+main.style :width, '800px'
+main.style height: '100%', border: '1px solid'
+main.data 'pageid', '1'
+main.data userid: 1, username: 'admin'
+```
+
+```html
+<div id="main" style="width: 800px; height: 100%; border: 1px solid" data-pageid="1" data-userid="10" data-username="artix">
+
+...
+
+</div>
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/artix75/weby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/weby/html.rb

@@ -0,0 +1,491 @@
+module Weby
+
+    class HTMLException < Exception
+    end
+
+    class HTML
+
+        attr_accessor :node, :nodeset, :document
+
+        @@prefix = 'wby'
+        @@evaluation_instance = nil
+        @@evaluation_binding = TOPLEVEL_BINDING
+        @@use_cache = true
+        @@cache = {}
+        @@include_path = nil
+
+        def initialize(obj, opts = {}, &block)
+            @source = opts[:source]
+            if obj.is_a? Nokogiri::XML::Node
+                @node = obj
+                @is_doc = obj.is_a? Nokogiri::XML::Document
+                @is_fragm = obj.is_a? Nokogiri::XML::DocumentFragment
+                @document = @node if @is_doc || @is_fragm
+                @document ||= @node.document
+            elsif obj.is_a? Nokogiri::XML::NodeSet
+                @nodeset = obj
+                @node = obj[0]
+            elsif obj.is_a? Symbol
+                @document = opts[:_doc] 
+                raise_err ':_doc option is missing' if !@document
+                @document = @document.document if @document.is_a?(HTML)
+                if !@document.is_a?(Nokogiri::XML::DocumentFragment) && 
+                   !@document.is_a?(Nokogiri::XML::Document)
+                    raise_err ':_doc must be Nokogiri::XML::Document[Fragment]'
+                end
+                @node = Nokogiri::XML::Element.new obj.to_s, @document
+                opts.delete :_doc
+                opts.each{|attr, val|
+                    next if val.nil?
+                    @node[attr] = val
+                }
+                self.exec(&block) if block_given?
+            elsif obj.is_a? String
+                if @source && @source[/\.rb$/]
+                    @node = Nokogiri::HTML::DocumentFragment.parse '' 
+                    self.exec :append, obj
+                else
+                    @node = Nokogiri::HTML::DocumentFragment.parse obj
+                end
+                @document = @node
+                @is_fragm = true
+            end
+            @document ||= (@nodeset || @node).document
+            if @@use_cache && @source
+                @@cache[@source] = self if !@@cache.key?(@source)
+            end
+        end
+
+        def builder
+            @builder ||= HTMLBuilder.new(self)
+        end
+
+        def exec(mode = :append, src = nil, &block)
+            if src
+                text = builder.mode(mode).instance_eval(src)
+            else
+                text = builder.mode(mode).instance_eval(&block)
+            end
+            @node.add_child text if text.is_a? String
+            text
+        end
+
+        def evaluate(opts = {})
+            return if !@node
+            _self = opts[:self] || @@evaluation_instance
+            _binding = opts[:binding] || @@evaluation_binding
+            conditional_attr = "#{@@prefix}-if"
+            conditionals = @node.css "*[#{conditional_attr}]"
+            conditionals.each{|n|
+                condition = n[conditional_attr]
+                args = [condition]
+                args += [@source, n.line] if @source
+                if _self
+                    ok = _self.instance_eval *args
+                else
+                    ok = _binding.eval *args
+                end
+                if !ok
+                    n.remove
+                else
+                    n.remove_attribute conditional_attr
+                end
+            }
+            imports = @node.css "#{@@prefix}-include"
+            imports.each{|n|
+                path = n['path'] 
+                if path
+                    path = resolvepath path
+                    if !File.exists? path
+                        line = (@source ? n.line : nil)
+                        raise_err "File not found: #{path}", line
+                    end
+                    fragm = HTML::load path
+                    next if !fragm.node
+                    fragm.evaluate self: _self, binding: _binding
+                    n.after fragm.node
+                    n.remove
+                end
+            }
+        end
+
+        def append(_node = nil, &block)
+            _node = _node.node if _node.is_a? HTML
+            @node.add_child _node if _node
+            self.exec(&block) if block_given?
+            self
+        end
+
+        def append_to(_node)
+            if @node
+                _node = _node.node if _node.is_a? HTML
+                _node.add_child(@node)
+            end
+            self
+        end
+
+        def prepend(_node = nil, &block)
+            _node = _node.node if _node.is_a? HTML
+            @node.prepend_child _node if _node
+            self.exec(:prepend, &block) if block_given?
+            self
+        end
+
+        def prepend_to(_node)
+            if @node
+                _node = _node.node if _node.is_a? HTML
+                _node.prepend_child(@node)
+            end
+            self
+        end
+
+        def find(selector)
+            self.class.new((@nodeset || @node).css(selector))
+        end
+
+        def children
+            return [] if !@node
+            HTML.new(@node.children)
+        end
+
+        def each(&block)
+            (@nodeset || [@node]).each &block 
+        end
+
+        def parent
+            self.class.new(@node.parent) if @node
+        end
+
+        def next
+            if @node && (nxt = @node.next)
+                self.class.new(nxt)
+            end
+        end
+
+        def [](attr)
+           (@node || {})[attr]
+        end
+
+        def []=(attr, val)
+            if @node
+                @node[attr] = val
+            end
+        end
+
+        def inner_html
+            return '' if !@node
+            @node.inner_html
+        end
+
+        def inner_html=(html)
+            @node.inner_html = html if @node
+        end
+
+        def remove
+            (@nodeset || @node).remove
+            self
+        end
+
+        def add_class(classname)
+            (@nodeset || [@node]).each{|n| add_class_to(n, classname)}
+            self
+        end
+
+        def remove_class(classname)
+            (@nodeset || [@node]).each{|n| remove_class_from(n, classname)}
+            self
+        end
+
+        def style(*args)
+            argl = args.length
+            _node = @node || {}
+            css = (_node['style']) || ''
+            hash = parse_css css
+            return hash if argl.zero?
+            if argl == 1
+                arg = args[0]
+                if hashlike? arg
+                    return if !@node
+                    arg.each{|prop, val|
+                        hash[prop] = val
+                    }
+                    @node['style'] = hash_to_css(hash)
+                    return self
+                else
+                    return hash[arg.to_s]
+                end
+            else
+                prop, val = args
+                hash[prop] = val
+                @node['style'] = hash_to_css(hash)
+                return self
+            end
+        end
+
+        def hide
+            (@nodeset || [@node]).each{|n|
+                css = n['style'] || ''
+                hash = parse_css css
+                hash['display'] = 'none'
+                n['style'] = hash_to_css(hash)
+            }
+            self
+        end
+
+        def data(*args)
+            argl = args.length
+            if argl.zero?
+                return {} if !@node
+                attrs = @node.attributes
+                res = {}
+                attrs.each{|a,v|
+                    res[a] = v if a[/^data-/]
+                }
+                res
+            elsif argl == 1
+                arg = args[0]
+                if hashlike?(arg)
+                    arg.each{|name, val|
+                        @node["data-#{name}"] = val
+                    } if @node
+                    self
+                else
+                   return nil if !@node
+                   @node["data-#{arg}"]
+                end
+            else
+                name, val = args
+                if @node
+                    @node["data-#{name}"] = val
+                end
+                self
+            end
+        end
+
+        def as_template(obj, opts = nil)
+            opts ||= {}
+            nl = opts[:new_line]
+            res = self
+            if @node
+                if obj.is_a? String
+                    @node.content = obj
+                elsif hashlike?(obj)
+                    obj.each{|attr, v|
+                        attr_s = attr.to_s
+                        if v.nil? && !@node[attr_s].nil?
+                            @node.remove_attribute attr_s
+                        elsif attr == :content
+                            v = '' if v.nil?
+                            @node.content = v.to_s
+                        elsif attr == :data && hashlike?(v)
+                            v.each{|data_name, data_val|
+                                @node["data-#{data_name}"] = data_val 
+                            }                            
+                        elsif attr == :select && hashlike?(v)
+                            v.each{|sel, o|
+                                e = self.find sel.to_s
+                                e.as_template(o)
+                            }
+                        else
+                            @node[attr_s] = v
+                        end
+                    }
+                elsif obj.is_a? Array
+                    last = @node
+                    obj.each{|o|
+                        _node = @node.clone
+                        e = HTML.new(_node)
+                        if block_given?
+                            yield e, o
+                        else
+                            e.as_template(o)
+                        end
+                        last.after("\n") if nl
+                        last.after(e.node)
+                        last = e.node
+                    }
+                    @node.remove
+                end
+            end
+            res
+        end
+
+        def to_html
+            @node.to_html
+        end
+
+        def to_xhtml
+            @node.to_xhtml
+        end
+
+        def to_xml
+            @node.to_xml
+        end
+
+        def to_s
+            super if !@node
+            if @node.xml?
+                to_xml
+            else
+                to_html
+            end
+        end
+
+        def clone
+            _clone = super
+            _clone.instance_eval{
+                @node = @node.clone if @node
+                @nodeset = @nodeset.clone if @nodeset
+                @document = @document.clone if @document
+            }
+            _clone
+        end
+
+        def HTML::parse(text, opts = nil)
+            text ||= ''
+            opts ||= {}
+            opts = {auto: true}.merge(opts)
+            if opts[:auto]
+                opts[:is_document] = !text.strip[/^<!doctype /i].nil?
+            end
+            if opts[:is_document]
+                HTML.new(Nokogiri::HTML::Document.parse(text))
+            else
+                HTML.new(text)
+            end
+        end
+
+        def HTML::parse_doc(text, opts = {})
+            opts[:is_document] = true
+            HTML::parse text, opts
+        end
+
+        def HTML::load(path, opts = {})
+            if @@use_cache
+                cached = @@cache[path]
+                return cached.clone if cached
+            end
+            opts[:source] = path
+            text = File.read path
+            HTML::parse text, opts
+        end
+
+        def HTML::load_doc(path)
+            HTML::load path, is_document: true, source: path
+        end
+
+        def HTML::prefix
+            @@prefix
+        end
+
+        def HTML::prefix=(prfx)
+            @@prefix = prfx
+        end
+
+        def HTML::evaluation_instance
+            @@evaluation_instance
+        end
+
+        def HTML::evaluation_instance=(obj)
+            @@evaluation_instance = obj
+        end
+
+        def HTML::evaluation_binding
+            @@evaluation_binding
+        end
+
+        def HTML::evaluation_binding=(b)
+            @@evaluation_binding = b
+        end
+
+        def HTML::include_path
+            @@include_path
+        end
+
+        def HTML::include_path=(path)
+            @@include_path = path
+        end
+        
+        private
+
+        def raise_err(msg, line = nil)
+            args = [HTMLException, msg]
+            args << "#{@source}:#{line}" if @source && line
+            raise *args
+        end
+
+        def add_class_to(_node, classname)
+            cls = _node['class'] || ''
+            classes = cls.split(/\s+/)
+            return if classes.include? classname
+            cls = (classes << classname).join(' ')
+            _node['class'] = cls
+        end
+
+        def remove_class_from(_node, classname)
+            cls = _node['class'] || ''
+            cls = cls.split(/\s+/).select{|c| c != classname}.join(' ')
+            _node['class'] = cls
+        end
+
+        def hashlike?(obj) 
+            obj.is_a?(Hash) || (!obj.is_a?(Array) && 
+                                obj.respond_to?(:[]) && 
+                                obj.respond_to?(:each))
+        end
+
+        def resolvepath(path)
+            return path if path[/^\//]
+            if (include_path = @@include_path)
+                script_path = File.dirname(File.expand_path($0))
+                include_path = File.join(script_path, include_path, path)
+                path = include_path if File.exists? path 
+            end
+            path
+        end
+
+        def parse_css(css)
+            o = {}
+            css = css.strip.gsub(/^\{/, '').gsub(/\}$/, '')
+            decls = css.split(';')
+            decls.each{|d|
+                prop, val = d.strip.split(':')
+                o[prop.strip] = val.strip
+            }
+            o
+        end
+
+        def hash_to_css(hash)
+            hash.to_a.map{|d|
+                prop, val = d
+                "#{prop}: #{val}"
+            }.join('; ')
+        end
+
+    end
+
+    class HTMLBuilder
+
+        def initialize(parent)
+            @parent = parent
+        end
+
+        def mode(mode)
+            @mode = mode
+            self
+        end
+
+        def method_missing(m, attrs = {}, &block)
+            attrs[:_doc] = @parent
+            element = HTML.new m, attrs, &block
+            if @mode == :prepend
+                @parent.prepend element
+            else
+                @parent.append element
+            end
+            element
+        end
+
+    end
+
+end

data/lib/weby/version.rb

@@ -0,0 +1,3 @@
+module Weby
+  VERSION = "0.0.1"
+end

data/lib/weby.rb

@@ -0,0 +1,6 @@
+require 'nokogiri'
+require "weby/version"
+require "weby/html"
+
+module Weby
+end

data/weby.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'weby/version'
+
+Gem::Specification.new do |spec|
+  lpath = File.dirname(lib)
+  spec.name          = "weby"
+  spec.version       = Weby::VERSION
+  spec.authors       = ["artix"]
+  spec.email         = ["artix2@gmail.com"]
+  spec.summary       = %q{Web programming for Ruby made easy.}
+  spec.description   = File.read(File.join(lpath, 'GEMDESC'))
+  spec.homepage      = "https://github.com/artix75/weby"
+  spec.license       = "BSD-3-Clause"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "nokogiri", "~> 1.8"
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: weby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- artix
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: 'Weby has been designed to easily write web interfaces. It can be used
+  to generate HTML code in a template based fashion or you''re free to create HTML
+  in a programmatic way, or even a mix of them.
+
+'
+email:
+- artix2@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- GEMDESC
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/weby.rb
+- lib/weby/html.rb
+- lib/weby/version.rb
+- weby.gemspec
+homepage: https://github.com/artix75/weby
+licenses:
+- BSD-3-Clause
+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.6.9
+signing_key: 
+specification_version: 4
+summary: Web programming for Ruby made easy.
+test_files: []