opal-vienna 0.7.0

data/opal/vienna/adapters/rest.rb

@@ -0,0 +1,97 @@
+module Vienna
+  class Model
+    def self.url(url = nil)
+      url ? @url = url : @url
+    end
+  end
+end
+
+module Vienna
+  # Adapter for a REST backend
+  class RESTAdapter < Adapter
+    def create_record(record, &block)
+      url = record_url(record)
+      options = { dataType: "json", payload: record.as_json }
+      HTTP.post(url, options) do |response|
+        if response.ok?
+          record.load Hash.new(response.body)
+          record.class.trigger :ajax_success, response
+          record.did_create
+          record.class.trigger :change, record.class.all
+        else
+          record.trigger_events :ajax_error, response
+        end
+      end
+
+      block.call(record) if block
+    end
+
+    def update_record(record, &block)
+      url = record_url(record)
+      options = { dataType: "json", payload: record.as_json }
+      HTTP.put(url, options) do |response|
+        if response.ok?
+          record.class.load_json response.body
+          record.class.trigger :ajax_success, response
+          record.did_update
+          record.class.trigger :change, record.class.all
+        else
+          record.trigger_events :ajax_error, response
+        end
+      end
+
+      block.call(record) if block
+    end
+
+    def delete_record(record, &block)
+      options = { dataType: "json" }
+      url = record_url(record)
+
+      HTTP.delete(url, options) do |response|
+        if response.ok?
+          record.did_destroy
+          record.class.trigger :ajax_success, response
+          record.class.trigger :change, record.class.all
+        else
+          record.class.trigger :ajax_error, response
+        end
+      end
+
+      block.call(record) if block
+    end
+
+    def find(record, id)
+      # TODO remote fetch
+      nil
+    end
+
+    def fetch(model, options = {}, &block)
+      id = options.fetch(:id, nil)
+      params = options.fetch(:params, nil)
+      url = id ? "#{record_url(model)}/#{id}" : record_url(model)
+      options = { dataType: "json", data: params }.merge(options)
+      HTTP.get(url, options) do |response|
+        if response.ok?
+          response.body.map { |json| model.load_json json }
+          model.trigger :ajax_success, response
+          model.trigger :refresh, model.all
+        else
+          model.trigger :ajax_error, response
+        end
+      end
+
+      block.call(model.all) if block
+    end
+
+    def record_url(record)
+      return record.to_url if record.respond_to? :to_url
+      return record.url if record.respond_to? :url
+
+      if klass_url = record.class.url
+        return "#{klass_url}/#{record.id}"
+      end
+
+      raise "Model does not define REST url: #{record}"
+    end
+  end
+end

data/opal/vienna/eventable.rb

@@ -0,0 +1,35 @@
+module Vienna
+  # A simple event registering/triggering module to mix into classes.
+  # Events are stored in the `@events` ivar.
+  module Eventable
+    # Register a handler for the given event name.
+    #
+    #   obj.on(:foo) { puts "foo was called" }
+    #
+    # @param [String, Symbol] name event name
+    # @return handler
+    def on(name, &handler)
+      @eventable ||= Hash.new { |hash, key| hash[key] = [] }
+      @eventable[name] << handler
+      handler
+    end
+
+    def off(name, handler)
+      if @eventable and evts = @eventable[name]
+        evts.delete handler
+      end
+    end
+
+    # Trigger the given event name and passes all args to each handler
+    # for this event.
+    #
+    #   obj.trigger(:foo)
+    #   obj.trigger(:foo, 1, 2, 3)
+    #
+    # @param [String, Symbol] name event name to trigger
+    def trigger(name, *args)
+      @eventable ||= Hash.new { |hash, key| hash[key] = [] }
+      @eventable[name].each { |handler| handler.call(*args) }
+    end
+  end
+end

data/opal/vienna/history_router.rb

