pione 0.2.2 → 0.3.0

data/lib/pione/transformer.rb

@@ -1,24 +0,0 @@
-require 'pione/transformer/transformer-module'
-require 'pione/transformer/literal-transformer'
-require 'pione/transformer/feature-expr-transformer'
-require 'pione/transformer/expr-transformer'
-require 'pione/transformer/flow-element-transformer'
-require 'pione/transformer/block-transformer'
-require 'pione/transformer/rule-definition-transformer'
-require 'pione/transformer/document-transformer'
-
-module Pione
-  # Transformer is a name space for PIONE document transformers and provides
-  # utilities.
-  module Transformer
-    # Transform by applying DocumentTransformer.
-    #
-    # @param syntax_tree [Hash]
-    #   target syntax tree
-    # @return [Object]
-    #   transformed object
-    def self.document(syntax_tree)
-      DocumentTransformer.new.apply(syntax_tree)
-    end
-  end
-end

data/lib/pione/transformer/block-transformer.rb

@@ -1,28 +0,0 @@
-module Pione
-  module Transformer
-    # BlockTransformer is a transformer for syntax tree of blocks.
-    module BlockTransformer
-      include TransformerModule
-
-      # Transform +:flow_block+ as Model::FlowBlock.
-      rule(:flow_block => sequence(:elements)) {
-        FlowBlock.new(*elements)
-      }
-
-      # Transform +:action_block+ as Model::ActionBlock.
-      rule(:action_block =>
-        { :key => simple(:keyword_Action),
-          :content => simple(:content) }
-      ) {
-        val = content.str
-        ActionBlock.new(val).tap do |x|
-          x.set_line_and_column(keyword_Action.line_and_column)
-        end
-      }
-
-      rule(:empty_block => simple(:any)) {
-        EmptyBlock.instance
-      }
-    end
-  end
-end

data/lib/pione/transformer/document-transformer.rb

@@ -1,58 +0,0 @@
-module Pione
-  module Transformer
-    # DocumentTransformer is a transformer for syntax tree of document.
-    class DocumentTransformer < Parslet::Transform
-      include LiteralTransformer
-      include FeatureExprTransformer
-      include ExprTransformer
-      include FlowElementTransformer
-      include BlockTransformer
-      include RuleDefinitionTransformer
-
-      # @param package_name [String]
-      #   package name of the document
-      def initialize(package_name="Main")
-        super()
-        @current_package_name = package_name
-        Thread.current[:current_package_name] = @current_package_name
-      end
-
-      def check_model_type(data, type)
-        data.pione_model_type == type
-      end
-
-      rule(:toplevel_assignment_line => simple(:assignment)) {
-        Naming.AssignmentLine(assignment.set_toplevel(true))
-      }
-
-      rule(:toplevel_param_line => simple(:naming_param_line)) {
-        assignment = naming_param_line.value
-        assignment.set_toplevel(true)
-        assignment.set_user_param(true)
-        Naming.ParamLine(assignment)
-      }
-
-      # Transform +:param_block+ as Naming::ParamBlock.
-      rule(:param_block => subtree(:tree)) {
-        param_type = tree[:param_type]
-        assignments = tree[:in_block_assignments]
-        _assignments = assignments.map do |assignment|
-          assignment.set_toplevel(true)
-          assignment.set_user_param(true)
-          case param_type
-          when "Advanced"
-            assignment.set_param_type(:advanced)
-          else
-            assignment.set_param_type(:basic)
-          end
-        end
-        Naming.ParamBlock(_assignments)
-      }
-
-      # Transform +:package+ as Naming::Package.
-      rule(:package => subtree(:tree)) {
-        @current_package = Naming.Package(tree[:package_name].to_s)
-      }
-    end
-  end
-end

data/lib/pione/transformer/feature-expr-transformer.rb

@@ -1,60 +0,0 @@
-module Pione
-  module Transformer
-    # FeatureExprTransformer is a transformer for syntax tree of feature
-    # expressions.
-    module FeatureExprTransformer
-      include TransformerModule
-
-      # Transform +:feature_name+ as feature expression model corresponding to
-      # the operator.
-      rule(:atomic_feature =>
-           { :operator => simple(:operator),
-             :symbol => simple(:symbol) }
-           ) do
-        case operator
-        when "+"
-          Feature::RequisiteExpr.new(symbol.str)
-        when "-"
-          Feature::BlockingExpr.new(symbol.str)
-        when "?"
-          Feature::PreferredExpr.new(symbol.str)
-        when "^"
-          Feature::PossibleExpr.new(symbol.str)
-        when "!"
-          Feature::RestrictiveExpr.new(symbol.str)
-        end
-      end
-
-      # Transform +:atomic_feature+ as empty feature or boundless feature.
-      rule(:atomic_feature => {:symbol => simple(:symbol)}) {
-        case symbol
-        when "*"
-          Feature.empty
-        when "@"
-          Feature.boundless
-        end
-      }
-
-      # Extract the content of +:feature_expr+.
-      rule(:feature_expr => simple(:expr)) do
-        expr
-      end
-
-      # Transform +:feature conjunction+ as Feature::AndExpr.
-      rule(:feature_conjunction => {
-             :left => simple(:left),
-             :right => simple(:right)
-           }) do
-        Feature::AndExpr.new(left, right)
-      end
-
-      # Transform +:feature_disjunction+ as Feature::OrExpr.
-      rule(:feature_disjunction => {
-             :left => simple(:left),
-             :right => simple(:right)
-           }) do
-        Feature::OrExpr.new(left, right)
-      end
-    end
-  end
-end

