pione 0.1.2 → 0.1.3

data/lib/pione/model/message.rb

@@ -1,84 +1,91 @@
-module Pione::Model
-  # Message represents method callers for PIONE model objects.
-  # @example
-  #   1.as_string()
-  # @example
-  #   '*.txt'.except('a*')
-  class Message < BasicModel
-    attr_reader :name
-    attr_reader :receiver
-    attr_reader :arguments
-
-    # Creates a message.
-    # @param [String] name
-    #   message name
-    # @param [BasicModel] receiver
-    #   message receiver
-    # @param [BasicModel] arguments
-    #   message arguments
-    def initialize(name, receiver, *arguments)
-      @name = name
-      @receiver = receiver.to_pione
-      @arguments = arguments.map{|arg| arg.to_pione}
-      super()
-    end
+module Pione
+  module Model
+    # Message represents method callers for PIONE model objects.
+    #
+    # @example
+    #   1.as_string()
+    # @example
+    #   '*.txt'.except('a*')
+    class Message < BasicModel
+      attr_reader :name
+      attr_reader :receiver
+      attr_reader :arguments
 
-    # Returns false because Message is a complex form.
-    # @return [Boolean]
-    #   false
-    def atomic?
-      false
-    end
+      # Create a message.
+      #
+      # @param name [String]
+      #   message name
+      # @param receiver [BasicModel]
+      #   message receiver
+      # @param arguments [BasicModel]
+      #   message arguments
+      def initialize(name, receiver, *arguments)
+        @name = name
+        @receiver = receiver.to_pione
+        @arguments = arguments.map{|arg| arg.to_pione}
+        super()
+      end
 
-    # Return PIONE model type of the message result according to type interface.
-    #
-    # @return [Symbol]
-    #   PIONE model type
-    def pione_model_type
-      if interface = @receiver.pione_model_type.method_interface[@name.to_s]
-        interface.output
-      else
-        raise MethodNotFound.new(@name.to_s, self)
+      # Return false because Message is a complex form.
+      #
+      # @return [Boolean]
+      #   false
+      def atomic?
+        false
       end
-    end
 
-    # Evaluates the application expression and returns application result.
-    # @param [VariableTable] vtable variable table for the evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      receiver = @receiver.eval(vtable)
-      arguments = @arguments.map{|arg| arg.eval(vtable)}
-      receiver.call_pione_method(@name, *arguments)
-    end
+      # Return PIONE model type of the message result according to type interface.
+      #
+      # @return [Symbol]
+      #   PIONE model type
+      def pione_model_type
+        if interface = @receiver.pione_model_type.method_interface[@name.to_s]
+          interface.output
+        else
+          raise MethodNotFound.new(@name.to_s, self)
+        end
+      end
 
-    # Returns true if the receiver or arguments include variables.
-    # @return [Boolean]
-    #   true if the receiver or arguments include variables
-    def include_variable?
-      @receiver.include_variable? or @arguments.any?{|arg| arg.include_variable?}
-    end
+      # Evaluate the application expression and returns application result.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for the evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        receiver = @receiver.eval(vtable)
+        arguments = @arguments.map{|arg| arg.eval(vtable)}
+        receiver.call_pione_method(@name, *arguments)
+      end
 
-    # @api private
-    def textize
-      args = [@name, @receiver.textize, @arguments.textize]
-      "message(\"%s\",%s,[%s])" % args
-    end
+      # Return true if the receiver or arguments include variables.
+      #
+      # @return [Boolean]
+      #   true if the receiver or arguments include variables
+      def include_variable?
+        @receiver.include_variable? or @arguments.any?{|arg| arg.include_variable?}
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      return false unless @name == other.name
-      return false unless @receiver == other.receiver
-      return false unless @arguments == other.arguments
-      return true
-    end
+      # @api private
+      def textize
+        args = [@name, @receiver.textize, @arguments.textize]
+        "message(\"%s\",%s,[%s])" % args
+      end
 
