python 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c712a1eeb1a31ce723c1fa4c0f6f499a3b04de9f
+  data.tar.gz: 0e3a1c2d0123e206072ee79a27d28fbe87d687bb
+SHA512:
+  metadata.gz: 75ab974d6430f574011536b451895263d6c62b82adf89eb73832b2393880aa9e550e8b3642e64d160e0787b4fffe230fec67db348d2cb0978c6194cb00e15d7e
+  data.tar.gz: 77723e0b9e1e3f01d22032442e0881bc3659d4955706b401a53962e839f9201ceddcfdb93508a35c60355f21013767bcb19c9cdca0395ffa85e0a37248c12540

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/documents/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in python.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# Python
+
+Python implemented in pure Ruby without any libraries.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'python'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install python
+
+## Usage
+
+Executable script "python.rb" will be installed in your bin path.
+You can execute python program by two way.
+One way is through command-line interpreter (REPL), and another is from source-file.
+
+### Command-line interpreter (REPL)
+
+    $ python.rb
+    python.rb> 1 + 2
+    3
+    python.rb>
+
+### Executing program from source file
+
+```python
+# demo.py
+class A:
+    def __init__(self, x):
+        self.x = x
+
+    def add(self, d):
+        self.x = self.x + d
+        return self
+
+a = A(1).add(2).add(3)
+print(a.x)
+```
+
+    $ python.rb demo.py
+    6
+    $
+
+## Contributing
+
+1. Fork it ( https://github.com/sawaken/python.rb/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

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/python.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'python'
+
+if ARGV[0]
+  File.open(ARGV[0], "r") do |file|
+    Python::FileInterpreter.new(file.read).execute
+  end
+else
+  repl = Python::REPL.new(STDOUT)
+  repl.start
+  while input = STDIN.gets
+    repl.read_eval_print(input)
+    repl.prompt
+  end
+end

data/examples/demo.py

@@ -0,0 +1,10 @@
+class A:
+    def __init__(self, x):
+        self.x = x
+        
+    def add(self, d):
+        self.x = self.x + d
+        return self
+
+a = A(1).add(2).add(3)
+print(a.x)

data/examples/fibonacci.py

@@ -0,0 +1,5 @@
+def fib(n):
+    cond = n == 0 or n == 1
+    return n if cond else fib(n - 1) + fib(n - 2)
+
+print(fib(10))

data/examples/twoclass.py

@@ -0,0 +1,9 @@
+class Y:
+    def __init__(self, val):
+        self.val = val
+
+class X:
+    def __init__(self, val):
+        self.y = Y(val)
+
+print(X(1).y.val)

data/features/programmer_caclulate_numerical_expression.feature

@@ -0,0 +1,50 @@
+Feature: programmer calculate numerical expression
+
+  The programmer calculates numerical expressions through REPL console.
+  REPL console print caluculated number in one line.
+
+  Scenario Outline: calculate numerical expression
+    Given I started repl but didn't input anything
+    When I input "<expression>"
+    Then the output expect be "<evaluated>"
+
+    Scenarios: without operator
+      | expression | evaluated |
+      |          1 |         1 |
+      |          0 |         0 |
+      |         -1 |        -1 |
+      |         +1 |         1 |
+
+    Scenarios: single operator
+      | expression | evaluated |
+      |      1 + 2 |         3 |
+      |      1 - 2 |        -1 |
+      |      1 * 2 |         2 |
+      |     1 // 2 |         0 |
+
+    Scenarios: without space between tokens
+      | expression | evaluated |
+      |        1+2 |         3 |
+      |    100+100 |       200 |
+
+    Scenarios: double operator
+      |  expression  | evaluated |
+      |    1 + 2 + 3 |         6 |
+      |    1 - 2 - 3 |        -4 |
+      |    1 * 2 * 3 |         6 |
+      |  9 // 3 // 2 |         1 |
+
+    Scenarios: priority
+      |   expression   | evaluated |
+      |      1 + 2 * 3 |         7 |
+      |      1 - 2 * 3 |        -5 |
+      |     1 + 6 // 3 |         3 |
+      |     1 - 6 // 3 |        -1 |
+
+    Scenarios: parentheses
+      |     expression     | evaluated |
+      |                (1) |         1 |
+      |               (-1) |        -1 |
+      |  (1 + 2) * (3 + 4) |        21 |
+      |      (1 - (2 - 3)) |         2 |
+      |      ((1 + 2) * 3) |         9 |

data/features/programmer_execute_from_source_file.feature

@@ -0,0 +1,10 @@
+Feature: programmer execute python program in source file
+
+  Scenario: execute script file
+    Given in silence, I am on shell
+    When I start interpreter with argument "number_of_the_beast.py":
+      """
+      six = 6
+      print(six * 100 + six * 10 + six)
+      """
+    Then the output expect be "666"

data/features/programmer_starts_repl_console.feature

@@ -0,0 +1,10 @@
+Feature: programmer starts REPL console
+
+  As a programmer
+  I want to start REPL console
+  So that I can input and run python code
+
+  Scenario: start REPL
+    Given I am not yet inputting anything
+    When I start a new REPL console
+    Then I expect see "python.rb> "

data/features/programmer_use_advanced_calculator.feature

@@ -0,0 +1,35 @@
+Feature: programmer use advanced calculator
+
+  The programmer calculates numerical expressions with conditions through REPL console.
+  REPL console print caluculated number in one line.
+
+  Scenario Outline: calculate numerical expression with conditions
+    Given I started repl but didn't input anything
+    When I input "<statement>"
+    Then the output expect be "<evaluated>"
+
+    Scenarios: with conditional operator
+      | statement | evaluated |
+      |     1 < 2 |      True |
+      | 1 < 2 < 3 |      True |
+      |     2 < 1 |     False |
+      |    1 == 1 |      True |
+      |    1 == 2 |     False |
+      |     2 > 1 |      True |
+
+    Scenarios: with not, and, or
+      | statement | evaluated |
+      |     not 1 |     False |
+      |     not 0 |      True |
+      |  not True |     False |
+      | not False |      True |
+      |   1 and 2 |         2 |
+      |   1 and 0 |         0 |
+      |    1 or 0 |         1 |
+      |    0 or 1 |         1 |
+      |    1 or 2 |         1 |
+
+    Scenarios: with conditional expression
+      |          statement          | evaluated |
+      |  1 + 1 if 1 == 2 else 2 + 2 |         4 |
+      |  1 + 1 if 1 == 1 else 2 + 2 |         2 |

data/features/programmer_use_class.feature

@@ -0,0 +1,42 @@
+Feature: programmer use class
+
+  Scenario: define simple class and make instance
+    Given in silence, I am on shell
+    When I start interpreter with argument "defineclass.py":
+      """
+      class A:
+        def mymethod(self, x):
+          return x
+
+      a = A()
+      print(a.mymethod(2))
+      """
+    Then the output expect be "2"
+
+  Scenario: define class having static variable and use it
+    Given in silence, I am on shell
+    When I start interpreter with argument "staticclassvariable.py":
+      """
+      class B:
+        staticvar = 123
+
+      b = B()
+      print(b.staticvar)
+      """
+    Then the output expect be "123"
+
+    Scenario: define two class
+      Given in silence, I am on shell
+      When I start interpreter with argument "class2.py":
+        """
+        class Y:
+          def __init__(self, val):
+            self.val = val
+
+        class X:
+          def __init__(self, val):
+            self.y = Y(val)
+
+        print(X(1).y.val)
+        """
+      Then the output expect be "1"

data/features/programmer_use_closure.feature

@@ -0,0 +1,66 @@
+Feature: programmer use closure
+
+  Scenario: calc fibonacci-number by using closure in script file
+    Given in silence, I am on shell
+    When I start interpreter with argument "fibonacci.py":
+      """
+      def fib(n):
+        cond = n == 0 or n == 1
+        return n if cond else fib(n - 1) + fib(n - 2)
+
+      print(fib(10))
+      """
+    Then the output expect be "55"
+
+  Scenario: play with a high-order function (a function returns a function) in script file
+    Given in silence, I am on shell
+    When I start interpreter with argument "highorder1.py":
+      """
+      def curried_add(a):
+        def add(b):
+          return a + b
+        return add
+
+      print(curried_add(1)(2))
+      """
+    Then the output expect be "3"
+
+    Scenario: play with a high-order function (a function takes a function) in script file
+      Given in silence, I am on shell
+      When I start interpreter with argument "highorder2.py":
+        """
+        def twice(f, arg):
+          return f(f(arg))
+
+        def double(a):
+          return a * 2
+
+        print(twice(double, 5))
+        """
+      Then the output expect be "20"
+
+    Scenario: argument-less function
+      Given in silence, I am on shell
+      When I start interpreter with argument "noargs.py":
+        """
+        def hello():
+          print(12)
+
+        hello()
+        """
+      Then the output expect be "12"
+
+    Scenario: double DEDENT
+      Given in silence, I am on shell
+      When I start interpreter with argument "doublededent.py":
+        """
+        def foo():
+          def bar():
+            return 1
+          def baz():
+            return 2
+
+        a = foo()
+        print(0)
+        """
+      Then the output expect be "0"

data/features/programmer_use_variables.feature

@@ -0,0 +1,12 @@
+Feature: programmer use variables on REPL console
+
+  Scenario: use variables
+    Given I started repl but didn't input anything
+    When I input "x = 1"
+    Then the output expect be ""
+    When I input "x"
+    Then the output expect be "1"
+    When I input "x = x + 1"
+    Then the output expect be ""
+    When I input "x"
+    Then the output expect be "2"

data/features/step_definitions/calculate_numerical_steps.rb

@@ -0,0 +1,67 @@
+class Out
+  def messages
+    @messages ||= []
+  end
+
+  def write(messge)
+    print(message)
+  end
+
+  def puts(message)
+    print(message + "\n")
+  end
+
+  def print(message)
+    messages << message
+  end
+end
+
+# Feature: programmer starts REPL console
+#-----
+
+Given(/^I am not yet inputting anything$/) do
+  @out = Out.new
+  @repl = Python::REPL.new(@out)
+end
+
+When(/^I start a new REPL console$/) do
+  @repl.start
+end
+
+Then(/^I expect see "([^"]*)"$/) do |message|
+  expect(@out.messages).to eq([message])
+end
+
+# Feature: programmer calculate numerical expression
+#-----
+
+Given(/^I started repl but didn't input anything$/) do
+  @out = Out.new
+  @repl = Python::REPL.new(@out)
+  @repl.start
+end
+
+When(/^I input "([^"]*)"$/) do |input|
+  @repl.read_eval_print(input)
+end
+
+Then(/^the output expect be "([^"]*)"$/) do |expected|
+  if expected != ""
+    expect(@out.messages.last).to eq(expected + "\n")
+  else
+    expect(@out.messages.last).to eq("")
+  end
+end
+
+# Feature: programmer execute python program in source file
+#-----
+
+Given(/^in silence, I am on shell$/) do
+
+end
+
+When(/^I start interpreter with argument "([^"]*)":$/) do |filename, code|
+  @out = Out.new
+  printfunc = Python::Builtins::Func.make_instance{|obj| @out.puts(obj.inspect)}
+  Python::FileInterpreter.new(code, "print" => printfunc).execute
+end