lissio 0.1.0.beta1

data/opal/lissio/model.rb

@@ -0,0 +1,204 @@
+#--
+#            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 'json'
+require 'forwardable'
+
+module Lissio
+
+class Model
+	class Property
+		attr_reader :name, :as
+
+		def initialize(name, options)
+			@name    = name
+			@default = options[:default]
+			@primary = options[:primary] || false
+			@as      = options[:as]
+		end
+
+		def primary?
+			@primary
+		end
+
+		def default
+			if Proc === @default && @default.lambda?
+				@default.call
+			else
+				@default
+			end
+		end
+
+		def new(data)
+			return default if data.nil?
+			return data if !@as || @as === data
+
+			if @as.ancestors.include?(Model)
+				if @as.primary.as === data
+					return data
+				else
+					return @as.new(*data)
+				end
+			end
+
+			case
+			when @as == Boolean then !!data
+			when @as == Array   then Array(data)
+			when @as == String  then data.to_s
+			when @as == Symbol  then data.to_sym
+			when @as == Integer then data.to_i
+			when @as == Float   then data.to_f
+			when @as == Time    then Time.parse(data)
+			when Proc === @as   then @as.call(data)
+			else                     @as.new(*data)
+			end
+		end
+
+		def define(klass)
+			name = @name
+			as   = @as
+
+			if Class === @as && @as.ancestors.include?(Model)
+				klass.define_method name do
+					if id = instance_variable_get("@#{name}")
+						as.fetch(id)
+					end
+				end
+
+				klass.define_method "#{name}=" do |value|
+					if instance_variable_get("@#{name}") != value.id!
+						@changed << name
+
+						instance_variable_set "@#{name}", value.id!
+					end
+				end
+			else
+				klass.define_method name do
+					instance_variable_get "@#{name}"
+				end
+
+				klass.define_method "#{name}=" do |value|
+					if instance_variable_get("@#{name}") != value
+						@changed << name
+
+						instance_variable_set "@#{name}", value
+					end
+				end
+			end
+		end
+	end
+
+	def self.inherited(klass)
+		klass.instance_eval {
+			@properties = {}
+		}
+
+		return if self == Model
+
+		klass.instance_eval {
+			def self.properties
+				superclass.properties.merge @properties
+			end
+		}
+	end
+
+	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.for(klass, *args, &block)
+		Class.new(self) {
+			adapter(klass, *args, &block)
+		}
+	end
+
+	def self.properties
+		@properties
+	end
+
+	def self.property(name, options = {})
+		# @properties is accessed directly to allow proper inheritance
+		@properties[name] = Property.new(name, options).tap {|property|
+			property.define(self)
+
+			if property.primary?
+				@primary = property
+			end
+		}
+	end
+
+	def self.primary
+		@primary
+	end
+
+	extend Forwardable
+	def_delegators :class, :adapter, :properties
+
+	attr_reader :fetched_with, :changed
+
+	def initialize(data = nil, *fetched_with)
+		@fetched_with = fetched_with
+		@changed      = []
+
+		if data
+			properties.each {|name, property|
+				instance_variable_set "@#{name}", property.new(data[name])
+			}
+		end
+	end
+
+	def changed?
+		not @changed.empty?
+	end
+
+	def id!
+		name, = properties.find {|_, property|
+			property.primary?
+		}
+
+		instance_variable_get "@#{name || :id}"
+	end
+
+	def to_h
+		Hash[properties.map {|name, _|
+			[name, instance_variable_get("@#{name}")]
+		}]
+	end
+
+	def as_json
+		hash = to_h
+		hash[JSON.create_id] = self.class.name
+
+		hash
+	end
+
+	def to_json
+		as_json.to_json
+	end
+
+	def self.json_create(data)
+		new(data)
+	end
+
+	def inspect
+		"#<#{self.class.name}: #{properties.map {|name, _|
+			"#{name}=#{instance_variable_get("@#{name}").inspect}"
+		}.join(' ')}>"
+	end
+end
+
+end

