qlang 0.0.27180000 → 0.0.27182000

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38ea44cfe5b2bff006fc553503a35c4d089f8109
-  data.tar.gz: 458fc83a85f7847b4f2258d8a8be725949b4ce32
+  metadata.gz: 3dd94575327cfcb2be0c2ba95bf28013810f0b44
+  data.tar.gz: 62e55299ddd4fef4e9cf9ab24bdfe245b1657c36
 SHA512:
-  metadata.gz: dd3ba3a14aec2546795f4cac2dd533736afbd3b02213b355b7a61ee9548874514cf9f5c6db5965197bf44d085926a7e89896d000d5d95fd59527285eda9d848e
-  data.tar.gz: 2fc98ec6103e6f16d5b90314365b412068f6abc1807e1cd75da2b94827e6bae40fedb1e743a6c286f21bcc656296860116f42173ca12100ee66ebd083f598ec4
+  metadata.gz: 2fd9b76b752cc9195600692e8074365f1a1294138477a891add49d8201c1e4208abdc05fa0a927bb87427c2fa4936852f01caefc082f80ca0354b91b2f1787b9
+  data.tar.gz: cffff8e5cbc59a18ba9fa7ad62f905d1bfc9e85c67b6f2713c27db0af3d3827965104c791c40f2066f1305a77461819cd94092088a50b4fda64085b987233fc0

data/README.md

@@ -60,27 +60,60 @@ f(1, 2)
 
 ## How to use
 
-Install it yourself as:
+Install qlang gme.
 
     $ gem install qlang
+    
+    
+## Use as native language
 
-### Compiler into R
+### Compile into R
+
+    $ qlang -R foo.q
+    
+### Compile into Ruby
 
-    $ qlang -c -R foo.q
+    $ qlang -Ruby foo.q
     
-### Compiler into Ruby
+### Compile into Python
+
+    $ qlang -Python foo.q
+
+
+## Use as math template within other langs
 
-    $ qlang -c -Ruby foo.q
 
-### Interpreter
+```rb
+class ExampleClass
+  def example_method
+    #your Ruby codes
+    ......
 
-    $ qlang -i
+I love mathematics.
+  a = (1 3 4)
+  # your Q codes
+Q.E.D
 
+  end
+end
+```
+
+    $ qlang -Ruby example.rb
+    
+
+```rb
+class ExampleClass
+  def example_method
+    #your Ruby codes
+    ......
+
+    a = Vector[1, 3, 4]
+
+  end
+end
+```
 
 ## Contributing
 
