jasonette-rails 0.1.2 → 0.2.0

data/lib/jasonette/core/body/footer.rb

@@ -0,0 +1,7 @@
+module Jasonette
+  class Body::Footer < Jasonette::Base
+    property :style
+    property :tabs
+    property :input
+  end
+end

data/lib/jasonette/core/body/footer/input.rb

@@ -0,0 +1,24 @@
+module Jasonette
+  class Body::Footer::Input < Jasonette::Base
+    property :style
+
+    def left uri=nil, &block
+      append Jasonette::Items.new(context).image(uri, true, "image", &block), "left"
+    end
+
+    def right caption=nil, &block
+      append Jasonette::Items.new(context).label(caption, true, &block), "right"
+    end
+
+    def textfield name=nil, value=nil, &block
+      append Jasonette::Items.new(context).textfield(name, value, true, &block), "textfield"
+    end
+
+    private
+    def append builder, msg
+      @attributes[msg] ||= {}
+      @attributes[msg].merge! builder.attributes!
+      builder
+    end
+  end
+end

data/lib/jasonette/core/body/footer/tabs.rb

@@ -0,0 +1,11 @@
+module Jasonette
+  class Body::Footer::Tabs < Jasonette::Base
+    property :style
+    property :items
+
+    def attributes!
+      super
+      @attributes.merge! items.attributes!
+    end
+  end
+end

data/lib/jasonette/core/body/header.rb

@@ -0,0 +1,21 @@
+module Jasonette
+  class Body::Header < Jasonette::Base
+    property :style
+
+    def menu caption=nil, image_uri=nil
+      item = Jasonette::Item.new(context) do
+        text caption unless caption.nil?
+        image image_uri unless image_uri.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item, "menu"
+    end
+
+    private
+    def append builder, msg
+      @attributes[msg] ||= {}
+      @attributes[msg].merge! builder.attributes!
+      builder
+    end
+  end
+end

data/lib/jasonette/core/body/header/search.rb

@@ -0,0 +1,6 @@
+module Jasonette
+  class Body::Header::Search < Jasonette::Base
+    property :style
+    property :action
+  end
+end

data/lib/jasonette/core/body/layers.rb

@@ -0,0 +1,4 @@
+module Jasonette
+  class Body::Layers < Jasonette::Items
+  end
+end

data/lib/jasonette/core/body/sections.rb

@@ -0,0 +1,5 @@
+module Jasonette
+  class Body::Sections < Jasonette::Base
+    property :items
+  end
+end

data/lib/jasonette/core/components.rb

@@ -1,13 +1,4 @@
 module Jasonette
   class Components < Jasonette::Items
-
-    private
-
-    def append builder
-      @attributes["components"] ||= []
-      @attributes["components"] << builder.attributes!
-      self
-    end
-
   end
 end

data/lib/jasonette/core/data.rb

@@ -0,0 +1,4 @@
+module Jasonette
+  class Data < Jasonette::Base
+  end
+end

data/lib/jasonette/core/item.rb

@@ -0,0 +1,21 @@
+module Jasonette
+  class Item < Jasonette::Base
+    property :action
+    property :style
+
+    def badge caption=nil
+      item = self.class.new(context) do
+        text caption unless caption.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item, "badge"
+    end
+
+    private
+    def append builder, msg
+      @attributes[msg] ||= {}
+      @attributes[msg].merge! builder.attributes!
+      builder
+    end
+  end
+end

data/lib/jasonette/core/items.rb

@@ -1,28 +1,112 @@
 module Jasonette
   class Items < Jasonette::Base
 
-    def label caption=nil
-      item = Jasonette::Base.new(@context) do
+    def label caption=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
         text caption unless caption.nil?
-        type "label"
-        with_attributes { instance_eval(&::Proc.new) } if block_given?
+        type "label" unless skip_type
+        encode(&::Proc.new) if block_given?
       end
       append item
     end
 
-    def image uri=nil
-      item = Jasonette::Base.new(@context) do
-        type "image"
-        url uri unless uri.nil?
-        with_attributes { instance_eval(&::Proc.new) } if block_given?
+    def text caption=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        text caption unless caption.nil?
+        type "text" unless skip_type
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def video uri=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "video" unless skip_type
+        file_url uri unless uri.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def image uri=nil, skip_type=false, url_key="url"
+      item = Jasonette::Item.new(context) do
+        type "image" unless skip_type
+        set! url_key, uri unless uri.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def button caption=nil, is_url=false, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "button" unless skip_type
+        unless caption.nil?
+          is_url ? (url caption) : (text caption)
+        end
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def slider name, value=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "slider" unless skip_type
+        name name
+        value value unless value.nil?
+        encode(&::Proc.new) if block_given?
       end
       append item
     end
 
     def layout orientation="vertical"