data/opal/lissio/router.rb

@@ -0,0 +1,164 @@
+#--
+#            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 'browser/history'
+
+module Lissio
+
+class Router
+	attr_reader :routes, :options
+
+	def initialize(options = {}, &block)
+		@routes   = []
+		@options  = options
+		@location = $document.location
+		@initial  = @location.uri
+		@history  = $window.history
+
+		@change = if fragment?
+			$window.on 'hash:change' do
+				update
+			end
+		else
+			$window.on 'pop:state' do |e|
+				if @initial == @location.uri
+					@initial = nil
+					break
+				else
+					@initial = nil
+				end
+
+				update
+			end
+		end
+
+		if block.arity == 0
+			instance_exec(&block)
+		else
+			block.call(self)
+		end if block
+	end
+
+	def fragment?
+		@options[:fragment] != false || !`window.history.pushState`
+	end
+
+	def html5!
+		return unless fragment?
+
+		@options[:fragment] = false
+
+		@change.off
+		@change = $window.on 'pop:state' do
+			update
+		end
+	end
+
+	def fragment!
+		return if fragment?
+
+		@options[:fragment] = true
+
+		@change.off
+		@change = $window.on 'hash:change' do
+			update
+		end
+	end
+
+	def path
+		if fragment?
+			if @location.fragment.empty?
+				"/"
+			else
+				@location.fragment.sub(/^#*/, '')
+			end
+		else
+			@location.path
+		end
+	end
+
+	def route(path, &block)
+		Route.new(path, &block).tap {|route|
+			@routes << route
+		}
+	end
+
+	def update
+		match path
+	end
+
+	def navigate(path)
+		if path == self.path
+			return update
+		end
+
+		if fragment?
+			@location.fragment = "##{path}"
+		else
+			@history.push(path)
+			update
+		end
+	end
+
+private
+	def match(path)
+		@routes.find {|route|
+			route.match path
+		}
+	end
+
+	class Route
+		# Regexp for matching named params in path
+		NAME = /:(\w+)/
+
+		# Regexp for matching named splats in path
+		SPLAT = /\\\*(\w+)/
+
+		attr_reader :names
+
+		def initialize(pattern, &block)
+			@names = []
+			@block = block
+
+			pattern = Regexp.escape(pattern)
+
+			pattern.scan(NAME) {|name,|
+				@names << name
+			}
+
+			pattern.scan(SPLAT) {|name,|
+				@names << name
+			}
+
+			pattern = pattern.gsub(NAME, "([^\\/]+)").
+			                  gsub(SPLAT, "(.+?)")
+
+			@regexp = Regexp.new "^#{pattern}$"
+		end
+
+		def match(path)
+			if match = @regexp.match(path)
+				params = {}
+
+				@names.each_with_index {|name, index|
+					params[name] = match[index + 1]
+				}
+
+				@block.call params if @block
+
+				true
+			else
+				false
+			end
+		end
+	end
+end
+
+end

data/opal/lissio/version.rb

@@ -0,0 +1,3 @@
+module Lissio
+	VERSION = '0.1.0.beta1'
+end

data/spec/route_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Lissio::Router::Route do
+  describe "#initialize" do
+    let(:route) { Lissio::Router::Route }
+
+    it "creates a regexp from the given pattern" do
+      route.new('foo').instance_variable_get(:@regexp).should eq(/^foo$/)
+    end
+
+    it "escapes slashes in the pattern" do
+      route.new('/foo/bar/').instance_variable_get(:@regexp).should eq(/^\/foo\/bar\/$/)
+    end
+
+    it "finds named params in pattern" do
+      r = route.new('/foo/:bar')
+      r.names.should eq(['bar'])
+
+      p = route.new('/:woosh/:kapow')
+      p.names.should eq(['woosh', 'kapow'])
+    end
+
+    it "finds splatted params in pattern" do
+      route.new('/foo/*baz').names.should eq(['baz'])
+    end
+
+    it "produces a regexp to match given pattern" do
+      route.new('/foo').instance_variable_get(:@regexp).match('/bar').should be_nil
+      route.new('/foo').instance_variable_get(:@regexp).match('/foo').should be_kind_of(MatchData)
+    end
+  end
+
+  describe "#match" do
+    let(:route) { Lissio::Router::Route }
+
+    it "returns false for a non matching route" do
+      route.new('/foo').match('/a/b/c').should be_false
+    end
+
+    it "returns true for a matching route" do
+      route.new('/foo').match('/foo').should be_true
+    end
+
+    it "calls block given to #initialize on matching a route" do
+      called = false
+      route.new('/foo') { called = true }.match('/foo')
+      called.should be_true
+    end
+
+    it "calls handler with an empty hash for a simple route" do
+      route.new('/foo') { |params| params.should eq({}) }.match('/foo')
+    end
+
+    it "returns a hash of named params for matching route" do
+      route.new('/foo/:first') { |params|
+        params.should eq({'first' => '123' })
+      }.match('/foo/123')
+
+      route.new('/:first/:second') { |params|
+        params.should eq({ 'first' => 'woosh', 'second' => 'kapow' })
+      }.match('/woosh/kapow')
+     end
+  end
+end
+

data/spec/router_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Lissio::Router do
+  let(:router) { Lissio::Router.new }
+
+  def set_native_hash(hash)
+    `window.location.hash = #{hash}`
+  end
+
+  describe "#update" do
+    it "should update Router.path" do
+      set_native_hash '#/hello/world'
+      router.update
+
+      router.path.should eq('/hello/world')
+    end
+
+    it "calls #match with the new @path" do
+      set_native_hash '#/foo/bar'
+      called = nil
+
+      router.define_singleton_method(:match) { |m| called = m }
+      called.should be_nil
+
+      router.update
+      called.should eq("/foo/bar")
+    end
+  end
+
+  describe "#route" do
+    it "should add a route" do
+      router.route('/users') {}
+      router.routes.size.should eq(1)
+
+      router.route('/hosts') {}
+      router.routes.size.should eq(2)
+    end
+  end
+
+  describe "#match" do
+    it "returns nil when no routes on router" do
+      router.match('/foo').should be_nil
+    end
+
+    it "returns a matching route for the path" do
+      a = router.route('/foo') {}
+      b = router.route('/bar') {}
+
+      router.match('/foo').should eq(a)
+      router.match('/bar').should eq(b)
+    end
+
+    it "returns nil when there are no matching routes" do
+      router.route('/woosh') {}
+      router.route('/kapow') {}
+
+      router.match('/ping').should be_nil
+    end
+
+    it "calls handler of matching route" do
+      out = []
+      router.route('/foo') { out << :foo }
+      router.route('/bar') { out << :bar }
+
+      router.match('/foo')
+      out.should eq([:foo])
+
+      router.match('/bar')
+      out.should eq([:foo, :bar])
+
+      router.match('/eek')
+      out.should eq([:foo, :bar])
+    end
+
+    it "works with / too" do
+      out = []
+      router.route('/') { out << :index }
+
+      $global.location.hash = ""
+      router.update
+
+      $global.location.hash = "#/"
+      router.update
+
+      out.should == [:index, :index]
+    end
+  end
+
+  describe "#navigate" do
+    it "should update location.hash" do
+      router.navigate "foo"
+      $global.location.hash.should eq("#foo")
+    end
+
+    it "triggers the route matchers" do
+      called = false
+      router.route("/foo") { called = true }
+
+      router.navigate("/bar")
+      router.update
+      called.should be_false
+
+      router.navigate("/foo")
+      router.update
+      called.should be_true
+    end
+  end
+end
+