-    alias :eql? :"=="
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        return false unless @name == other.name
+        return false unless @receiver == other.receiver
+        return false unless @arguments == other.arguments
+        return true
+      end
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @name.hash + @receiver.hash + @arguments.hash
+      # @api private
+      def hash
+        @name.hash + @receiver.hash + @arguments.hash
+      end
     end
   end
 end

data/lib/pione/model/package.rb

@@ -1,48 +1,52 @@
-module Pione::Model
-  # Package is a PIONE model class for rule package.
-  class Package < BasicModel
-    attr_reader :name
-    set_pione_model_type TypePackage
+module Pione
+  module Model
+    # Package is a PIONE model class for rule package.
+    class Package < BasicModel
+      attr_reader :name
+      set_pione_model_type TypePackage
 
-    # Creates a package with name.
-    # @param [String] name
-    #   package name
-    def initialize(name)
-      @name = name
-      super()
-    end
+      # Create a package with name.
+      #
+      # @param name [String]
+      #   package name
+      def initialize(name)
+        @name = name
+        super()
+      end
 
-    # @api private
-    def task_id_string
-      "Package<#{@name}>"
-    end
+      # @api private
+      def task_id_string
+        "Package<#{@name}>"
+      end
 
-    # @api private
-    def textize
-      "package(\"%s\")" % [@name]
-    end
+      # @api private
+      def textize
+        "package(\"%s\")" % [@name]
+      end
 
-    # Return a rule path.
-    # @param [RuleExpr] other
-    #   rule expression
-    # @return [String]
-    #   rule path string
-    def +(other)
-      raise ArgumentError.new(other) unless other.kind_of?(RuleExpr)
-      "#{@name}:#{other.name}"
-    end
+      # Return a rule path.
+      #
+      # @param other [RuleExpr]
+      #   rule expression
+      # @return [String]
+      #   rule path string
+      def +(other)
+        raise ArgumentError.new(other) unless other.kind_of?(RuleExpr)
+        "#{@name}:#{other.name}"
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @name == other.name
-    end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @name == other.name
+      end
 
-    alias :eql? :"=="
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @value.hash
+      # @api private
+      def hash
+        @value.hash
+      end
     end
   end
 end

data/lib/pione/model/parameters.rb

@@ -1,282 +1,311 @@
-module Pione::Model
-  # Parameters is a PIONE mode class for parameters.
-  class Parameters < BasicModel
-    # InvalidParameter is raised when you specify invalid parameter.
-    class InvalidParameter < TypeError
-      # Creates a error.
-      # @param [Object] key
-      #   specified key
-      def initialize(key)
-        @key = key
-      end
+module Pione
+  module Model
+    # Parameters is a PIONE mode class for parameters.
+    class Parameters < BasicModel
+      # InvalidParameter is raised when you specify invalid parameter.
+      class InvalidParameter < TypeError
+        # Create a error.
+        #
+        # @param [Object] key
+        #   specified key
+        def initialize(key)
+          @key = key
+        end
 
-      # @api private
-      def message
-        "invalid parameter key: %s" % [@key.inspect]
+        # @api private
+        def message
+          "invalid parameter key: %s" % [@key.inspect]
+        end
       end
-    end
 
-    # InvalidArgument is raised when you specify invalid argument.
-    class InvalidArgument < TypeError
-      # Creates a error.
-      # @param [Object] val
-      #   specified value
-      def initialize(val)
-        @val = val
-      end
+      # InvalidArgument is raised when you specify invalid argument.
+      class InvalidArgument < TypeError
+        # Create a error.
+        #
+        # @param [Object] val
+        #   specified value
+        def initialize(val)
+          @val = val
+        end
 
-      # @api private
-      def message
-        "invalid argument value: %s" % [@val.inspect]
+        # @api private
+        def message
+          "invalid argument value: %s" % [@val.inspect]
+        end
       end
-    end
 
-    class << self
-      # Creates a empty parameters object.
-      # @return [Parameters]
-      #   empty parameters
-      def empty
-        self.new({})
-      end
+      class << self
+        # Create a empty parameters object.
+        #
+        # @return [Parameters]
+        #   empty parameters
+        def empty
+          self.new({})
+        end
 