data/lib/pione/transformer/flow-element-transformer.rb

@@ -1,66 +0,0 @@
-module Pione
-  module Transformer
-    # FlowElementTransformer is a transformer for syntax tree of flow elements.
-    module FlowElementTransformer
-      include TransformerModule
-
-      # Extract the content of +:flow_elements+.
-      rule(:flow_elements => sequence(:elements)) {
-        elements
-      }
-
-      # Transform +:call_rule: as Model::CallRule.
-      rule(:call_rule => subtree(:rule_expr)) {
-        CallRule.new(rule_expr)
-      }
-
-      # Trasnform +:if_block+ as Model::ConditionalBlock.
-      rule(:if_block =>
-           { :condition => simple(:condition),
-             :if_true_elements => sequence(:if_true),
-             :if_else_block => simple(:if_false)
-           }) {
-        block = {
-          Model::BooleanSequence.new([Model::PioneBoolean.true]) =>
-          Model::FlowBlock.new(*if_true)
-        }
-        block[:else] = if_false if if_false
-        Model::ConditionalBlock.new(condition, block)
-      }
-
-      # Transform +:else_block+ as Model::FlowBlock.
-      rule(:else_block => {:elements => sequence(:elements)}) {
-        Model::FlowBlock.new(*elements)
-      }
-
-      # Transform +:case_block+ as Model::ConditionalBlock.
-      rule(:case_block =>
-        { :condition => simple(:condition),
-          :when_blocks => sequence(:when_blocks),
-          :case_else_block => simple(:else_block) }) {
-        block = {}
-        when_blocks.each do |when_block|
-          block[when_block.value] = when_block.body
-        end
-        block[:else] = else_block if else_block
-        Model::ConditionalBlock.new(condition, block)
-      }
-
-      # Transform +:when_block+ as Model::WhenBlock.
-      rule(:when_block =>
-        { :value => simple(:value),
-          :elements => sequence(:elements) }
-      ) {
-        OpenStruct.new(value: value, body: Model::FlowBlock.new(*elements))
-      }
-
-    # Transform +:assignment+ as Model::Assignment.
-      rule(:assignment =>
-        { :symbol => simple(:symbol),
-          :value => simple(:value) }
-      ) {
-        Model::Assignment.new(symbol, value)
-      }
-    end
-  end
-end

data/lib/pione/transformer/literal-transformer.rb

@@ -1,91 +0,0 @@
-module Pione
-  module Transformer
-    # LiteralTransformer is a transformer for syntax tree of literals.
-    module LiteralTransformer
-      include TransformerModule
-
-      # Tranform +:boolean+ as Model::PioneBoolean.
-      rule(:boolean => simple(:s)) do
-        val = (s == "true")
-        Model::PioneBoolean.new(val).tap do |x|
-          x.set_line_and_column(s.line_and_column)
-          break Model::BooleanSequence.new([x])
-        end
-      end
-
-      # Transform +:string+ as Model::PioneString.
-      rule(:string => simple(:s)) do
-        # convert backslash notations
-        val = s.str.gsub(/\\(.)/){$1}
-        Model::PioneString.new(val).tap do |x|
-          x.set_line_and_column(s.line_and_column)
-          break Model::StringSequence.new([x])
-        end
-      end
-
-      # NOTE: how do we get the position of empty string?
-      rule(:string => sequence(:empty)) do
-        # convert backslash notations
-        Model::StringSequence.new([Model::PioneString.new("")])
-      end
-
-      # Transform +:integer+ as Model::PioneInteger.
-      rule(:integer => simple(:i)) do
-        Model::PioneInteger.new(i.to_i).tap do |x|
-          x.set_line_and_column(i.line_and_column)
-          break Model::IntegerSequence.new([x])
-        end
-      end
-
-      # Transform +:float+ as Model::PioneFloat.
-      rule(:float => simple(:f)) do
-        Model::PioneFloat.new(f.to_f).tap do |x|
-          x.set_line_and_column(f.line_and_column)
-          break Model::FloatSequence.new([x])
-        end
-      end
-
-      # Transform +:variable+ as Model::Variable.
-      rule(:variable => simple(:var)) do
-        Model::Variable.new(var.str).tap do |x|
-          x.set_line_and_column(var.line_and_column)
-        end
-      end
-
-      # Transform +:data_name+ as Model::DataExpr.
-      rule(:data_name => simple(:name)) do
-        # convert backslash notations
-        val = name.str.gsub(/\\(.)/){$1}
-        Model::DataExpr.new(val).tap do |x|
-          x.set_line_and_column(name.line_and_column)
-          break Model::DataExprSequence.new([x])
-        end
-      end
-
-      # Transform +:package_name+ as Model::PackageExpr.
-      rule(:package_name => simple(:name)) do
-        val = name.str
-        Model::PackageExpr.new(val).tap do |x|
-          x.set_line_and_column(name.line_and_column)
-        end
-      end
-
-      # Transform +:rule_name+ as Model::RuleExpr.
-      rule(:rule_name => simple(:name)) do
-        package = PackageExpr.new(Thread.current[:current_package_name])
-        val = name.str
-        RuleExpr.new(package, val).tap do |x|
-          x.set_line_and_column(name.line_and_column)
-        end
-      end
-
-      # ticket
-      rule(:ticket => simple(:name)) do
-        line_and_column = name.line_and_column
-        TicketExpr.new(name.to_s) do
-          set_line_and_column(line_and_column)
-        end.to_seq
-      end
-    end
-  end
-end

