ryb 0.1.3.1 → 0.2.0.2

data/lib/ryb/properties/files.rb

@@ -1,25 +0,0 @@
-module Ryb
-  module Properties
-    module Files
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        def files
-          @files ||= {
-            :source => []
-          }
-        end
-
-        def add_source_files(*files)
-          self.files[:source].push(*((([*files]).flatten).map(&Dir.method(:glob)).flatten))
-        end
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/properties/flags.rb

@@ -1,33 +0,0 @@
-module Ryb
-  module Properties
-    module Flags
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        def flags
-          @flags ||= {
-            :generate_debug_symbols => false,
-            :optimize => :none
-          }
-        end
-
-        def generate_debug_symbols; flags[:generate_debug_symbols]; end
-        def generate_debug_symbols=(do_generate_debug_symbols)
-          flags[:generate_debug_symbols] = do_generate_debug_symbols
-        end
-
-        def optimize; flags[:optimize]; end
-        def optimize=(optimization)
-          raise "..." unless [:none, :size, :speed].include?(optimization)
-          flags[:optimization] = optimization
-        end
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/properties/named.rb

@@ -1,17 +0,0 @@
-module Ryb
-  module Properties
-    module Named
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        attr_reader :name
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/properties/paths.rb

@@ -1,37 +0,0 @@
-module Ryb
-  module Properties
-    module Paths
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        def paths
-          @paths ||= {
-            :includes => [],
-            :libraries => [],
-            :binaries => []
-          }
-        end
-
-        # TODO(mtwilliams): Refactor.
-        # TODO(mtwilliams): Verify existence of paths.
-        def add_includes_paths(*paths)
-          self.paths[:includes].push(*(([*paths]).flatten))
-        end
-
-        def add_libraries_paths(*paths)
-          self.paths[:libraries].push(*(([*paths]).flatten))
-        end
-
-        def add_binaries_paths(*paths)
-          self.paths[:binaries].push(*(([*paths]).flatten))
-        end
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/properties/suffix.rb

@@ -1,17 +0,0 @@
-module Ryb
-  module Properties
-    module Suffix
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        attr_accessor :suffix
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/properties/targets.rb

@@ -1,36 +0,0 @@
-require 'ryb/targets/windows'
-require 'ryb/targets/macosx'
-require 'ryb/targets/linux'
-
-module Ryb
-  module Properties
-    module Targets
-      module ClassMethods
-      end
-
-      module InstanceMethods
-        def targets
-          @targets ||= {}
-        end
-
-        def target(name, &block)
-          target = {:windows => Ryb::Targets::Windows,
-                    :macosx => Ryb::Targets::MacOSX,
-                    :linux => Ryb::Targets::Linux}[name].new(&block)
-          targets.merge!(name => target) do |_, *targets|
-            targets[0].instance_variable_set(:@version, targets[1].instance_variable_get(:@version))
-            targets[0].suffix ||= targets[1].suffix
-            targets[0].defines.merge!(targets[1].defines)
-            targets[0].flags.merge!(targets[1].flags)
-            targets[0]
-          end
-        end
-      end
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-        klass.include(InstanceMethods)
-      end
-    end
-  end
-end

data/lib/ryb/target.rb

@@ -1,16 +0,0 @@
-require 'ryb/name'
-require 'ryb/properties'
-
-module Ryb
-  class Target
-    include Properties::Named
-    include Properties::Suffix
-    include Properties::Defines
-    include Properties::Flags
-
-    def initialize(name, opts={})
-      @name = Name.new(name, opts[:pretty])
-      yield self if block_given?
-    end
-  end
-end

data/lib/ryb/targets/linux.rb

@@ -1,11 +0,0 @@
-require 'ryb/target'
-
-module Ryb
-  module Targets
-    class Linux < Target
-      def initialize(&block)
-        super('linux', pretty: 'Linux', &block)
-      end
-    end
-  end
-end

data/lib/ryb/targets/macosx.rb

@@ -1,33 +0,0 @@
-require 'ryb/target'
-
-module Ryb
-  module Targets
-    class MacOSX < Target
-      class Version
-        attr_accessor :major
-        attr_accessor :minor
-
-        def initialize(major, minor)
-          @major = major; @minor = minor;
-        end
-
-        def to_s
-          "#{major}.#{minor}"
-        end
-      end
-
-      attr_reader :version
-      def version=(version)
-        raise "..." unless version =~ /^(\d+)\.(\d+)$/
-        major, minor = *((/^(\d+)\.(\d+)$/.match(version))[1..2].map(&:to_i))
-        raise "..." if major != 10
-        raise "..." if minor <= 5
-        @version = Version.new(major, minor)
-      end
-
-      def initialize(&block)
-        super('macosx', pretty: 'Mac OS X', &block)
-      end
-    end
-  end
-end

