Skip to content
Permalink
Browse files

Allow adding arbitrary licenses

  • Loading branch information...
imobachgs committed Apr 5, 2018
1 parent 6a80fb3 commit ad67762e2dc68954f8f9a3ae2d32061d11b27775
@@ -51,11 +51,13 @@ y2rns_fetchers_DATA = \
y2licenses_fetchersdir = "${yast2dir}/lib/y2packager/licenses_fetchers"
y2licenses_fetchers_DATA = \
lib/y2packager/licenses_fetchers/base.rb \
lib/y2packager/licenses_handlers/dummy.rb \
lib/y2packager/licenses_fetchers/rpm.rb \
lib/y2packager/licenses_fetchers/url.rb

y2licenses_handlersdir = "${yast2dir}/lib/y2packager/licenses_handlers"
y2licenses_handlers_DATA = \
lib/y2packager/licenses_handlers/dummy.rb \
lib/y2packager/licenses_handlers/rpm.rb

EXTRA_DIST = $(module_DATA) $(ynclude_DATA) $(ylib_DATA) $(y2packager_DATA) $(y2rns_fetchers_DATA) \
@@ -39,11 +39,11 @@ class << self
# @param source [:rpm,:url] Source to get the license from. For the time being,
# only :rpm is really supported.
# @return [License]
def find(product_name, source)
def find(product_name, source, options = {})
return cache[product_name] if cache[product_name]

# This could be done in the constructor.
fetcher = LicensesFetchers.for(source, product_name)
fetcher = LicensesFetchers.for(source, product_name, options)
new_license = License.new(fetcher)
return unless new_license.id

@@ -13,15 +13,16 @@
require "yast"
require "y2packager/licenses_fetchers/rpm"
require "y2packager/licenses_fetchers/url"
require "y2packager/licenses_fetchers/dummy"

module Y2Packager
module LicensesFetchers
# Return the licenses proper fetcher for a given source
#
# @param source [Symbol] :rpm or :url
def self.for(source, product_name)
def self.for(source, product_name, options = {})
klass = const_get(source.to_s.capitalize)
klass.new(product_name)
klass.new(product_name, options)
end
end
end
@@ -27,7 +27,7 @@ class Base
# Constructor
#
# @param product_name [String] to get licenses for
def initialize(product_name)
def initialize(product_name, _options = {})
@product_name = product_name
end
end
@@ -0,0 +1,49 @@
# ------------------------------------------------------------------------------
# Copyright (c) 2018 SUSE LLC, All Rights Reserved.
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of version 2 of the GNU General Public License as published by the
# Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# ------------------------------------------------------------------------------

require "y2packager/licenses_fetchers/base"

module Y2Packager
module LicensesFetchers
# FIXME: Finish implementation
class Dummy < Base
def initialize(product_name, options = {})
super
@content = options[:content]
end
# Return the license text to be confirmed
#
# It will return the empty string ("") if the license does not exist or if
# it was already confirmed.
#
# @param lang [String] Language
# @return [String,nil] Product's license; nil if the product was not found.
def license_content(_lang)
@content
end

# Return available locales for product's license
#
# @return [Array<String>] Language codes ("de_DE", "en_US", etc.)
def license_locales
[License::DEFAULT_LANG]
end

# Determine whether the license should be accepted or not
#
# @return [Boolean] true if the license acceptance is required
def license_confirmation_required?
false
end
end
end
end
@@ -11,6 +11,7 @@
# ------------------------------------------------------------------------------

require "y2packager/licenses_handlers/rpm"
require "y2packager/licenses_handlers/dummy"

module Y2Packager
module LicensesHandlers
@@ -0,0 +1,38 @@
# ------------------------------------------------------------------------------
# Copyright (c) 2018 SUSE LLC, All Rights Reserved.
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of version 2 of the GNU General Public License as published by the
# Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# ------------------------------------------------------------------------------

module Y2Packager
module LicensesHandlers
class Dummy
attr_reader :product_name

# Constructor
#
# @param product_name [String] Product's name
def initialize(product_name)
@product_name = product_name
end

# Determine whether the license should be accepted or not
#
# @return [Boolean] true if the license acceptance is required
def license_confirmation_required?
end

# Set the license confirmation for the product
#
# @param confirmed [Boolean] true if it should be accepted; false otherwise
def license_confirmation=(confirmed)
end
end
end
end
@@ -52,14 +52,17 @@ class << self
# @param source [:rpm,:url] Source to get the license from. For the time being,
# only :rpm is really supported.
# @return [ProductLicense]

def find(product_name, source = :rpm)
def find(product_name, source = :rpm, options = {})
return cache[product_name] if cache[product_name]
license = License.find(product_name, source)
license = License.find(product_name, source, options)
return nil unless license
cache[product_name] = ProductLicense.new(product_name, license, source: source)
end

def find_or_create(product_name, content)
find(product_name, :dummy, {content: content})
end

# Clear product licenses cache
def clear_cache
@cache = nil
@@ -31,7 +31,8 @@
end

it "returns a product license for the given product" do
expect(Y2Packager::License).to receive(:find).with("SLES", :rpm).and_return(license)
expect(Y2Packager::License).to receive(:find).with("SLES", :rpm, {})
.and_return(license)
product_license = described_class.find("SLES", :rpm)
expect(product_license).to be_a(Y2Packager::ProductLicense)
expect(product_license.license).to eq(license)
@@ -50,6 +51,15 @@
end
end

describe ".find_or_create" do
it "returns a product license with the given content" do
product_license = described_class.find_or_create("SLES", "Some predefined content")
expect(product_license).to be_a(Y2Packager::ProductLicense)
license = product_license.license
expect(license.content_for).to eq("Some predefined content")
end
end

describe "#content_for" do
it "delegates to License#content_for" do
expect(license).to receive(:content_for).with("es_ES").and_return("contenido")

0 comments on commit ad67762

Please sign in to comment.
You can’t perform that action at this time.