@@ -0,0 +1,44 @@
+require 'opal-jquery'
+
+module Vienna
+  class HistoryRouter
+    attr_reader :path, :routes
+
+    def initialize(&block)
+      @routes = []
+      @location = $global.location
+
+      Window.on(:popstate) { update }
+
+      instance_eval(&block) if block
+    end
+
+    def route(path, &handler)
+      route = Router::Route.new(path, &handler)
+      @routes << route
+      route
+    end
+
+    def update
+      path = if @location.pathname.empty?
+                '/'
+              else
+                @location.pathname
+              end
+
+      unless @path == path
+        @path = path
+        match @path
+      end
+    end
+
+    def match(path)
+      @routes.find { |r| r.match path }
+    end
+
+    def navigate(path)
+      `history.pushState(null, null, path)`
+      update
+    end
+  end
+end

data/opal/vienna/model.rb

@@ -0,0 +1,222 @@
+require 'vienna/eventable'
+require 'vienna/record_array'
+
+module Vienna
+  class Model
+    include Eventable
+    extend Eventable
+
+    attr_accessor :id
+    attr_writer :loaded
+    attr_writer :new_record
+
+    class << self
+      attr_reader :identity_map
+      attr_reader :all
+    end
+
+    def self.reset!
+      @identity_map = {}
+      @all = RecordArray.new
+    end
+
+    def self.inherited(base)
+      base.reset!
+    end
+
+    def self.attributes(*attributes)
+      attributes.each { |name| attribute name }
+    end
+
+    def self.attribute(name)
+      columns << name
+      attr_accessor name
+    end
+
+    def self.columns
+      @columns ||= []
+    end
+
+    def self.primary_key(primary_key = nil)
+      primary_key ? @primary_key = primary_key : @primary_key ||= :id
+    end
+
+    def self.adapter(klass = nil)
+      return @adapter = klass.new if klass
+      @adapter || raise("No adapter for #{self}")
+    end
+
+    def self.find(id, &block)
+      if record = identity_map[id]
+        return record
+      end
+
+      record = self.new
+      self.adapter.find(record, id, &block)
+    end
+
+    def self.load(attributes)
+      unless id = attributes[primary_key]
+        raise ArgumentError, "no id (#{primary_key}) given"
+      end
+
+      map = identity_map
+      unless model = map[id]
+        model = self.new
+        model.id = id
+        map[id] = model
+        self.all << model
+      end
+
+      model.load(attributes)
+
+      model
+    end
+
+    def self.load_json(json)
+      load Hash.new json
+    end
+
+    def self.create(attrs = {})
+      model = self.new(attrs)
+      model.save
+      model
+    end
+
+    def self.fetch(options = {}, &block)
+      reset!
+      adapter.fetch(self, options, &block)
+    end
+
+    def self.from_form(form)
+      attrs = {}
+      `#{form}.serializeArray()`.each do |field|
+        key, val = `field.name`, `field.value`
+        attrs[key] = val
+      end
+      model = new attrs
+      if attrs.has_key?(self.primary_key) and ! attrs[self.primary_key].empty?
+        model.instance_variable_set('@new_record', false) 
+      end
+      model
+    end
+
+    def as_json
+      json = {}
+      json[:id] = self.id if self.id
+
+      self.class.columns.each { |name| json[name] = __send__(name) }
+      json
+    end
+
+    def to_json
+      as_json.to_json
+    end
+
+    def trigger_events(name)
+      self.class.trigger(name, self)
+      self.trigger(name)
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{self.class.columns.map { |name|
+        "#{name}=#{__send__(name).inspect}"
+      }.join(" ")}>"
+    end
+
+    def load(attributes = nil)
+      self.loaded = true
+      self.new_record = false
+
+      self.attributes = attributes if attributes
+
+      trigger_events :load
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    def save(&block)
+      @new_record ? create(&block) : update(&block)
+    end
+
+    def create(&block)
+      self.class.adapter.create_record(self, &block)
+    end
+
+    def update(attributes = nil, &block)
+      self.attributes = attributes if attributes
+      self.class.adapter.update_record(self, &block)
+    end
+
+    def destroy(&block)
+      self.class.adapter.delete_record(self, &block)
+    end
+
+    # Should be considered a private method. This is called by an adapter when
+    # this record gets deleted/destroyed. This method is then responsible from
+    # remoing this record instance from the class' identity_map, and triggering
+    # a `:destroy` event. If you override this method, you *must* call super,
+    # otherwise undefined bad things will happen.
+    def did_destroy
+      @destroyed = true
+      self.class.identity_map.delete self.id
+      self.class.all.delete self
+
+      trigger_events(:destroy)
+    end
+
+    # A private method. This is called by the adapter once this record has been
+    # created in the backend.
+    def did_create
+      @new_record = false
+      self.class.identity_map[self.id] = self
+      self.class.all.push self
+
+      trigger_events(:create)
+    end
+
+    # A private method. This is called by the adapter when this record has been
+    # updated in the adapter. It should not be called directly. It may be
+    # overriden, aslong as `super()` is called.
+    def did_update
+      trigger_events(:update)
+    end
+
+    def [](attribute)
+      instance_variable_get "@#{attribute}"
+    end
+
+    def []=(attribute, value)
+      instance_variable_set "@#{attribute}", value
+    end
+
+    def attributes=(attributes)
+      attributes.each do |name, value|
+        setter = "#{name}="
+        if respond_to? setter
+          __send__ setter, value
+        else
+          instance_variable_set "@#{name}", value
+        end
+      end
+    end
+
+    def initialize(attributes = nil)
+      @attributes = {}
+      @new_record = true
+      @loaded     = false
+
+      self.attributes = attributes if attributes
+    end
+  end
+end

