olelo 0.9.0

data/lib/olelo/attributes.rb

@@ -0,0 +1,285 @@
+module Olelo
+  # Include module to add attribute editor to a class.
+  module Attributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Attribute data structure
+    # @api private
+    class Attribute
+      include Util
+
+      # @api private
+      attr_reader :key, :name
+
+      def initialize(parent, name)
+        @name = name.to_s
+        @key = ['attribute', parent.path, name].compact.join('_')
+      end
+
+      def label
+        @label ||= Locale.translate(key, :fallback => titlecase(name))
+      end
+
+      def label_tag
+        type = self.class.name.split('::').last.downcase
+        title = Locale.translate("type_#{type}", :fallback => titlecase(type))
+        %{<label for="#{key}" title="#{escape_html title}">#{escape_html label}</label>}
+      end
+
+      def build_form(attr)
+        "#{label_tag}#{field_tag(attr)}<br/>"
+      end
+
+      class String < Attribute
+        def field_tag(attr)
+          %{<input class="observe" type="text" id="#{key}" name="#{key}" value="#{escape_html attr}"/>}
+        end
+
+        def parse(params)
+          value = params[key]
+          value if !value.blank?
+        end
+      end
+
+      class List < Attribute
+        def field_tag(attr)
+          %{<input class="observe" type="text" id="#{key}" name="#{key}" value="#{escape_html attr.to_a.join(', ')}"/>}
+        end
+
+        def parse(params)
+          value = params[key]
+          value.split(/\s*,\s*/) if !value.blank?
+        end
+      end
+
+      class Integer < Attribute
+        def field_tag(attr)
+          %{<input class="observe" type="text" id="#{key}" name="#{key}" value="#{escape_html attr}"/>}
+        end
+
+        def parse(params)
+          value = params[key]
+          value.to_i if !value.blank?
+        end
+      end
+
+      class Boolean < Attribute
+        def field_tag(attr)
+          %{<input class="observe" type="checkbox" id="#{key}" name="#{key}" value="true"#{attr ? ' checked="checked"' : ''}/>}
+        end
+
+        def build_form(attr)
+          "<div class=\"indent\">#{field_tag(attr)}#{label_tag}</div><br/>\n"
+        end
+
+        def parse(params)
+          value = params[key]
+          true if value == 'true'
+        end
+      end
+
+      class Enum < Attribute
+        def initialize(parent, name, values = {})
+          super(parent, name)
+          raise 'Values must be Proc, Hash or Array' unless Proc === values || Hash === values || Array === values
+          @values = values
+        end
+
+        def field_tag(attr)
+          html = %{<select class="observe" id="#{key}" name="#{key}">
+                   <option#{values.any? {|value,label| attr == value} ? '' : ' selected="selected"'}></option>}
+          values.sort_by(&:last).each do |value,label|
+            value_attr = value == label ? '' : %{ value="#{escape_html value}"}
+            selected_attr = attr == value ? ' selected="selected"' : ''
+            html << %{<option#{value_attr}#{selected_attr}>#{escape_html label}</option>}
+          end
+          html << '</select>'
+        end
+
+        def parse(params)
+          value = params[key]
+          value if values.include?(value)
+        end
+
+        private
+
+        def values
+          if Proc === @values
+            @values = @values.call
+            raise 'Values must be Hash or Array' unless Hash === @values || Array === @values
+          end
+          @values = Hash[*@values.zip(@values)] if Array === @values
+          @values
+        end
+      end
+
+      class Suggestions < Enum
+        def field_tag(attr)
+          %{<input class="observe" type="text" id="#{key}" name="#{key}" value="#{escape_html(values[attr] || attr)}"/>
+            <script type="text/javascript">
+            $('##{key}').combobox({ source: #{escape_javascript values.values.sort.to_json} });
+            </script>}
+        end
+
+        def parse(params)
+          value = params[key]
+          inverted_values[value] || value if !value.blank?
+        end
+
+        def inverted_values
+          @inverted_values ||= values.invert
+        end
+      end
+    end
+
+    # Data structure for group of attributes
+    # @api private
+    class AttributeGroup
+      include Util
+
+      # @api private
+      attr_reader :name, :path, :children
+
+      def initialize(parent = nil, name = nil)
+        @name = name.to_s
+        @path = parent ? [parent.path, name].compact.join('_') : nil
+        @children = {}
+      end
+
+      def label
+        @label ||= name.blank? ? '' : Locale.translate("group_#{path}", :fallback => titlecase(name))
+      end
+
+      # Build form for this group
+      # @return [String] html
+      # @api private
+      #
+      def build_form(attr)
+        html = label.blank? ? '' : "<h3>#{escape_html label}</h3>\n"
+        html << children.sort_by do |name, child|
+          [Attribute === child ? 0 : 1, child.label]
+        end.map do |name, child|
+          child.build_form(attr ? attr[name] : nil)
+        end.join
+      end
+
+      # Parse params and return attribute hash for this group
+      # @return [Hash]
+      # @api private
+      #
+      def parse(params)
+        attr = {}
+        children.each_pair do |name, child|
+          value = child.parse(params)
+          attr[name] = value if value
+        end
+        attr.empty? ? nil : attr
+      end
+    end
+
+    # DSL class used to initialize AttributeGroup
+    class AttributeDSL
+      include Util
+
+      # Initialize DSL with `group`
+      #
+      # @param [Olelo::Attributes::AttributeGroup] AttributeGroup to modify in this DSL block
+      # @yield DSL block
+      #
+      def initialize(group, &block)
+        @group = group
+        instance_eval(&block)
+      end
+
+      def string(name, values = nil, &block)
+        @group.children[name.to_s] = if values || block
+                                       Attribute::Suggestions.new(@group, name, block ? block : values)
+                                     else
+                                       Attribute::String.new(@group, name)
+                                     end
+      end
+
+      def integer(name)
+        @group.children[name.to_s] = Attribute::Integer.new(@group, name)
+      end
+
+      def boolean(name)
+        @group.children[name.to_s] = Attribute::Boolean.new(@group, name)
+      end
+
+      def list(name)
+        @group.children[name.to_s] = Attribute::List.new(@group, name)
+      end
+
+      def enum(name, values = nil, &block)
+        @group.children[name.to_s] = Attribute::Enum.new(@group, name, block ? block : values)
+      end
+
+      # Define attribute group
+      #
+      # @yield DSL block
+      # @return [void]
+      # @api public
+      #
+      def group(name, &block)
+        AttributeDSL.new(@group.children[name.to_s] ||= AttributeGroup.new(@group, name), &block)
+      end
+    end
+
+    # Extends class with attribute editor DSL
+    module ClassMethods
+      # Root attribute group
+      #
+      # @return [AttributeGroup] Root editor group
+      # @api private
+      #
+      def attribute_group
+        @attribute_group ||= AttributeGroup.new
+      end
+
+      # Add attribute to the attribute editor
+      #
+      # @yield DSL block
+      # @return [void]
+      # @api public
+      #
+      # @example add string attribute title
+      #   attributes do
+      #     string :title
+      #   end
+      #
+      # @example add group with multiple attributes
+      #   attributes do
+      #     group :acl do
+      #       list :read
+      #       list :write
+      #     end
+      #
+      def attributes(&block)
+        AttributeDSL.new(attribute_group, &block)
+      end
+    end
+
+    # Parse attributes from params hash
+    #
+    # @param [Hash] params submitted params hash
+    # @return [Hash] Attributes
+    # @api public
+    #
+    def update_attributes(params)
+      self.attributes = self.class.attribute_group.parse(params)
+    end
+
+    # Generate attribute editor form
+    #
+    # @param [Hash] default_values to use for the form
+    # @return [String] Generated html form
+    # @api public
+    #
+    def attribute_editor
+      self.class.attribute_group.build_form(attributes).html_safe
+    end
+  end
+end

data/lib/olelo/config.rb

@@ -0,0 +1,88 @@
+module Olelo
+  class Config
+    include Enumerable
+
+    attr_reader :base, :hash
+
+    def initialize(base = nil)
+      @hash = {}
+      @base = base.freeze
+   end
+
+    def [](key)
+      key = key.to_s
+      if i = key.index('.')
+        not_found(key) unless Config === hash[key[0...i]]
+        hash[key[0...i]][key[i+1..-1]]
+      else
+        not_found(key) if !hash.include?(key)
+        hash[key]
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      if i = key.index('.')
+        child(key[0...i])[key[i+1..-1]] = value
+      elsif Hash === value
+        child(key).update(value)
+      else
+        hash[key] = value.freeze
+      end
+    end
+
+    def update(hash)
+      hash.each_pair do |key, value|
+        self[key] = value
+      end
+    end
+
+    def load(file)
+      load!(file) if File.file?(file)
+    end
+
+    def load!(file)
+      update(YAML.load_file(file))
+    end
+
+    def each(&block)
+      hash.each(&block)
+    end
+
+    def self.instance
+      @instance ||= Config.new
+    end
+
+    def self.[](key)
+      instance[key]
+    end
+
+    def to_hash
+      h = Hash.with_indifferent_access
+      hash.each_pair do |k, v|
+        h[k] = Config === v ? v.to_hash : v
+      end
+      h
+    end
+
+    def freeze
+      hash.freeze
+      super
+    end
+
+    private
+
+    def not_found(key)
+      raise(NameError, "Configuration key #{base ? "#{base}.#{key}" : key} not found")
+    end
+
+    def child(key)
+      if child = hash[key]
+        raise "Configuration key #{key} is already used" unless Config === child
+        child
+      else
+        hash[key] = Config.new(base ? "#{base}.#{key}" : key)
+      end
+    end
+  end
+end

data/lib/olelo/extensions.rb

@@ -0,0 +1,252 @@
+class Module
+  # Generate accessor method with question mark
+  #
+  # @param [String, Symbol...] attrs Attributes to generate setter for
+  # @return [void]
+  #
+  def attr_reader?(*attrs)
+    attrs.each do |a|
+      module_eval "def #{a}?; !!@#{a}; end"
+    end
+  end
+
+  # Generate attribute setter
+  #
+  # A setter accepts an argument to
+  # set a value. It acts as a getter without an argument.
+  #
+  # @see Ruby facets
+  # @param [String, Symbol...] attrs Attributes to generate setter for
+  # @return [void]
+  #
+  def attr_setter(*attrs)
+    code, made = '', []
+    attrs.each do |a|
+      code << "def #{a}(*a); a.size > 0 ? (@#{a}=a[0]; self) : @#{a} end\n"
+      made << a.to_sym
+    end
+    module_eval(code)
+    made
+  end
+
+  # Redefine a module method
+  #
+  # Replaces alias_method_chain and allows to call
+  # overwritten method via super.
+  #
+  # @param [Symbol, String] name of method
+  # @yield New method block
+  # @return [void]
+  #
+  def redefine_method(name, &block)
+    if instance_methods(false).any? {|x| x.to_s == name.to_s }
+      method = instance_method(name)
+      mod = Module.new do
+        define_method(name) {|*args| method.bind(self).call(*args) }
+      end
+      remove_method(name)
+      include(mod)
+    end
+    include(Module.new { define_method(name, &block) })
+  end
+
+  if method(:const_defined?).arity == 1
+    # Ruby 1.8
+    def local_const_defined?(const)
+      const_defined?(const)
+    end
+  else
+    # Ruby 1.9
+    def local_const_defined?(const)
+      const_defined?(const, false)
+    end
+  end
+end
+
+class Hash
+  # Stolen from rails
+  class WithIndifferentAccess < Hash
+    def initialize(arg = {})
+      if Hash === arg
+        super()
+        update(arg)
+      else
+        super(arg)
+      end
+    end
+
+    alias_method :regular_include, :include?
+    alias_method :regular_writer, :[]=
+    alias_method :regular_update, :update
+
+    def default(key = nil)
+      if Symbol === key && regular_include(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def []=(key, value)
+      regular_writer(convert_key(key), value)
+      value
+    end
+
+    def update(other)
+      other.each_pair {|key, value| regular_writer(convert_key(key), value) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    def dup
+      WithIndifferentAccess.new(self)
+    end
+
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def to_hash
+      Hash.new(default).merge(self)
+    end
+
+    protected
+
+    def convert_key(key)
+      Symbol === key ? key.to_s : key
+    end
+  end
+
+  def with_indifferent_access
+    hash = WithIndifferentAccess.new(self)
+    hash.default = self.default
+    hash
+  end
+
+  def self.with_indifferent_access(arg = {})
+    WithIndifferentAccess.new(arg)
+  end
+end
+
+class Object
+  # Metaclass of object
+  #
+  # @return [Class]
+  #
+  def metaclass
+    (class << self; self; end)
+  end
+
+  # Returns true if object is empty or false
+  #
+  # @return [Boolean]
+  #
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # Try to call method if it exists or return nil
+  #
+  # @param [String, Symbol] name Method name
+  # @param args Method arguments
+  # @return Method result or nil
+  #
+  def try(name, *args)
+    respond_to?(name) ? send(name, *args) : nil
+  end
+end
+
+class NilClass;   def blank?; true;  end; end
+class FalseClass; def blank?; true;  end; end
+class TrueClass;  def blank?; false; end; end
+
+class String
+  # Faster blank?
+  alias blank? empty?
+
+  # Try to force encoding
+  #
+  # Force encoding of string and revert
+  # to original encoding if string has no valid encoding
+  #
+  # @param [Encoding, String] enc New encoding
+  # @return self
+  #
+  def try_encoding(enc)
+    old_enc = encoding
+    if old_enc != enc
+      force_encoding(enc)
+      force_encoding(old_enc) if !valid_encoding?
+    end
+    self
+  end
+
+  # Check if string starts with s
+  #
+  # @param [String] s
+  # @return [Boolean]
+  #
+  def starts_with?(s)
+    index(s) == 0
+  end
+
+  # Check if string ends with s
+  #
+  # @param [String] s
+  # @return [Boolean]
+  #
+  def ends_with?(s)
+    rindex(s) == size - s.size
+  end
+
+  # Clean up path (replaces '..', '.' etc.)
+  #
+  # @return [String] cleaned path
+  #
+  def cleanpath
+    names = []
+    split('/').each do |name|
+      case name
+      when '..'
+        names.pop
+      when '.'
+      when ''
+      else
+        names.push name
+      end
+    end
+    names.join('/')
+  end
+
+  # Concatenate path components with /
+  #
+  # Calls {#cleanpath} on result.
+  #
+  # @param [String] path component
+  # @return [String] this string concatenated with path
+  #
+  def /(path)
+    "#{self}/#{path}".cleanpath
+  end
+end