pione 0.2.2 → 0.3.0

data/lib/pione/model/block.rb

@@ -1,262 +0,0 @@
-module Pione
-  module Model
-    # ActionBlock represents content script of action.
-    #
-    # @example
-    #   Action
-    #     echo "abc"
-    #   End
-    #   #=> ActionBlock.new("  echo \"abc\"")
-    class ActionBlock < BasicModel
-      attr_reader :content
-
-      # Create an action block.
-      #
-      # @param content [String]
-      #   action content of shell script
-      def initialize(content)
-        @content = content
-        super()
-      end
-
-      # Evaluate the block. Variables of the content is expanded by the variable
-      # table.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        self.class.new(vtable.expand(@content))
-      end
-
-      # Return true if the content includes variables.
-      #
-      # @return [Boolean]
-      #   true if the content includes variables
-      def include_variable?
-        return VariableTable.check_include_variable(@content)
-      end
-
-      # @api private
-      def textize
-        "action_block(\"#{@content}\")"
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @content == other.content
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @content.hash
-      end
-    end
-
-    # FlowBlock represents flow element sequence.
-    #
-    # @example
-    #   Flow
-    #     rule Test1
-    #     rule Test2
-    #     rule Test3
-    #   End
-    #   #=> Block.new([ CallRule.new('Test1'),
-    #                   CallRule.new('Test2'),
-    #                   CallRule.new('Test3') ])
-    class FlowBlock < BasicModel
-      attr_reader :elements
-
-      # Create a flow block.
-      #
-      # @param elements [Array<BasicModel>]
-      #   flow elements
-      def initialize(*elements)
-        unless elements.all? {|elt| elt.kind_of?(BasicModel)}
-          raise ArgumentError.new(elements)
-        end
-        @elements = elements
-      end
-
-      # Evaluate each elements and return it.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        assignments = @elements.select{|elt| elt.kind_of?(Assignment)}
-        conditional_blocks = @elements.select{|elt| elt.kind_of?(ConditionalBlock)}
-        call_rules = @elements.select{|elt| elt.kind_of?(CallRule)}
-
-        if not(assignments.empty?)
-          assignments.each do |assignment|
-            assignment.eval(vtable)
-          end
-          FlowBlock.new(*(conditional_blocks+call_rules)).eval(vtable)
-        elsif not(conditional_blocks.empty?)
-          exception = nil
-          new_blocks = []
-          next_blocks = []
-          conditional_blocks.each do |block|
-            begin
-              new_blocks << block.eval(vtable)
-            rescue UnboundVariableError => e
-              exception = e
-              next_blocks << block
-            end
-          end
-          # fail to evaluate conditional blocks
-          if conditional_blocks == next_blocks
-            raise exception
-          end
-          # next
-          elements = new_blocks.inject([]){|elts, block| elts += block.elements}
-          FlowBlock.new(*(elements + next_blocks + call_rules)).eval(vtable)
-        else
-          FlowBlock.new(*call_rules.map{|call_rule| call_rule.eval(vtable)})
-        end
-      end
-
-      # Return true if the elements include variables.
-      #
-      # @return [Boolean]
-      #   true if the elements include variables
-      def include_variable?
-        @elements.any?{|elt| elt.include_variable?}
-      end
-
-      # @api private
-      def textize
-        "flow_block(%s)" % [@elements.map{|elt| elt.textize}.join(",")]
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @elements == other.elements
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @elements.hash
-      end
-    end
-
-    # ConditionalBlock represents conditional flow applications.
-    #
-    # @example
-    #   # if statement
-    #   if $X == "a"
-    #     rule Test1
-    #   else
-    #     rule Test2
-    #   end
-    #   #=> ConditionalBlock.new(
-    #         Message.new("==", Variable.new('X'), StringSequence.new([PioneString.new("a")])),
-    #         { true => [CallRule.new('Test1')],
-    #           :else => [CallRule.new('Test2')] })
-    # @example
-    #   # case statement
-    #   case $X
-    #   when "a"
-    #     rule Test1
-    #   when "b"
-    #     rule Test2
-    #   else
-    #     rule Test3
-    #   end
-    #   # => ConditionalBlock.new(
-    #          Variable.new('X'),
-    #          { 'a' => FlowBlock.new(CallRule.new('Test1')),
-    #            'b' => FlowBlock.new(CallRule.new('Test2')),
-    #            :else => FlowBlock.new(CallRule.new('Test3')) })
-    class ConditionalBlock < BasicModel
-      attr_reader :condition
-      attr_reader :blocks
-
-      # Create a conditional block.
-      #
-      # @param condition [BasicModel]
-      #   condition value
-      # @param blocks [Hash{BasicModel => FlowBlock}]
-      #   condition key and block
-      def initialize(condition, blocks={})
-        unless blocks.all?{|key,val|
-            (key.kind_of?(BasicModel) or key == :else) &&
-            val.kind_of?(FlowBlock)
-          }
-          raise ArgumentError.new(blocks)
-        end
-        @condition = condition
-        @blocks = blocks
-      end
-
-      # Evaluate the condition and returns the flow block.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        value = @condition.eval(vtable)
-        if block = @blocks.find {|key, _| key == value}
-          return block[1].eval(vtable)
-        elsif block = @blocks[:else]
-          return block.eval(vtable)
-        else
-          return FlowBlock.new
-        end
-      end
-
-      # Return ture if blocks include variables.
-      #
-      # @return [Boolean]
-      #   ture if blocks include variables
-      def include_variable?
-        @blocks.values.any?{|block| block.include_variable?}
-      end
-
-      # @api private
-      def textize
-        "conditional_block(%s,{%s})" % [
-          @condition.textize,
-          @blocks.map{|val, block| "%s=>%s" % [val,block]}.join(",")
-        ]
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @condition == other.condition && @blocks == other.blocks
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @condition.hash + @blocks.hash
-      end
-    end
-
-    # EmptyBlock is no elements block.
-    class EmptyBlock < BasicModel
-      include Singleton
-
-      def eval(vtable)
-        return self
-      end
-
-      def include_variable?
-        false
-      end
-
-      def textize
-        "empty_block()"
-      end
-    end
-  end
-end

