redson 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7bd4e9b64e97c83a614eeeecdd816bd8c66b4ad0
+  data.tar.gz: 31c813cb8cebf3d164c6f16ccabb2a25aa02fb21
+SHA512:
+  metadata.gz: 6ac622ead6741509e73b4215c4dac2792181d590d8441a01f873a7f4ddf4bba450c30d3a07a3716c69cdcd5b848c9bdfbfc39f3ac3d0b8c4470bd4fa853d0ac7
+  data.tar.gz: c506406de60f5252992d38d38887a29c4f22f6ae91bc7da2ecd0aa50ab673ed1c57a0848b6083bdb60197d8265083667fdc7b035322ddd09628633cf68901911

data/lib/redson.rb

@@ -0,0 +1,6 @@
+require "opal"
+require "opal-jquery"
+
+# Register our library code path with opal build tools
+# This allows opal-rails to pick us up
+Opal.append_path File.join(File.dirname(File.expand_path(__FILE__)), '..', 'opal')

data/lib/redson/version.rb

@@ -0,0 +1,3 @@
+module Redson
+  VERSION = "0.0.1"
+end

data/opal/redson.rb

@@ -0,0 +1,9 @@
+require "redson/ext/element"
+require "redson/version"
+require "redson/error"
+require "redson/binding"
+require "redson/observable"
+require "redson/model"
+require "redson/view"
+require "redson/widget"
+require "redson/form"

data/opal/redson/binding.rb

@@ -0,0 +1,34 @@
+module Redson
+  class Binding
+    def initialize(element_matcher, options)
+      @element_matcher = element_matcher
+      @options = options
+      @options[:notify_on] ||= 'keyup'
+      validate!
+    end
+    
+    def element_matcher
+      @element_matcher
+    end
+    
+    def notify_on
+      @options[:notify_on]
+    end
+    
+    def to
+      @options[:to]
+    end
+    
+    def notification_handler
+      @options[:notification_handler]
+    end
+    
+    def validate!
+      raise ":to missing when setting up binding for #{element_matcher}" unless to
+    end
+    
+    def create_for(widget)
+      widget.bind(element_matcher, to, notify_on, notification_handler)
+    end
+  end
+end

data/opal/redson/error.rb

@@ -0,0 +1,3 @@
+require "redson/error/no_such_event_error"
+require "redson/error/model_api_path_not_set_error"
+require "redson/error/not_a_dom_element_error"

data/opal/redson/error/model_api_path_not_set_error.rb

@@ -0,0 +1,9 @@
+module Redson
+  module Error
+    class ModelApiPathNotSetError < StandardError
+      def initialize(model)
+        super("api_path is not set for #{model.class.name}")
+      end
+    end
+  end
+end

data/opal/redson/error/no_such_event_error.rb

@@ -0,0 +1,9 @@
+module Redson
+  module Error
+    class NoSuchEventError < StandardError
+      def initialize(event_name)
+        super("No such event is emitted: #{event_name}")
+      end
+    end
+  end
+end

data/opal/redson/error/not_a_dom_element_error.rb

@@ -0,0 +1,9 @@
+module Redson
+  module Error
+    class NotADomElementError < StandardError
+      def initialize(thing)
+        super("Expected a jQuery DOM element, got #{thing} instead")
+      end
+    end
+  end
+end

data/opal/redson/ext/element.rb

@@ -0,0 +1,18 @@
+# reopening opal-jquery object
+class Element
+  def self.find!(selector)
+    elements = self.find(selector)
+    raise "No elements matching #{selector} found" if elements.empty?
+    elements
+  end
+  
+  def find!(selector)
+    elements = self.find(selector)
+    raise "No elements matching #{selector} found inside #{self.inspect}" if elements.empty?
+    elements
+  end
+  
+  def input?
+    attr('data-rs-type') == 'input'
+  end
+end

data/opal/redson/form.rb

@@ -0,0 +1,3 @@
+require "redson/form/model"
+require "redson/form/view"
+require "redson/form/widget"

data/opal/redson/form/model.rb

@@ -0,0 +1,6 @@
+module Redson
+  module Form
+    class Model < Redson::Model
+    end
+  end
+end

data/opal/redson/form/view.rb

