ryb 0.1.3.1 → 0.2.0.2

data/lib/ryb/dsl.rb

@@ -0,0 +1,280 @@
+module Ryb
+  module DomainSpecificLanguage
+    module Configurations
+      def configuration(name, opts={}, &block)
+        @spec.configurations ||= []
+
+        existing_config = find_by_canonical_name(@spec.configurations, name)
+        config = existing_config || Ryb::Configuration.new
+        existing_pretty_name = config.name.pretty if existing_config
+        config.name = Ryb::Name.new(name, :pretty => existing_pretty_name || opts[:pretty])
+
+        @spec.configurations << config unless existing_config
+
+        DomainSpecificLanguage.for(config).instance_eval(&block)
+      end
+
+      def platform(name, opts={}, &block)
+        # TODO(mtwilliams): Refactor this.
+        @spec.platforms ||= []
+
+        existing_platform = find_by_canonical_name(@spec.platforms, name)
+        platform = existing_platform || Ryb::Platform.new
+        existing_pretty_name = platform.name.pretty if existing_platform
+        platform.name ||= Ryb::Name.new(name, :pretty => existing_pretty_name || opts[:pretty])
+
+        @spec.platforms << platform unless existing_platform
+
+        DomainSpecificLanguage.for(platform).instance_eval(&block)
+      end
+
+      def architecture(name, opts={}, &block)
+        # TODO(mtwilliams): Refactor this.
+        @spec.architectures ||= []
+
+        existing_arch = find_by_canonical_name(@spec.architectures, name)
+        arch = existing_arch || Ryb::Architecture.new
+        existing_pretty_name = arch.name.pretty if existing_arch
+        arch.name ||= Ryb::Name.new(name, :pretty => existing_pretty_name || opts[:pretty])
+
+        @spec.architectures << arch unless existing_arch
+
+        DomainSpecificLanguage.for(arch).instance_eval(&block)
+      end
+
+      private
+        def find_by_canonical_name(ary_of_named_things, name)
+          (ary_of_named_things.select do |existing_thing|
+              existing_thing.name.canonicalize == name.to_s
+            end).first
+        end
+    end
+
+    module Environment
+      def add_include_path(path)
+        @spec.paths ||= Paths.new
+        @spec.paths.includes = @spec.paths.includes + [path]
+      end
+
+      def add_include_paths(*paths_and_patterns)
+        [*paths_and_patterns].each do |path_or_pattern|
+          [*(Dir.glob(path_or_pattern))].each do |path|
+            add_include_path(path)
+          end
+        end
+      end
+
+      def add_library_path(path)
+        @spec.paths ||= Paths.new
+        @spec.paths.libraries = @spec.paths.libraries + [path]
+      end
+
+      def add_library_paths(*paths_and_patterns)
+        [*paths_and_patterns].each do |path_or_pattern|
+          [*(Dir.glob(path_or_pattern))].each do |path|
+            add_library_path(path)
+          end
+        end
+      end
+
+      def add_binary_path(path)
+        @spec.paths ||= Paths.new
+        @spec.paths.binaries = @spec.paths.binaries + [path]
+      end
+
+      def add_binary_paths(*paths_and_patterns)
+        [*paths_and_patterns].each do |path_or_pattern|
+          [*(Dir.glob(path_or_pattern))].each do |path|
+            add_binary_path(path)
+          end
+        end
+      end
+    end
+
+    module Preprocessor
+      def define(defines)
+        @spec.defines ||= Hash.new
+        @spec.defines = @spec.defines.merge(defines)
+      end
+    end
+
+    module Flags
+      def treat_warnings_as_errors=(flag)
+        @spec.treat_warnings_as_errors = flag
+      end
+
+      def generate_debug_symbols=(flag)
+        @spec.generate_debug_symbols = flag
+      end
+
+      def link_time_code_generation=(flag)
+        @spec.link_time_code_generation = flag
+      end
+
+      def optimize=(goal)
+        @spec.optimize = goal
+      end
+    end
+
+    module Code
+      def add_source_file(file)
+        case file
+          when SourceFile
+            @spec.sources ||= []
+            @spec.sources = @spec.sources + [file]
+          when String
+            add_source_file(SourceFile.new(file))
+          end
+      end
+
+      def add_source_files(*files_and_patterns)
+        [*files_and_patterns].each do |file_or_pattern|
+          case file_or_pattern
+            when SourceFile
+              add_source_file(file_or_pattern)
+            when String
+              [*(Dir.glob(file_or_pattern))].each do |file|
+                add_source_file(file)
+              end
+            end
+        end
+      end
+    end
+
+    module Dependencies
+      def add_dependency(product)
+        @spec.dependencies ||= []
+        @spec.dependencies = @spec.dependencies + [Ryb::InternalDependency.new(product)]
+      end
+
+      def add_external_dependency(lib_or_framework)
+        @spec.dependencies ||= []
+        @spec.dependencies = @spec.dependencies + [Ryb::ExternalDependency.new(lib_or_framework)]
+      end
+    end
+
+    class Configuration
+      def initialize(config)
+        @spec = @config = config
+      end
+
+      def prefix=(prefix)
+        @config.prefix = prefix
+      end
+
+      def suffix=(suffix)
+        @config.suffix = suffix
+      end
+
+      include Environment
+      include Preprocessor
+      include Flags
+      include Code
+      include Dependencies
+    end
+
+    class Platform < Configuration
+      def initialize(platform)
+        super(platform)
+        @platform = platform
+      end
+    end
+
+    class Architecture < Configuration
+      def initialize(arch)
+        super(arch)
+        @arch = arch
+      end
+    end
+
+    class Product
+      def initialize(product)
+        @spec = @product = product
+      end
+
+      def author=(author)
+        @product.author = author
+      end
+
+      def description=(description)
+        @product.description = description
+      end
+
+      def license=(license)
+        @product.license = license
+      end
+
+      def version=(version)
+        @product.version = version
+      end
+
+      include Configurations
+      include Environment
+      include Preprocessor
+      include Flags
+      include Code
+      include Dependencies
+    end
+
+    class Application < Product
+      def initialize(app)
+        super(app)
+        @app = app
+      end
+    end
+
+    class Library < Product
+      def initialize(lib)
+        super(lib)
+        @lib = lib
+      end
+
+      def linkage=(linkage)
+        @lib.linkage = linkage
+      end
+    end
+
+    class Project
+      def initialize(project)
+        @spec = @project = project
+      end
+
+      include Configurations
+      include Environment
+      include Preprocessor
+
+      def application(name, opts={}, &block)
+        # TODO(mtwilliams): Verify uniqueness.
+        app = Ryb::Application.new
+        app.name = Ryb::Name.new(name, :pretty => opts[:pretty])
+        DomainSpecificLanguage.for(app).instance_eval(&block)
+        @project.products ||= []
+        @project.products = @project.products + [app]
+      end
+
+      def library(name, opts={}, &block)
+        # TODO(mtwilliams): Verify uniqueness.
+        lib = Ryb::Library.new
+        lib.name = Ryb::Name.new(name, :pretty => opts[:pretty])
+        DomainSpecificLanguage.for(lib).instance_eval(&block)
+        @project.products ||= []
+        @project.products = @project.products + [lib]
+      end
+    end
+
+    FOR = {Ryb::Configuration => Configuration,
+           Ryb::Platform      => Platform,
+           Ryb::Architecture  => Architecture,
+           Ryb::Application   => Application,
+           Ryb::Library       => Library,
+           Ryb::Project       => Project}
+
+    def self.for(obj)
+      # TODO(mtwilliams): Use `__poured__` rather than manually building?
+      # poured = spec.class_variable_get(:@@__poured__)
+
+      # Hide behind a SimpleDelegator so users don't play with our internals.
+      SimpleDelegator.new(FOR[obj.class].new(obj))
+    end
+  end
+end

