kaiser-ruby 0.5.1 → 0.7

data/lib/kaiser_ruby/version.rb

@@ -1,3 +1,3 @@
 module KaiserRuby
-  VERSION = "0.5.1"
+  VERSION = "0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kaiser-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: '0.7'
 platform: ruby
 authors:
 - Marcin Ruszkiewicz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-29 00:00:00.000000000 Z
+date: 2018-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,33 +67,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.11'
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0.20'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0.20'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0'
 description: 
 email:
 - marcin.ruszkiewicz@polcode.net
@@ -119,8 +119,9 @@ files:
 - kaiser-ruby.gemspec
 - lib/kaiser_ruby.rb
 - lib/kaiser_ruby/cli.rb
-- lib/kaiser_ruby/rockstar_parser.rb
-- lib/kaiser_ruby/rockstar_transform.rb
+- lib/kaiser_ruby/parser.rb
+- lib/kaiser_ruby/refinements.rb
+- lib/kaiser_ruby/transformer.rb
 - lib/kaiser_ruby/version.rb
 homepage: https://github.com/marcinruszkiewicz/kaiser-ruby
 licenses:

data/lib/kaiser_ruby/rockstar_parser.rb

@@ -1,310 +0,0 @@
-module KaiserRuby
-  class RockstarParser < Parslet::Parser
-    # ORDER OF THESE RULES ABSOLUTELY MATTERS
-    # DON'T MESS WITH IT
-
-    # all the keywords separately, so that variable names can't use them
-
-    rule(:reserved) do
-      mysterious_value_keywords | null_value_keywords | true_value_keywords | false_value_keywords |
-      plus_keywords | minus_keywords | times_keywords | over_keywords | increment_keywords |
-      assignment_keywords | poetic_string_keywords | poetic_number_keywords |
-      say_keywords | flow_keywords | comparison_keywords | function_keywords
-    end
-
-    rule(:mysterious_value_keywords) { str('mysterious') }
-    rule(:null_value_keywords) { str('nothing') | str('nowhere') | str('nobody') | str('empty') | str('gone') }
-    rule(:false_value_keywords) { str('false') | str('wrong') | str('no') | str('lies') }
-    rule(:true_value_keywords) { str('true') | str('right') | str('yes') | str('ok') }
-    rule(:plus_keywords) { str('plus') | str('with') }
-    rule(:minus_keywords) { str('minus') | str('without') }
-    rule(:minus_keywords) { str('minus') | str('without') }
-    rule(:times_keywords) { str('times') | str('of') }
-    rule(:over_keywords) { str('over') }
-    rule(:poetic_number_keywords) { str('is') | str('was') | str('were') }
-    rule(:say_keywords) { str('Say') | str('Shout') | str('Scream') | str('Whisper') }
-    rule(:flow_keywords) { str('If') | str('Else') | str('While') | str('Until') }
-    rule(:increment_keywords) { str('Knock') | str('Build') }
-    rule(:assignment_keywords) { str('Put') | str('into') }
-    rule(:poetic_string_keywords) { str('says') }
-    rule(:comparison_keywords) { str("is") | not_keywords | gt_keywords | gte_keywords | lt_keywords | lte_keywords }
-    rule(:function_keywords) { str('Break it down') | str('Take it to the top') | str('Give back') | str('takes') | str('taking') | str('Listen to') }
-
-    rule(:pronouns) { (str('he') | str('she') | str('it') | str('they') | str('them') | str('her') | str('him') | str('its')).as(:pronoun) }
-
-    # variable names
-    # using [[:upper:]] etc here allows for metal umlauts and other UTF characters
-
-    rule(:proper_word) { reserved.absent? >> match['[[:upper:]]'] >> match['[[:alpha:]]'].repeat }
-    rule(:common_variable_name) do
-      (
-        str('A ') | str('a ') |
-        str('An ') | str('an ') |
-        str('The ') | str('the ') |
-        str('My ') | str('my ') |
-        str('Your ') | str('your ')
-      ) >> reserved.absent? >> match['[[:lower:]]'].repeat >> match[','].maybe.ignore
-    end
-    rule(:proper_variable_name) do
-      (proper_word >> (space >> proper_word).repeat) >> match[','].maybe.ignore
-    end
-
-    rule(:variable_names) do
-      (pronouns | common_variable_name | proper_variable_name).as(:variable_name)
-    end
-
-    # all the different value types (except Object for now)
-
-    rule(:mysterious_value) { mysterious_value_keywords.as(:mysterious_value) }
-    rule(:null_value) { null_value_keywords.as(:null_value) }
-    rule(:true_value) { true_value_keywords.as(:true_value) }
-    rule(:false_value) { false_value_keywords.as(:false_value) }
-    rule(:string_value) { (str('"') >> match['^"'].repeat >> str('"')).as(:string_value) }
-    rule(:numeric_value) { match['0-9\.'].repeat.as(:numeric_value) }
-    rule(:unquoted_string) { match['^\n'].repeat.as(:unquoted_string) }
-    rule(:string_as_number) { reserved.absent? >> match['^\n'].repeat.as(:string_as_number) }
-
-    # assignment
-
-    rule(:basic_assignment_expression) do
-      match('Put ').present? >>
-      (
-        str('Put ') >> string_input.as(:right) >> str(' into ') >> variable_names.as(:left)
-      ).as(:assignment)
-    end
-
-    # math operations
-
-    rule(:increment) do
-      (
-        str('Build ') >> variable_names.as(:variable_name) >> str(' up')
-      ).as(:increment)
-    end
-
-    rule(:decrement) do
-      (
-        str('Knock ') >> variable_names.as(:variable_name) >> str(' down')
-      ).as(:decrement)
-    end
-
-    rule(:addition) do
-      (match('.*? plus') | match('.*? with')).present? >>
-      (
-        value_or_variable.as(:left) >> space >> plus_keywords >> space >> value_or_variable.as(:right)
-      ).as(:addition)
-    end
-
-    rule(:subtraction) do
-      (match('.*? minus') | match('.*? without')).present? >>
-      (
-        value_or_variable.as(:left) >> space >> minus_keywords >> space >> value_or_variable.as(:right)
-      ).as(:subtraction)
-    end
-
-    rule(:division) do
-      match('.*? over').present? >>
-      (
-        value_or_variable.as(:left) >> space >> over_keywords >> space >> value_or_variable.as(:right)
-      ).as(:division)
-    end
-
-    rule(:multiplication) do
-      (match('.*? times') | match('.*? of')).present? >>
-      (
-        value_or_variable.as(:left) >> space >> times_keywords >> space >> value_or_variable.as(:right)
-      ).as(:multiplication)
-    end
-
-    # functions
-
-    rule(:function) do
-      match('.*? takes').present? >>
-      (
-        variable_names.as(:function_name) >> str(' takes') >>
-        (space >> str('and ').maybe >> variable_names.as(:argument_name)).repeat.as(:arguments) >> eol >>
-        scope {
-          inner_block_line.repeat.as(:function_block) >>
-          (eol | eof).as(:enddef)
-        }
-      ).as(:function_definition)
-    end
-
-    rule(:function_call) do
-      (
-        variable_names.as(:function_name) >> str(' taking') >>
-        (space >> str('and ').maybe >> variable_names.as(:argument_name)).repeat.as(:arguments)
-      ).as(:function_call)
-    end
-
-    # poetic assignments
-
-    rule(:poetic_type_literal) do
-      (flow_keywords.absent?) >>
-      (
-        variable_names.as(:left) >> str(' is ') >> (mysterious_value | null_value | false_value | true_value).as(:right)
-      ).as(:assignment)
-    end
-
-    rule(:poetic_string_literal) do
-      (
-        variable_names.as(:left) >> str(' says ') >> unquoted_string.as(:right)
-      ).as(:assignment)
-    end
-
-    rule(:poetic_number_literal) do
-      (flow_keywords.absent?) >>
-      (
-        variable_names.as(:left) >> space >> poetic_number_keywords >> space >> string_as_number.as(:right)
-      ).as(:assignment)
-    end
-
-    # single statements
-
-    rule(:print_function) do
-      (
-        say_keywords >> space >> (function_call | value_or_variable).as(:output)
-      ).as(:print)
-    end
-
-    rule(:break_function) do
-      str('Break it down').as(:break)
-    end
-
-    rule(:continue_function) do
-      str('Take it to the top').as(:continue)
-    end
-
-    rule(:return_function) do
-      str('Give back ') >> (math_operations | value_or_variable).as(:return_value)
-    end
-
-    rule(:input) do
-      str('Listen to ') >> variable_names.as(:input_variable)
-    end
-
-    # comparisons
-
-    rule(:gte_keywords) { str(' is as ') >> (str('high') | str('great') | str('big') | str('strong')) >> str(' as ') }
-    rule(:gte) do
-      (
-        value_or_variable.as(:left) >> gte_keywords >> (math_operations | value_or_variable).as(:right)
-      ).as(:gte)
-    end
-
-    rule(:lte_keywords) { str(' is as ') >> (str('low') | str('little') | str('small') | str('weak')) >> str(' as ') }
-    rule(:lte) do
-      (
-        value_or_variable.as(:left) >> lte_keywords >> (math_operations | value_or_variable).as(:right)
-      ).as(:lte)
-    end
-
-    rule(:equality) do
-      (
-        value_or_variable.as(:left) >> str(' is ') >> (math_operations | value_or_variable).as(:right)
-      ).as(:equals)
-    end
-
-    rule(:not_keywords) { str(' is not ') | str(" ain't ")}
-    rule(:inequality) do
-      (
-        value_or_variable.as(:left) >> not_keywords >> (math_operations | value_or_variable).as(:right)
-      ).as(:not_equals)
-    end
-
-    rule(:gt_keywords) { str(' is ') >> (str('higher') | str('greater') | str('bigger') | str('stronger')) >> str(' than ') }
-    rule(:gt) do
-      (
-        value_or_variable.as(:left) >> gt_keywords >> (math_operations | value_or_variable).as(:right)
-      ).as(:gt)
-    end
-
-    rule(:lt_keywords) { str(' is ') >> (str('lower') | str('less') | str('smaller') | str('weaker')) >> str(' than ') }
-    rule(:lt) do
-      (
-        value_or_variable.as(:left) >> lt_keywords >> (math_operations | value_or_variable).as(:right)
-      ).as(:lt)
-    end
-
-
-
-    # flow control - if, else, while, until
-
-    rule(:if_else_block) do
-      (
-        str('If ') >> comparisons.as(:if_condition) >>
-          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
-          scope {
-            inner_block_line.repeat.as(:if_block)
-          } >>
-        str('Else') >> eol >>
-          scope {
-            inner_block_line.repeat.as(:else_block)
-          } >> (eol | eof).as(:endif)
-      ).as(:if_else)
-    end
-
-    rule(:if_block) do
-      (
-        str('If ') >> comparisons.as(:if_condition) >>
-          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
-          scope {
-            inner_block_line.repeat.as(:if_block)
-          } >> (eol | eof).as(:endif)
-      ).as(:if)
-    end
-
-    rule(:while_block) do
-      (
-        str('While ') >> comparisons.as(:while_condition) >>
-          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
-          scope {
-            inner_block_line.repeat.as(:while_block)
-          } >> (eol | eof).as(:endwhile)
-      ).as(:while)
-    end
-
-    rule(:until_block) do
-      (
-        str('Until ') >> comparisons.as(:until_condition) >>
-          (space >> (str('and') | str('or')).as(:and_or) >> space >> comparisons.as(:second_condition)).maybe >> eol >>
-          scope {
-            inner_block_line.repeat.as(:until_block)
-
-          } >> (eol | eof).as(:enduntil)
-      ).as(:until)
-    end
-
-    # sets of rules
-
-    rule(:simple_values) { mysterious_value | null_value | false_value | true_value | string_value | numeric_value }
-    rule(:value_or_variable) { variable_names | simple_values }
-    rule(:math_operations) { increment | decrement | addition | subtraction | multiplication | division }
-    rule(:expressions) { basic_assignment_expression | math_operations }
-    rule(:comparisons) { gte | gt | lte | lt | inequality | equality }
-    rule(:flow_control) { if_block | if_else_block | while_block | until_block }
-    rule(:poetics) { poetic_type_literal | poetic_string_literal | poetic_number_literal }
-    rule(:functions) { function_call | function | print_function | break_function | continue_function | return_function | input }
-    rule(:line_elements) { flow_control | poetics | expressions | functions | eol }
-
-    # handle multiple lines in a file
-
-    rule(:string_input) { line_elements | value_or_variable }
-    rule(:line) { (line_elements >> eol.maybe).as(:line) }
-    rule(:inner_block_line) { ( (flow_control | poetics | expressions | functions) >> eol.maybe).as(:line) }
-    rule(:lyrics) { line.repeat.as(:lyrics) }
-    root(:lyrics)
-
-    # DRY helpers
-
-    rule(:eol) { match["\n"] }
-    rule(:eof) { any.absent? }
-    rule(:space) { match[' \t'].repeat(1) }
-  end
-
-  # this is an alternative parser that enables all the RSpec tests to pass
-  # it specifically has a single line rule that matches a string instead of lines
-  # it also matches the value_or_variable rule, so that the value creation can be tested
-  class RockstarSingleLineParser < KaiserRuby::RockstarParser
-    root(:string_input)
-  end
-end