@@ -0,0 +1,47 @@
+module Redson
+  module Form
+    class View < Redson::View
+      def initialize_view_elements
+        raise "#{this_element.inspect} is not a form element" unless this_element.is('form')
+        disable_submit_event_propagation!
+        write_current_view_state_to_model
+        trigger_save_on_submit
+      end
+      
+      def trigger_save_on_submit
+        %x{
+          self.$this_element().on('submit', function(event) {
+            self.$model().$save();
+          });
+        }
+      end
+      
+      def write_current_view_state_to_model
+        input_elements.each do |element|
+          model[element['name']] = element.value
+        end
+        model.api_path = self.action_attribute
+      end
+      
+      def disable_submit_event_propagation!
+        %x{
+          self.$this_element().on('submit', function(event) {
+            event.preventDefault();
+          });
+        }
+      end
+      
+      def action_attribute
+        this_element['action']
+      end
+  
+      def submit_element
+        this_element.find('input[type=submit]')
+      end
+  
+      def input_elements
+        this_element.find('input[type!=submit]')
+      end
+    end
+  end
+end

data/opal/redson/form/widget.rb

@@ -0,0 +1,6 @@
+module Redson
+  module Form
+    class Widget < Redson::Widget
+    end
+  end
+end

data/opal/redson/model.rb

@@ -0,0 +1,95 @@
+class Redson::Model
+  include Redson::Observable
+  
+  def self.validates_presence_of(key)
+  end
+    
+  def initialize
+    @_redson_api_path = nil
+    @_redson_state = {}
+    @_redson_nested_keys = {}
+    @_redson_observers = `jQuery({})`
+    @_redson_attributes_namespace = nil
+    reset_errors
+    initialize_observable
+  end
+  
+  def [](key)
+    @_redson_state[key]
+  end
+    
+  def []=(key, value)
+    if @_redson_nested_keys.include?(key) 
+      keys = @_redson_nested_keys[key]
+      @_redson_state[keys[0]] ||= {}
+      @_redson_state[keys[0]][keys[1]] = value
+    elsif `/\[/.test(#{key})`
+      keys = parse_keys(key)
+      @_redson_attributes_namespace = keys[0]
+      @_redson_nested_keys[key] = keys
+      @_redson_state[keys[0]] ||= {}
+      @_redson_state[keys[0]][keys[1]] = value
+    else
+      @_redson_state[key] = value
+    end
+  end
+  
+  def attributes_namespace
+    @_redson_attributes_namespace
+  end
+  
+  def reset_errors
+    @_redson_server_validation_errors = {}
+  end
+  
+  def errors
+    @_redson_server_validation_errors
+  end
+  
+  def valid?
+    errors.empty?
+  end
+  
+  def api_path
+    @_redson_api_path
+  end
+  
+  def api_path=(path) 
+    @_redson_api_path = path.end_with?(".json") ? path : "#{path}.json"
+  end
+  
+  def save
+    raise Redson::Error::ModelApiPathNotSetError.new(self) unless api_path
+    if self['_method'] == 'patch'
+      HTTP.put(api_path, :payload => @_redson_state) { |response| process_response(response) }
+    else
+      HTTP.post(api_path, :payload => @_redson_state) { |response| process_response(response) }
+    end
+  end
+  
+  def process_response(response)
+    if response.status_code == 201
+      reset_errors
+      puts :created
+      notify_observers(:created)
+    elsif response.status_code == 200
+      reset_errors
+      puts :updated
+      notify_observers(:updated)
+    elsif response.status_code == 422
+      @_redson_server_validation_errors = response.json
+      puts :unprocessable_entity
+      notify_observers(:unprocessable_entity)
+    else
+      puts "Unhandled Response Status #{response.status_code}, expected 200, 201 or 422"
+    end
+  end
+  
+  def parse_keys(nested_key)
+    nested_key.split(/\]\[|\[|\]/)
+  end
+  
+  def inspect
+    "#{super}\napi_path: #{api_path}\nattributes:\n#{@_redson_state.inspect}\nerrors:\n#{errors.inspect}"
+  end
+end

data/opal/redson/observable.rb

@@ -0,0 +1,38 @@
+module Redson
+  module Observable
+    def self.scoped_event_name(event_name)
+      "redson.#{event_name}"
+    end
+    
+    def initialize_observable
+      `this._redson_observers = jQuery({})`
+      @_redson_cached_observer_names = {}
+    end
+
+    def register_observer(observer, options = {})
+      event_name = options[:on]
+      handler_method_name = options[:notify]
+      handler_method_name = handler_method_name ? "#{handler_method_name}" : generate_default_handler_name_for(event_name)
+      handler_method_name = "$#{handler_method_name}"
+      scoped_event_name = Observable.scoped_event_name(event_name)
+      `this._redson_observers.on(scoped_event_name, jQuery.proxy(observer[handler_method_name], observer))`
+      self
+    end
+
+    def notify_observers(event_name)
+      scoped_event_name = Observable.scoped_event_name(event_name)
+      `this._redson_observers.trigger(scoped_event_name)`
+      self
+    end
+
+    def generate_default_handler_name_for(event_name)
+      if @_redson_cached_observer_names[event_name]
+        @_redson_cached_observer_names[event_name]
+      else
+        underscored_class_name = self.class.name.split("::").last.scan(/[A-Z][a-z]*/).join("_").downcase
+        default_handler_name = "#{underscored_class_name}_#{event_name}_handler"
+        @_redson_cached_observer_names[event_name] = default_handler_name
+      end
+    end
+  end
+end