-      item = Jasonette::Layout.new(@context) do
+      item = Jasonette::Layout.new(context) do
         type orientation
-        with_attributes { instance_eval(&::Proc.new) } if block_given?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def textfield name=nil, value=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "textfield" unless skip_type
+        name name unless name.nil?
+        value value unless value.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def textarea name=nil, value=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "textarea" unless skip_type
+        name name unless name.nil?
+        value value unless value.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def space height=nil, skip_type=false
+      item = Jasonette::Item.new(context) do
+        type "space" unless skip_type
+        height height unless height.nil?
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def map skip_type=false
+      item = Jasonette::Map.new(context) do
+        type "map" unless skip_type
+        encode(&::Proc.new) if block_given?
+      end
+      append item
+    end
+
+    def merge! items
+      item = Jasonette::Item.new(context) do
+        merge! items
+        encode(&::Proc.new) if block_given?
       end
       append item
     end
@@ -30,9 +114,10 @@ module Jasonette
     private
 
     def append builder
-      @attributes["items"] ||= []
-      @attributes["items"] << builder.attributes!
-      self
+      @attributes = [] if @attributes.empty?
+      raise "HashError : You may have used `set!` before" if ::Hash === @attributes
+      @attributes << builder.attributes!
+      builder
     end
   
   end

data/lib/jasonette/core/layout.rb

@@ -1,9 +1,6 @@
 module Jasonette
-  class Layout < Jasonette::Base
+  class Layout < Jasonette::Item
+    super_property
     property :components
-
-    def attributes!
-      @attributes.merge components.attributes!
-    end
   end
 end

data/lib/jasonette/core/map.rb

@@ -0,0 +1,6 @@
+module Jasonette
+  class Map < Jasonette::Item
+    super_property
+    property :pins, :is_many
+  end
+end

data/lib/jasonette/core/options.rb

@@ -0,0 +1,9 @@
+module Jasonette
+  class Options < Jasonette::Base
+    property :data, :is_many, :is_single
+    property :action
+    property :form, :is_many
+    property :items
+    property :options
+  end
+end

data/lib/jasonette/{jason/body/header.rb → core/pins.rb}

@@ -1,5 +1,5 @@
 module Jasonette
-  class Jason::Body::Header < Jasonette::Base
+  class Pins < Jasonette::Base
     property :style
   end
 end

data/lib/jasonette/core/properties.rb

@@ -1,11 +1,41 @@
 module Jasonette::Properties
+  TYPES = [:is_many, :is_single]
+  DEFAULT_IS_ARRAY = [:items, :components, :layers]
+
+  class PropertyEnum
+    include Enumerable
+    attr_accessor :properties
+
+    def initialize properties = {}
+      @properties = properties
+    end
+
+    def merge! value
+      properties.merge! value if value.is_a? Hash
+      properties.merge! value.properties if value.is_a? self.class
+    end
+
+    def names; properties.keys end
+    def value; properties end
+
+    def has_type?(name, ptype)
+      value[name.to_sym][ptype.to_sym] rescue false
+    end
+  end
+
   module ClassMethods
-    def property name
-      properties << name
+
+    def super_property
+      properties.merge!(superclass.properties)
+    end
+
+    def property name, *types
+      types << :is_many if DEFAULT_IS_ARRAY.include?(name)
+      properties.merge! "#{name}".to_sym => TYPES.map { |type| { type => types.include?(type) } }.reduce({}, :merge)
     end
 
     def properties
-      @properties ||= []
+      PropertyEnum.new @properties ||= {}
     end
   end
 
@@ -13,8 +43,44 @@ module Jasonette::Properties
     base.send :extend, ClassMethods
   end
 
-  def properties
-    self.class.properties
+  def property_names
+    self.class.properties.names
+  end
+
+  def property_variables
+    property_names.map { |i| "@#{i}".to_sym }
+  end
+
+  TYPES.each do |type|
+    define_method("#{type}?") { |name| self.class.properties.has_type?(name, type) }
+    define_method("ivar_#{type}_for_property") { |name| "@#{type}_#{name}" }
+    define_method("get_#{type}_ivar") do |name|
+      instance_variable_get(send("ivar_#{type}_for_property", name)) || (is_many?(name) ? [] : nil)
+    end
+    define_method("set_#{type}_ivar") do |name, value|
+      instance_variable_set(send("ivar_#{type}_for_property", name), value)
+    end
+  end
+  define_method("property_type_methods") { TYPES.map { |type| "#{type}?" } }
+
+  def has_any_property_type? name
+    property_type_methods.map { |m| send(m, name) }.any?
+  end
+
+  def has_property? name
+    property_names.include?(name.to_sym)
+  end
+
+  def ivar_for_property name
+    "@#{name}"
+  end
+
+  def set_ivar name, value
+    instance_variable_set(ivar_for_property(name), value)
+  end
+
+  def get_ivar name
+    instance_variable_get(ivar_for_property(name))
   end
 
   def prop name