data/lib/kaiser_ruby/rockstar_transform.rb

@@ -1,224 +0,0 @@
-module KaiserRuby
-  class RockstarTransform < Parslet::Transform
-    @@last_variable = nil
-    @@indent = 0
-
-    class << self
-      def last_variable=(value)
-        @@last_variable = value
-      end
-
-      def up_indent
-        @@indent += 2
-      end
-
-      def down_indent
-        @@indent -= 2
-      end
-    end
-
-    rule(variable_name: simple(:str)) do |context|
-      self.last_variable = parameterize(context[:str])
-      parameterize(context[:str])
-    end
-    rule(pronoun: simple(:_)) { @@last_variable }
-
-    rule(mysterious_value: simple(:_)) { 'nil' }
-    rule(null_value: simple(:_)) { '0' }
-    rule(true_value: simple(:_)) { 'true' }
-    rule(false_value: simple(:_)) { 'false' }
-    rule(string_value: simple(:str)) { str }
-    rule(numeric_value: simple(:num)) { num }
-    rule(unquoted_string: simple(:str)) { "\"#{str}\"" }
-    rule(string_as_number: simple(:str)) do |context|
-      if context[:str].to_s.include?('.')
-        context[:str].to_s.gsub(/[^A-Za-z\s\.]/, '').split('.').map do |sub|
-          str_to_num(sub.strip)
-        end.join('.').to_f
-      else
-        str_to_num(context[:str]).to_i
-      end
-    end
-
-    rule(assignment: { left: simple(:left), right: simple(:right) }) { "#{left} = #{right}" }
-    rule(increment: simple(:str)) { "#{str} += 1" }
-    rule(decrement: simple(:str)) { "#{str} -= 1" }
-    rule(addition: { left: simple(:left), right: simple(:right) }) { "#{left} + #{right}" }
-    rule(subtraction: { left: simple(:left), right: simple(:right) }) { "#{left} - #{right}" }
-    rule(multiplication: { left: simple(:left), right: simple(:right) }) { "#{left} * #{right}" }
-    rule(division: { left: simple(:left), right: simple(:right) }) { "#{left} / #{right}" }
-
-    rule(print: { output: simple(:output) }) { "puts #{output}" }
-    rule(continue: simple(:_)) { "next" }
-    rule(break: simple(:_)) { "break" }
-    rule(input_variable: simple(:var)) { "print '> '\n__input = STDIN.gets.chomp\n#{var} = Integer(__input) rescue input" }
-
-    rule(equals: { left: simple(:left), right: simple(:right) }) { "#{left} == #{right}" }
-    rule(not_equals: { left: simple(:left), right: simple(:right) }) { "#{left} != #{right}" }
-    rule(gt: { left: simple(:left), right: simple(:right) }) { "#{left} > #{right}" }
-    rule(gte: { left: simple(:left), right: simple(:right) }) { "#{left} >= #{right}" }
-    rule(lte: { left: simple(:left), right: simple(:right) }) { "#{left} <= #{right}" }
-    rule(lt: { left: simple(:left), right: simple(:right) }) { "#{left} < #{right}" }
-
-    rule(if: {
-      if_condition: simple(:if_condition),
-      if_block: sequence(:if_block_lines),
-      endif: simple(:_)
-    } ) do |context|
-      output = "#{' ' * @@indent}if #{context[:if_condition]}\n"
-      self.up_indent
-      output += context[:if_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endif"
-      output
-    end
-
-    rule(if: {
-      if_condition: simple(:if_condition),
-      and_or: simple(:and_or),
-      second_condition: simple(:second_condition),
-      if_block: sequence(:if_block_lines),
-      endif: simple(:_)
-    } ) do |context|
-      proper_and_or = context[:and_or] == 'and' ? '&&' : '||'
-      output = "#{' ' * @@indent}if #{context[:if_condition]} #{proper_and_or} #{context[:second_condition]}\n"
-      self.up_indent
-      output += context[:if_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endif"
-      output
-    end
-
-    rule(if_else: {
-      if_condition: simple(:if_condition),
-      if_block: sequence(:if_block_lines),
-      else_block: sequence(:else_block_lines),
-      endif: simple(:_)
-    } ) do |context|
-      output = "#{' ' * @@indent}if #{context[:if_condition]}\n"
-      self.up_indent
-      output += context[:if_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}else\n"
-      self.up_indent
-      output += context[:else_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endifelse"
-      output
-    end
-
-    rule(if_else: {
-      if_condition: simple(:if_condition),
-      and_or: simple(:and_or),
-      second_condition: simple(:second_condition),
-      if_block: sequence(:if_block_lines),
-      else_block: sequence(:else_block_lines),
-      endif: simple(:_)
-    } ) do |context|
-      proper_and_or = context[:and_or] == 'and' ? '&&' : '||'
-      output = "#{' ' * @@indent}if #{context[:if_condition]} #{proper_and_or} #{context[:second_condition]}\n"
-      self.up_indent
-      output += context[:if_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}else\n"
-      self.up_indent
-      output += context[:else_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endifelse"
-      output
-    end
-
-    rule(while: {
-      while_condition: simple(:while_condition),
-      while_block: sequence(:while_block_lines),
-      endwhile: simple(:_)
-    } ) do |context|
-      output = "#{' ' * @@indent}while #{context[:while_condition]}\n"
-      self.up_indent
-      output += context[:while_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endwhile"
-      output
-    end
-
-    rule(while: {
-      while_condition: simple(:while_condition),
-      and_or: simple(:and_or),
-      second_condition: simple(:second_condition),
-      while_block: sequence(:while_block_lines),
-      endwhile: simple(:_)
-    } ) do |context|
-      proper_and_or = context[:and_or] == 'and' ? '&&' : '||'
-      output = "#{' ' * @@indent}while #{context[:while_condition]} #{proper_and_or} #{context[:second_condition]}\n"
-      self.up_indent
-      output += context[:while_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # endwhile"
-      output
-    end
-
-    rule(until: {
-      until_condition: simple(:until_condition),
-      until_block: sequence(:until_block_lines),
-      enduntil: simple(:_)
-    } ) do |context|
-      output = "#{' ' * @@indent}until #{context[:until_condition]}\n"
-      self.up_indent
-      output += context[:until_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # enduntil"
-      output
-    end
-
-    rule(until: {
-      until_condition: simple(:until_condition),
-      and_or: simple(:and_or),
-      second_condition: simple(:second_condition),
-      until_block: sequence(:until_block_lines),
-      enduntil: simple(:_)
-    } ) do |context|
-      proper_and_or = context[:and_or] == 'and' ? '&&' : '||'
-      output = "#{' ' * @@indent}until #{context[:until_condition]} #{proper_and_or} #{context[:second_condition]}\n"
-      self.up_indent
-      output += context[:until_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # enduntil"
-      output
-    end
-
-    rule(argument_name: simple(:str)) { str }
-    rule(return_value: simple(:value)) { "return #{value}" }
-
-    rule(function_definition: {
-      function_name: simple(:function_name),
-      arguments: sequence(:arguments),
-      function_block: sequence(:function_block_lines),
-      enddef: simple(:_)
-    } ) do |context|
-      output = "#{' ' * @@indent}def #{context[:function_name]}(#{context[:arguments].join(', ')})\n"
-      self.up_indent
-      output += context[:function_block_lines].map { |l| "#{' ' * @@indent}#{l}\n" }.join
-      self.down_indent
-      output += "#{' ' * @@indent}end # enddef"
-      output
-    end
-
-    rule(function_call: {
-      function_name: simple(:function_name),
-      arguments: sequence(:arguments)
-    } ) do
-      "#{function_name}(#{arguments.join(', ')})"
-    end
-
-    rule(line: simple(:line)) { line == "\n" ? nil : line }
-    rule(lyrics: sequence(:lines)) { lines.join("\n") + "\n" }
-
-    def self.parameterize(string)
-      string.to_s.downcase.gsub(/\s+/, '_')
-    end
-
-    def self.str_to_num(string)
-      string.to_s.split(/\s+/).map { |e| e.length % 10 }.join
-    end
-  end
-end