ryb 0.1.3.1 → 0.2.0.2

data/lib/ryb/paths.rb

@@ -0,0 +1,7 @@
+module Ryb
+  Paths = Struct.new(:includes, :libraries, :binaries) do
+    def initialize(includes=[], libraries=[], binaries=[])
+      super
+    end
+  end
+end

data/lib/ryb/preprocessor.rb

@@ -0,0 +1,10 @@
+module Ryb
+  module Preprocessor
+    include Pour::Pourable
+
+    property :defines, Typespec.hash[Typespec.string => Typespec.or[Typespec.nothing,
+                                                                    Typespec.boolean,
+                                                                    Typespec.number,
+                                                                    Typespec.string]]
+  end
+end

data/lib/ryb/product.rb

@@ -0,0 +1,31 @@
+module Ryb
+  class Product < Pour::Mould
+    property :name, Typespec.t[Ryb::Name]
+
+    property :author,      Typespec.string
+    property :description, Typespec.string
+    property :license,     Typespec.string
+    property :version,     Typespec.string
+
+    # TODO(mtwilliams): Code signing.
+    # property :certificate, Typespec.struct[:public  => Typespec.string,
+    #                                        :private => Typespec.string]
+
+    pour Configurations
+    pour Environment
+    pour Preprocessor
+    pour Flags
+
+    pour Code
+
+    pour Dependencies
+  end
+
+  class Application < Product
+  end
+
+  class Library < Product
+    # Link at compile-time or load-time.
+    property :linkage, Typespec.enum[:static, :dynamic]
+  end
+end

data/lib/ryb/project.rb

@@ -1,34 +1,11 @@
-require 'ryb/name'
-require 'ryb/properties'
-
-require 'ryb/architecture'
-require 'ryb/configuration'
-require 'ryb/library'
-require 'ryb/application'
-
 module Ryb
-  class Project
-    include Properties::Named
-    include Properties::Defines
-    include Properties::Flags
-    include Properties::Paths
-    include Properties::Architectures
-    include Properties::Targets
-    include Properties::Configurations
-
-    def initialize(name, opts={})
-      @name = Name.new(name, opts[:pretty])
-      yield self if block_given?
-    end
+  class Project < Pour::Mould
+    property :name, Typespec.t[Ryb::Name]
 
-    def libraries; @libraries ||= [] end
-    def library(*args, &block)
-      self.libraries << Library.new(*args, &block)
-    end
+    pour Configurations
+    pour Environment
+    pour Preprocessor
 
-    def applications; @applications ||= [] end
-    def application(*args, &block)
-      self.applications << Application.new(*args, &block)
-    end
+    property :products, Typespec.array[Typespec.t[Ryb::Product]]
   end
 end

data/lib/ryb/source_file.rb

@@ -0,0 +1,62 @@
+module Ryb
+  class SourceFile
+    attr_reader :path
+    attr_reader :language
+    attr_reader :inconsequential
+
+    def initialize(path, opts={})
+      @path = path
+      @language = opts[:language] || SourceFile.language_from_path(path)
+      @inconsequential = SourceFile.inconsequential?(@path)
+
+      # TODO(mtwilliams): Use Ryb::UnsupportedLanguage.
+      unless Ryb::Languages.supported?(@language)
+        raise "..." unless @inconsequential
+      end
+    end
+
+    alias :eql? :==
+    def ==(other)
+      self.path == other.path
+    end
+
+    def self.c(path)
+      SourceFile.new(path, :language => :c)
+    end
+
+    def self.cpp(path)
+      SourceFile.new(path, :language => :cpp)
+    end
+
+    def self.csharp(path)
+      SourceFile.new(path, :language => :csharp)
+    end
+
+    def self.language_from_path(path)
+      if ext = File.extname(path)[1..-1]
+        self.language_from_extension(ext)
+      end
+    end
+
+    EXTENSIONS_TO_LANGUAGE = {%w{h}                 => :c,
+                              %w{c}                 => :c,
+                              %w{hh hpp hxx h++}    => :cpp,
+                              %w{cc cpp cxx c++}    => :cpp,
+                              %w{cs}                => :csharp}
+
+    def self.language_from_extension(ext)
+      EXTENSIONS_TO_LANGUAGE.each do |extensions, language|
+        return language if extensions.include?(ext)
+      end
+      :unknown
+    end
+
+    INCONSEQUENTIAL = %w{h hpp hxx h++ inl}
+
+    def self.inconsequential?(path)
+      if ext = File.extname(path)[1..-1]
+        INCONSEQUENTIAL.include? ext
+      end
+    end
+  end
+end

