mulang-php 0.1.0

data/README.md

@@ -0,0 +1,15 @@
+[![Build Status](https://travis-ci.org/mumuki/mulang-php.svg?branch=master)](https://travis-ci.org/mumuki/mulang-php)
+[![Code Climate](https://codeclimate.com/github/mumuki/mulang-php/badges/gpa.svg)](https://codeclimate.com/github/mumuki/mulang-php)
+[![Test Coverage](https://codeclimate.com/github/mumuki/mulang-php/badges/coverage.svg)](https://codeclimate.com/github/mumuki/mulang-php)
+
+# Mulang::PHP
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mumuki/mulang-php. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [GPLv3](http://opensource.org/licenses/gpl-license).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mulang/php"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+ require "pry"
+ Pry.start
+
+#require "irb"
+#IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mulang/php.rb

@@ -0,0 +1,20 @@
+require 'ast'
+require 'parser/current'
+require 'mumukit/core'
+
+require_relative "./php/version"
+
+module Mulang
+  module PHP
+    def self.parse(php_ast)
+      Mulang::PHP::AstProcessor.new.process_block php_ast
+    end
+
+    def self.language
+      Mumukit::Language::External.new { |it| parse(it) }
+    end
+  end
+end
+
+require_relative "./php/sexp"
+require_relative './php/ast_processor'

data/lib/mulang/php/ast_processor.rb

@@ -0,0 +1,271 @@
+module Mulang::PHP
+  class AstProcessor
+    include AST::Sexp
+    include Mulang::PHP::Sexp
+
+    def initialize
+      define_binary_operators!
+    end
+
+    def process_block(stmts)
+      sequence *process(stmts)
+    end
+
+    def process(node)
+      return ms(:None) if node.nil?
+
+      if node.is_a?(Array)
+        return node.map { |it| process it }
+      end
+
+      if node.is_a?(Hash)
+        return send "on_#{node[:nodeType]}", node
+      end
+
+      ms(:Other)
+    end
+
+    def process_array(array, &f)
+      array.map f
+    end
+
+    def get_name(node)
+      node[:parts].first
+    end
+
+    def define_binary_operators!
+      [
+        { token: '===', name: 'Identical', supports_assign?: false },
+        { token: '!==', name: 'NotIdentical', supports_assign?: false },
+        { token: '.', name: 'Concat', supports_assign?: true },
+        { token: '+', name: 'Plus', supports_assign?: true },
+        { token: '-', name: 'Minus', supports_assign?: true },
+        { token: '*', name: 'Mul', supports_assign?: true },
+        { token: '/', name: 'Div', supports_assign?: true },
+        { token: '%', name: 'Mod', supports_assign?: true },
+        { token: '**', name: 'Pow', supports_assign?: true },
+        { token: '>', name: 'Greater', supports_assign?: false },
+        { token: '<', name: 'Smaller', supports_assign?: false },
+        { token: '>=', name: 'GreaterOrEqual', supports_assign?: false },
+        { token: '<=', name: 'SmallerOrEqual', supports_assign?: false },
+        { token: '&', name: 'BitwiseAnd', supports_assign?: true },
+        { token: '|', name: 'BitwiseOr', supports_assign?: true },
+        { token: '&&', name: 'BooleanAnd', supports_assign?: false },
+        { token: '||', name: 'BooleanOr', supports_assign?: false },
+        { token: 'and', name: 'LogicalAnd', supports_assign?: false },
+        { token: 'or', name: 'LogicalOr', supports_assign?: false },
+        { token: 'xor', name: 'LogicalXOr', supports_assign?: false }
+      ].each { |it|
+        self.class.redefine_method(:"on_Expr_BinaryOp_#{it[:name]}") { |node|
+          process_binary_operator it[:token], node
+        }
+
+        if it[:supports_assign?]
+          self.class.redefine_method(:"on_Expr_AssignOp_#{it[:name]}") { |node|
+            binary_operator "#{it[:token]}=", process(node[:var]), process(node[:expr])
+          }
+        end
+      }
+    end
+
+    def process_binary_operator(operator, node)
+      binary_operator operator, process(node[:left]), process(node[:right])
+    end
+
+    # ---
+
+    # VALUES
+
+    def on_Stmt_Expression(node)
+      process node[:expr]
+    end
+
+    def on_Expr_Variable(node)
+      ms :Reference, node[:name]
+    end
+
+    def on_Scalar_DNumber(node)
+      ms :MuNumber, node[:value]
+    end
+    alias on_Scalar_LNumber on_Scalar_DNumber
+
+    def on_Scalar_String(node)
+      ms :MuString, node[:value]
+    end
+
+    def on_Expr_ConstFetch(node)
+       value = get_name(node[:name]).downcase
+
+      case value
+        when 'true'
+          ms :MuBool, true
+        when 'false'
+          ms :MuBool, false
+        when 'null'
+          ms :None
+        else
+          ms :Reference, value
+      end
+    end
+
+    def on_Expr_Array(node)
+      items = node[:items]
+      is_array = items.all? { |it| it[:key].nil? }
+
+      is_array ? ms(:MuList, process(items))
+               : ms(:MuObject, process_block(items))
+    end
+
+    def on_Expr_ArrayItem(node)
+      value = process(node[:value])
+
+      node[:key] ? ms(:Attribute, node[:key][:value].to_s, value)
+                 : value
+    end
+
+    def on_Expr_Closure(node)
+      ms :Lambda, process(node[:params]), process_block(node[:stmts])
+    end
+
+    def on_Param(node)
+      ms :VariablePattern, node[:var][:name]
+    end
+
+    # OPERATORS
+
+    def on_Expr_BinaryOp_Equal(node)
+      ms :Equal, [process(node[:left]), process(node[:right])]
+    end
+
+    def on_Expr_BinaryOp_NotEqual(node)
+      ms :NotEqual, [process(node[:left]), process(node[:right])]
+    end
+
+    def on_Expr_PostInc(node)
+      binary_operator '+', process(node[:var]), ms(:MuNumber, 1)
+    end
+    alias on_Expr_PreInc on_Expr_PostInc
+
+    def on_Expr_PostDec(node)
+      binary_operator '-', process(node[:var]), ms(:MuNumber, 1)
+    end
+    alias on_Expr_PreDec on_Expr_PostDec
+
+    # FUNCTION CALLS
+
+    def on_Expr_FuncCall(node)
+      application get_name(node[:name]), process(node[:args])
+    end
+
+    def on_Arg(node)
+      process node[:value]
+    end
+
+    # DECLARATIONS
+
+    def on_Stmt_Function(node)
+      simple_function node[:name][:name], process(node[:params]), process_block(node[:stmts])
+    end
+
+    def on_Stmt_Return(node)
+      ms :Return, process(node[:expr])
+    end
+
+    # STATEMENTS
+
+    def on_Expr_Assign(node)
+      left = node[:var]
+      exp = process(node[:expr])
+
+      if left[:nodeType] == 'Expr_PropertyFetch'
+        simple_send process(left[:var]), "#{left[:name][:name]}=", [exp]
+      else
+        ms :Assignment, left[:name], exp
+      end
+    end
+
+    def on_Stmt_Echo(node)
+      ms :Print, process_block(node[:exprs])
+    end
+
+    def on_Stmt_If(node)
+      condition = node[:cond]
+      body = node[:stmts]
+      else_block = node[:else]
+
+      ms :If, process(condition), process_block(body), process(else_block)
+    end
+    alias on_Stmt_ElseIf on_Stmt_If
+
+    def on_Stmt_Else(node)
+      process_block node[:stmts]
+    end
+
+    def on_Stmt_For(node)
+      ms :ForLoop, process_block(node[:init]), process_block(node[:cond]), process_block(node[:loop]), process_block(node[:stmts])
+    end
+
+    def on_Stmt_While(node)
+      ms :While, process(node[:cond]), process_block(node[:stmts])
+    end
+
+    def on_Stmt_Foreach(node)
+      ms :For, [ms(:Generator, ms(:VariablePattern, node[:valueVar][:name]), process(node[:expr]))], process_block(node[:stmts])
+    end
+
+    # OOP
+
+    def on_Expr_PropertyFetch(node)
+      simple_send process(node[:var]), node[:name][:name], []
+    end
+
+    def on_Expr_MethodCall(node)
+      simple_send process(node[:var]), node[:name][:name], process(node[:args])
+    end
+
+    def on_Expr_New(node)
+      ms :New, process(node[:class]), process(node[:args])
+    end
+
+    def on_Name(node)
+      ms :Reference, get_name(node)
+    end
+
+    def on_Stmt_Class(node)
+      superclass = node.dig(:extends, :parts)&.first
+      interfaces = node[:implements].map { |it| { nodeType: 'Stmt_Implement', name: get_name(it) } }
+
+      ms :Class, node[:name][:name], superclass, process_block(interfaces.concat(node[:stmts]))
+    end
+
+    def on_Stmt_Implement(node)
+      ms :Implement, ms(:Reference, node[:name])
+    end
+
+    def on_Stmt_Property(node)
+      prop = node[:props].first
+      ms :Attribute, prop[:name][:name], process(prop[:default])
+    end
+
+    def on_Stmt_ClassMethod(node)
+      name = node[:name][:name]
+      params = process(node[:params])
+
+      if node[:stmts].nil?
+        ms :TypeSignature, name, ms(:ParameterizedType, params.map { |it| 'Any' }, 'Any', [])
+      else
+        simple_method name, params, process_block(node[:stmts])
+      end
+    end
+
+    def on_Stmt_Interface(node)
+      parents = node[:extends].map { |it| get_name(it) }
+      ms :Interface, node[:name][:name], parents, process_block(node[:stmts])
+    end
+
+    def method_missing(m, *args, &block)
+      puts m, args
+      ms :Other, "#{m}: #{args.to_s}", nil
+    end
+  end
+end

data/lib/mulang/php/sexp.rb

@@ -0,0 +1,55 @@
+module Mulang::PHP
+  module Sexp
+    def sequence(*contents)
+      if contents.empty?
+        ms(:None)
+      elsif contents.size == 1
+        contents[0]
+      else
+        ms(:Sequence, *contents)
+      end
+    end
+
+    def ms(tag, *contents)
+      if contents.empty?
+        {tag: tag}
+      elsif contents.size == 1
+        {tag: tag, contents: contents.first}
+      else
+        {tag: tag, contents: contents}
+      end
+    end
+
+    def simple_function(name, args, body)
+      callable :Function, name, args, body
+    end
+
+    def simple_method(name, args, body)
+      callable :Method, name, args, body
+    end
+
+    def callable(type, name, args, body)
+      {
+          tag: type,
+          contents: [
+              name,
+              [
+                  [ args, {tag: :UnguardedBody, contents: body }]
+              ]
+          ]
+      }
+    end
+
+    def application(name, args)
+      ms :Application, [ms(:Reference, name), args]
+    end
+
+    def binary_operator(operator, left, right)
+      application operator, [left, right]
+    end
+
+    def simple_send(sender, message, args)
+      ms(:Send, sender, ms(:Reference, message), args)
+    end
+  end
+end

data/lib/mulang/php/version.rb

@@ -0,0 +1,5 @@
+module Mulang
+  module PHP
+    VERSION = "0.1.0"
+  end
+end

data/mulang-php.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mulang/php/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mulang-php"
+  spec.version       = Mulang::PHP::VERSION
+  spec.authors       = ["Rodrigo Alfonso", "Franco Leonardo Bulgarelli"]
+  spec.email         = ["rodri042@gmail.com", "franco@mumuki.org"]
+
+  spec.summary       = "PHP integration for the Mulang Language Analyzer"
+  spec.description   = "PHP - Mulang Parser"
+  spec.homepage      = "https://mumuki.io"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency "parser"
+  spec.add_dependency "ast"
+  spec.add_dependency "mumukit-core", "~> 1.0"
+  spec.add_dependency "mulang", "~> 4.0"
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: mulang-php
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Alfonso
+- Franco Leonardo Bulgarelli
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mumukit-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mulang
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: PHP - Mulang Parser
+email:
+- rodri042@gmail.com
+- franco@mumuki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- COPYRIGHT.txt
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/.gitkeep
+- bin/console
+- bin/setup
+- lib/mulang/php.rb
+- lib/mulang/php/ast_processor.rb
+- lib/mulang/php/sexp.rb
+- lib/mulang/php/version.rb
+- mulang-php.gemspec
+homepage: https://mumuki.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: PHP integration for the Mulang Language Analyzer
+test_files: []