data/lib/ryb/targets/windows.rb

@@ -1,13 +0,0 @@
-require 'ryb/target'
-
-module Ryb
-  module Targets
-    class Windows < Target
-      attr_accessor :sdk
-
-      def initialize(&block)
-        super('windows', pretty: 'Windows', &block)
-      end
-    end
-  end
-end

data/lib/ryb/version.rb

@@ -1,11 +0,0 @@
-module Ryb
-  module VERSION #:nodoc:
-    MAJOR, MINOR, PATCH, PRE = [0, 1, 3, 1]
-    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
-  end
-
-  # Returns the semantic version of Ryb.
-  def self.version
-    Ryb::VERSION::STRING
-  end
-end

data/lib/ryb/windows.rb

@@ -1,40 +0,0 @@
-module Ryb
-  module Windows
-    POSSIBLE_SDK_INSTALL_DIRECTORY_REGISTRY_KEYS =
-      ["SOFTWARE\\Wow6432Node\\Microsoft\\Microsoft SDKs\\Windows",
-       "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows"]
-
-    def self.sdk
-      if Ryb.platform == :windows
-        if ENV.key?('WindowsSdkDir')
-          ENV['WindowsSdkDir']
-        else
-          # TODO(mtwilliams): Escape, i.e. .gsub(/\\/,'/').gsub(/\ /,'\\ ')?
-          self.sdks.first
-        end
-      end
-    end
-
-    def self.sdk?
-      !self.sdk.nil?
-    end
-
-    def self.sdks
-      if Ryb.platform == :windows
-        require 'win32/registry'
-        @sdks ||= begin
-          (POSSIBLE_SDK_INSTALL_DIRECTORY_REGISTRY_KEYS.map do |key|
-            begin
-              ::Win32::Registry::HKEY_CURRENT_USER.open(key, ::Win32::Registry::KEY_READ)['CurrentInstallFolder']
-            rescue
-              begin
-                ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, ::Win32::Registry::KEY_READ)['CurrentInstallFolder']
-              rescue
-              end
-            end
-          end).compact
-        end
-      end
-    end
-  end
-end

data/lib/ryb/xcode.rb