data/opal/redson/version.rb

@@ -0,0 +1,3 @@
+module Redson
+  VERSION = "0.0.1"
+end

data/opal/redson/view.rb

@@ -0,0 +1,56 @@
+class Redson::View
+  attr_reader :target_element, :this_element, 
+              :template_element, :model, :form
+  
+  
+  def initialize(model, target_element, template_element = nil)
+    @target_element = target_element
+    @template_element = template_element
+    @this_element = template_element ? template_element.clone : target_element
+    @this_element = `jQuery(self.this_element)`
+    @model = model
+    initialize_view_elements
+    @model.register_observer(
+            self, :on => :created
+          ).register_observer(
+            self, :on => :updated
+          ).register_observer(
+            self, :on => :unprocessable_entity
+          )
+  end
+  
+  def model_created_handler(event)
+    Kernel.p :model_created_handler
+  end
+
+  def model_updated_handler(event)
+    Kernel.p :model_updated_handler
+  end
+
+  def model_unprocessable_entity_handler(event)
+    Kernel.p :model_unprocessable_entity_handler
+    model.errors.each do |key, values|
+      target_element.find("input[name=#{model.attributes_namespace}\\[#{key}\\]]").add_class("error")
+    end
+  end
+    
+  def initialize_view_elements
+    raise "initialize_view_elements must be overriden in #{self.class}"
+  end
+  
+  def find_element!(matcher)
+    this_element.find!(matcher)
+  end
+  
+  def render
+    target_element.append(this_element) unless target_element == this_element
+  end
+      
+  def bind(element_matcher, to, event_name_to_update_on, notification_handler)
+    element = this_element.find!(element_matcher)
+    element.on(event_name_to_update_on) do |event|
+      model[to] = element.value
+      self.method(notification_handler).call(event)
+    end
+  end
+end

data/opal/redson/widget.rb