-1. Fork it ( https://github.com/gogotanaka/Q/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Welcome any your PR or issue.
+You can become commiter, if you commit even once.

data/bin/qlang

@@ -15,6 +15,8 @@ when '-i'
       puts e
     end
   end
+when '-v'
+  puts Qlang::VERSION
 when '-R', '-Ruby'
   exec = Qlang::Exec::Compiler.new(ARGV)
   exec.output!

data/lib/qlang.rb

@@ -3,6 +3,7 @@ require 'dydx'
 include Dydx
 
 require "qlang/version"
+require 'qlang/utils/ruby_ext'
 require 'qlang/lexer'
 require 'qlang/parser'
 
@@ -12,10 +13,22 @@ require 'qlang/iq'
 
 require 'kconv'
 require 'matrix'
+require 'yaml'
+require 'singleton'
 
 module Qlang
-  # compiles into R as default.
-  $type = :R
+  class MetaInfo
+    include Singleton
+    attr_accessor :lang, :opts
+
+    def _load
+      # compiles into R as default.
+      lang = :r
+    end
+  end
+  $meta_info = MetaInfo.instance
+
+  LANGS_HASH = YAML.load_file("./lib/qlang/utils/langs.yml")['langs']
 
   class << self
     def compile(str)
@@ -23,30 +36,14 @@ module Qlang
       Kconv.tosjis(Parser.execute(lexed))
     end
 
-    def to_ruby
-      $type = :Ruby
-      Qlang
-    end
-
-    def to_r
-      $type = :R
-      Qlang
+    LANGS_HASH.keys.each do |lang_name|
+      define_method("to_#{lang_name}") do |*opts|
+        $meta_info.lang = lang_name.to_sym
+        $meta_info.opts = opts
+        Qlang
+      end
     end
 
-    def to_haskell
-      $type = :Hskl
-      Qlang
-    end
-
-    def to_scala
-      $type = :Scla
-      Qlang
-    end
-
-    def to_java
-      $type = :Scla
-      Qlang
-    end
   end
 end
 

data/lib/qlang/api.rb

@@ -6,50 +6,15 @@ require 'qlang/api/integral_api'
 
 module Qlang
   module Api
-    # TODO:
-    class ::String
-      def rm(str_or_rgx)
-        gsub(str_or_rgx, '')
-      end
-
-      def rm!(str_or_rgx)
-        gsub!(str_or_rgx, '')
-        self
-      end
-
-      def rms!(*str_or_rgxs)
-        str_or_rgxs.each do |str_or_rgx|
-          rm!(str_or_rgx)
-        end
-        self
-      end
-
-      def split_by_sp
-        split(/ +/)
-      end
-
-      # FIX:
-      def equalize!
-        rms!(/\A +/, / +\z/)
-        if self =~ /\A\(/ && self =~ /\)\z/
-          rms!(/\A\(/, /\)\z/)
-          rms!(/\A +/, / +\z/)
-        else
-          self
-        end
-      end
-    end
-
     class ::Matrix
       def to_q
-        q_rows = rows.map { |row| row.join(' ') }.join('; ')
-        "(#{q_rows})"
+        rows.map(&:join_by_sp).join('; ').parentheses
       end
     end
 
     class ::Vector
       def to_q
-        "(#{elements.join(' ')})"
+        elements.join_by_sp.parentheses
       end
     end
   end

data/lib/qlang/api/func_api.rb

@@ -2,11 +2,13 @@ module Qlang
   module Api
     module FuncApi
       def execute(func_name, args, contents)
-        case $type
-        when :R
+        case $meta_info.lang
+        when :r
           "#{func_name} <- function(#{ args.join(' ,') }) #{contents}"
-        when :Ruby
+        when :ruby
           "#{func_name}(#{ args.join(' ,') }) <= #{contents}"
+        else
+          fail "Function is not implemented for #{LANGS_HASH[$meta_info.lang.to_s]}"
         end
 
       end

data/lib/qlang/api/integral_api.rb

@@ -3,11 +3,11 @@ module Qlang
     module IntegralApi
       def execute(func, delta, range)
         a, b = range.split('..')
-        case $type
-        when :R
-          fail 'Integral is not implemented for R'
-        when :Ruby
+        case $meta_info.lang
+        when :ruby
           "S(#{func}, #{delta})[#{a}, #{b}]"
+        else
+          fail "Integral is not implemented for #{LANGS_HASH[$meta_info.lang.to_s]}"
         end
 
       end

data/lib/qlang/api/list_api.rb

@@ -2,12 +2,12 @@ module Qlang
   module Api
     module ListApi
       def execute(arys)
-        case $type
-        when :R
+        case $meta_info.lang
+        when :r
           combineds_by_equal = arys.map { |ary| "#{ary[0]}=#{ary[1]}" }.join(', ')
           "list(#{combineds_by_equal})"
-        when :Ruby
-          fail 'List is not implemented for Ruby'
+        else
+          fail "List is not implemented for #{LANGS_HASH[$meta_info.lang.to_s]}"
         end
 
       end

data/lib/qlang/api/matrix_api.rb

@@ -4,12 +4,14 @@ module Qlang
       def execute(rows)
         row_count = rows.count
         column_count = rows.first.count
-        case $type
-        when :R
+        case $meta_info.lang
+        when :r
           "matrix(#{VectorApi.execute(rows.flatten)}, #{row_count}, #{column_count}, byrow = TRUE)"
-        when :Ruby
+        when :ruby
           arys_str = rows.map { |row| "[#{row.join(', ')}]" }.join(', ')
           "Matrix[#{arys_str}]"
+        else
+          fail "Matrix is not implemented for #{LANGS_HASH[$meta_info.lang.to_s]}"
         end
       end
       module_function :execute

data/lib/qlang/api/vector_api.rb

@@ -2,11 +2,15 @@ module Qlang
   module Api
     module VectorApi
       def execute(nums)
-        case $type
-        when :R
+        case $meta_info.lang
+        when :r
           "c(#{nums.join(', ')})"
-        when :Ruby
+        when :ruby
           "Vector[#{nums.join(', ')}]"
+        when :python
+          "array([#{nums.join(', ')}])"
+        else
+          fail "Vector is not implemented for #{LANGS_HASH[$meta_info.lang.to_s]}"
         end
       end
       module_function :execute

data/lib/qlang/exec.rb

@@ -37,9 +37,10 @@ module Qlang
         def parse(file_path)
           file = open_file(file_path)
           input_string = read_file(file)
-          input_string =~ /I love mathematics\.(.*)Q\.E\.D/m
           file.close
-          Kconv.tosjis(Qlang.compile($1))
+          input_string.gsub(/(.*)I love mathematics\.(.*)Q\.E\.D(.*)/m) {
+            "#{$1}#{Kconv.tosjis(Qlang.compile($2))}#{$3}"
+          }
         end
 
         def write!(output_path, string)

data/lib/qlang/lexer/base.rb

@@ -1,7 +1,6 @@
 require 'strscan'
 require 'qlang/lexer/tokens'
 
-
 module Qlang
   module Lexer
     class Base
@@ -30,88 +29,57 @@ module Qlang
         end
       end
 
-      def get_value(token_with_num)
-        num = to_num(token_with_num)
-        values[num]
+      # Accessor
+      ## GET(without side effect)
+      def get_value(num)
+        num = num.to_i
+        @lexeds.map { |lexed| lexed.values.first }[num]
       end
 
-      def squash_with_prn(token_with_num, value)
-        num = to_num(token_with_num)
-        3.times do
-          @lexeds.delete_at(num - 1)
-        end
-        @lexeds.insert(num - 1, {R: ":%|#{value}|%:"})
+      def token_str
+        @lexeds.map.with_index { |lexed, i| ":#{lexed.keys.first}#{i}" }.join
       end
 
-      def squash_to_cont(token_with_num, count)
-        num = to_num(token_with_num)
-        value = ''
-        count.times do
-          value += values[num]
-          @lexeds.delete_at(num)
+      ## POST(with side effect, without idempotence.)
+      def parsed!(parsed, target)
+        case target
+          when Range
+            parsed_between!((target.first.to_i)..(target.last.to_i), parsed)
+          else
+            parsed_at!(target.to_i, parsed)
         end
-        @lexeds.insert(num, {CONT: value})
       end
 
-      def ch_token(token_with_num, token)
-        num = to_num(token_with_num)
-        before_hash = @lexeds.delete_at(num)
-        @lexeds.insert(num, {token => before_hash.values.first})
-      end
-
-      def tokens
-        @lexeds.map { |lexed| lexed.keys.first }
-      end
-
-      def token_with_nums
-        @lexeds.map.with_index { |lexed, i| ":#{lexed.keys.first}#{i}" }
-      end
-
-      def ch_value(token_with_num, value)
-        num = to_num(token_with_num)
-        before_hash = @lexeds.delete_at(num)
-        @lexeds.insert(num, {before_hash.keys.first => value })
+      def squash!(range, token: :CONT)
+        range = (range.first.to_i)..(range.last.to_i)
+        value = values[range].join
+        range.count.times { @lexeds.delete_at(range.first) }
+        @lexeds.insert(range.first, { token => value })
       end
 
+      # Legacy Accessor
       def values
         @lexeds.map { |lexed| lexed.values.first }
       end
 
-      def token_str
-        token_with_nums.join
-      end
-
       def [](index)
         @lexeds[index]
       end
 
-      def split(separator)
-        values.chunk { |e| e == separator }.reject { |sep, _| sep }.map { |_, ans| ans }
-      end
+      private
+        def parsed_at!(token_position, parsed)
+          @lexeds.delete_at(token_position)
+          @lexeds.insert(token_position, { R: parsed })
+        end
 
-      def fix_r_txt!
-        @lexeds.map! do |hash|
-          if value = (hash[:R] || hash[:CONT])
-            ary = hash.first
-            ary[1] = value.gsub(/:%\|/,'').gsub(/\|%:/,'')
-            hash = Hash[*ary]
+        def parsed_between!(token_range, parsed)
+          start_pos = token_range.first
+          token_range.count.times do
+            @lexeds.delete_at(start_pos)
           end
-          hash
+          @lexeds.insert(start_pos, { R: parsed })
         end
-      end
 
-      # NEW APIs
-      def parsed!(token_position, parsed)
-        @lexeds.delete_at(token_position)
-        @lexeds.insert(token_position, { R: parsed })
-      end
-
-      private
-
-        def to_num(token_with_num)
-          token_with_num =~ /\d+/
-          $&.to_i
-        end
     end
   end
 end