@@ -22,8 +88,8 @@ module Jasonette::Properties
   end
 
   def properties_empty?
-    properties.all? do |ivar_name|
-      ivar = instance_variable_get(:"@#{ivar_name}")
+    property_names.all? do |ivar_name|
+      ivar = get_ivar(ivar_name)
       ivar.nil? || ivar.empty?
     end
   end
@@ -35,37 +101,100 @@ module Jasonette::Properties
     klass
   end
 
-  def property_get! name
-    ivar_name = "@#{name}"
-    if instance_variable_get(ivar_name).nil?
-      klass = klass_for_property name
-      instance_variable_set(ivar_name, klass.new(@context))
+  def parent_jasonette_set klass
+    instance_variable_set("@_parent_jasonette", klass)
+
+    (klass.instance_variables - klass.property_variables).each do |var|
+      instance_variable_set(var, klass.instance_variable_get(var)) unless instance_variable_get(var)
+    end
+    klass
+  end
+
+  def parent_jasonette
+    instance_variable_get("@_parent_jasonette")
+  end
+
+  def create_new_klass name
+    klass = klass_for_property name
+    new_klass = klass.new(@context)
+    new_klass.parent_jasonette_set self
+    new_klass
+  end
+
+  def all_instance_variable_set name, *args
+    new_klass = create_new_klass name
+
+    set_ivar(name, new_klass) if (get_ivar(name).nil? || is_many?(name))
+    ivar = get_ivar(name)
+
+    if is_single?(name)
+      new_klass.set_is_single_ivar(name, args.first)
+    end
+
+    if is_many?(name)
+      ivar_all = get_is_many_ivar(name)
+      set_is_many_ivar(name, ivar_all << ivar)
     end
-    instance_variable_get(ivar_name)
+  end
+
+  def property_get! name, *args
+    all_instance_variable_set(name, *args)
+    get_ivar(name)
   end
 
   def property_set! name, *args, &block
-    ivar = property_get! name
+    ivar = property_get! name, *args
     return ivar unless block_given?
     ivar.tap { |v| v.encode(&block) }
   end
 
+  def get_default_for_property name
+    is_many_ivars = get_is_many_ivar(name)
+
+    single_default = is_single?(name) && is_many_ivars.to_a.length <= 1 ? {} : nil
+    many_default = is_many?(name) ? [] : nil
+    single_default || many_default || {}
+  end
+
   def merge_properties
-    properties.each do |property_name|
-      ivar = instance_variable_get(:"@#{property_name}")
+    property_names.each do |property_name|
+      property_name = property_name.to_s
+      ivar = get_ivar(property_name)
       next if ivar.nil? || ivar.empty?
-      @attributes[property_name.to_s] ||= {}
-      @attributes[property_name.to_s].merge! ivar.attributes!
+      @attributes[property_name] = get_default_for_property(property_name)
+
+      if !has_any_property_type?(property_name)
+        @attributes[property_name].merge! ivar.attributes!
+        next
+      end
+
+      if is_many?(property_name)
+        get_is_many_ivar(property_name).each do |iv|
+          ivar_attributes = iv.attributes!
+          if is_single?(property_name) && (single_ivar = iv.get_is_single_ivar(property_name))
+            @attributes[property_name] = @attributes[property_name].reduce({}, :merge) if ::Array === @attributes[property_name]
+            @attributes[property_name][single_ivar] ||= {}
+            @attributes[property_name][single_ivar].merge! ivar_attributes
+          else
+            if ::Hash === @attributes[property_name]
+              @attributes[property_name].merge! ivar_attributes
+            elsif DEFAULT_IS_ARRAY.map(&:to_s).include?(property_name) && ::Array === ivar_attributes
+              @attributes[property_name] += ivar_attributes
+            else
+              @attributes[property_name] << ivar_attributes
+            end
+          end
+        end
+      end
     end
   end
 
   def property_sender target, name, *args, &block
+    raise "unhandled definition! : use different property name then `#{name}`" if Object.new.methods.include?(name.to_sym)
     if block_given?
-      target.send name, *args, &block
+      target.set! name, _scope { block.call }
     elsif args.one? && args.first.is_a?(Hash)
-      target.send name do
-        args.first.each{ |key, value| json.set! key, value.to_s }
-      end
+      target.set! name, args.first
     else
       raise "unhandled definition!"
     end