-      # Merges arguments' parameters.
-      # @param [Array<Parameters>] list
-      #   merge target elements
-      # @return [Parameters]
-      #   merged result
-      def merge(*list)
-        new_params = empty
-        list.each do |params|
-          new_params = new_params.merge(params)
+        # Merge arguments' parameters.
+        #
+        # @param list [Array<Parameters>]
+        #   merge target elements
+        # @return [Parameters]
+        #   merged result
+        def merge(*list)
+          new_params = empty
+          list.each do |params|
+            new_params = new_params.merge(params)
+          end
+          return new_params
         end
-        return new_params
       end
-    end
 
-    attr_reader :data
-    set_pione_model_type TypeParameters
-
-    # Creates a parameters object.
-    # @param [Hash{Variable => BasicModel}] data
-    #   parameters data table
-    def initialize(data)
-      raise TypeError.new(data) unless data.kind_of?(Hash)
-      data.each do |key, val|
-        raise InvalidParameter.new(key) unless key.kind_of?(Variable)
-        raise InvalidArgument.new(val) unless val.kind_of?(BasicModel)
+      attr_reader :data
+      set_pione_model_type TypeParameters
+
+      # Create a parameters object.
+      #
+      # @param [Hash{Variable => BasicModel}] data
+      #   parameters data table
+      def initialize(data)
+        raise TypeError.new(data) unless data.kind_of?(Hash)
+        data.each do |key, val|
+          raise InvalidParameter.new(key) unless key.kind_of?(Variable)
+          raise InvalidArgument.new(val) unless val.kind_of?(BasicModel)
+        end
+        @data = data
+        super()
       end
-      @data = data
-      super()
-    end
 
-    # Evaluates the object with variable table.
-    # @param [VariableTable] vtable
-    #   variable tabale for evaluation
-    # @return [BasicModel]
-    #   evaluated result
-    def eval(vtable)
-      return self.class.empty if empty?
-      data = @data.map{|key, val| [key, val.eval(vtable)]}.flatten(1)
-      self.class.new(Hash[*data])
-    end
+      # Evaluate the object with variable table.
+      #
+      # @param vtable [VariableTable]
+      #   variable tabale for evaluation
+      # @return [BasicModel]
+      #   evaluated result
+      def eval(vtable)
+        return self.class.empty if empty?
+        data = @data.map{|key, val| [key, val.eval(vtable)]}.flatten(1)
+        self.class.new(Hash[*data])
+      end
 
-    # Returns true if parameters include variables.
-    # @return [Boolean]
-    #   true if parameters include variables
-    def include_variable?
-      @data.any? {|_, val| val.include_variable?}
-    end
+      # Return true if parameters include variables.
+      #
+      # @return [Boolean]
+      #   true if parameters include variables
+      def include_variable?
+        @data.any? {|_, val| val.include_variable?}
+      end
 
-    # @api private
-    def textize
-      "{" + @data.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
-    end
+      # @api private
+      def textize
+        "{" + @data.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
+      end
 
-    # Returns value of parameter name.
-    # @param [String] name
-    #   parameter name to get the value
-    # @return [BasicModel]
-    #   the value
-    def [](name)
-      @data[Variable.new(name)]
-    end
+      # Return value of parameter name.
+      #
+      # @param name [String]
+      #   parameter name to get the value
+      # @return [BasicModel]
+      #   the value
+      def [](name)
+        @data[Variable.new(name)]
+      end
 
-    # Returns the value corresponding to the parameter name. Raises an error
-    # when the parameter name is kind of a variable.
-    # @param [Variable] name
-    #   variable to get the value
-    # @return [BasicModel]
-    #   the value
-    def get(name)
-      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
-      @data[name]
-    end
+      # Return the value corresponding to the parameter name. Raises an error
+      # when the parameter name is kind of a variable.
+      #
+      # @param name [Variable]
+      #   variable to get the value
+      # @return [BasicModel]
+      #   the value
+      def get(name)
+        raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+        @data[name]
+      end
 