data/lib/ryb/environment.rb

@@ -0,0 +1,9 @@
+module Ryb
+  module Environment
+    include Pour::Pourable
+
+    property :paths, Typespec.struct[:includes  => Typespec.array[Typespec.string],
+                                     :libraries => Typespec.array[Typespec.string],
+                                     :binaries  => Typespec.array[Typespec.string]]
+  end
+end

data/lib/ryb/flags.rb

@@ -0,0 +1,17 @@
+module Ryb
+  module Flags
+    include Pour::Pourable
+
+    # Prevent code that raises warnings from succesfully compiling.
+    property :treat_warnings_as_errors, Typespec.boolean
+
+    # Have the compiler generate debugging information.
+    property :generate_debug_symbols, Typespec.boolean
+
+    # Link (and optimize) code as late as possible.
+    property :link_time_code_generation, Typespec.boolean
+
+    # Optimize for size, or speed, or neither.
+    property :optimize, Typespec.enum[:nothing, :size, :speed]
+  end
+end

data/lib/ryb/gem.rb

@@ -0,0 +1,58 @@
+require 'ostruct'
+
+module Ryb
+  module Gem
+    # The name of this Gem.
+    def self.name
+      "ryb"
+    end
+
+    # The name and email address of the primary author.
+    def self.author
+      self.authors.first
+    end
+
+    # The name and email addresses of all authors.
+    def self.authors
+      [["Michael Williams", "m.t.williams@live.com"]].map do |author|
+        name, email = author
+        OpenStruct.new(name: name, email: email)
+      end
+    end
+
+    # This Gem's homepage URL.
+    def self.homepage
+      "https://RubifiyYourBuild.com/"
+    end
+
+    # This Gem's URL.
+    def self.url
+      "https://rubygems.org/gems/#{self.name}"
+    end
+
+    # A short summary of this Gem.
+    def self.summary
+      "Rubifiy your builds!"
+    end
+
+    # A full description of this Gem.
+    def self.description
+      "Ryb is a clean and extensible Ruby library and tool that generates build files for Visual Studio, XCode, Make, and Ninja."
+    end
+
+    module VERSION #:nodoc:
+      MAJOR, MINOR, PATCH, PRE = [0, 2, 0, 2]
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+
+    # The semantic version of the this Gem.
+    def self.version
+      Gem::VERSION::STRING
+    end
+
+    # The license covering this Gem.
+    def self.license
+      "Public Domain"
+    end
+  end
+end

