RubyGems - sculpt - Versions diffs - 0.1 - Mend

sculpt 0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

data/lib/sculpt/elements.rb +72 -0
data/lib/sculpt/sculpt_helpers.rb +29 -0
data/lib/sculpt/sculpture.rb +133 -0
data/lib/sculpt.rb +56 -0
metadata +48 -0

data/lib/sculpt/elements.rb ADDED Viewed

@@ -0,0 +1,72 @@
+class Tag < ElementContainer
+    include SculptHelpers
+    attr_accessor :name, :text, :attrs, :singelton, :inline
+    def initialize(name,text = '', attrs = {},&block)
+        @name = name
+        @attrs = {}
+        @elements = []
+        @inline = false
+        if text.kind_of?(Hash)
+            if attrs.kind_of? Tag
+                @inline = attrs
+                @elements << attrs
+                return self
+            else
+                @attrs = attrs
+                @attrs.merge!(text)
+                @text = '' # otherwise stays nil
+            end
+        elsif text.kind_of?(Tag)
+            @inline = text
+            @elements << text
+            @text = ''
+            @attrs = attrs
+            return self
+        else
+            @text = text
+            @attrs = attrs
+        end
+        if block_given?
+            @elements += elements_from_block(&block)
+        end
+        @singleton = is_singleton? name
+    end
+    def generate_html(ugly = false)
+        pp = Sculpt.pretty and not ugly
+        n = @name.to_s
+        open = "<#{n}"
+        @attrs.each do |k, v|
+            open += " #{k}=\"#{v}\""
+        end
+        open += '>'
+        return open if @singleton
+        close = "</#{n}>"
+        return open + @text + close unless @elements.any?
+        html = ''
+        @elements.each do |element|
+            html += element.generate_html
+            html += "\n" if pp unless inline or element.kind_of? Static
+        end
+        return "#{open}\n#{html}#{close}" if pp and not inline
+        return open + html + close
+    end
+end
+class Static
+    attr_accessor :string
+    def initialize(string)
+        @string = string
+    end
+    def generate_html
+        return @string+"\n" if Sculpt.pretty?
+        @string
+    end
+end

data/lib/sculpt/sculpt_helpers.rb ADDED Viewed

