instedd-pigeon 0.1.1

data/app/helpers/pigeon/renderer/base.rb

@@ -0,0 +1,172 @@
+module Pigeon
+  module Renderer
+    class Base
+      include Sprockets::Helpers::RailsHelper
+      include Sprockets::Helpers::IsolatedHelper
+      include ActionView::Helpers::OutputSafetyHelper
+      include ActionView::Helpers::TextHelper
+      include ActionView::Helpers::TagHelper
+      include ActionView::Helpers::AssetTagHelper
+
+      class << self
+        def handle(command, handler)
+          @handlers ||= {}
+          @handlers[command.to_s] = handler
+        end
+
+        def find_handler(command)
+          @handlers ||= {}
+          @handlers.fetch(command.to_s) do |command|
+            if superclass.respond_to?(:find_handler)
+              self.superclass.find_handler(command)
+            else
+              nil
+            end
+          end
+        end
+      end
+
+      attr_accessor :delegate
+
+      handle :raw, :render_raw
+      handle :template, :render_template_command
+      handle :wizard, :render_template_command
+      handle :page, :render_template_command
+
+      def render(v)
+        return '' if v.empty?
+
+        if v.first.starts_with? '@'
+          render_at_command(v)
+        else
+          render_vector(v)
+        end
+      end
+
+      def render_at_command(v)
+        command = v.first[1..-1]
+        handler = find_handler(command)
+        if !handler.nil?
+          dispatch_command_handler(handler, v)
+        elsif delegate.present? && delegate.respond_to?(:call)
+          delegate.call(v)
+        else
+          ''
+        end
+      end
+
+      def extract_options(data)
+        if data[1].is_a?(Hash)
+          [data[0], data[1], data.drop(2)]
+        else
+          [data[0], {}, data.drop(1)]
+        end
+      end
+
+      def render_vector(v)
+        selector, user_options, content = extract_options(v)
+        tag_name, options = parse_tag_name(selector)
+
+        options.update(user_options.with_indifferent_access) do |key, oldval, newval|
+          case key.to_s
+          when "id"
+            oldval
+          when "class"
+            oldval + " " + newval
+          else
+            newval
+          end
+        end
+
+        if tag_name.downcase == 'img'
+          if URI(path = options[:src]).relative?
+            options[:src] = image_path(path)
+          end
+        end
+
+        if content.empty?
+          if %w(br meta img link script hr).include? tag_name.downcase
+            tag tag_name, options
+          else
+            content_tag tag_name, '', options
+          end
+        else
+          content_html = safe_join(content.map do |elt|
+            case elt
+            when Array
+              render(elt)
+            else
+              elt
+            end
+          end)
+          content_tag tag_name, content_html, options
+        end
+      end
+
+      def render_raw(data)
+        data.drop(1).join.html_safe
+      end
+
+      def render_template_command(v)
+        command, options, content = extract_options(v)
+
+        options = options.inject({}) do |options, (key, value)|
+          if %w(class style).include?(key.to_s) || key.to_s.starts_with?('data-')
+            options[key] = value
+          else
+            options["data-#{key.to_s}"] = value
+          end
+          options
+        end
+        if %w(@template @wizard).include?(command)
+          options["data-application-name"] ||= Pigeon.config.application_name
+          options["data-twitter-path"] = Pigeon::Engine.routes.url_helpers.twitter_path
+        end
+
+        case command
+        when '@wizard'
+          render ["div.pigeon.pigeon_wizard", options] + content
+        when '@page'
+          render ["div.pigeon_wizard_page", options] + content
+        when '@template'
+          render ["div.pigeon.pigeon_template", options] + content
+        else
+          ''
+        end
+      end
+
+    private
+
+      def parse_tag_name(input)
+        tag_name = input.scan(/\A[^#.]*/).first
+        tag_name = 'div' if tag_name.blank?
+        options = {}.with_indifferent_access
+        classes = []
+        input.scan(/[#.][^#.]+/) do |tok|
+          case tok.first
+          when '#'
+            options[:id] = tok[1..-1]
+          when '.'
+            classes << tok[1..-1]
+          end
+        end
+        options[:class] = classes.join(' ') unless classes.empty?
+
+        [tag_name, options]
+      end
+
+      def find_handler(command)
+        self.class.find_handler(command)
+      end
+
+      def dispatch_command_handler(handler, data)
+        if handler.is_a?(Symbol)
+          self.send(handler, data)
+        elsif handler.is_a?(Proc)
+          handler.class(data)
+        end
+      end
+    end
+  end
+end
+

data/app/helpers/pigeon/renderer/channel_renderer.rb

@@ -0,0 +1,58 @@
+module Pigeon
+  module Renderer
+    class ChannelRenderer < Base
+      include Pigeon::ChannelHelper
+
+      attr_accessor :output_buffer
+      attr_accessor :channel, :scope
+
+      handle :field, :render_attribute_command
+      handle :label, :render_attribute_command
+      handle :attr, :render_attribute_command
+      handle :hidden, :render_attribute_command
+
+      def initialize(channel = nil, scope = nil)
+        self.channel = channel
+        self.scope = scope
+      end
+
+      def render_attribute_command(v)
+        command, options, content = extract_options(v)
+        name = content.first
+        options[:scope] = scope if scope.present?
+
+        case command
+        when '@field'
+          pigeon_channel_attribute_field(channel, name, options)
+        when '@label'
+          pigeon_channel_attribute_label(channel, name, options)
+        when '@attr'
+          if options.include?(:class)
+            options[:class] << ' pigeon_attribute'
+          else
+            options[:class] = 'pigeon_attribute'
+          end
+          pigeon_channel_attribute(channel, name, options)
+        when '@hidden'
+          options = options.update({ :type => :hidden })
+          pigeon_channel_attribute_field(channel, name, options)
+        else
+          ''
+        end
+      end
+
+      def render_template_command(v)
+        command, options, content = extract_options(v)
+        if %w(@wizard @template).include?(command)
+          options["data-scope"] ||= scope if scope.present?
+          options["data-persisted"] = channel.persisted?
+          options["data-kind"] = channel.kind
+          options["data-name"] = channel.name
+        end
+        super([command, options] + content)
+      end
+
+    end
+  end
+end
+

data/app/helpers/pigeon/renderer.rb

@@ -0,0 +1,8 @@
+module Pigeon
+  module Renderer
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+  end
+end
+

data/app/helpers/pigeon/tag_helper.rb

@@ -0,0 +1,26 @@
+module Pigeon
+  module TagHelper
+    def pigeon_verboice_channel_kinds_for_select
+      options_for_select(pigeon_schema_options(VerboiceChannel.schemas))
+    end
+
+    def pigeon_nuntium_channel_kinds_for_select
+      options_for_select(pigeon_schema_options(NuntiumChannel.schemas))
+    end
+
+    def pigeon_channel_kinds_for_select
+      grouped_options_for_select({
+        "Voice Channel" => 
+          pigeon_schema_options(VerboiceChannel.schemas, 'verboice/'),
+        "Message Channel" => 
+          pigeon_schema_options(NuntiumChannel.schemas, 'nuntium/')
+      })
+    end
+
+    def pigeon_schema_options(schemas, value_prefix = '')
+      schemas.map do |c|
+        [c.humanized_name, "#{value_prefix}#{c.kind}"]
+      end.sort_by(&:first)
+    end
+  end
+end

data/app/helpers/pigeon/template_helper.rb

@@ -0,0 +1,20 @@
+module Pigeon
+  module TemplateHelper
+    def pigeon_render_template(template, &block)
+      renderer = Renderer::Base.new
+      renderer.delegate = block if block_given?
+      renderer.render template
+    end
+
+    def pigeon_render_channel_template(channel, template = nil, scope = 'channel', &block)
+      renderer = Renderer::ChannelRenderer.new channel, scope
+      renderer.delegate = block if block_given?
+      template ||= channel.schema.template
+      renderer.render template
+    end
+
+    def pigeon_render_channel(channel, scope = 'channel')
+      pigeon_render_channel_template(channel, nil, scope)
+    end
+  end
+end

data/app/helpers/pigeon/text_helper.rb

@@ -0,0 +1,16 @@
+module Pigeon
+  module TextHelper
+
+    def channel_type_humanize(channel_type)
+      case channel_type
+      when :verboice
+        "Voice channel"
+      when :nuntium
+        "Message channel"
+      else
+        "Unknown channel"
+      end
+    end
+
+  end
+end

data/app/models/pigeon/channel.rb

@@ -0,0 +1,220 @@
+module Pigeon
+  class Channel
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include NestedScopes
+
+    class << self
+      def type() nil end
+
+      def schemas
+        []
+      end
+
+      def find_type(type)
+        begin 
+          "Pigeon::#{type.to_s.capitalize}Channel".constantize
+        rescue
+          nil
+        end
+      end
+
+      def find_schema(kind)
+        schemas.find { |s| s.kind == kind }
+      end
+
+      def channel_accessor(*names)
+        options = names.extract_options!
+
+        names.each do |name|
+          reader, line = "def #{name}; attributes['#{name}']; end", __LINE__
+          writer, line = "def #{name}=(value); attributes['#{name}'] = value; end", __LINE__
+
+          class_eval reader, __FILE__, line unless options[:instance_reader] == false
+          class_eval writer, __FILE__, line unless options[:instance_writer] == false
+        end
+      end
+
+      def list
+        raise NotImplementedError
+      end
+
+      def find(*arguments)
+        scope = arguments.slice!(0)
+        options = arguments.slice!(0) || {}
+
+        case scope
+        when :all
+          list.map { |id| find_single(id) }
+        when :first
+          find_single(list.first)
+        when :last
+          find_single(list.first)
+        else
+          find_single(scope)
+        end
+      end
+
+      def all()   find(:all)   end
+      def first() find(:first) end
+      def last()  find(:last)  end
+
+    private
+
+      def find_single(id)
+        raise NotImplementedError
+      end
+    end
+
+    attr_reader :attributes
+    attr_accessor :schema
+
+    channel_accessor :name, :kind
+
+    validates_presence_of :name, :kind
+
+    def type
+      self.class.type
+    end
+
+    def initialize(attrs = {}, persisted = false)
+      @errors = ChannelErrors.new(self)
+      @attributes = {}.with_indifferent_access
+      @persisted = persisted
+      @destroyed = false
+      
+      attrs = attrs.dup
+      @schema = attrs.delete(:schema) || self.class.find_schema(attrs[:kind])
+      attrs[:kind] ||= @schema.kind unless @schema.nil?
+
+      load_default_values
+      load_schema_defaults
+      
+      load(attrs)
+    end
+
+    def read_attribute_for_validation(key)
+      attributes[key]
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    alias :id :name
+    alias :id= :name=
+
+    def known_attributes
+      schema.try(:known_attributes) || []
+    end
+
+    def method_missing(method_symbol, *arguments)
+      method_name = method_symbol.to_s
+
+      if method_name =~ /(=|\?)$/
+        case $1
+        when "="
+          attributes[$`] = arguments.first
+        when "?"
+          attributes[$`]
+        end  
+      else 
+        return attributes[method_name] if attributes.include?(method_name)
+        # not set right now but we know about it
+        return nil if known_attributes.include?(method_name)
+        super
+      end  
+    end  
+
+    def generate_name
+      "#{kind || 'channel'}-#{Time.now.strftime('%Y%m%d%H%M%S%3N')}"
+    end
+
+    def generate_name!
+      self.name = generate_name
+    end
+
+    def [](key)
+      attributes[key]
+    end
+
+    def []=(key, value)
+      attributes[key] = value
+    end
+
+    def read_attribute(attr_name)
+      find_attr_recursive(attr_name, attributes)
+    end
+
+    def write_attribute(attr_name, value)
+      hash, key = find_attr_ref_recursive(attr_name, attributes)
+      hash && hash[key] = value
+    end
+
+    def assign_attributes(new_attributes)
+      return if new_attributes.blank?
+
+      new_attributes = new_attributes.stringify_keys
+      new_attributes.each do |key, value|
+        if value.is_a?(Hash)
+          write_attribute(key, read_attribute(key).merge(value))
+        else
+          write_attribute(key, value)
+        end
+      end
+    end
+
+    def attributes=(new_attributes)
+      return unless new_attributes.is_a?(Hash)
+      assign_attributes(new_attributes)
+    end
+
+    def human_attribute_name(attr_name, options = {})
+      (!schema.nil? && schema.find_attribute(attr_name).try(:humanized_name)) || 
+        self.class.human_attribute_name(attr_name, options)
+    end
+
+    def save
+      raise NotImplementedError
+    end
+
+    def save!
+      save || raise(ChannelInvalid.new(self))
+    end
+
+    def destroy
+      raise NotImplementedError
+    end
+
+  private
+
+    def load_default_values
+    end
+
+    def load_schema_defaults
+      load schema.default_values unless schema.nil?
+    end
+
+    def load(attributes)
+      (attributes || {}).each do |key, value|
+        @attributes[key.to_s] = case value
+                                  when Hash
+                                    (@attributes[key.to_s] || {}).merge(value)
+                                  else
+                                    value.duplicable? ? value.dup : value
+                                  end
+      end
+    end
+  end
+end
+

data/app/models/pigeon/channel_attribute.rb

@@ -0,0 +1,64 @@
+module Pigeon
+  class ChannelAttribute < NestedAttribute
+    attr_reader :type, :default_value, :humanized_name, :label, :tooltip, :user_editable, :options
+    attr_writer :scope
+
+    def initialize(name, type, options = {})
+      raise ArgumentError, "name cannot be blank (scope was '#{options[:scope]}')" unless name.present?
+      raise ArgumentError, "invalid type #{type}" unless self.class.valid_type?(type)
+
+      @name = name
+      @type = type.to_sym
+      options = options.with_indifferent_access
+
+      @scope = options.delete(:scope)
+
+      @default_value = options['default_value'] || options['value']
+      @humanized_name = options['humanized_name'] || options['display']
+      @label = options['label']
+      if @label.present?
+        @humanized_name ||= @label
+      elsif @humanized_name.present?
+        @label ||= @humanized_name
+      else
+        @label = name.to_s.humanize
+        @humanized_name = @label
+      end
+      @tooltip = options['tooltip']
+      @user_editable = options['user'].nil? ? true : options['user']
+      @options = options['options'] || []
+    end
+
+    def self.valid_type?(type)
+      %w(string boolean password enum integer timezone hidden).include?(type.to_s)
+    end
+
+    def self.build_default(name, hint_value = nil)
+      type = case hint_value
+             when Fixnum
+               :integer
+             when FalseClass, TrueClass
+               :boolean
+             else
+               :string
+             end
+      name, scope = build_scope_recursive(name)
+      new name, type, value: hint_value, scope: scope
+    end
+
+  private
+
+    extend NestedScopes
+
+    def self.build_scope_recursive(name, scope = nil)
+      fold_scoped_name(name, [nil, scope]) do |(current, scope), name|
+        if current.nil?
+          [name, scope]
+        else
+          [name, NestedAttribute.new(current, scope)]
+        end
+      end
+    end
+
+  end
+end

data/app/models/pigeon/channel_schema.rb

@@ -0,0 +1,113 @@
+module Pigeon
+  class ChannelSchema
+    include NestedScopes
+
+    class << self
+      def from_hash(type, hash)
+        self.new type, hash["kind"], hash["humanized_name"], hash["attributes"], hash["template"]
+      end
+
+      def list_from_hash(type, hash)
+        hash.map do |name, data|
+          data["kind"] ||= name
+          from_hash type, data
+        end
+      end
+    end
+
+    attr_reader :type, :kind, :humanized_name, :attribute_data, :template_data
+
+    def initialize(type, kind, humanized_name = nil, attributes = [], template = nil)
+      raise ArgumentError, "type cannot be blank" if type.blank?
+      raise ArgumentError, "kind cannot be blank" if kind.blank?
+
+      @type = type
+      @kind = kind
+      @humanized_name = humanized_name || kind
+      @attribute_data = attributes
+      @template_data = template
+    end
+
+    def attributes
+      @attributes ||= process_attributes(@attribute_data)
+    end
+
+    def known_attributes
+      attributes.keys
+    end
+
+    def user_attributes
+      flattened_map_filter(attributes) do |attr|
+        attr.user_editable ? attr.scoped_name : nil
+      end
+    end
+
+    def default_values
+      recursive_map_filter(attributes, &:default_value)
+    end
+
+    def template
+      @template ||= @template_data ? process_template(@template_data) : default_template
+    end
+
+    def type_kind
+      "#{type}/#{kind}"
+    end
+
+    def default_template
+      ["@template"] + user_attributes.map do |attr_name|
+        ["@attr", attr_name]
+      end
+    end
+
+    def find_attribute(name)
+      find_attr_recursive(name, attributes)
+    end
+
+  private
+
+    # recursive map-filter of the channel schema attributes
+    def flattened_map_filter(attributes, &block)
+      attributes.inject([]) do |result, (name, attr)|
+        if attr.is_a? Hash
+          value = flattened_map_filter(attr, &block)
+          result + value
+        else
+          value = yield(attr)
+          result + [value].reject(&:nil?)
+        end
+      end
+    end
+
+    def recursive_map_filter(attributes, &block)
+      attributes.inject({}) do |result, (name, attr)|
+        if attr.is_a? Hash
+          value = recursive_map_filter(attr, &block)
+        else
+          value = yield(attr)
+        end
+        result[name] = value if value.present?
+        result
+      end
+    end
+
+    def process_attributes(attributes, scope = nil)
+      Hash[attributes.map do |attr|
+        name = attr["name"]
+        if attr["attributes"].present?
+          # recursively process nested attributes
+          attribute = process_attributes(attr["attributes"], NestedAttribute.new(name, scope))
+        else
+          type = attr["type"] || "string"
+          attribute = Pigeon::ChannelAttribute.new(name, type, attr)
+          attribute.scope = scope
+        end
+        [name, attribute]
+      end].with_indifferent_access
+    end
+
+    def process_template(template)
+      template
+    end
+  end
+end