@@ -0,0 +1,154 @@
+class Redson::Widget
+  TEMPLATES_ELEMENT_MATCHER = "#r-templates"
+  TEMPLATE_ELEMENT_MATCHER = ".r-template"
+  ELEMENT_MATCHER = ".r-element"
+  INPUT_TYPE_ATTRIBUTE_MATCHER = "[data-rs-type='input']"
+  
+  KEY_DEFAULTS = 'defaults'
+  KEY_BINDINGS = 'bindings'
+  KEY_WIDGET_NAME = 'widget_name'
+  KEY_TEMPLATE_ELEMENT_MATCHER = 'template_element_matcher'
+  KEY_TARGET_ELEMENT_MATCHER = 'target_element_matcher'
+  KEY_VIEW_KLASS_NAME = 'view_klass_name'
+  KEY_MODEL_KLASS_NAME = 'model_klass_name'
+  KEY_USE_TEMPLATE = 'use_template'
+  
+  attr_reader :view
+  
+  def self.inherited(base_klass)
+    base_klass.initialize_widget_klass
+  end
+  
+  def initialize(target_element = nil)
+    raise Redson::Error::NotADomElementError.new(target_element) unless target_element.class == Element
+    @model = model_klass.new
+    @view = view_klass.new(
+              @model,
+              target_element || Element.find!(target_element_matcher),
+              using_template? ? Element.find!(template_element_matcher) : nil
+              )
+    setup_bindings
+  end
+  
+  def setup_bindings
+    self.class.bindings.each do |binding|
+      binding.create_for(self)
+    end
+  end
+  
+  def bind(element_matcher, to, event_name_to_update_on, notification_handler)
+    view.bind(element_matcher, to, event_name_to_update_on, notification_handler)
+  end
+    
+  def render
+    view.render
+  end
+    
+  def widget_name
+    self.class.widget_name
+  end
+  
+  def target_element_matcher
+    self.class.target_element_matcher
+  end
+  
+  def template_element_matcher
+    self.class.template_element_matcher
+  end
+
+  def using_template?
+    self.class.using_template?
+  end
+  
+  def view_klass
+    self.class.view_klass
+  end
+
+  def model_klass
+    self.class.model_klass
+  end
+  
+  def self.instantiate_all_in_document
+    widgets = []
+    Element.find(target_element_matcher).each do |target|
+      widgets << self.new(target)
+    end
+    widgets
+  end
+  
+  def self.render_all_in_document
+    instantiate_all_in_document.each do |widget|
+      widget.render
+    end
+  end
+  
+  def self.initialize_widget_klass
+    @_redson_widget_config = {}
+    @_redson_widget_config[KEY_DEFAULTS] = {}
+    @_redson_widget_config[KEY_BINDINGS] = []
+    @_redson_widget_config[KEY_WIDGET_NAME] = self.name.split(/::/)[-2].downcase
+    @_redson_widget_config[KEY_DEFAULTS][KEY_USE_TEMPLATE] = true
+    @_redson_widget_config[KEY_DEFAULTS][KEY_TEMPLATE_ELEMENT_MATCHER] = "#{TEMPLATE_ELEMENT_MATCHER}.#{widget_name}"
+    @_redson_widget_config[KEY_DEFAULTS][KEY_VIEW_KLASS_NAME] = "#{self.name}".sub("::Widget", "::View")
+    @_redson_widget_config[KEY_DEFAULTS][KEY_MODEL_KLASS_NAME] = "#{self.name}".sub("::Widget", "::Model")
+  end
+  
+  def self.bind(element_matcher, options)
+    @_redson_widget_config[KEY_BINDINGS] << Binding.new(element_matcher, options)
+  end
+  
+  def self.widget_name
+    @_redson_widget_config[KEY_WIDGET_NAME]
+  end
+  
+  def self.bindings
+    @_redson_widget_config[KEY_BINDINGS]
+  end
+    
+  def self.target_element_matcher
+    @_redson_widget_config[KEY_DEFAULTS][KEY_TARGET_ELEMENT_MATCHER]
+  end
+  
+  # TODO
+  # We're using the 'set_' prefix to distinguish getters and setters
+  # Using the exact same name but different arity seems to confuse 
+  # the Opal compiler, as does differentiating using '='
+  def self.set_target_element_matcher(matcher)
+    @_redson_widget_config[KEY_DEFAULTS][KEY_TARGET_ELEMENT_MATCHER] = matcher
+  end
+
+  def self.template_element_matcher
+    @_redson_widget_config[KEY_DEFAULTS][KEY_TEMPLATE_ELEMENT_MATCHER]
+  end
+  
+  def self.set_template_element_matcher(matcher)
+    @_redson_widget_config[KEY_DEFAULTS][KEY_TEMPLATE_ELEMENT_MATCHER] = matcher
+  end
+
+  def self.disable_template!
+    @_redson_widget_config[KEY_DEFAULTS][KEY_USE_TEMPLATE] = false
+  end
+  
+  def self.using_template?
+    @_redson_widget_config[KEY_DEFAULTS][KEY_USE_TEMPLATE]
+  end
+        
+  def self.view_klass
+    # TODO
+    # Because Kernel.const_get("Foo::Bar::View") doesn't work on Opal
+    @view_klass ||= load_fully_qualified_constant(@_redson_widget_config[KEY_DEFAULTS][KEY_VIEW_KLASS_NAME])
+  end
+  
+  def self.model_klass
+    # TODO
+    # Because Kernel.const_get("Foo::Bar::View") doesn't work on Opal
+    @model_klass ||= load_fully_qualified_constant(@_redson_widget_config[KEY_DEFAULTS][KEY_MODEL_KLASS_NAME])
+  end
+  
+  private
+  def self.load_fully_qualified_constant(constant_string)
+    constant_string.split("::").inject(Kernel) do |const, name| 
+      const.const_get(name)
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: redson
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sidu Ponnappa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal-jquery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-livereload
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Redson is a browser based MVC component framework written in Ruby using
+  the Opal ruby-to-js compiler.
+email:
+- ckponnappa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redson.rb
+- lib/redson/version.rb
+- opal/redson.rb
+- opal/redson/binding.rb
+- opal/redson/error.rb
+- opal/redson/error/model_api_path_not_set_error.rb
+- opal/redson/error/no_such_event_error.rb
+- opal/redson/error/not_a_dom_element_error.rb
+- opal/redson/ext/element.rb
+- opal/redson/form.rb
+- opal/redson/form/model.rb
+- opal/redson/form/view.rb
+- opal/redson/form/widget.rb
+- opal/redson/model.rb
+- opal/redson/observable.rb
+- opal/redson/version.rb
+- opal/redson/view.rb
+- opal/redson/widget.rb
+homepage: http://github.com/kaiwren/redson
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Redson is a browser based MVC component framework written in Ruby using the
+  Opal ruby-to-js compiler.
+test_files: []