@@ -0,0 +1,29 @@
+module SculptHelpers
+    def elements_from_block(&block)
+        result = Sculpture.new
+        result.instance_eval(&block)
+        result.elements
+    end
+    def is_singleton? tag
+        [:area, :base, :br, :col, :command, :embed, :hr, :img, :input, :link, :meta, :param, :source].include? tag
+    end
+    def special_attr(att, val, extra)
+        attrs = {att => val}
+        return attrs.merge(extra) if extra.kind_of? Hash
+        attrs
+    end
+end
+# plus some string additions from mynyml/unindent on github
+class String
+  def unindent
+    indent = self.split("\n").select {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min || 0
+    self.gsub(/^[[:blank:]]{#{indent}}/, '')
+  end
+  def unindent!
+    self.replace(self.unindent)
+  end
+end

data/lib/sculpt/sculpture.rb ADDED Viewed

@@ -0,0 +1,133 @@
+class Sculpture < ElementContainer
+    #
+    # This is a container class for elements.
+    # It responds to all the method calls in a block that generates HTMl.
+    #
+    include SculptHelpers
+    def generate_html
+        @elements.map(&:generate_html).join('')
+    end
+    def add_tag(tag)
+        @elements << tag
+        @elements.delete(tag.inline) if tag.inline # dupe prevention
+        tag
+    end
+    #
+    # block methods
+    # use these to make elements
+    #
+    # kenrnel overrides here
+    def p(text='',attrs = {},&block)
+        # necessary to override the Kernel#p method
+        add_tag Tag.new(:p, text.unindent.lstrip, attrs, &block)
+    end
+    def puts(text)
+        @elements << Static.new(text.unindent.lstrip)
+    end
+    def pbr(text)
+        # adds raw text plus a line break
+        @elements << Static.new(text + '<br>')
+    end
+    # other constructors here
+    def doctype
+        @elements << Static.new('<!DOCTYPE html>') # enforce HTML5
+    end
+    def js(*args)
+        args.each do |arg|
+            attrs = {type:"text/javascript", src:arg}
+            add_tag Tag.new(:script, attrs)
+        end
+    end
+    private
+    def _stylesheet(name)
+        attrs = {type:"text/css", rel:"stylesheet", href:name}
+        add_tag Tag.new(:link, attrs)
+    end
+    def css(*args)
+        if args[0].respond_to? :to_a
+            args[0].each {|sheet| _stylesheet sheet}
+        end
+        args.each {|sheet| _stylesheet sheet}
+    end
+    def a(text, href = '', ahash = {}, &block)
+        # funky constructor for easier linking
+        attrs = special_attr(:href, href, ahash)
+        add_tag Tag.new(:a, text, attrs, &block)
+    end
+    def img(src, ahash = {})
+        # funky img constructor
+        attrs = special_attr(:src, src, ahash)
+        add_tag Tag.new(:img, attrs)
+    end
+    private
+    def _listgen(list_type, tarr, attrs, &block)
+        # constructor for lists from arrays. e.g. => ul [1,2,3]
+        tag = Tag.new(list_type)
+        tag.attrs = attrs
+        if tarr.kind_of? Array or tarr.kind_of? Range
+            tarr.each do |item|
+                tag.elements << Tag.new(:li, item)
+            end
+        elsif tarr.respond_to? :to_s and not tarr.empty?
+            tag.text = tarr
+        elsif block_given?
+            tag.elements += elements_from_block(&block)
+        end
+        add_tag tag
+    end
+    def ul(tarr = '', attrs = {}, &block)
+        _listgen(:ul, tarr, attrs, &block)
+    end
+    def ol(tarr, attrs = {}, &block)
+        _listgen(:ol, tarr, attrs, &block)
+    end
+    def method_missing(method, *args, &block)
+        #
+        # general tag constructor
+        # custom tag initialisation here
+        #
+        arg1 = args[0]
+        arg1 = '' unless arg1
+        arg2 = args[1]
+        arg2 = {} unless arg2
+        arg3 = args[2]
+        m = method.to_s
+        if m.end_with? '_s'
+            # inline string methods
+            meth = m[0..-3].to_sym
+            case meth
+            when :a
+                attrs = special_attr(:href, arg2, arg3)
+                tag = Tag.new(:a, arg1, attrs, &block)
+            when :img
+                attrs = special_attr(:src, arg1, arg2)
+                tag = Tag.new(:img, attrs)
+            else
+                tag = Tag.new(meth, arg1, arg2, &block)
+            end
+            return tag.generate_html
+        end
+        add_tag Tag.new(method, arg1, arg2, &block)
+    end
+end

data/lib/sculpt.rb ADDED Viewed

@@ -0,0 +1,56 @@
+#
+# Sculpt
+#
+# An HTMl5 generator in Ruby.
+# Syntax is everything.
+#
+class ElementContainer
+    attr_accessor :elements
+    def initialize
+        @elements = []
+    end
+end
+require_relative 'sculpt/sculpt_helpers'
+require_relative 'sculpt/elements'
+require_relative 'sculpt/sculpture'
+class Sculpt
+    #
+    # The Sculpt class is used externally.
+    # Most of the time this is the only class users will play with.
+    #
+    class << self
+        attr_accessor :pretty
+    end
+    def self.pretty?
+        @pretty
+    end
+    def self.render_doc(&block)
+        puts self.make_doc(&block)
+    end
+    def self.make_doc(&block)
+        self.make do
+            doctype
+            html(&block)
+        end
+    end
+    def self.render(&block)
+        puts self.make(&block)
+    end
+    def self.make(&block)
+        result = Sculpture.new
+        result.instance_eval(&block)
+        result.generate_html
+    end
+end
+Sculpt.pretty = true # pretty print by default

metadata ADDED Viewed

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: sculpt
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease:
+platform: ruby
+authors:
+- Alex Coplan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-06-10 00:00:00.000000000 Z
+dependencies: []
+description: ! "Sculpt is an HTML generator in Ruby.\n    Syntax is everything"
+email: lexy0202@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sculpt/elements.rb
+- lib/sculpt/sculpt_helpers.rb
+- lib/sculpt/sculpture.rb
+- lib/sculpt.rb
+homepage: http://github.com/alexcoplan/sculpt
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: An HTML generator in Ruby.
+test_files: []