starlark_compiler 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b74a86696f726f3151ccdd78309c4b1ebea7bf398cb9208798a52e673be4051
-  data.tar.gz: 365d6a79086a1dd56e173ab2f849f6ce35369a39c377fe135251efcd495a2433
+  metadata.gz: 663c6958d605dfe906b15293619e97fff4040f4fa57568b88c5d76a343a04083
+  data.tar.gz: c04c32107df5dfd72be317e48f3f6b96683a21c02b648c8e1f8932859c9b8072
 SHA512:
-  metadata.gz: e8c9cfde13ec42a01be510b584b63a8316b0cdeefbd9c6c507d6c25aa60915db40d03102ef4bde0d4dbb2d6333195adb943114d14d3707991781858d73ca1512
-  data.tar.gz: a2f8569be65150c0f0ee30ccc20a0ec8d6b4f1dd03b5879e9349d07ac25e6c424d3207d8c816befa387018325bfd9f4b45207aa548e31d65ba7ff2331a7b2a8a
+  metadata.gz: 7cfa2e574e4a1be840990253089e61680d58232e9370af894e1cbb502ff8ba1aa145961c2161dd157e0c5d49cdf9bbdf1e2618cbb2c4b0ee18ee146a5dc2e59a
+  data.tar.gz: d12126d5aecf51ff166c650372620b6171791df5704aea2cf7a8e8e5d5cb68730cd2d0a42c892ec7b58a9c82128893fbc0b51f89cebc1e0f3835f92d3bd96d95

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    starlark_compiler (0.2.0)
+    starlark_compiler (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -48,4 +48,4 @@ DEPENDENCIES
   starlark_compiler!
 
 BUNDLED WITH
-   2.1.2
+   2.1.4

data/lib/starlark_compiler.rb

@@ -6,5 +6,6 @@ module StarlarkCompiler
   class Error < StandardError; end
 
   require_relative 'starlark_compiler/ast'
+  require_relative 'starlark_compiler/build_file'
   require_relative 'starlark_compiler/writer'
 end

data/lib/starlark_compiler/ast.rb

@@ -12,34 +12,37 @@ module StarlarkCompiler
       @toplevel << node
     end
 
-    def self.build(&blk)
-      Class.new do
-        def const_name_for(str)
-          str = str.to_s
-          return str if str !~ /_/ && str =~ /[A-Z]+.*/
+    class Builder
+      def const_name_for(str)
+        str = str.to_s
+        return str if str !~ /_/ && str =~ /[A-Z]+.*/
 
-          str.split('_').map(&:capitalize).join.to_sym
-        end
+        str.split('_').map(&:capitalize).join.to_sym
+      end
 
-        def respond_to_missing?(name)
-          AST.constants.include?(const_name_for(name))
-        end
+      def respond_to_missing?(name)
+        AST.constants.include?(const_name_for(name))
+      end
 
-        def method_missing(name, *args, **kwargs)
-          const_name = const_name_for(name)
-          begin
-            v = AST.const_get(const_name)
-          rescue NameError
-            super
+      def method_missing(name, *args, **kwargs)
+        const_name = const_name_for(name)
+        begin
+          v = AST.const_get(const_name)
+        rescue NameError
+          super
+        else
+          if kwargs.empty?
+            v.new(*args)
           else
-            if kwargs.empty?
-              v.new(*args)
-            else
-              v.new(*args, **kwargs)
-            end
+            v.new(*args, **kwargs)
           end
         end
-      end.new.instance_exec(&blk)
+      end
+    end
+    private_constant :Builder
+
+    def self.build(&blk)
+      Builder.new.instance_exec(&blk)
     end
 
     class Node

data/lib/starlark_compiler/build_file.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'starlark_compiler/ast'
+require 'starlark_compiler/writer'
+
+module StarlarkCompiler
+  class BuildFile
+    def initialize(package:, workspace: Dir.pwd)
+      @loads = Hash.new { |h, k| h[k] = Set.new }
+      @targets = {}
+      @package = package
+      @workspace = workspace
+      @path = File.join(@workspace, @package, 'BUILD.bazel')
+    end
+
+    def add_load(from:, of:) # rubocop:disable Naming/MethodParameterName
+      @loads[from] |= Array(of)
+    end
+
+    def add_target(function_call)
+      name = function_call.kwargs.fetch(:name)
+      if @targets[name]
+        raise Error, "Target named #{name.inspect} already exists in #{package}"
+      end
+
+      @targets[name] = function_call
+    end
+
+    def save!
+      File.open(@path, 'w') do |f|
+        Writer.write(ast: to_starlark, io: f)
+      end
+    end
+
+    def to_starlark
+      loads = @loads
+              .sort_by { |k, _| k }
+              .map { |f, fn| AST.build { function_call('load', f, *fn.sort) } }
+      targets = @targets
+                .sort_by { |k, _| k }
+                .map { |_f, fn| normalize_function_call_kwargs(fn) }
+      AST.new(toplevel: loads + targets)
+    end
+
+    private
+
+    # from https://github.com/bazelbuild/buildtools/blob/90de5e7001fbdfec29d4128bb508e01169f46950/tables/tables.go#L171-L202
+    KWARG_NAME_PRIORITY = {
+      name: -99,
+      gwt_name: -98,
+      package_name: -97,
+      visible_node_name: -96,
+      size: -95,
+      timeout: -94,
+      testonly: -93,
+      src: -92,
+      srcdir: -91,
+      srcs: -90,
+      out: -89,
+      outs: -88,
+      hdrs: -87,
+      has_services: -86,
+      include: -85,
+      of: -84,
+      baseline: -83,
+      # All others sort here, at 0.
+      destdir: 1,
+      exports: 2,
+      runtime_deps: 3,
+      deps: 4,
+      implementation: 5,
+      implements: 6,
+      alwayslink: 7
+    }.freeze
+    private_constant :KWARG_NAME_PRIORITY
+
+    def normalize_function_call_kwargs(func)
+      kwargs = func.kwargs.sort_by do |k, _v|
+        [KWARG_NAME_PRIORITY.fetch(k, 0), k]
+      end.to_h
+      func.kwargs.replace(kwargs)
+      func
+    end
+  end
+end

data/lib/starlark_compiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StarlarkCompiler
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/starlark_compiler/writer.rb

@@ -24,7 +24,10 @@ module StarlarkCompiler
       case ast
       when AST
         ast.toplevel.each_with_index do |o, i|
-          io << "\n\n" unless i.zero?
+          unless i.zero?
+            write_newline
+            write_newline unless o.is_a?(AST::FunctionCall) && o.name == 'load'
+          end
           write_node(o)
         end
       when AST::Node
@@ -32,16 +35,16 @@ module StarlarkCompiler
       else
         raise Error, "Trying to write unknown object #{ast.inspect}"
       end
-      io << "\n"
+      write_newline
     end
 
-    def write_node(node, start_of_line: true)
-      write_start_of_line if start_of_line
+    def write_node(node)
       delegate('write_%s', node)
     end
 
-    def write_start_of_line
-      io << '  ' * indent
+    def write_newline
+      io << "\n"
+      io << '    ' * indent
     end
 
     def write_string(str)
@@ -73,65 +76,63 @@ module StarlarkCompiler
     def write_function_call(call)
       single_line = single_line?(call)
       io << call.name << '('
-      io << "\n" unless single_line
       final_index = single_line && call.kwargs.empty? && call.args.size.pred
       call.args.each_with_index do |arg, idx|
-        indented do
-          write_node(arg, start_of_line: !single_line)
-          unless final_index == idx
-            io << ','
-            io << (single_line ? ' ' : "\n")
-          end
+        indented(single_line: single_line) do |indenter|
+          indenter.write_newline
+          write_node(arg)
+          indenter.write_comma unless final_index == idx
         end
       end
       final_index = single_line && call.kwargs.size.pred
       call.kwargs.each_with_index do |(k, v), idx|
-        indented do
-          write_start_of_line unless single_line
+        indented(single_line: single_line) do |indenter|
+          indenter.write_newline
           io << "#{k} = "
-          write_node(v, start_of_line: false)
-          unless final_index == idx
-            io << ','
-            io << (single_line ? ' ' : "\n")
-          end
+          write_node(v)
+          indenter.write_comma unless final_index == idx
         end
       end
-      write_start_of_line unless single_line
+      write_newline unless single_line
       io << ')'
     end
 
     def write_array(array)
       single_line = single_line?(array)
       io << '['
+      end_index = array.elements.size.pred
       array.elements.each_with_index do |node, i|
-        unless i.zero?
-          io << ','
-          io << "\n" unless single_line
+        indented(single_line: single_line) do |indenter|
+          indenter.write_newline
+          write_node(node)
+          indenter.write_comma unless i == end_index && single_line
         end
-        write_node(node, start_of_line: !single_line)
       end
+      write_newline unless single_line
       io << ']'
     end
 
     def write_dictionary(dictionary)
       single_line = single_line?(dictionary)
       io << '{'
+      end_index = dictionary.elements.size.pred
       dictionary.elements.each_with_index do |(key, value), i|
-        unless i.zero?
-          io << ','
-          io << "\n" unless single_line
+        indented(single_line: single_line) do |indenter|
+          indenter.write_newline
+          write_node(key)
+          io << ': '
+          write_node(value)
+          indenter.write_comma unless i == end_index && single_line
         end
-        write_node(key, start_of_line: !single_line)
-        io << ': '
-        write_node(value, start_of_line: false)
       end
+      write_newline unless single_line
       io << '}'
     end
 
     def write_binary_operator(operator)
-      write_node(operator.lhs, start_of_line: false)
+      write_node(operator.lhs)
       io << " #{operator.operator} "
-      write_node(operator.rhs, start_of_line: false)
+      write_node(operator.rhs)
     end
 
     def write_none(_none)
@@ -143,14 +144,26 @@ module StarlarkCompiler
     end
 
     def write_false(_none)
-      io << 'True'
+      io << 'False'
     end
 
-    def indented
-      @indent += 1
-      yield
+    Indenter = Struct.new(:writer, :should_indent) do
+      def write_newline
+        writer.write_newline if should_indent
+      end
+
+      def write_comma
+        writer.io << (should_indent ? ',' : ', ')
+      end
+    end
+    private_constant :Indenter
+
+    def indented(single_line:)
+      should_indent = !single_line
+      @indent += 1 if should_indent
+      yield Indenter.new(self, should_indent)
     ensure
-      @indent -= 1
+      @indent -= 1 if should_indent
     end
 
     def single_line?(node)
@@ -182,16 +195,13 @@ module StarlarkCompiler
     end
 
     def single_line_array?(array)
-      if array.elements.all? { |e| e.is_a?(AST::String) }
-        array.elements.sum { |s| s.str.length } < 50
-      else
-        array.elements.size <= 1 && array.elements.all?(&method(:single_line?))
-      end
+      array.elements.size <= 1 &&
+        array.elements.all?(&method(:single_line?))
     end
 
     def single_line_dictionary?(dictionary)
       dictionary.elements.size <= 1 &&
-        dictionary.elements.each_value.all?(&method(:single_line?))
+        dictionary.elements.each_key.all?(&method(:single_line?))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: starlark_compiler
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Giddins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-24 00:00:00.000000000 Z
+date: 2020-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,6 +45,7 @@ files:
 - bin/setup
 - lib/starlark_compiler.rb
 - lib/starlark_compiler/ast.rb
+- lib/starlark_compiler/build_file.rb
 - lib/starlark_compiler/version.rb
 - lib/starlark_compiler/writer.rb
 - starlark_compiler.gemspec