lissio 0.1.0.beta1

data/opal/lissio/application.rb

@@ -0,0 +1,66 @@
+require 'singleton'
+require 'forwardable'
+
+module Lissio
+
+class Application < Component
+	def self.inherited(klass)
+		super
+
+		klass.include Singleton
+
+		$document.on :load do
+			klass.start
+		end
+	end
+
+	def self.expose(what, options = {})
+		if what.start_with?(?@)
+			name = what[1 .. -1]
+
+			define_singleton_method name do
+				instance.__send__ name
+			end
+
+			attr_reader name
+		else
+			define_singleton_method what do |*args, &block|
+				instance.__send__ what, *args, &block
+			end
+		end
+	end
+
+	expose :start
+	expose :refresh
+	expose :navigate
+	expose :@router
+
+	extend Forwardable
+	def_delegators :@router, :navigate, :route
+
+	def initialize
+		@router = Lissio::Router.new(fragment: false)
+	end
+
+	def start
+		render
+
+		@router.update
+	end
+
+	def refresh
+		@router.update
+	end
+
+	element :body
+
+	on :click, 'a[href^="/"]' do |e|
+		unless e.alt? || e.ctrl? || e.meta? || e.shift?
+			e.stop!
+
+			navigate e.target[:href] || e.target.ancestors('a').first[:href]
+		end
+	end
+end
+
+end

data/opal/lissio/collection.rb

@@ -0,0 +1,70 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'forwardable'
+
+module Lissio
+
+class Collection
+	def self.adapter(klass = nil, *args, &block)
+		if klass
+			@adapter.uninstall if @adapter
+
+			@adapter = klass.new(self, *args, &block)
+			@adapter.install
+		else
+			@adapter
+		end
+	end
+
+	def self.model(klass = nil)
+		klass ? @model = klass : @model
+	end
+
+	def self.parse(&block)
+		block ? @parse = block : @parse
+	end
+
+	extend Forwardable
+	def_delegators :class, :adapter, :model
+	def_delegators :@items, :empty?, :length, :[], :to_a
+
+	def initialize(data = nil, *fetched_with)
+		@fetched_with = fetched_with
+
+		if data
+			@items = data.map {|datum|
+				next datum if Model === datum
+
+				if block = self.class.parse
+					block.call(datum)
+				else
+					model.new(datum)
+				end
+			}
+		end
+	end
+
+	include Enumerable
+
+	def each(&block)
+		return enum_for :each unless block
+
+		@items.each(&block)
+
+		self
+	end
+
+	def inspect
+		"#<#{self.class.name}: #{@items.inspect}>"
+	end
+end
+
+end

data/opal/lissio/component.rb

@@ -0,0 +1,177 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Lissio
+
+class Component
+	def self.inherited(klass)
+		return if self == Component
+
+		element = @element
+		tag     = @tag
+		events  = @events
+
+		klass.instance_eval {
+			@element = element if element
+			@tag     = tag if tag
+			@events  = events.clone if events
+		}
+	end
+
+	def self.element(name = nil)
+		name ? @element = name : @element
+	end
+
+	def self.tag(options = nil)
+		options ? @tag = options : @tag
+	end
+
+	def self.events
+		@events ||= Hash.new { |h, k| h[k] = [] }
+	end
+
+	def self.on(name, selector = nil, method = nil, &block)
+		if block
+			events[name] << [selector, block]
+
+			[name, selector, block]
+		elsif method
+			events[name] << [selector, method]
+
+			[name, selector, method]
+		else
+			events[name] << [nil, method]
+
+			[name, nil, method]
+		end
+	end
+
+	def self.off(id)
+		name, selector, block = id
+
+		events[name].delete([selector, block])
+	end
+
+	def self.render(&block)
+		define_method :render do
+			instance_exec(&block)
+
+			super
+		end
+	end
+
+	def self.html(string = nil, &block)
+		if block
+			render {
+				if block.arity == 1
+					element.inner_dom { |d|
+						instance_exec(d, &block)
+					}
+				else
+					element.inner_dom(&block)
+				end
+			}
+		else
+			render {
+				element.inner_html = string
+			}
+		end
+	end
+
+	def self.css(content = nil, &block)
+		if content || block
+			@style.remove if @style
+
+			@style = CSS(content, &block)
+			@style.append_to($document.head)
+		else
+			CSS::StyleSheet.new(@style)
+		end
+	end
+
+	attr_accessor :parent
+
+	def initialize(parent = nil)
+		@parent = parent
+	end
+
+	def tag
+		{ name: :div }.merge(self.class.tag || {})
+	end
+
+	def element
+		return @element if @element
+
+		scope = parent ? parent.element : $document
+		elem  = if elem = self.class.element
+			scope.at(elem)
+		else
+			DOM::Element.create tag[:name]
+		end
+
+		unless elem
+			raise ArgumentError, 'element not found'
+		end
+
+		elem.add_class(*tag[:class]) if tag[:class]
+		elem[:id] = tag[:id] if tag[:id]
+
+		self.class.events.each {|name, blocks|
+			blocks.each {|selector, block|
+				if block.is_a? Symbol
+					elem.on(name, selector, &method(block))
+				else
+					elem.on(name, selector) {|*args|
+						instance_exec(*args, &block)
+					}
+				end
+			}
+		}
+
+		@element = elem
+	end
+
+	def on(name, selector = nil, method = nil, &block)
+		self.class.on(name, selector, method, &block)
+
+		if @element
+			if block
+				@element.on(name, selector) {|*args|
+					instance_exec(*args, &block)
+				}
+			elsif method
+				@element.on(name, selector, &method(method))
+			else
+				@element.on(name, &method(method))
+			end
+		end
+
+		self
+	end
+
+	# When overriding, remember to call super as last.
+	def render(*)
+		element.trigger :render, self
+		element
+	end
+
+	def remove
+		@element.remove if @element
+	end
+
+	alias destroy remove
+end
+
+
+Browser::DOM::Builder.for Component do |_, item|
+	item.render
+end
+
+end