-    # Adds the parameter value and return new parameters.
-    # @param [Variable] name
-    # @param [BasicModel] value
-    # @return [Parameters]
-    #   new parameters with the parameter
-    def set(name, value)
-      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
-      raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
-      self.class.new(@data.merge({name => value}))
-    end
+      # Add the parameter value and return new parameters.
+      #
+      # @param name [Variable]
+      #   variable
+      # @param value [BasicModel]
+      #   value
+      # @return [Parameters]
+      #   new parameters with the parameter
+      def set(name, value)
+        raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+        raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
+        self.class.new(@data.merge({name => value}))
+      end
 
-    # Adds the parameter value.
-    # @param [Variable] name
-    # @param [BasicModel] value
-    # @return [void]
-    def set!(name, value)
-      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
-      raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
-      @data.merge!({name => value})
-    end
+      # Add the parameter value.
+      #
+      # @param name [Variable]
+      #   variable
+      # @param value [BasicModel]
+      #   value
+      # @return [void]
+      def set!(name, value)
+        raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+        raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
+        @data.merge!({name => value})
+      end
 
-    # Adds the parameter value safety and return new parameters.
-    # @param [Variable] name
-    # @param [BasicModel] value
-    # @return [Parameters]
-    #   new parameters with the parameter
-    def set_safety(name, value)
-      if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
-        set(name, value)
+      # Add the parameter value safety and return new parameters.
+      #
+      # @param name [Variable]
+      #   variable
+      # @param value [BasicModel]
+      #   vlaue
+      # @return [Parameters]
+      #   new parameters with the parameter
+      def set_safety(name, value)
+        if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+          set(name, value)
+        end
       end
-    end
 
-    # Adds the parameter value safety.
-    # @param [Variable] name
-    # @param [BasicModel] value
-    # @return [void]
-    def set_safety!(name, value)
-      if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
-        set!(name, value)
+      # Add the parameter value safety.
+      #
+      # @param name [Variable]
+      #   variable
+      # @param value [BasicModel]
+      #   value
+      # @return [void]
+      def set_safety!(name, value)
+        if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+          set!(name, value)
+        end
       end
-    end
 
-    # Deletes the parameter by name.
-    # @param [Variable] name
-    #   target's name
-    # @return [Parameters]
-    #   new parameters that deleted the target
-    def delete(name)
-      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
-      new_data = @data.clone
-      new_data.delete(name)
-      self.class.new(new_data)
-    end
+      # Delete the parameter by name.
+      #
+      # @param name [Variable]
+      #   target's name
+      # @return [Parameters]
+      #   new parameters that deleted the target
+      def delete(name)
+        raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+        new_data = @data.clone
+        new_data.delete(name)
+        self.class.new(new_data)
+      end
 
-    # Returns true if the parameters is empty.
-    # @return [Boolean]
-    #   true if the parameters is empty
-    def empty?
-      @data.empty?
-    end
+      # Return true if the parameters is empty.
+      #
+      # @return [Boolean]
+      #   true if the parameters is empty
+      def empty?
+        @data.empty?
+      end
 
-    # Updates parameters with the argument and return new parameters with it.
-    # @param [BasicModel] other
-    #   merge target
-    # @return [Parameters]
-    #   new parameters that merged the target
-    def merge(other)
-      case other
-      when Parameters
-        self.class.new(@data.merge(other.data))
-      when Variable
-        self.class.new(@data.merge({other => UndefinedValue.new}))
-      when Assignment
-        self.class.new(@data.merge({other.variable => other.expr}))
-      else
-        raise TypeError.new(other)
+      # Update parameters with the argument and return new parameters with it.
+      #
+      # @param other [BasicModel]
+      #   merge target
+      # @return [Parameters]
+      #   new parameters that merged the target
+      def merge(other)
+        case other
+        when Parameters
+          self.class.new(@data.merge(other.data))
+        when Variable
+          self.class.new(@data.merge({other => UndefinedValue.new}))
+        when Assignment
+          self.class.new(@data.merge({other.variable => other.expr}))
+        else
+          raise TypeError.new(other)
+        end
       end
-    end
 