@@ -1,145 +0,0 @@
-require 'ryb/project'
-
-module Ryb
-  module XCode
-    module Project
-    end
-
-    module Target
-      def self.setup_for_version(xc_project, xc_target, version)
-        xc_target.build_configuration_list.set_setting('SDKROOT', "macosx#{version}")
-      end
-
-      def self.add_file_references(xc_project, xc_target, files)
-        sources = xc_project.main_group['Source'] || xc_project.main_group.new_group('Source')
-        files.each do |file|
-          *dirs, file = Pathname(file).each_filename.to_a
-          group = dirs.reduce(sources) {|group, dir| group[dir] || group.new_group(dir, dir)}
-          ref = group.new_file(file)
-          xc_target.add_file_references([ref])
-        end
-      end
-    end
-
-    def self.generate_project_files_for(project, opts={})
-      # TODO(mtwilliams): Take into account opts[:root].
-      xc_proj = Xcodeproj::Project.new("#{project.name}.xcodeproj")
-      puts "Generating #{xc_proj.path}..."
-
-      xc_products_group = xc_proj.main_group['Products']
-      xc_products_group_for_libs = xc_products_group.new_group('lib', 'lib')
-      xc_products_group_for_bins = xc_products_group.new_group('bin', 'bin')
-
-      project.configurations.each do |name, config|
-        xc_build_configuration = xc_proj.build_configuration_list[config.name]
-        xc_build_configuration ||= xc_proj.build_configuration_list[config.name.capitalize]
-        xc_build_configuration ||= xc_proj.add_build_configuration(config.name, :release)
-        xc_build_configuration.name = (config.name.pretty || config.name.capitalize)
-        defines = project.defines.merge(config.defines)
-        xc_build_configuration.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] = defines.map {|name, value| "#{name}=#{value}"}
-      end
-
-      xc_proj.build_configuration_list.set_setting('SYMROOT', opts[:built])
-      xc_proj.build_configuration_list.set_setting('CONFIGURATION_BUILD_DIR', opts[:built])
-      xc_proj.build_configuration_list.sort
-
-      (project.libraries + project.applications).each do |target|
-        puts " Adding '#{target.name.pretty || target.name}' as target..."
-        type = :application if target.is_a? Ryb::Application
-        type = {:static => :static_library, :dynamic => :dynamic_library}[target.linkage] if target.is_a? Ryb::Library
-        name = target.name
-        platform = :osx
-        deployment_target = (target.targets[:macosx].version.to_s if (target.targets[:macosx] and target.targets[:macosx].verison))
-        xc_target = xc_proj.new_target(type, name, platform, deployment_target)
-
-        # case type
-        # when :application
-        #   xc_target.product_reference.move(xc_products_group_for_bins)
-        # when :static_library
-        #   xc_target.product_reference.move(xc_products_group_for_libs)
-        # when :dynamic_library
-        #   xc_target.product_reference.move(xc_products_group_for_bins)
-        # end
-        # xc_target.product_reference.set_source_tree(:group)
-
-        # if target.name.pretty
-        #   xc_target.name = target.name.pretty
-        #   xc_target.product_name = target.name
-        # end
-
-        if target.targets[:macosx] and target.targets[:macosx].verison
-          Target.setup_for_version(xc_proj, xc_target, target.targets[:macosx].version)
-        end
-
-        # TODO(mtwilliams): Refactor.
-        configs = ((project.configurations.keys | target.configurations.keys).map do |config|
-          project_config = project.configurations[config]
-           if project_config
-             project_config = project_config.dup
-             project_config.instance_variable_set(:@defines, project.defines.merge(project_config.defines))
-           end
-          target_config = target.configurations[config]
-           if target_config
-             target_config = target_config.dup
-             target_config.instance_variable_set(:@defines, target.defines.merge(target_config.defines))
-           end
-          config = if project_config and target_config
-                     project_config.instance_variable_set(:@defines, project_config.defines.merge(target_config.defines))
-                     project_config
-                   else
-                     project_config || target_config
-                   end
-
-          [config.name, config]
-        end).to_h
-
-        configs.each do |name, config|
-          xc_build_configuration = xc_target.build_configuration_list[config.name]
-          xc_build_configuration ||= xc_target.build_configuration_list[config.name.capitalize]
-          xc_build_configuration ||= xc_target.add_build_configuration(config.name, :release)
-          xc_build_configuration.name = (config.name.pretty || config.name.capitalize)
-          xc_build_configuration.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] = config.defines.map {|name, value| "#{name}=#{value}"}
-        end
-
-        expand_path_variables = lambda { |path|
-          path.gsub(/\:built/, opts[:built])
-        }
-
-        includes = target.paths[:includes].map(&expand_path_variables).map(&File.method(:expand_path))
-        xc_target.build_configuration_list.set_setting('USER_HEADER_SEARCH_PATHS', includes)
-        libraries = target.paths[:libraries].map(&expand_path_variables).map(&File.method(:expand_path))
-        libraries.each(&FileUtils.method(:mkdir_p))
-        xc_target.build_configuration_list.set_setting('LIBRARY_SEARCH_PATHS', libraries)
-        binaries = target.paths[:binaries].map(&expand_path_variables).map(&File.method(:expand_path))
-        binaries.each(&FileUtils.method(:mkdir_p))
-        # ???
-
-        xc_target.build_configuration_list.sort
-
-        xc_target.build_configuration_list.set_setting('BUILT_PRODUCTS_DIR', opts[:built])
-        case type
-        when :application
-          xc_target.build_configuration_list.set_setting('CONFIGURATION_BUILD_DIR', File.join(opts[:built], 'bin'))
-        when :static_library
-          xc_target.build_configuration_list.set_setting('CONFIGURATION_BUILD_DIR', File.join(opts[:built], 'lib'))
-        when :dynamic_library
-          xc_target.build_configuration_list.set_setting('CONFIGURATION_BUILD_DIR', File.join(opts[:built], 'bin'))
-        end
-
-        Target.add_file_references(xc_proj, xc_target, target.files[:source])
-
-        target.dependencies.each do |dependency|
-          xc_target_for_dep = [*(xc_proj.targets.objects.select {|target| target.product_name == dependency})].first
-          if xc_target_for_dep
-            xc_target.add_dependency(xc_target_for_dep)
-            xc_target
-          else
-            raise "Not implemented, yet!"
-          end
-        end
-      end
-
-      xc_proj.save
-    end
-  end
-end