data/lib/pione/transformer/rule-definition-transformer.rb

@@ -1,80 +0,0 @@
-module Pione
-  module Transformer
-    # RuleDefinitionTransformer is a transformer for syntax tree of rule definitions.
-    module RuleDefinitionTransformer
-      include TransformerModule
-
-      # @api private
-      def check_model_type(obj, pione_model_type)
-        pione_model_type.match(obj.pione_mode_type)
-      end
-      module_function :check_model_type
-
-      # Transform +:rule_definition+ as Model::Rule.
-      rule(:rule_definition => {
-          :rule_header => simple(:rule_expr),
-          :rule_conditions => sequence(:conditions),
-          :block => simple(:block) }) {
-        features = Feature.empty if Naming::FeatureLine.values(conditions).empty?
-        features = Feature::AndExpr.new(*Naming::FeatureLine.values(conditions)) unless features
-        condition = Component::RuleCondition.new(
-          inputs: Naming::InputLine.values(conditions),
-          outputs: Naming::OutputLine.values(conditions),
-          params: Parameters.merge(*Naming::ParamLine.values(conditions)),
-          features: features,
-          constraints: Constraints.new(Naming::ConstraintLine.values(conditions))
-        )
-        case block
-        when ActionBlock
-          Component::ActionRule
-        when FlowBlock
-          Component::FlowRule
-        when EmptyBlock
-          Component::EmptyRule
-        end.new(rule_expr.package_expr.name, rule_expr.name, condition, block)
-      }
-
-      # Transform +:input_line+ as Naming::InputLine.
-      rule(:input_line => simple(:data_expr)) {
-        TypeDataExpr.check(data_expr)
-        Naming.InputLine(data_expr)
-      }
-
-      # Transform +output_line+ as Naming::OutputLine.
-      rule(:output_line => simple(:data_expr)) {
-        TypeDataExpr.check(data_expr)
-        Naming.OutputLine(data_expr)
-      }
-
-      # Transform +param_line+ as Naming::ParamLine.
-      rule(:param_line => subtree(:tree)) {
-        param = tree[:param_expr]
-        param_type = tree[:param_type]
-        unless TypeAssignment.match(param) or param.kind_of?(Variable)
-          raise PioneModelTypeError.new(param, TypeAssignment)
-        end
-        case param_type
-        when "advanced"
-          param.set_param_type(:advanced)
-        else
-          param.set_param_type(:basic)
-        end
-        Naming.ParamLine(param)
-      }
-
-      # Transform +:feature_line+ as Naming::FeatureLine.
-      rule(:feature_line => simple(:feature)) {
-        TypeFeature.check(feature)
-        Naming.FeatureLine(feature)
-      }
-
-      rule(:constraint_line => simple(:constraint)) {
-        Naming.ConstraintLine(constraint)
-      }
-
-      rule(:annotation_line => simple(:expr)) {
-        Naming.AnnotationLine(expr)
-      }
-    end
-  end
-end

data/lib/pione/transformer/transformer-module.rb

@@ -1,39 +0,0 @@
-module Pione
-  module Transformer
-    # TransformerModule enables parslet's transforms to be defined by multiple
-    # modules.
-    module TransformerModule
-      class << self
-        # @api private
-        def included(mod)
-          singleton = class << mod; self; end
-          create_pair_by(Parslet, Parslet::Transform).each do |name, orig|
-            singleton.__send__(:define_method, name) do |*args, &b|
-              orig.__send__(name, *args, &b)
-            end
-          end
-
-          class << mod
-            def included(klass)
-              name = :@__transform_rules
-              klass_rules = klass.instance_variable_get(name)
-              klass_rules = klass_rules ? klass_rules + rules : rules
-              klass.instance_variable_set(name, klass_rules)
-            end
-          end
-        end
-
-        private
-
-        # Create module and the methods pair by modules.
-        #
-        # @api private
-        def create_pair_by(*mods)
-          mods.inject([]) do |list, mod|
-            list + (mod.methods.sort - Object.methods.sort).map{|m| [m, mod]}
-          end
-        end
-      end
-    end
-  end
-end