-    # Updates parameters with the argument destructively.
-    # @param [BasicModel] other
-    #   merge target
-    # @return [void]
-    def merge!(other)
-      case other
-      when Parameters
-        @data.merge!(other.data)
-      when Variable
-        @data.merge!({other => UndefinedValue.new})
-      when Assignment
-        @data.merge!({other.variable => other.expr})
-      else
-        raise TypeError.new(other)
+      # Update parameters with the argument destructively.
+      #
+      # @param [BasicModel] other
+      #   merge target
+      # @return [void]
+      def merge!(other)
+        case other
+        when Parameters
+          @data.merge!(other.data)
+        when Variable
+          @data.merge!({other => UndefinedValue.new})
+        when Assignment
+          @data.merge!({other.variable => other.expr})
+        else
+          raise TypeError.new(other)
+        end
       end
-    end
 
-    # Converts into variable table.
-    # @return [VariableTable]
-    #   variable table which values are same as the parameters.
-    def as_variable_table
-      VariableTable.new(@data)
-    end
+      # Convert into variable table.
+      #
+      # @return [VariableTable]
+      #   variable table which values are same as the parameters.
+      def as_variable_table
+        VariableTable.new(@data)
+      end
 
-    # Returns key list.
-    # @return [Array<Variable>]
-    #   parameter key list
-    def keys
-      @data.keys.sort
-    end
+      # Return key list.
+      #
+      # @return [Array<Variable>]
+      #   parameter key list
+      def keys
+        @data.keys.sort
+      end
 
-    # @api private
-    def string_form
-      "{" + @data.map{|k,v| "#{k}: #{v}"}.join(", ") + "}"
-    end
+      # @api private
+      def string_form
+        "{" + @data.map{|k,v| "#{k}: #{v}"}.join(", ") + "}"
+      end
 
-    # @api private
-    def to_json(*args)
-      @data.to_json(*args)
-    end
+      # @api private
+      def to_json(*args)
+        @data.to_json(*args)
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @data == other.data
-    end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @data == other.data
+      end
 
-    alias :eql? :"=="
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @data.hash
+      # @api private
+      def hash
+        @data.hash
+      end
     end
-  end
 
-  TypeParameters.instance_eval do
-    define_pione_method('==', [TypeParameters], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec.data == other.data)
-    end
+    TypeParameters.instance_eval do
+      define_pione_method('==', [TypeParameters], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec.data == other.data)
+      end
 
-    define_pione_method("!=", [TypeParameters], TypeBoolean) do |rec, other|
-      PioneBoolean.not(rec.call_pione_method("==", other))
-    end
+      define_pione_method("!=", [TypeParameters], TypeBoolean) do |rec, other|
+        PioneBoolean.not(rec.call_pione_method("==", other))
+      end
 
-    define_pione_method("[]", [TypeString], TypeAny) do |rec, name|
-      rec.get(Variable.new(name.value))
-    end
+      define_pione_method("[]", [TypeString], TypeAny) do |rec, name|
+        rec.get(Variable.new(name.value))
+      end
 
-    define_pione_method("get", [TypeString], TypeAny) do |rec, name|
-      rec.get(Variable.new(name.value))
-    end
+      define_pione_method("get", [TypeString], TypeAny) do |rec, name|
+        rec.get(Variable.new(name.value))
+      end
 
-    define_pione_method(
-      "set",
-      [TypeString, TypeAny],
-      TypeParameters
-    ) do |rec, name, val|
-      rec.set(Variable.new(name.value), val)
-    end
+      define_pione_method(
+        "set",
+        [TypeString, TypeAny],
+        TypeParameters
+      ) do |rec, name, val|
+        rec.set(Variable.new(name.value), val)
+      end
 
-    define_pione_method("empty?", [], TypeBoolean) do |rec|
-      PioneBoolean.new(rec.empty?)
-    end
+      define_pione_method("empty?", [], TypeBoolean) do |rec|
+        PioneBoolean.new(rec.empty?)
+      end
 
-    define_pione_method("as_string", [], TypeString) do |rec|
-      PioneString.new(rec.string_form)
+      define_pione_method("as_string", [], TypeString) do |rec|
+        PioneString.new(rec.string_form)
+      end
     end
   end
 end