data/lib/ryb/visual_studio.rb

@@ -1,68 +1,104 @@
 module Ryb
   module VisualStudio
-    POSSIBLE_INSTALL_DIRECTORY_REGISTRY_KEYS =
-      ["SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\14.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\14.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\12.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\12.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\12.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\12.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\11.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\11.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\11.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\11.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\10.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\10.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\10.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\9.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\9.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\9.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\9.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\8.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\8.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\8.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\7.1\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\7.1\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\7.1\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\7.1\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\7.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\7.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\7.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\7.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\6.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VisualStudio\\6.0\\Setup\\VC",
-       "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\6.0\\Setup\\VC",
-       "SOFTWARE\\Microsoft\\VCExpress\\6.0\\Setup\\VC"]
+    module Compiler
+      STANDARD_FLAGS = [
+        # Suppress the annoying startup banner.
+        "/nologo",
+        # Don't link after compilation.
+        "/c",
+        # Be vocal about shit code.
+        "/W4",
+        # Fuck off, RTTI.
+        "/GR-",
+        # Don't optimize for one architecture at the loss of another.
+        "/favor:blend"
+      ]
 
-    def self.install
-      if Ryb.platform == :windows
-        if ENV.key?('VCInstallDir')
-          ENV['VCInstallDir']
-        else
-          # TODO(mtwilliams): Escape, i.e. .gsub(/\\/,'/').gsub(/\ /,'\\ ')?
-          self.installs.first
-        end
+      def self.include_paths_to_flags(paths)
+        [*paths].map{|path| "/I\"#{path}\""}
+      end
+
+      def self.defines_to_flags(defines)
+        return [] unless defines
+        (defines.map do |name, value|
+          case value
+            when TrueClass
+              "/D#{name}=1"
+            when FalseClass
+              "/D#{name}=0"
+            when Integer
+              "/D#{name}=#{value}"
+            when String
+              "/D#{name}=#{value.to_s}"
+            else
+              nil
+            end
+        end).compact
+      end
+
+      def self.treat_warnings_as_errors_to_flag(enabled)
+        enabled ? %w{/WX} : []
+      end
+
+      def self.generate_debug_symbols_to_flag(enabled)
+        # HACK(mtwilliams): Force writes to PDBs to be serialized.
+        # Refer to https://msdn.microsoft.com/en-us/library/dn502518.aspx.
+        enabled ? %w{/MDd /Zi /FS} : %w{/MD}
+      end
+
+      def self.link_time_code_generation_to_flag(enabled)
+        enabled ? %w{/WX} : []
       end
-    end
 
-    def self.installed?
-      !self.install.nil?
+      def self.optimization_to_flags(optimization)
+        case
+          when :nothing
+            %w{/Od /RTCsu /fp:precise /fp:except}
+          when :size
+            %w{/Os /fp:fast /fp:except-}
+          when :speed
+            %w{/Ox /fp:fast /fp:except-}
+          end
+      end
+
+      def self.architecture_to_flags(architecture)
+        case architecture
+          when :x86
+            %w{/arch:IA32}
+          when :x86_64
+            # TODO(mtwilliams): Determine if we can specify a minimum of SSE2?
+            []
+          else
+            []
+          end
+      end
     end
 
-    def self.installs
-      if Ryb.platform == :windows
-        require 'win32/registry'
-        @installs ||= begin
-          (POSSIBLE_INSTALL_DIRECTORY_REGISTRY_KEYS.map do |key|
-            begin
-              ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, ::Win32::Registry::KEY_READ)['ProductDir']
-            rescue
-            end
-          end).compact
-        end
+    module Linker
+      STANDARD_FLAGS = [
+        # Suppress the annoying startup banner.
+        "/nologo",
+        # Don't create or embed a manifest file.
+        "/manifest:no"
+      ]
+
+      def self.library_paths_to_flags(paths)
+        [*paths].map{|path| "/LIBPATH:\"#{path}\""}
+      end
+
+      def self.generate_debug_symbols_to_flag(enabled)
+        enabled ? %w{/DEBUG} : %w{}
+      end
+
+      def self.architecture_to_flags(architecture)
+        case architecture
+          when :x86
+            %w{/machine:X86}
+          when :x86_64
+            %w{/machine:X64}
+          end
       end
     end
   end
 end
+

data/lib/rybfile.rb

@@ -1,15 +1,35 @@
 require 'ryb'
-require 'ostruct'
 