data/lib/pione/model/boolean.rb

@@ -1,168 +0,0 @@
-module Pione
-  module Model
-    # PioneBoolean representes truth value in PIONE system.
-    class PioneBoolean < Value
-      # Returns the value in ruby.
-      attr_reader :value
-
-      class << self
-        # Return true value in PIONE system.
-        #
-        # @return [PioneBoolean]
-        #   true value
-        def true
-          new(true)
-        end
-
-        # Return false value in PIONE system.
-        #
-        # @return [PioneBoolean]
-        #   false value
-        def false
-          new(false)
-        end
-
-        # Return inverse value of it.
-        #
-        # @param boolean [Boolean]
-        #   target value
-        # @return [PioneBoolean]
-        #   true if the param is false, or false
-        def not(boolean)
-          new(not(boolean.value))
-        end
-
-        # Return true value if arguments include true value.
-        #
-        # @param args [Array<PioneBoolean>]
-        # @return [PioneBoolean]
-        #   true value if arguments include true value
-        def or(*args)
-          new(args.any?{|arg| arg.true?})
-        end
-
-        # Return true value if all arguments has true value.
-        #
-        # @param args [Array<PioneBoolean>]
-        # @return [PioneBoolean]
-        #   true value if all arguments has true value
-        def and(*args)
-          new(args.all?{|arg| arg.true?})
-        end
-      end
-
-      # Create a value.
-      #
-      # @param value [Boolean]
-      #   true or false
-      def initialize(value)
-        raise ArgumentError.new(value) unless value == true or value == false
-        @value = value
-      end
-
-      # @api private
-      def textize
-        @value.to_s
-      end
-
-      # Return true if the value is true.
-      #
-      # @return [Boolean]
-      #   true if the value is true
-      def true?
-        @value == true
-      end
-
-      # Return true if the value is false.
-      #
-      # @return [Boolean]
-      #   true if the value is false
-      def false?
-        @value == false
-      end
-
-      def to_seq
-        BooleanSequence.new([self])
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @value == other.value
-      end
-
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @value.hash
-      end
-
-      def inspect
-        "#<PioneBoolean %s>" % @value
-      end
-    end
-
-    class BooleanSequence < OrdinalSequence
-      set_pione_model_type TypeBoolean
-      set_element_class PioneBoolean
-      set_shortname "BSeq"
-
-      def value
-        @value ||= @elements.inject(true){|b, elt| b and elt.value}
-      end
-    end
-
-    #
-    # pione methods
-    #
-
-    TypeBoolean.instance_eval do
-      define_pione_method("and", [TypeBoolean], TypeBoolean) do |vtable, rec, other|
-        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
-          rec_elt.value && other_elt.value
-        end
-      end
-
-      define_pione_method("or", [TypeBoolean], TypeBoolean) do |vtable, rec, other|
-        sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
-          rec_elt.value || other_elt.value
-        end
-      end
-
-      define_pione_method("as_integer", [], TypeInteger) do |vtable, rec|
-        sequential_map1(TypeInteger, rec) {|rec| rec.value ? 1 : 0}
-      end
-
-      define_pione_method("as_float", [], TypeFloat) do |vtable, rec|
-        sequential_map1(TypeFloat, rec) {|rec| rec.value ? 1.0 : 0.0}
-      end
-
-      define_pione_method("as_string", [], TypeString) do |vtable, rec|
-        sequential_map1(TypeString, rec) {|rec| rec.value.to_s}
-      end
-
-      define_pione_method("as_data_expr", [], TypeDataExpr) do |vtable, rec|
-        sequential_map1(TypeDataExpr, rec) {|rec| rec.value.to_s}
-      end
-
-      define_pione_method("not", [], TypeBoolean) do |vtable, rec|
-        sequential_map1(TypeBoolean, rec) do |elt|
-          not(elt.value)
-        end
-      end
-
-      define_pione_method("every?", [], TypeBoolean) do |vtable, rec|
-        PioneBoolean.new(not(rec.elements.include?(PioneBoolean.false))).to_seq
-      end
-
-      define_pione_method("any?", [], TypeBoolean) do |vtable, rec|
-        PioneBoolean.new(rec.elements.include?(PioneBoolean.true)).to_seq
-      end
-
-      define_pione_method("one?", [], TypeBoolean) do |vtable, rec|
-        PioneBoolean.new(rec.elements.select{|elt| elt == PioneBoolean.true}.size == 1).to_seq
-      end
-    end
-  end
-end

