opal-vienna 0.7.0

data/opal/vienna/observable_array.rb

@@ -0,0 +1,73 @@
+require 'vienna/observable'
+
+module Vienna
+  module ObservableArray
+    include Vienna::Observable
+
+    attr_reader :content
+
+    def initialize(content = [])
+      @content = content
+    end
+
+    def inspect
+      "#<ObservableArray: #{content.inspect}>"
+    end
+
+    alias to_s inspect
+
+    def array_content_did_change(idx, removed, added)
+      if observers = @array_observers
+        observers.each { |obj|
+          obj.array_did_change(self, idx, removed, added)
+        }
+      end
+
+      attribute_did_change :size
+      attribute_did_change :content
+      attribute_did_change :empty?
+    end
+
+    def add_array_observer(obj)
+      (@array_observers ||= []) << obj
+    end
+
+    def <<(obj)
+      length = @content.length
+      @content << obj
+
+      array_content_did_change length, 0, 1
+      self
+    end
+
+    def delete(obj)
+      if idx = @content.index(obj)
+        @content.delete_at idx
+        array_content_did_change idx, 1, 0
+      end
+
+      obj
+    end
+
+    def insert(idx, obj)
+      if idx > @content.length
+        raise ArgumentError, 'out of range'
+      end
+
+      @content.insert idx, obj
+      array_content_did_change idx, 0, 1
+
+      self
+    end
+
+    def clear
+      length = @content.length
+      @content.clear
+
+      array_content_did_change 0, length, 0
+      self
+    end
+
+    alias push <<
+  end
+end

data/opal/vienna/output_buffer.rb

@@ -0,0 +1,13 @@
+require 'template'
+
+module Vienna
+  class OutputBuffer < Template::OutputBuffer
+    def capture(*args, &block)
+      old = @buffer
+      tmp = @buffer = []
+      yield(*args) if block_given?
+      @buffer = old
+      tmp.join
+    end
+  end
+end

data/opal/vienna/record_array.rb

@@ -0,0 +1,31 @@
+require 'vienna/observable_array'
+
+module Vienna
+  class RecordArray
+    include ObservableArray
+
+    attr_writer :content
+
+    def ==(arr)
+      if arr.respond_to? :content
+        @content == arr.content
+      else
+        @content == arr
+      end
+    end
+
+    def method_missing(sym, *args, &block)
+      @content.__send__(sym, *args, &block)
+    end
+
+    def each(&block)
+      @content.each(&block)
+    end
+
+    def size
+      @content.size
+    end
+
+    alias length size
+  end
+end

data/opal/vienna/router.rb