data/opal/lissio/component/alert.rb

@@ -0,0 +1,110 @@
+module Lissio; class Component
+
+class Alert < Component
+	def self.new!(message, options = {})
+		new(message, options.merge({ escape: false }))
+	end
+
+	attr_reader :message, :options
+
+	def initialize(message, options = {})
+		@message = message
+		@options = options
+	end
+
+	def render
+		if @options[:escape] == false
+			element.inner_html = @message
+		else
+			element << @message
+		end
+
+		super
+	end
+
+	tag class: :alert
+
+	css do
+		rule '.alert' do
+			border 1.px, :solid, :transparent
+
+			padding 15.px
+
+			rule 'a' do
+				font weight: :bold
+			end
+		end
+	end
+
+	def self.customize(*args, &block)
+		if args.length == 1
+			options = args.first
+		else
+			name, options = args
+		end
+
+		name    ||= "alert-custom-#{rand(10000)}"
+		options ||= {}
+
+		if self == Alert
+			inherited = []
+		else
+			inherited = class_names
+		end
+
+		Class.new(self) {
+			define_singleton_method :class_names do
+				inherited + [name]
+			end
+
+			tag class: [:alert, name, *inherited]
+
+			css do
+				rule ".alert#{".#{inherited.join('.')}" unless inherited.empty?}.#{name}" do
+					instance_exec(&block) if block
+
+					if value = options[:background] || options[:bg]
+						background color: value
+					end
+
+					if value = options[:foreground] || options[:fg]
+						color value
+					end
+
+					if value = options[:border]
+						border color: value
+					end
+
+					if value = options[:padding]
+						padding value
+					end
+				end
+			end
+		}
+	end
+
+	Info = customize :info,
+		background: '#d9edf7',
+		foreground: '#3a87ad',
+		border:     '#bce8f1'
+
+	Success = customize :success,
+		message:    "The operation was successful.",
+		background: '#dff0d8',
+		foreground: '#468847',
+		border:     '#d6e9c6'
+
+	Warning = customize :warning,
+		message:    "Something might have gone wrong.",
+		background: '#fcf8e3',
+		foreground: '#c09853',
+		border:     '#fbeed5'
+
+	Danger = customize :danger,
+		message:    "An unexpected error has occurred.",
+		background: '#f2dede',
+		foreground: '#b94a48',
+		border:     '#eed3d7'
+end
+
+end; end

data/opal/lissio/component/container.rb

@@ -0,0 +1,56 @@
+module Lissio; class Component
+
+class Container < Component
+	class Definer
+		def initialize(&block)
+			@list = []
+
+			if block.arity == 0
+				instance_exec(&block)
+			else
+				block.call(self)
+			end
+		end
+
+		def render(what)
+			@list << what
+		end
+
+		def to_a
+			@list
+		end
+	end
+
+	def initialize(parent, &block)
+		super(parent)
+
+		if block
+			@content = Definer.new(&block).to_a
+		else
+			@content = []
+		end
+	end
+
+	def render(*content, &block)
+		content = @content.dup if content.empty?
+		content.compact! # FIXME: when it's fixed
+
+		element.clear
+
+		content.each {|c|
+			if String === c
+				element << c
+			else
+				element << c.render
+			end
+		}
+
+		if block
+			element << DOM(&block)
+		end
+
+		super
+	end
+end
+
+end; end