data/lib/ryb/helpers/defaults.rb

@@ -0,0 +1,26 @@
+module Ryb
+  module Helpers
+    module Defaults
+      def self.targets
+        @@targets = begin
+          case RbConfig::CONFIG["host_os"]
+            when /mswin|windows|mingw|cygwin/i
+              ['windows']
+            when /darwin/i
+              ['macosx']
+            when /linux/i
+              ['linux']
+            end
+        end
+      end
+
+      def self.toolchains
+        @@toolchains ||= {
+          'windows' => 'msvc',
+          'macosx' => 'clang+llvm',
+          'linux' => 'gcc'
+        }
+      end
+    end
+  end
+end

data/lib/ryb/helpers/pretty_string.rb

@@ -0,0 +1,47 @@
+module Ryb
+  module Helpers
+    class PrettyString < String
+      # @!attribute [r] pretty
+      # @return [String] A more readable description of the string.
+      attr_reader :pretty
+
+      # @param [Hash] opts Optional arguments.
+      # @param [String] str The string.
+      # @param opts [String] :pretty A more readable description of the string.
+      def initialize(str, opts={})
+        super(str.to_s)
+        @pretty = opts[:pretty] if opts.include? :pretty
+      end
+
+      # Perform the comparision on the non-pretty values of all derivatives
+      # of strings, i.e. coerce any stringy values into ::String before
+      # comparing.
+      #
+      # @example
+      #   greeting_1 = PrettyString.new('greeting', pretty: 'Eh!')
+      #   greeting_2 = PrettyString.new('greeting', pretty: 'Aloha!')
+      #   greeting_1 == greeting_2 #=> true
+      alias :eql? :==
+      def ==(other)
+        if other.is_a? String
+          self.to_s == other.to_s
+        else
+          super(other)
+        end
+      end
+
+      # @return [String] A more readable description of the string.
+      #
+      # @example
+      #   greeting = PrettyString.new("greeting", pretty: "How you doin'?") #=> "greeting"
+      #   greeting.inspect #=> <Ryb::Helpers::PrettyString "greeting" @pretty: "How you doin'?">
+      def inspect
+        if self.pretty
+          "<#{self.class.to_s} \"#{self.to_s}\" @pretty: \"#{self.pretty}\">"
+        else
+          "<#{self.class.to_s} \"#{self.to_s}\">"
+        end
+      end
+    end
+  end
+end

data/lib/ryb/languages.rb

@@ -0,0 +1,13 @@
+module Ryb
+  module Languages
+    SUPPORTED = [:c, :cpp, :csharp]
+
+    def self.supported
+      SUPPORTED
+    end
+
+    def self.supported?(language)
+      supported.include?(language)
+    end
+  end
+end