-# TODO(mtwilliams): Improve the handling of Rybfiles.
-module Rybfile
-  def self.load(path)
-    begin
-      return OpenStruct.new(:project => eval(File.read(path), binding(), path)).freeze
-    rescue SignalException, SystemExit
-      raise
-    rescue SyntaxError, Exception => e
-      raise "Invalid Rybfile!\n #{path}\n #{e}"
+class Rybfile < Pour::Mould
+  property :project, Typespec.t[Ryb::Project]
+
+  class DomainSpecificLanguage
+    def initialize(rybfile)
+      @rybfile = rybfile
+    end
+
+    def project(name, opts={}, &block)
+      # TODO(mtwilliams): Allow multiple projects?
+      # TODO(mtwilliams): Allow other Rybfiles to be 'included'.
+      @rybfile.project = Ryb::Project.new
+      @rybfile.project.name = Ryb::Name.new(name, :pretty => opts[:pretty])
+
+      Ryb::DomainSpecificLanguage.for(@rybfile.project).instance_eval(&block)
+    end
+
+    def self.for(rybfile)
+      # Hide behind a SimpleDelegator so users don't play with our internals.
+      SimpleDelegator.new(self.new(rybfile))
     end
   end
+
+  def self.load(path)
+    rybfile = Rybfile.new
+
+    # TODO(mtwilliams): Rewrite exceptions from Typespec/Pour into Ryb and attach
+    # source information (the file and line number from the responsible Rybfile.)
+    DomainSpecificLanguage.for(rybfile).instance_eval(File.read(path), path)
+
+    rybfile
+  end
 end

data/lib/rybfile/walker.rb