data/lib/pione/model/call-rule.rb

@@ -1,86 +0,0 @@
-module Pione
-  module Model
-    # CallRule represents the application of a rule.
-    #
-    # @example
-    #   # simple rule calling:
-    #   rule r1
-    #   #=> CallRule.new(RuleExpr.new('r1'))
-    # @example
-    #   # with absolute path:
-    #   rule /abc:a
-    #   #=> CallRule.new(RuleExpr.new('/abc:a'))
-    # @example
-    #   # with variable:
-    #   rule $X
-    #   #=> CallRule.new(Variable.new('X'))
-    class CallRule < BasicModel
-      attr_reader :expr
-
-      # Create a callee rule.
-      #
-      # @param expr [BasicModel]
-      #   callee rule
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-
-      # Return a rule path string with expanding variables.
-      #
-      # @return [String]
-      #   rule path(package name and rule name)
-      def rule_path
-        if @expr.include_variable?
-          raise UnboundVariableError.new(@expr)
-        end
-        @expr.rule_path
-      end
-
-      # Return true if the expression has variables.
-      #
-      # @return [Boolean]
-      #   true if the expression has variables
-      def include_variable?
-        @expr.include_variable?
-      end
-
-      # Evaluate the expression.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        self.class.new(@expr.eval(vtable))
-      end
-
-      # Return a set of call-rules that the rule expression are expanded.
-      #
-      # @return [Set<CallRule>]
-      #   a set of call-rules
-      def to_set
-        @expr.to_set.map do |expr|
-          self.class.new(expr)
-        end
-      end
-
-      # @api private
-      def textize
-        "call_rule(%s)" % [@expr.textize]
-      end
-
-      # @api private
-      def ==(other)
-        @expr == other.expr
-      end
-
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @expr.hash
-      end
-    end
-  end
-end