data/opal/vienna/observable.rb

@@ -0,0 +1,90 @@
+module Vienna
+  module Observable
+
+    def add_observer(attribute, &handler)
+      unless observers = @attr_observers
+        observers = @attr_observers = {}
+      end
+
+      if attribute.include? '.'
+        return PathObserver.create(self, attribute, handler)
+      end
+
+      unless handlers = observers[attribute]
+        handlers = observers[attribute] = []
+        replace_writer_for(attribute)
+      end
+
+      handlers << handler
+    end
+
+    def remove_observer(attribute, handler)
+      return unless @attr_observers
+
+      if handlers = @attr_observers[attribute]
+        handlers.delete handler
+      end
+    end
+
+    # Triggers observers for the given attribute. You may call this directly if
+    # needed, but it is generally called automatically for you inside a
+    # replaced setter method.
+    def attribute_did_change(attribute)
+      return unless @attr_observers
+
+      if handlers = @attr_observers[attribute]
+        new_val = __send__(attribute) if respond_to?(attribute)
+        handlers.each { |h| h.call new_val }
+      end
+    end
+
+    # private?
+    def replace_writer_for(attribute)
+      if respond_to? "#{attribute}="
+        define_singleton_method("#{attribute}=") do |val|
+          result = super val
+          attribute_did_change(attribute)
+          result
+        end
+      end
+    end
+  end
+
+  class PathObserver
+    def self.create(object, path, handler)
+      parts = path.split '.'
+      base = PathObserver.new parts[0]
+      last = base
+
+      parts.drop(1).each do |attr|
+        last = last.next = PathObserver.new(attr)
+      end
+
+      base.object = object
+      last.handler = handler
+    end
+
+    attr_accessor :next, :handler
+
+    def initialize(attr)
+      @attr = attr
+    end
+
+    def object=(obj)
+      return if obj == @object
+
+      if @object = obj
+        obj.add_observer(@attr) { value_changed }
+      end
+
+      value_changed
+    end
+
+    def value_changed
+      value = @object.__send__ @attr
+
+      @next.object = value if @next
+      @handler.call value if @handler
+    end
+  end
+end