@@ -0,0 +1,202 @@
+require 'ryb'
+require 'rybfile'
+
+class Rybfile
+  class Walker
+    def initialize(vistor, rybfile, opts)
+      @vistor = vistor
+      @rybfile = rybfile
+      @root = opts.fetch(:root, '.')
+      @build = opts.fetch(:build, '_build')
+      # HACK(mtwilliams): Assume debug, development, and release builds are standard.
+      @configurations = opts.fetch(:configurations, %w{debug development release})
+      @platforms = opts.fetch(:platforms, Ryb::Helpers::Defaults.targets)
+      # HACK(mtwilliams): Assume x86 and x86_64 architectures are standard.
+      @architectures = opts.fetch(:architectures, %w{x86 x86_64})
+    end
+
+    def walk
+      # TODO(mtwilliams): Walk in two steps. The first builds an internal hash
+      # of projects and their products that is a deferred copy of this code and
+      # caches the results. Then iterate over this tree, passing the the lazy
+      # evaluation Proc and let users evalute them. This will cascade when
+      # doing dependency resolution (hitting cached versions along the way),
+      # thus allowing generators for build systems like Visual Studio, that
+      # don't allow us to defer dependency resolution inside, them to be written
+      # without much fuss (i.e. write linearly but execute depth-first.)
+
+      on_project(@rybfile.project)
+    end
+
+    def on_project(project)
+      @vistor.on_project(project)
+
+      project.products.each {|product| on_product(project, product)}
+
+      builds = to_applicable_build_matrix(
+        to_canonical_names(project.configurations),
+        to_canonical_names(project.platforms),
+        to_canonical_names(project.architectures))
+
+      builds.each do |config, platform, arch|
+        on_project_triplet(project, [config, platform, arch])
+      end
+    end
+
+    def on_product(project, product)
+      @vistor.on_product(project, product)
+
+      builds = to_applicable_build_matrix(
+        to_canonical_names(project.configurations) | to_canonical_names(product.configurations),
+        to_canonical_names(project.platforms) | to_canonical_names(product.platforms),
+        to_canonical_names(project.architectures) | to_canonical_names(product.architectures))
+
+      builds.each do |config, platform, arch|
+        on_product_triplet(project, product, [config, platform, arch])
+      end
+    end
+
+    def on_project_triplet(project, triplet)
+      # TODO(mtwilliams): Extract into a helper function.
+      config, platform, arch = *triplet
+      config = find_by_canonical_name(project.configurations, config)
+      platform = find_by_canonical_name(project.platforms, platform)
+      arch = find_by_canonical_name(project.architectures, arch)
+
+      tripletised = lambda {
+        Hashie::Mash.new({
+          :configuration => config,
+          :platform => platform,
+          :architecture => arch,
+          :triplet => triplet
+        })
+      }
+
+      @vistor.on_project_triplet(project, tripletised)
+    end
+
+    def on_product_triplet(project, product, triplet)
+      # TODO(mtwilliams): Extract into a helper function.
+      config, platform, arch = *triplet
+      project_config   = find_by_canonical_name(project.configurations, config)
+      project_platform = find_by_canonical_name(project.platforms, platform)
+      project_arch     = find_by_canonical_name(project.architectures, arch)
+      product_config   = find_by_canonical_name(product.configurations, config)
+      product_platform = find_by_canonical_name(product.platforms, platform)
+      product_arch     = find_by_canonical_name(product.architectures, arch)
+
+      # TODO(mtwilliams): Refactor into #merge and #merge!
+      config   = merge_configuration_settings(project_config, product_config)
+      platform = merge_platform_settings(project_platform, product_platform)
+      arch     = merge_architecture_settings(project_arch, product_arch)
+
+      # TODO(mtwilliams): Build a completly flattened description of the product
+      # for this |triplet|.
+
+      tripletised = lambda {
+        Hashie::Mash.new({
+          :configuration => config,
+          :platform => platform,
+          :architecture => arch,
+          :triplet => triplet
+        })
+      }
+
+      @vistor.on_product_triplet(project, product, tripletised)
+    end
+
+    private
+      def to_canonical_names(collection)
+        [*collection].map(&:name).map(&:canonicalize)
+      end
+
+      def match_on_canonical_name(name)
+        proc {|obj| obj.name.canonicalize == name.to_s}
+      end
+
+      def filter_by_canonical_name(collection, name)
+        matcher = match_on_canonical_name(name)
+        [*collection].select(&matcher).compact
+      end
+
+      def find_by_canonical_name(collection, name)
+        filter_by_canonical_name(collection, name).first
+      end
+
+    private
+      def to_applicable_build_matrix(configurations, platforms, architectures)
+        applicable_configurations = configurations & @configurations
+        applicable_platforms = platforms & @platforms
+        applicable_architectures = architectures & @architectures
+        to_build_matrix(applicable_configurations, applicable_platforms, applicable_architectures)
+      end
+
+      def to_build_matrix(configurations, platforms, architectures)
+        configurations.product(platforms.product(architectures)).map(&:flatten)
+      end
+
+    private
+      def merge_configuration_settings(base, overlay)
+        merged = Ryb::Configuration.new
+
+        merged.name = base.name
+        merged.prefix = base.prefix if (base and base.prefix)
+        merged.prefix = overlay.prefix if (overlay and overlay.prefix)
+        merged.suffix = base.suffix if (base and base.suffix)
+        merged.suffix = overlay.suffix if (overlay and overlay.suffix)
+
+        merged.paths = Ryb::Paths.new
+        merged.defines = Hash.new
+
+        if base and base.paths
+          merged.paths.includes += base.paths.includes
+          merged.paths.libraries += base.paths.libraries
+          merged.paths.binaries += base.paths.binaries
+        end
+
+        if overlay and overlay.paths
+          merged.paths.includes += overlay.paths.includes
+          merged.paths.libraries += overlay.paths.libraries
+          merged.paths.binaries += overlay.paths.binaries
+        end
+
+        merged.defines.merge!(base.defines) if base and base.defines
+        merged.defines.merge!(overlay.defines) if overlay and overlay.defines
+
+        merged.treat_warnings_as_errors = false
+        merged.generate_debug_symbols = false
+        merged.link_time_code_generation = false
+        merged.optimize = :nothing
+
+        if base
+          merged.treat_warnings_as_errors = base.treat_warnings_as_errors unless base.treat_warnings_as_errors().nil?
+          merged.generate_debug_symbols = base.generate_debug_symbols unless base.generate_debug_symbols().nil?
+          merged.link_time_code_generation = base.link_time_code_generation unless base.link_time_code_generation().nil?
+          merged.optimize = base.optimize unless base.optimize().nil?
+        end
+
+        if overlay
+          merged.treat_warnings_as_errors = overlay.treat_warnings_as_errors unless overlay.treat_warnings_as_errors().nil?
+          merged.generate_debug_symbols = overlay.generate_debug_symbols unless overlay.generate_debug_symbols().nil?
+          merged.link_time_code_generation = overlay.link_time_code_generation unless overlay.link_time_code_generation().nil?
+          merged.optimize = overlay.optimize unless overlay.optimize().nil?
+        end
+
+        base_dependencies = base ? (base.dependencies || []) : []
+        overlay_dependencies = overlay ? (overlay.dependencies || []) : []
+        dependencies = base_dependencies | overlay_dependencies
+
+        merged.dependencies = dependencies
+
+        merged
+      end
+
+      def merge_platform_settings(base, overlay)
+        merge_configuration_settings(base, overlay)
+      end
+
+      def merge_architecture_settings(base, overlay)
+        merge_configuration_settings(base, overlay)
+      end
+  end
+end