base.rb in nyaplot-0.2.0.rc1

- old
+ new
@@ -1,71 +1,105 @@
 require 'json'
 
 module Nyaplot
+  module Base
+    attr_accessor :dependency, :uuid
 
-  # The module to be included by internal classes
-  module Jsonizable
-
     def self.included(cls)
-      cls.extend ClassMethod
+      cls.extend ClassMethods
     end
 
-    def before_to_json
+    # @example
+    #   Glyph::Scatter.new(data: data, x: :x, y: :y)
+    #   #-> #<Nyaplot::Glyph::Scatter|0aff1e>
+    #
+    def initialize(*args)
+      @uuid = SecureRandom.uuid
+      @dependency= []
+      @args = {}
+
+      class << @args
+        def to_json(*args)
+          args_ = self.reduce({}) do |memo, val|
+            memo[val[0]]= val[1].is_a?(Nyaplot::Base) ? {sync: val[1].uuid} : val[1]
+            memo
+          end
+          args_.to_json
+        end
+      end
+
+      self.attr(args.first) if args.length == 1 && args.first.is_a?(Hash)
     end
 
-    # This method should be excuted when initializing class includes Jsonizable
-    def init_properties
-      @properties = {}
+    def attr(hash)
+      hash.each do |val|
+        self.send(val[0], val[1])
+      end
     end
 
-    def to_json(*args)
-      before_to_json
-      @properties.to_json
+    def add_dependency(*given)
+      given.each do |obj|
+        raise RuntimeError unless obj.is_a?(Nyaplot::Base)
+        @dependency.push(obj)
+      end
     end
 
-    # Prepared to expressly set property
-    def set_property(symbol, val)
-      self.send(symbol, val)
+    def remove_dependency(obj)
+      @dependency.delete(obj)
     end
 
-    # Prepared to expressly get property
-    def get_property(symbol)
-      self.send(symbol)
+    def verify
+      raise "Type name should be specified" if self.class.class_variable_get("@@type".to_sym).nil?
+      args = self.class.class_variable_get("@@required_args".to_sym)
+      args.each do |s|
+        raise s.to_s + " of " + self.to_s + " should be set" unless @args.has_key?(s)
+      end
     end
 
-    module ClassMethod
+    # over-write it
+    def before_to_json
+    end
 
-      # Define getter/setter for each property
-      # @param [Symbol] symbols Name for each property
-      def define_properties(*symbols)
-        symbols.each do |symbol|
-          define_method(symbol) {|val=nil|
-            return @properties[symbol] if val.nil?
-            @properties[symbol] = val
-            return self
-          }
+    def to_json(*args)
+      before_to_json
+      verify
+      {
+        type: self.class.class_variable_get("@@type".to_sym),
+        uuid: @uuid,
+        args: @args
+      }.to_json
+    end
+
+    module ClassMethods
+      def type(symbol)
+        self.class_variable_set("@@type".to_sym, symbol)
+      end
+
+      private
+      def define_accessor(s)
+        define_method(s) do |val=nil|
+          next @args[s] if val.nil?
+          if val.is_a? Nyaplot::Base
+            remove_dependency(@args[s]) unless @args[s].nil?
+            add_dependency(val)
+          end
+          @args[s] = val
+          self
         end
       end
 
-      # Define getter/setter for each property and group.
-      # Grouped properties will be merged into one parameter when running to_json.
-      # @param [Symbol] name Group name
-      # @param [Symbol] symbols Name for each property
-      # @example
-      #   define_group_properties(:options, [:hoge, :nya]) #The methods :options, :hoge, :nya are defined
-      #   options({})
-      #   hoge(3)
-      #   nya(4)
-      #   some_instance.to_json #-> {options:{hoge: 3, nya:4}}
-      def define_group_properties(name, symbols)
-        define_properties(name)
-        symbols.each do |symbol|
-          define_method(symbol) {|val=nil|
-            return @properties[name][symbol] if val.nil?
-            @properties[name][symbol] = val
-            return self
-          }
+      def required_args(*symbols)
+        name = "@@required_args".to_sym
+        arr = (self.class_variable_defined?(name) ? self.class_variable_get(name) : [])
+        self.class_variable_set(name, arr.concat(symbols))
+
+        symbols.each do |s|
+          define_accessor s
         end
+      end
+
+      def optional_args(*symbols)
+        symbols.each {|s| define_accessor s}
       end
     end
   end
 end