@@ -0,0 +1,85 @@
+require 'native'
+
+module Vienna
+  class Router
+    attr_reader :path, :routes
+
+    def initialize(&block)
+      @routes = []
+      @location = $global.location
+
+      $global.addEventListener 'hashchange', -> { update }, false
+
+      instance_eval(&block) if block
+    end
+
+    def route(path, &handler)
+      route = Route.new(path, &handler)
+      @routes << route
+      route
+    end
+
+    def update
+      @path = if @location.hash.empty?
+        "/"
+      else
+        @location.hash.sub(/^#*/, '')
+      end
+
+      match @path
+    end
+
+    def match(path)
+      @routes.find { |r| r.match path }
+    end
+
+    # Navigate to the given hash location. This adds the '#' 
+    # fragment to the start of the path
+    def navigate(path)
+      @location.hash = "##{path}"
+    end
+
+    class Route
+      # Regexp for matching named params in path
+      NAMED = /:(\w+)/
+
+      # Regexp for matching named splats in path
+      SPLAT = /\\\*(\w+)/
+
+      OPTIONAL = /\\\((.*?)\\\)/
+
+      attr_reader :regexp, :named
+
+      def initialize(pattern, &handler)
+        @named, @handler = [], handler
+
+        pattern = Regexp.escape pattern
+        pattern = pattern.gsub OPTIONAL, "(?:$1)?"
+
+        pattern.gsub(NAMED) { |m| @named << m[1..-1] }
+        pattern.gsub(SPLAT) { |m| @named << m[2..-1] }
+
+        pattern = pattern.gsub NAMED, "([^\\/]*)"
+        pattern = pattern.gsub SPLAT, "(.*?)"
+
+        @regexp = Regexp.new "^#{pattern}$"
+      end
+
+      # Return a hash of all named parts to values if route matches path, or
+      # nil otherwise
+      def match(path)
+        if match = @regexp.match(path)
+          params = {}
+          @named.each_with_index { |name, i| params[name] = match[i + 1] }
+
+          @handler.call params if @handler
+
+          return true
+        end
+
+        false
+      end
+    end
+  end
+end
+

data/opal/vienna/template_view.rb

@@ -0,0 +1,41 @@
+require 'template'
+require 'vienna/view'
+require 'vienna/output_buffer'
+require 'active_support/core_ext/string'
+
+module Vienna
+  class TemplateView < View
+    def self.template(name = nil)
+      if name
+        @template = name
+      elsif @template
+        @template
+      elsif name = self.name
+        @template = name.sub(/View$/, '').demodulize.underscore
+      end
+    end
+
+    def render
+      before_render
+
+      if template = Template[self.class.template]
+        element.html = _render_template(template)
+      end
+
+      after_render
+    end
+
+    def partial(name)
+      Template[name].render(self)
+    end
+
+    def _render_template(template)
+      @output_buffer = OutputBuffer.new
+      instance_exec @output_buffer, &template.body
+    end
+
+    def before_render; end
+
+    def after_render; end
+  end
+end

data/opal/vienna/view.rb

@@ -0,0 +1,93 @@
+module Vienna
+  class View
+    def self.element(selector = nil)
+      selector ? @element = selector : @element
+    end
+
+    def self.tag_name(tag = nil)
+      define_method(:tag_name) { tag } if tag
+    end
+
+    def self.class_name(css_class = nil)
+      define_method(:class_name) { css_class } if css_class
+    end
+
+    def self.events
+      @events ||= []
+    end
+
+    def self.on(name, selector = nil, method = nil, &handler)
+      handler = proc { |evt| __send__(method, evt) } if method
+      events << [name, selector, handler]
+    end
+
+    attr_accessor :parent
+
+    def element
+      return @element if @element
+
+      @element = create_element
+      @element.add_class class_name
+      setup_events
+
+      @element
+    end
+
+    def create_element
+      scope = (self.parent ? parent.element : Element)
+
+      if el = self.class.element
+        scope.find el
+      else
+        e = scope.new tag_name
+        e.add_class class_name
+      end
+    end
+
+    def render
+    end
+
+    def class_name
+      ""
+    end
+
+    def tag_name
+      "div"
+    end
+
+    def find(selector)
+      element.find(selector)
+    end
+
+    def setup_events
+      return @dom_events if @dom_events
+
+      el = element
+      @dom_events = self.class.events.map do |event|
+        name, selector, handler = event
+        wrapper = proc { |e| instance_exec(e, &handler) }
+
+        el.on(name, selector, &wrapper)
+        [name, selector, wrapper]
+      end
+    end
+
+    def teardown_events
+      el = element
+      @dom_events.each do |event|
+        name, selector, wrapper = event
+        el.off(name, selector, &wrapper)
+      end
+    end
+
+    def remove
+      element.remove
+    end
+
+    def destroy
+      teardown_events
+      remove
+    end
+  end
+end
+

data/spec/eventable_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+class EventableSpec
+  include Vienna::Eventable
+
+  def events
+    @eventable
+  end
+end
+
+describe Vienna::Eventable do
+  subject { EventableSpec.new }
+
+  describe "#on" do
+    it "should register event handlers for given name" do
+      handler = Proc.new {}
+      subject.on(:foo, &handler)
+
+      expect(subject.events[:foo]).to eq([handler])
+    end
+
+    it "returns the given handler" do
+      handler = Proc.new {}
+      expect(subject.on(:foo, &handler)).to eq(handler)
+    end
+  end
+
+  describe "#off" do
+    it "has no affect if no handlers defined at all" do
+      subject.off(:bar, proc {})
+      subject.on(:foo) { raise "err" }
+      subject.off(:bar, proc {})
+    end
+
+    it "removes the handler for the event" do
+      called = false
+      handler = subject.on(:foo) { called = true }
+
+      subject.off(:foo, handler)
+      subject.trigger(:foo)
+      expect(called).to be_falsy
+    end
+  end
+
+  describe "#trigger" do
+    it "should call handler" do
+      called = false
+
+      subject.on(:foo) { called = true }
+      called.should == false
+
+      subject.trigger(:foo)
+      called.should == true
+    end
+
+    it "should pass all arguments to handler" do
+      args = nil
+      subject.on(:foo) { |*a| args = a }
+
+      subject.trigger(:foo)
+      args.should == []
+
+      subject.trigger(:foo, 1)
+      args.should == [1]
+
+      subject.trigger(:foo, 1, 2, 3)
+      args.should == [1, 2, 3]
+    end
+
+    it "should allow multiple different events to be registered" do
+      result = []
+      subject.on(:foo) { result << :foo }
+      subject.on(:bar) { result << :bar }
+
+      subject.trigger(:foo)
+      result.should == [:foo]
+
+      subject.trigger(:bar)
+      result.should == [:foo, :bar]
+    end
+
+    it "should allow multiple handlers for an event" do
+      count = 0
+
+      subject.on(:foo) { count += 1 }
+      subject.on(:foo) { count += 1 }
+      subject.on(:foo) { count += 1 }
+      subject.on(:foo) { count += 1 }
+      subject.trigger(:foo)
+
+      count.should == 4
+    end
+  end
+end

data/spec/history_router_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'vienna/history_router'
+
+describe Vienna::HistoryRouter do
+  describe '#update' do
+    it 'updates path' do
+      subject.navigate('/foo')
+      expect(subject.path).to eq('/foo')
+    end
+
+    it 'calls #match with the new path' do
+      expect(subject).to receive('match').with('/new_url')
+      subject.navigate('/new_url')
+    end
+  end
+
+  describe '#route' do
+    it 'should add a new route' do
+      subject.route('/users') {}
+      expect(subject.routes.size).to eq(1)
+
+      subject.route('/hosts') {}
+      expect(subject.routes.size).to eq(2)
+    end
+  end
+
+  describe '#match' do
+    it 'returns nil when no routes on router' do
+      expect(subject.match('/foo')).to be_nil
+    end
+
+    it 'returns the matching route for the path' do
+      a = subject.route('/foo') {}
+      b = subject.route('/bar') {}
+
+      expect(subject.match('/foo')).to eq(a)
+      expect(subject.match('/bar')).to eq(b)
+    end
+
+    it 'returns nil when no matching route' do
+      subject.route('/foo') {}
+      subject.route('/bar') {}
+
+      expect(subject.match('/baz')).to be_nil
+    end
+  end
+end